melonjs 20.7.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/input/pointerevent.d.ts

@@ -77,6 +77,14 @@ export declare function unbindPointer(button?: number): void;
 /**
  * allows registration of event listeners on the object target. <br>
  * melonJS will pass a me.Pointer object to the defined callback.
+ *
+ * Regions under the pointer are asked in the order they are drawn, topmost
+ * first, and the walk continues downwards until a callback returns `false`.
+ * Depth is resolved per container, so a child's `pos.z` orders it among its
+ * siblings only and a cross-container pair is decided at the common ancestor,
+ * matching what is drawn on top. `app.viewport` is asked BEFORE all of them
+ * rather than as a fallback, so a callback registered on it should not return
+ * `false` unless it means to swallow every pointer event in the game.
  * @see Pointer
  * @see {@link http://www.w3.org/TR/pointerevents/#list-of-pointer-events | W3C Pointer Event list}
  * @param eventType - The event type for which the object is registering <br>

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

@@ -1 +1 @@
-{"version":3,"file":"pointerevent.d.ts","sourceRoot":"","sources":["../../src/input/pointerevent.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,OAAO,MAAM,cAAc,CAAC;AA6kBnC;;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":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAepD,OAAO,OAAO,MAAM,cAAc,CAAC;AA2mBnC;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;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/level/gltf/GLTFModel.d.ts

@@ -28,26 +28,41 @@
  * app.world.addChild(boat);
  *
  * // ...then drive it like anything else
- * boat.pos.set(steerX, waterLevel);
- * boat.depth = travelled;
+ * boat.setPosition(steerX, waterLevel, travelled);
  * boat.rotate(lean - lastLean, AXIS_Z);
  */
 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)
      * @param {boolean} [options.lit=false] - render the part meshes through the lit batcher
      * @param {boolean} [options.castGroundShadow] - give the parts a ground shadow; omit to inherit the application setting
      * @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}). `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;
         castGroundShadow?: boolean | undefined;
         shadowGroundY?: number | undefined;
+        shadowOpacity?: number | undefined;
+        shadowScale?: number | undefined;
+        shadowOffset?: number | undefined;
+        shadowStretch?: number | undefined;
+        shadowDirectionX?: number | undefined;
+        shadowDirectionZ?: number | undefined;
+        shadowGroundNormal?: number[] | Vector3d | undefined;
+        shadowLight?: any;
     });
     /**
      * playback multiplier for the current animation (1 = authored speed).
@@ -120,36 +135,8 @@ export default class GLTFModel extends Container {
      * @returns {GLTFModel} this, for chaining
      */
     stop(): GLTFModel;
-    /**
-     * {@link Container#draw} translates the renderer by `pos` so children draw
-     * in container-local space. This rig's children are already in world space,
-     * so that translation is undone here rather than doubling the placement.
-     * Paired with `autoTransform = false`, which suppresses the matching
-     * rotation fold.
-     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
-     * @param {Camera2d} [viewport] - the camera rendering this frame
-     */
-    draw(renderer: CanvasRenderer | WebGLRenderer, viewport?: Camera2d): void;
-    /**
-     * Where this model is, as a 2D box — what culling, picking and the physics
-     * broadphase all read.
-     *
-     * A `Container` has no dimensions of its own, and one left that way reports
-     * an EMPTY bounds: a model claiming to be nowhere, which the broadphase
-     * cannot place. A rig's size is known at load from the glTF scene AABB, so
-     * this is a placement of a measurement taken once in the constructor rather
-     * than a walk of the parts — `Container#updateBounds` with
-     * `enableChildBoundsUpdate` would re-measure the whole rig on every call,
-     * and that flag is for a group whose extent really is its members' union.
-     *
-     * The box is the model's bounding SPHERE squared off, so a turned model
-     * still reports something that contains it. Generous bounds only cost
-     * broadphase pruning; tight ones lose contacts.
-     * @param {boolean} [absolute=true] - in world rather than local coordinates
-     * @returns {Bounds} this model's bounding box
-     */
-    updateBounds(absolute?: boolean): Bounds;
 }
 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":"AA0DA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACC;;;;;;;;OAQG;IACH,kBARW,OAAO,wBAAwB,EAAE,QAAQ,YAEjD;QAAyB,KAAK;QACJ,WAAW;QACX,GAAG;QACH,gBAAgB;QACjB,aAAa;KACxC,EAsRA;IAzQA;;;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;IAqFzD;;;;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;IAED;;;;;;;;OAQG;IACH,eAHW,cAAc,GAAC,aAAa,aAC5B,QAAQ,QAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,wBAHW,OAAO,GACL,MAAM,CAgBlB;IAED;;;OAGG;IACH,cAOC;IAED;;;;;;;;;;;;;;OAcG;IACH,eAJa,MAAM,EAAE,CA4BpB;IAED;;;;;OAKG;IACH,4DAqBC;IAED;;;;;;;OAOG;IACH,2CAJa,MAAM,EAAE,CAyCpB;IAED;;;;;;;;OAQG;IACH,+CASC;CACD;sBAvxBqB,+BAA+B;2CAUX,+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

@@ -1,4 +1,11 @@
 
+/**
+ * additional import for TypeScript
+ * @import Container from "../../renderable/container.js";
+ * @import Mesh from "../../renderable/mesh.js";
+ * @import {Light3d} from "../../lighting/light3d.ts";
+ * @import {Vector3d} from "../../math/vector3d.ts";
+ */
 /**
  * A loadable 3D scene parsed from a glTF / GLB asset. Instances are created
  * and registered with the {@link level} director (usually automatically by
@@ -75,6 +82,28 @@ export default class GLTFScene {
      * 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.
+     * @param {number} [options.shadowOpacity] - how dark the blobs are ({@link Mesh#shadowOpacity})
+     * @param {number} [options.shadowScale] - blob footprint multiplier ({@link Mesh#shadowScale})
+     * @param {number} [options.shadowOffset] - how far to slide them along the light, in blob radii ({@link Mesh#shadowOffset})
+     * @param {number} [options.shadowStretch] - how much longer they are along it ({@link Mesh#shadowStretch})
+     * @param {number} [options.shadowDirectionX] - x of the ground direction they are cast along ({@link Mesh#shadowDirectionX})
+     * @param {number} [options.shadowDirectionZ] - z of that direction ({@link Mesh#shadowDirectionZ})
+     * @param {number[]|Vector3d} [options.shadowGroundNormal] - up normal of the floor, for a scene that is not level ({@link Mesh#shadowGroundNormal})
+     * @param {Light3d} [options.shadowLight] - a light to take the direction from, re-read every draw ({@link Mesh#shadowLight})
+     * @example
+     * // a loaded scene lit by a sun the game owns, so a day/night cycle
+     * // carries the shadows with it
+     * const sun = new Light3d({ direction: [0.4, 1, 0.2] });
+     * app.world.addChild(sun);
+     * await level.load("village", {
+     *     scale: 40,
+     *     castGroundShadow: true,
+     *     shadowGroundY: 0,
+     *     shadowLight: sun,
+     *     shadowOffset: 0.6,
+     *     shadowStretch: 1.8,
+     *     async: true,
+     * });
      */
     addTo(container: Container, options?: {
         scale?: number | undefined;
@@ -83,7 +112,17 @@ export default class GLTFScene {
         lightIntensityScale?: number | undefined;
         castGroundShadow?: boolean | undefined;
         shadowGroundY?: number | undefined;
+        shadowOpacity?: number | undefined;
+        shadowScale?: number | undefined;
+        shadowOffset?: number | undefined;
+        shadowStretch?: number | undefined;
+        shadowDirectionX?: number | undefined;
+        shadowDirectionZ?: number | undefined;
+        shadowGroundNormal?: number[] | Vector3d | undefined;
+        shadowLight?: Light3d | undefined;
     }): void;
 }
-import InstancedMesh from "../../renderable/instanced_mesh.js";
+import type Container from "../../renderable/container.js";
+import type { Vector3d } from "../../math/vector3d.ts";
+import { Light3d } from "../../lighting/light3d.ts";
 //# sourceMappingURL=GLTFScene.d.ts.map

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":"AA+XA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,oCALW,aAAa,aACb,MAAM,QAyChB;AAhbD;;;;;;;;;GASG;AACH;IAwCC;;;;;;;;;;;;;OAaG;IACH,oBAJU,aAAa,CAAC,MAAM,CAAC,CAW5B;IA5DH;;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;IAyBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;IACH,iBAhCW,SAAS,YAEjB;QAAyB,KAAK;QACJ,WAAW;QAEX,MAAM;QAQP,mBAAmB;QAQlB,gBAAgB;QAMjB,aAAa;KAIxC,QA4KA;IAED;;;;;;;;;;;;;OAaG;IACH,sBAPW,SAAS,SACT,MAAM,SACN,MAAM,WACN,MAAM,QAsEhB;IAED;;;;;;OAMG;IACH,gBAAY;CACZ;0BAzXyB,oCAAoC"}
+{"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/level.d.ts

@@ -234,7 +234,42 @@ export type LevelLoadOptions = {
      * - (glTF/GLB only) world Y the ground shadows land on
      */
     shadowGroundY?: number;
+    /**
+     * - (glTF/GLB only) how dark the blobs are ({@link Mesh#shadowOpacity})
+     */
+    shadowOpacity?: number;
+    /**
+     * - (glTF/GLB only) blob footprint multiplier ({@link Mesh#shadowScale})
+     */
+    shadowScale?: number;
+    /**
+     * - (glTF/GLB only) how far to slide them along the light, in blob radii ({@link Mesh#shadowOffset})
+     */
+    shadowOffset?: number;
+    /**
+     * - (glTF/GLB only) how much longer they are along it ({@link Mesh#shadowStretch})
+     */
+    shadowStretch?: number;
+    /**
+     * - (glTF/GLB only) x of the ground direction they are cast along
+     */
+    shadowDirectionX?: number;
+    /**
+     * - (glTF/GLB only) z of that direction
+     */
+    shadowDirectionZ?: number;
+    /**
+     * - (glTF/GLB only) up normal of the floor, for a scene that is not level
+     */
+    shadowGroundNormal?: number[] | Vector3d;
+    /**
+     * - (glTF/GLB only) a {@link Light3d} to take the shadow direction from, re-read every draw
+     */
+    shadowLight?: Light3d;
 };
 import TMXTileMap from "./tiled/TMXTileMap.js";
 import GLTFScene from "./gltf/GLTFScene.js";
+import type Container from "../renderable/container.js";
+import type { Vector3d } from "../math/vector3d.ts";
+import type { Light3d } from "../lighting/light3d.ts";
 //# sourceMappingURL=level.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":"AAqGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,iCALU,aAAa,CAAC,MAAM,CAAC,CAY5B;;IAQF;;;;;;;OAOG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CAkCnB;;;;;;;;;;;;;;;;;;;IAUE,uBACQ,MAAM,WACN,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBA,uBACQ,MAAM;gBACuB,KAAK;qBAChC,OAAO,CACjB;IA4FH;;;;OAIG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,4BAFa,UAAU,GAAC,SAAS,CAIhC;;;;;;;;;;;IAKE,yBACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;IASA;gBACqC,KAAK;qBAChC,OAAO,CACjB;;;;;;;;;;;;;;;IAoBA,uBACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;IAaA;gBACqC,KAAK;qBAChC,OAAO,CACjB;;;;;;;;;;;;;;;IAsBA,2BACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;IAaA;gBACqC,KAAK;qBAChC,OAAO,CACjB;IAeH;;;;OAIG;IACH,uBAFa,MAAM,CAIlB;;;;;;;;;;;;;;;;;;;;gBAlWY,SAAS;;;;;;;;YAET,OAAO;;;;cACP,OAAO;;;;wBACP,OAAO;;;;YACP,MAAM;;;;kBACN,OAAO;;;;aACP,OAAO;;;;0BACP,MAAM;;;;uBACN,OAAO;;;;oBACP,MAAM;;uBAtHG,uBAAuB;sBADxB,qBAAqB"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../src/level/level.js"],"names":[],"mappings":"AA4GA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,iCALU,aAAa,CAAC,MAAM,CAAC,CAY5B;;IAQF;;;;;;;OAOG;IACH,qBALW,MAAM,WACN,MAAM,wBAEJ,OAAO,CAkCnB;;;;;;;;;;;;;;;;;;;IAUE,uBACQ,MAAM,WACN,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAiBA,uBACQ,MAAM;gBACuB,KAAK;qBAChC,OAAO,CACjB;IA4FH;;;;OAIG;IACH,8BAFa,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,4BAFa,UAAU,GAAC,SAAS,CAIhC;;;;;;;;;;;IAKE,yBACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;IASA;gBACqC,KAAK;qBAChC,OAAO,CACjB;;;;;;;;;;;;;;;IAoBA,uBACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;IAaA;gBACqC,KAAK;qBAChC,OAAO,CACjB;;;;;;;;;;;;;;;IAsBA,2BACQ,gBAAgB,GAAG;QAAE,KAAK,EAAE,IAAI,CAAA;KAAE,GAChC,OAAO,CAAC,OAAO,CAAC,CAC1B;;;;;;;;;;;;;;;IAaA;gBACqC,KAAK;qBAChC,OAAO,CACjB;IAeH;;;;OAIG;IACH,uBAFa,MAAM,CAIlB;;;;;;;;;;;;;;;;;;;;gBA1WY,SAAS;;;;;;;;YAET,OAAO;;;;cACP,OAAO;;;;wBACP,OAAO;;;;YACP,MAAM;;;;kBACN,OAAO;;;;aACP,OAAO;;;;0BACP,MAAM;;;;uBACN,OAAO;;;;oBACP,MAAM;;;;oBACN,MAAM;;;;kBACN,MAAM;;;;mBACN,MAAM;;;;oBACN,MAAM;;;;uBACN,MAAM;;;;uBACN,MAAM;;;;yBACN,MAAM,EAAE,GAAC,QAAQ;;;;kBACjB,OAAO;;uBArIE,uBAAuB;sBADxB,qBAAqB;2BAKjB,4BAA4B;8BAG3B,qBAAqB;6BADtB,wBAAwB"}

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

@@ -34,7 +34,7 @@ export default class TMXLayer extends Renderable {
      * @type {TMXTilesetGroup}
      */
     tilesets: TMXTilesetGroup;
-    tileset: any;
+    tileset: TMXTileset | null;
     maxTileSize: {
         width: number;
         height: number;
@@ -111,7 +111,7 @@ export default class TMXLayer extends Renderable {
      * layer.setRenderer(map.getRenderer());
      */
     setRenderer(renderer: TMXRenderer): void;
-    renderer: any;
+    renderer: TMXRenderer | undefined;
     /**
      * Return the layer current renderer object
      * @returns {TMXRenderer} renderer
@@ -176,6 +176,9 @@ export default class TMXLayer extends Renderable {
     clearTile(x: number, y: number): void;
 }
 import Renderable from "../../renderable/renderable.js";
+import type TMXTilesetGroup from "./TMXTilesetGroup.js";
+import type TMXTileset from "./TMXTileset.js";
 import Tile from "./TMXTile.js";
 import CanvasRenderer from "../../video/canvas/canvas_renderer";
+import type TMXRenderer from "./renderer/TMXRenderer.js";
 //# sourceMappingURL=TMXLayer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TMXLayer.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXLayer.js"],"names":[],"mappings":"AAuHA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,iBARW,MAAM,QACN,MAAM,aACN,MAAM,cACN,MAAM,eACN,MAAM,YACN,eAAe,KACf,MAAM,EA6LhB;IAtLA,eAA4C;IAC5C,gBAA+C;IAG/C,oBAA8B;IAE9B;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,UAFU,eAAe,CAED;IAGxB,aAAwE;IAGxE;;;MAGC;IAaD;;;OAGG;IACH,kBAFU,UAAU,EAAE,CAEI;IAE1B;;;OAGG;IACH,YAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,OAFU,MAAM,CAEO;IASvB,UAAqB;IACrB,aAAuB;IACvB,aAAwB;IA8BxB;;;;;;;;;OASG;IACH,WAFU,WAAW,CAEsC;IAE3D;;;;;;;;;;;;OAYG;IACH,YAJU,KAAK,CAAC,IAAI,GAAC,IAAI,CAAC,GAAC,IAAI,CAIT;IAEtB;;;;;OAKG;IACH,aAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;;;;OAcG;IACH,YAHU,MAAM,CAGQ;IAwBzB,wBAkCC;IAfC,2CAKE;IAOH,+BAAgD;IAKjD;;;;;;;;OAQG;IACH,2BAkEC;IAED;;;;;;;OAOG;IACH,kCANW,MAAM,cACN,OAAO,GACL;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,CAgD1C;IAGD,0BAOC;IAED;;;;;;;OAOG;IACH,sBANW,WAAW,QASrB;IAFA,cAAwB;IAIzB;;;OAGG;IACH,eAFa,WAAW,CAIvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;OAUG;IACH,WATW,MAAM,KACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;;OAMG;IACH,cALW,IAAI,KACJ,MAAM,KACN,MAAM,GACJ,IAAI,CAgChB;IAnBC;;;OAGG;IACH,uCAA6B;IAiB/B;;;;;;OAMG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;;;;;OASG;IACH,UARW,MAAM,KACN,MAAM,gBACN,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,QA8BhB;IAED;;;;OAIG;IACH,yBAQC;IAED;;;;OAIG;IACH,qCAIC;CACD;uBAptBsB,gCAAgC;iBAStC,cAAc;2BARJ,oCAAoC"}
+{"version":3,"file":"TMXLayer.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXLayer.js"],"names":[],"mappings":"AA6HA;;;;GAIG;AACH;IACC;;;;;;;;OAQG;IACH,iBARW,MAAM,QACN,MAAM,aACN,MAAM,cACN,MAAM,eACN,MAAM,YACN,eAAe,KACf,MAAM,EA6LhB;IAtLA,eAA4C;IAC5C,gBAA+C;IAG/C,oBAA8B;IAE9B;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,UAFU,eAAe,CAED;IAGxB,2BAAwE;IAGxE;;;MAGC;IAaD;;;OAGG;IACH,kBAFU,UAAU,EAAE,CAEI;IAE1B;;;OAGG;IACH,YAFU,OAAO,CAEM;IAEvB;;;;;OAKG;IACH,aAHU,MAAM,CAGmC;IAEnD;;;OAGG;IACH,OAFU,MAAM,CAEO;IASvB,UAAqB;IACrB,aAAuB;IACvB,aAAwB;IA8BxB;;;;;;;;;OASG;IACH,WAFU,WAAW,CAEsC;IAE3D;;;;;;;;;;;;OAYG;IACH,YAJU,KAAK,CAAC,IAAI,GAAC,IAAI,CAAC,GAAC,IAAI,CAIT;IAEtB;;;;;OAKG;IACH,aAFU,MAAM,CAEI;IAEpB;;;;;;;;;;;;;;OAcG;IACH,YAHU,MAAM,CAGQ;IAwBzB,wBAkCC;IAfC,2CAKE;IAOH,+BAAgD;IAKjD;;;;;;;;OAQG;IACH,2BAkEC;IAED;;;;;;;OAOG;IACH,kCANW,MAAM,cACN,OAAO,GACL;QAAC,EAAE,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAC,CAgD1C;IAGD,0BAOC;IAED;;;;;;;OAOG;IACH,sBANW,WAAW,QASrB;IAFA,kCAAwB;IAIzB;;;OAGG;IACH,eAFa,WAAW,CAIvB;IAED;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;OAUG;IACH,WATW,MAAM,KACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;;OAMG;IACH,cALW,IAAI,KACJ,MAAM,KACN,MAAM,GACJ,IAAI,CAgChB;IAnBC;;;OAGG;IACH,uCAA6B;IAiB/B;;;;;;OAMG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;IAED;;;;;;;;;OASG;IACH,UARW,MAAM,KACN,MAAM,gBACN,MAAM,GACJ,IAAI,CA6ChB;IAED;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,QA8BhB;IAED;;;;OAIG;IACH,yBAQC;IAED;;;;OAIG;IACH,qCAIC;CACD;uBA1tBsB,gCAAgC;iCAgBvB,sBAAsB;4BAD3B,iBAAiB;iBAN3B,cAAc;2BARJ,oCAAoC;6BAanC,2BAA2B"}

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

@@ -1,3 +1,2 @@
 
-import Tile from "./TMXTile.js";
 //# sourceMappingURL=TMXObject.d.ts.map

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/TMXTile.d.ts

@@ -58,6 +58,7 @@ export default class Tile extends Bounds {
      */
     getRenderable(settings?: object): Renderable;
 }
-import { Matrix2d } from "../../math/matrix2d.ts";
 import { Bounds } from "../../physics/bounds.ts";
+import type TMXTileset from "./TMXTileset.js";
+import type Renderable from "../../renderable/renderable.js";
 //# sourceMappingURL=TMXTile.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TMXTile.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTile.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;GAiBG;AACH,8CARW,QAAQ,YACR,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,CAyBpB;AAED;;;GAGG;AACH;IACC;;;;;OAKG;IACH,eALW,MAAM,KACN,MAAM,OACN,MAAM,WACN,UAAU,EAmFpB;IAhEA;;;OAGG;IACH,SAFU,UAAU,CAEE;IAEtB;;;;;OAKG;IACH,kBAJU,QAAQ,GAAC,IAAI,CAIK;IAE5B;;;OAGG;IACH,KAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,KAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,UAFU,OAAO,CAE+B;IAEhD;;;OAGG;IACH,UAFU,OAAO,CAE+B;IAEhD;;;OAGG;IACH,WAFU,OAAO,CAEiC;IAElD;;;OAGG;IACH,SAFU,OAAO,CAE8C;IAYhE;;;;;OAKG;IACH,4BAJW,QAAQ,QAoBlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,UAAU,CAmDtB;CACD;yBArOwB,wBAAwB;uBAC1B,yBAAyB"}
+{"version":3,"file":"TMXTile.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTile.js"],"names":[],"mappings":"AAsBA;;;;;;;;;;;;;;;;;GAiBG;AACH,8CARW,QAAQ,YACR,MAAM,SACN,MAAM,UACN,MAAM,GACJ,QAAQ,CAyBpB;AAED;;;GAGG;AACH;IACC;;;;;OAKG;IACH,eALW,MAAM,KACN,MAAM,OACN,MAAM,WACN,UAAU,EAmFpB;IAhEA;;;OAGG;IACH,SAFU,UAAU,CAEE;IAEtB;;;;;OAKG;IACH,kBAJU,QAAQ,GAAC,IAAI,CAIK;IAE5B;;;OAGG;IACH,KAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,KAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,UAFU,OAAO,CAE+B;IAEhD;;;OAGG;IACH,UAFU,OAAO,CAE+B;IAEhD;;;OAGG;IACH,WAFU,OAAO,CAEiC;IAElD;;;OAGG;IACH,SAFU,OAAO,CAE8C;IAYhE;;;;;OAKG;IACH,4BAJW,QAAQ,QAoBlB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GACJ,UAAU,CAmDtB;CACD;yBA3OwB,wBAAwB;uBAC1B,yBAAyB;4BAMrB,iBAAiB;4BADjB,gCAAgC"}

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

@@ -98,9 +98,9 @@ export default class TMXTileMap {
     hexsidelength: number;
     staggeraxis: any;
     staggerindex: any;
-    bounds: any;
-    width: any;
-    height: any;
+    bounds: Bounds;
+    width: number;
+    height: number;
     backgroundcolor: any;
     initialized: boolean;
     /**
@@ -108,7 +108,7 @@ export default class TMXTileMap {
      * @returns {TMXRenderer} a TMX renderer
      */
     getRenderer(): TMXRenderer;
-    renderer: import("./renderer/TMXHexagonalRenderer.js").default | import("./renderer/TMXIsometricRenderer.js").default | import("./renderer/TMXOrthogonalRenderer.js").default | import("./renderer/TMXObliqueRenderer.js").default | undefined;
+    renderer: import("./renderer/TMXHexagonalRenderer.js").default | import("./renderer/TMXIsometricRenderer.js").default | import("./renderer/TMXOrthogonalRenderer.js").default | undefined;
     /**
      * return the map bounding rect
      * @returns {Bounds}
@@ -149,6 +149,9 @@ export default class TMXTileMap {
     destroy(): void;
 }
 import TMXTilesetGroup from "./TMXTilesetGroup.js";
+import type { Bounds } from "../../physics/bounds.ts";
+import type TMXRenderer from "./renderer/TMXRenderer.js";
 import Container from "../../renderable/container.js";
+import type Renderable from "../../renderable/renderable.js";
 import TMXLayer from "./TMXLayer.js";
 //# sourceMappingURL=TMXTileMap.d.ts.map

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":"AA2IA;;;;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,YAAoD;IAGpD,WAA8B;IAC9B,YAAgC;IAGhC,qBAA2C;IAwB3C,qBAAwB;IAGzB;;;OAGG;IACH,eAFa,WAAW,CAUvB;IAHC,+OAAuC;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;4BAhnB2B,sBAAsB;sBAV5B,+BAA+B;qBAOhC,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/TMXTileset.d.ts

@@ -84,7 +84,7 @@ export default class TMXTileset {
      * @type {Map}
      */
     private animations;
-    image: any;
+    image: HTMLImageElement | import("../../loader/parsers/compressed_textures/compressed_image.js").CompressedImage | null | undefined;
     texture: any;
     atlas: any;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"TMXTileset.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTileset.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IACC;;;;OAIG;IACH,qBAJY,MAAM,iBACN,MAAM,kBACN,MAAM,EAqPjB;IAlPA;;;;;OAKG;IACH,gBAJU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAIE;IAE/B;;;;;OAKG;IACH,iBAJU,GAAG,CAAC,MAAM,EAAE,gBAAgB,GAAC,iBAAiB,CAAC,CAIzB;IAEhC;;;OAGG;IACH,UAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,SAFU,MAAM,CAEY;IAe5B;;;OAGG;IACH,MAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,WAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,YAFU,MAAM,CAEqB;IAErC;;;;OAIG;IACH,SAHU,MAAM,CAGsB;IAEtC;;;;OAIG;IACH,QAHU,MAAM,CAGoB;IAEpC;;;OAGG;IACH,YAFU,QAAQ,CAEc;IAEhC;;;OAGG;IACH,YAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,cAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,OAFU,MAAM,CAE0B;IAE1C;;;;OAIG;IACH,gBAHU,MAAM,CAGsC;IAEtD;;;;OAIG;IACH,UAHU,MAAM,CAG6B;IAE7C;;;;;OAKG;IACH,cAJU,MAAM,CAIkC;IAElD;;;;;OAKG;IACH,eAJU,MAAM,CAIqC;IAErD;;;;;OAKG;IACH,sBAAsB;IACtB;;;OAGG;IACH,sBAAsB;IACtB;;;OAGG;IACH,kBAA+B;IAC/B;;;OAGG;IACH,kBAAgC;IAChC;;;OAGG;IACH,wBAAwB;IACxB;;;OAGG;IACH,wBAAwB;IACxB;;;OAGG;IACH,wBAAwB;IAsBxB;;;;;OAKG;IACH,cAJU,GAAG,CAAC,MAAM,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAI/C;IAE7B;;;;OAIG;IACH,mBAA2B;IAE3B;;;;;OAKG;IACH,oBAAoB;IAsCrB;;;;;;;;;;;OAWG;IACH,4CAgEC;IAED;;;;;OAKG;IACH,oBAJW,MAAM,EAAE,GAAC,MAAM,QA4GzB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,QA2ChB;IArCA,WAAoC;IASpC,aAKE;IACF,WAAoC;IAwBrC;;;;OAIG;IACH,kBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,SAAS,CAIxD;IAED;;;;;;OAMG;IACH,qBALW,MAAM,QACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;OAMG;IACH,WALW,MAAM,GACJ,OAAO,CAyBnB;IAED;;;;;;;;OAQG;IACH,mBAPW,cAAc,GAAC,aAAa,MAC5B,MAAM,MACN,MAAM,WACN,IAAI,QAsFd;IAED;;;;;;;;;;;;;;OAcG;IACH,sBARW,cAAc,GAAC,aAAa,MAC5B,MAAM,MACN,MAAM,OACN,MAAM,YACN,MAAM,QAgGhB;CACD;yBArxBwB,wBAAwB"}
+{"version":3,"file":"TMXTileset.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTileset.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IACC;;;;OAIG;IACH,qBAJY,MAAM,iBACN,MAAM,kBACN,MAAM,EAqPjB;IAlPA;;;;;OAKG;IACH,gBAJU,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAIE;IAE/B;;;;;OAKG;IACH,iBAJU,GAAG,CAAC,MAAM,EAAE,gBAAgB,GAAC,iBAAiB,CAAC,CAIzB;IAEhC;;;OAGG;IACH,UAFU,MAAM,CAEiB;IAEjC;;;OAGG;IACH,SAFU,MAAM,CAEY;IAe5B;;;OAGG;IACH,MAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,WAFU,MAAM,CAEmB;IAEnC;;;OAGG;IACH,YAFU,MAAM,CAEqB;IAErC;;;;OAIG;IACH,SAHU,MAAM,CAGsB;IAEtC;;;;OAIG;IACH,QAHU,MAAM,CAGoB;IAEpC;;;OAGG;IACH,YAFU,QAAQ,CAEc;IAEhC;;;OAGG;IACH,YAFU,OAAO,CAEM;IAEvB;;;OAGG;IACH,cAFU,OAAO,CAEQ;IAEzB;;;OAGG;IACH,OAFU,MAAM,CAE0B;IAE1C;;;;OAIG;IACH,gBAHU,MAAM,CAGsC;IAEtD;;;;OAIG;IACH,UAHU,MAAM,CAG6B;IAE7C;;;;;OAKG;IACH,cAJU,MAAM,CAIkC;IAElD;;;;;OAKG;IACH,eAJU,MAAM,CAIqC;IAErD;;;;;OAKG;IACH,sBAAsB;IACtB;;;OAGG;IACH,sBAAsB;IACtB;;;OAGG;IACH,kBAA+B;IAC/B;;;OAGG;IACH,kBAAgC;IAChC;;;OAGG;IACH,wBAAwB;IACxB;;;OAGG;IACH,wBAAwB;IACxB;;;OAGG;IACH,wBAAwB;IAsBxB;;;;;OAKG;IACH,cAJU,GAAG,CAAC,MAAM,EAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAI/C;IAE7B;;;;OAIG;IACH,mBAA2B;IAE3B;;;;;OAKG;IACH,oBAAoB;IAsCrB;;;;;;;;;;;OAWG;IACH,4CAgEC;IAED;;;;;OAKG;IACH,oBAJW,MAAM,EAAE,GAAC,MAAM,QA4GzB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,QA2ChB;IArCA,oIAAoC;IASpC,aAKE;IACF,WAAoC;IAwBrC;;;;OAIG;IACH,kBAHW,MAAM,GACJ,gBAAgB,GAAC,iBAAiB,GAAC,SAAS,CAIxD;IAED;;;;;;OAMG;IACH,qBALW,MAAM,QACN,MAAM,QAMhB;IAED;;;;OAIG;IACH,cAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,MAAM,CAYlB;IAED;;;;OAIG;IACH,0BAHW,MAAM,GACJ,MAAM,GAAC,SAAS,CAI5B;IAED;;;;;;OAMG;IACH,WALW,MAAM,GACJ,OAAO,CAyBnB;IAED;;;;;;;;OAQG;IACH,mBAPW,QAAQ,MACR,MAAM,MACN,MAAM,WACN,IAAI,QAsFd;IAED;;;;;;;;;;;;;;OAcG;IACH,sBARW,QAAQ,MACR,MAAM,MACN,MAAM,OACN,MAAM,YACN,MAAM,QAgGhB;CACD;yBArxBwB,wBAAwB"}

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

@@ -1,3 +1,7 @@
+/**
+ * additional import for TypeScript
+ * @import TMXTileset from "./TMXTileset.js";
+ */
 /**
  * an object containing all tileset
  */
@@ -23,4 +27,5 @@ export default class TMXTilesetGroup {
      */
     getTilesetByGid(gid: number): TMXTileset;
 }
+import type TMXTileset from "./TMXTileset.js";
 //# sourceMappingURL=TMXTilesetGroup.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TMXTilesetGroup.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTilesetGroup.js"],"names":[],"mappings":"AAEA;;GAEG;AACH;IAEE,gBAAkB;IAClB,eAAe;IAEf;;;OAGG;IACH,kBAAwB;IAGzB;;;OAGG;IACH,aAFW,UAAU,QAKpB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,UAAU,CAItB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,UAAU,CAmCtB;CACD"}
+{"version":3,"file":"TMXTilesetGroup.d.ts","sourceRoot":"","sources":["../../../src/level/tiled/TMXTilesetGroup.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;;GAEG;AACH;IAEE,gBAAkB;IAClB,eAAe;IAEf;;;OAGG;IACH,kBAAwB;IAGzB;;;OAGG;IACH,aAFW,UAAU,QAKpB;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,UAAU,CAItB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,UAAU,CAmCtB;CACD;4BA3E0B,iBAAiB"}

package/build/level/tiled/factories/shape.d.ts

@@ -1,3 +1,2 @@
 
-import Renderable from "../../../renderable/renderable.js";
 //# sourceMappingURL=shape.d.ts.map

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

@@ -7,17 +7,18 @@ export default class TMXHexagonalRenderer extends TMXRenderer {
      * @param {TMXTileMap} map - the TMX map
      */
     constructor(map: TMXTileMap);
-    hexsidelength: any;
+    hexsidelength: number;
     staggerX: boolean;
     staggerEven: boolean;
-    sidelengthx: any;
-    sidelengthy: any;
+    sidelengthx: number;
+    sidelengthy: number;
     sideoffsetx: number;
     sideoffsety: number;
-    columnwidth: any;
-    rowheight: any;
+    columnwidth: number;
+    rowheight: number;
     centers: Vector2d[];
 }
 import TMXRenderer from "./TMXRenderer.js";
 import { Vector2d } from "../../../math/vector2d.ts";
+import type TMXTileMap from "../TMXTileMap.js";
 //# sourceMappingURL=TMXHexagonalRenderer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"TMXHexagonalRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXHexagonalRenderer.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAgCpB;IA3BA,mBAA2C;IAC3C,kBAAuC;IACvC,qBAA8C;IAE9C,iBAAoB;IACpB,iBAAoB;IAUpB,oBAA0D;IAC1D,oBAA2D;IAE3D,iBAAsD;IACtD,eAAoD;IAEpD,oBAKC;IAGF;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,0DA0BC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAiBC;IAED;;;OAGG;IACH,sCAiBC;IAED;;;OAGG;IACH,wCAiBC;IAED;;;OAGG;IACH,yCAiBC;IAED;;;;OAIG;IACH,+CAqFC;IAED;;;;OAIG;IACH,+CAoBC;IAED;;;;OAIG;IACH,4DAaC;IAED;;;;;OAKG;IACH,wFAYC;IAED;;;;OAIG;IACH,0DAoKC;CACD;wBAvhBuB,kBAAkB;yBAHH,2BAA2B"}
+{"version":3,"file":"TMXHexagonalRenderer.d.ts","sourceRoot":"","sources":["../../../../src/level/tiled/renderer/TMXHexagonalRenderer.js"],"names":[],"mappings":"AAuBA;;;GAGG;AACH;IACC;;OAEG;IACH,iBAFW,UAAU,EAgCpB;IA3BA,sBAA2C;IAC3C,kBAAuC;IACvC,qBAA8C;IAE9C,oBAAoB;IACpB,oBAAoB;IAUpB,oBAA0D;IAC1D,oBAA2D;IAE3D,oBAAsD;IACtD,kBAAoD;IAEpD,oBAKC;IAGF;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,0DA0BC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,qCAiBC;IAED;;;OAGG;IACH,sCAiBC;IAED;;;OAGG;IACH,wCAiBC;IAED;;;OAGG;IACH,yCAiBC;IAED;;;;OAIG;IACH,+CAqFC;IAED;;;;OAIG;IACH,+CAoBC;IAED;;;;OAIG;IACH,4DAaC;IAED;;;;;OAKG;IACH,wFAYC;IAED;;;;OAIG;IACH,0DAoKC;CACD;wBA3hBuB,kBAAkB;yBAHH,2BAA2B;4BAOvC,kBAAkB"}