melonjs 18.3.0 → 19.1.0

package/build/renderable/mesh.d.ts

@@ -0,0 +1,147 @@
+/**
+ * A renderable object for displaying textured triangle meshes.
+ * Supports loading from Wavefront OBJ models (via `loader.preload` with type "obj")
+ * or from raw geometry data (vertices, uvs, indices).
+ * Includes a built-in perspective projection and supports 3D transforms
+ * through the standard Renderable API (`rotate`, `scale`, `translate`).
+ * Works on both WebGL (hardware depth testing) and Canvas (painter's algorithm) renderers.
+ * @category Game Objects
+ */
+export default class Mesh extends Renderable {
+    /**
+     * @param {number} x - the x screen position of the mesh object
+     * @param {number} y - the y screen position of the mesh object
+     * @param {object} settings - Configuration parameters for the Mesh object
+     * @param {string} [settings.model] - name of a preloaded OBJ model (via loader.preload with type "obj")
+     * @param {Float32Array|number[]} [settings.vertices] - vertex positions as x,y,z triplets (alternative to settings.model)
+     * @param {Float32Array|number[]} [settings.uvs] - texture coordinates as u,v pairs (alternative to settings.model)
+     * @param {Uint16Array|number[]} [settings.indices] - triangle vertex indices (alternative to settings.model)
+     * @param {HTMLImageElement|TextureAtlas|string} [settings.texture] - the texture to apply (image name, HTMLImageElement, or TextureAtlas). If omitted and settings.material is provided, the texture is resolved from the MTL material's map_Kd.
+     * @param {string} [settings.material] - name of a preloaded MTL material (via loader.preload with type "mtl"). When provided, the diffuse texture (map_Kd), tint color (Kd), and opacity (d) are automatically applied.
+     * @param {number} settings.width - display width in pixels (the 3D model is normalized and scaled to fit this size)
+     * @param {number} settings.height - display height in pixels (the 3D model is normalized and scaled to fit this size)
+     * @param {boolean} [settings.cullBackFaces=true] - enable backface culling
+     * @example
+     * // create from OBJ + MTL (texture auto-resolved from material)
+     * let mesh = new me.Mesh(0, 0, {
+     *     model: "fox",
+     *     material: "fox",
+     *     width: 200,
+     *     height: 200,
+     * });
+     *
+     * // create from OBJ with explicit texture (no MTL needed)
+     * let mesh = new me.Mesh(0, 0, {
+     *     model: "cube",
+     *     texture: "cube_texture",
+     *     width: 200,
+     *     height: 200,
+     * });
+     *
+     * // 3D rotation using the standard rotate() API
+     * mesh.rotate(Math.PI / 4, new me.Vector3d(0, 1, 0)); // rotate around Y axis
+     *
+     * // 2D rotation (Z axis, same as Sprite)
+     * mesh.rotate(Math.PI / 4);
+     */
+    constructor(x: number, y: number, settings: {
+        model?: string | undefined;
+        vertices?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        uvs?: number[] | Float32Array<ArrayBufferLike> | undefined;
+        indices?: number[] | Uint16Array<ArrayBufferLike> | undefined;
+        texture?: string | HTMLImageElement | TextureAtlas | undefined;
+        material?: string | undefined;
+        width: number;
+        height: number;
+        cullBackFaces?: boolean | undefined;
+    });
+    /**
+     * the original (untransformed) vertex positions as x,y,z triplets
+     * @type {Float32Array}
+     */
+    originalVertices: Float32Array;
+    /**
+     * texture coordinates as u,v pairs
+     * @type {Float32Array}
+     */
+    uvs: Float32Array;
+    /**
+     * number of vertices
+     * @type {number}
+     */
+    vertexCount: number;
+    /**
+     * the projected vertex positions, updated each draw call
+     * @type {Float32Array}
+     */
+    vertices: Float32Array;
+    /**
+     * whether to cull back-facing triangles
+     * @type {boolean}
+     * @default true
+     */
+    cullBackFaces: boolean;
+    /**
+     * the texture atlas used by this mesh
+     * @type {TextureAtlas}
+     */
+    texture: TextureAtlas;
+    /**
+     * Projection matrix applied automatically before the model transform in draw().
+     * Defaults to a perspective projection (45° FOV, camera at z=-2.5) suitable for
+     * viewing unit-cube-sized geometry. Set to identity for orthographic (flat) projection.
+     * Most users don't need to modify this — the default works for standard OBJ models.
+     * @type {Matrix3d}
+     */
+    projectionMatrix: Matrix3d;
+    /** @ignore */
+    _hullPoints: Vector2d[];
+    /** @ignore */
+    _hullPolygon: Polygon | null;
+    /**
+     * Project all vertices through projectionMatrix × currentTransform
+     * and store the results in `this.vertices`.
+     * @param {number} [offsetX=0] - x offset added to each projected vertex
+     * @param {number} [offsetY=0] - y offset added to each projected vertex
+     * @param {number} [zScale=0] - scale factor for Z output (0 = skip Z, 1000 = depth buffer range)
+     * @ignore
+     */
+    _projectVertices(offsetX?: number, offsetY?: number, zScale?: number): void;
+    /**
+     * Draw the mesh (automatically called by melonJS).
+     * Projects vertices through projectionMatrix × currentTransform and calls renderer.drawMesh().
+     * @param {CanvasRenderer|WebGLRenderer} renderer - a renderer instance
+     */
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
+    /**
+     * Render the mesh at its current state (transforms, projection, tint) to an offscreen canvas.
+     * The returned canvas can be used with `renderer.drawImage()`, as a `Sprite` image source,
+     * or converted to an ImageBitmap via `createImageBitmap()`.
+     * @returns {HTMLCanvasElement} an offscreen canvas containing the rendered mesh
+     * @example
+     * // snapshot the mesh and create a Sprite from it
+     * const canvas = mesh.toCanvas();
+     * const sprite = new me.Sprite(100, 100, { image: canvas });
+     *
+     * // or draw directly
+     * renderer.drawImage(mesh.toCanvas(), 100, 100);
+     */
+    toCanvas(): HTMLCanvasElement;
+    /**
+     * Render the mesh at its current state to an ImageBitmap.
+     * Useful for creating textures or sprites from the rendered mesh.
+     * @returns {Promise<ImageBitmap>} a promise that resolves to an ImageBitmap of the rendered mesh
+     * @example
+     * const bitmap = await mesh.toImageBitmap();
+     * const sprite = new me.Sprite(100, 100, { image: bitmap });
+     */
+    toImageBitmap(): Promise<ImageBitmap>;
+}
+import Renderable from "./renderable.js";
+import { TextureAtlas } from "./../video/texture/atlas.js";
+import { Matrix3d } from "../math/matrix3d.ts";
+import { Vector2d } from "../math/vector2d.ts";
+import { Polygon } from "../geometries/polygon.ts";
+import type CanvasRenderer from "./../video/canvas/canvas_renderer.js";
+import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
+//# sourceMappingURL=mesh.d.ts.map

package/build/renderable/mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh.d.ts","sourceRoot":"","sources":["../../src/renderable/mesh.js"],"names":[],"mappings":"AAsBA;;;;;;;;GAQG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,eAnCW,MAAM,KACN,MAAM,YAEd;QAA0B,KAAK;QACU,QAAQ;QACR,GAAG;QACJ,OAAO;QACS,OAAO;QACrC,QAAQ;QACT,KAAK,EAAtB,MAAM;QACW,MAAM,EAAvB,MAAM;QACa,aAAa;KACxC,EAqKF;IArIC;;;OAGG;IACH,kBAFU,YAAY,CAEkB;IAExC;;;OAGG;IACH,KAFU,YAAY,CAEA;IAQtB;;;OAGG;IACH,aAFU,MAAM,CAEsB;IAkBvC;;;OAGG;IACH,UAFU,YAAY,CAEgC;IAEtD;;;;OAIG;IACH,eAHU,OAAO,CAIoD;IAgCpE;;;OAGG;IACH,SAFU,YAAY,CAEM;IAiB7B;;;;;;OAMG;IACH,kBAFU,QAAQ,CAEoB;IAetC,cAAc;IACd,wBAEE;IACF,cAAc;IACd,6BAAwB;IAGzB;;;;;;;OAOG;IACH,2BALW,MAAM,YACN,MAAM,WACN,MAAM,QAiBhB;IAED;;;;OAIG;IACH,eAFW,cAAc,GAAC,aAAa,QAKtC;IAyBD;;;;;;;;;;;;OAYG;IACH,YATa,iBAAiB,CAoH7B;IAED;;;;;;;OAOG;IACH,iBALa,OAAO,CAAC,WAAW,CAAC,CAOhC;CACD;uBAvYsB,iBAAiB;6BADX,6BAA6B;yBAPjC,qBAAqB;yBACrB,qBAAqB;wBAHtB,0BAA0B;gCAcnB,sCAAsC;+BACvC,oCAAoC"}

package/build/renderable/renderable.d.ts

@@ -1,6 +1,6 @@
 /**
  * additional import for TypeScript
- * @import {Matrix2d} from "../math/matrix2d.ts";
+ * @import {Matrix3d} from "../math/matrix3d.ts";
  * @import Entity from "./entity/entity.js";
  * @import Container from "./container.js";
  * @import {Line} from "./../geometries/line.ts";
@@ -31,10 +31,14 @@ export default class Renderable extends Rect {
      */
     anchorPoint: ObservablePoint;
     /**
-     * the renderable default transformation matrix
-     * @type {Matrix2d}
+     * the renderable transformation matrix (4x4).
+     * For standard 2D use, only the 2D components are used (rotate around Z, scale X/Y, translate X/Y).
+     * For 3D use (e.g. Mesh), the full 4x4 matrix supports rotation around any axis,
+     * 3D translation, and perspective projection.
+     * Use the `rotate()`, `scale()`, and `translate()` methods rather than modifying this directly.
+     * @type {Matrix3d}
      */
-    currentTransform: Matrix2d;
+    currentTransform: Matrix3d;
     /**
      * the renderable physic body
      * @type {Body}
@@ -182,13 +186,33 @@ export default class Renderable extends Rect {
     mask: Rect | RoundRect | Polygon | Line | Ellipse;
     /**
      * an optional shader, to be used instead of the default built-in one, when drawing this renderable (WebGL only).
-     * Use {@link ShaderEffect} for a simplified API that only requires a fragment `apply()` function,
-     * or {@link GLShader} for full control over vertex and fragment shaders.
+     * Use {@link ShaderEffect} for a custom fragment `apply()` function,
+     * or one of the built-in effect presets:
+     * - {@link FlashEffect} — flash the sprite with a solid color (hit feedback)
+     * - {@link OutlineEffect} — colored outline around the sprite (selection, hover)
+     * - {@link GlowEffect} — soft colored glow around the sprite (power-ups, magic)
+     * - {@link DesaturateEffect} — partial or full grayscale (disabled, death)
+     * - {@link PixelateEffect} — progressive pixelation (teleport, retro)
+     * - {@link BlurEffect} — box blur (defocus, backdrop)
+     * - {@link ChromaticAberrationEffect} — RGB channel offset (impact, glitch)
+     * - {@link DissolveEffect} — noise-based dissolve (death, spawn)
+     * - {@link DropShadowEffect} — offset shadow beneath the sprite
+     * - {@link ScanlineEffect} — horizontal scanlines with optional CRT curvature and vignette
+     * - {@link TintPulseEffect} — pulsing color overlay (poison, freeze, fire)
+     * - {@link WaveEffect} — sine wave distortion (underwater, heat haze)
+     * - {@link InvertEffect} — color inversion (negative image, X-ray)
+     * - {@link SepiaEffect} — warm vintage photo tone
+     * - {@link HologramEffect} — flickering holographic projection (sci-fi)
+     *
+     * Use {@link GLShader} for full control over vertex and fragment shaders.
      * In Canvas mode, this property is ignored.
      * @type {GLShader|ShaderEffect}
      * @default undefined
      * @example
-     * // grayscale effect — converts the sprite to black and white
+     * // apply a built-in effect
+     * mySprite.shader = new FlashEffect(renderer, { intensity: 1.0 });
+     * @example
+     * // custom shader effect
      * mySprite.shader = new ShaderEffect(renderer, `
      *     vec4 apply(vec4 color, vec2 uv) {
      *         float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
@@ -196,18 +220,6 @@ export default class Renderable extends Rect {
      *     }
      * `);
      * @example
-     * // pulsing brightness effect — makes the sprite glow rhythmically
-     * const effect = new ShaderEffect(renderer, `
-     *     uniform float uTime;
-     *     vec4 apply(vec4 color, vec2 uv) {
-     *         float pulse = 0.8 + 0.2 * sin(uTime * 3.0);
-     *         return vec4(color.rgb * pulse, color.a);
-     *     }
-     * `);
-     * mySprite.shader = effect;
-     * // update the uniform each frame
-     * effect.setUniform("uTime", time);
-     * @example
      * // to remove a custom shader
      * mySprite.shader = undefined;
      */
@@ -264,7 +276,7 @@ export default class Renderable extends Rect {
      * renderable cache tint value used by the getter/setter
      * @ignore
      */
-    _tint: Color;
+    _tint: import("../index.ts").Color;
     /**
      * returns the parent application (or game) to which this renderable is attached to
      * @return {Application} the parent application or undefined if not attached to any container/app
@@ -315,6 +327,11 @@ export default class Renderable extends Rect {
      * @type {boolean}
      */
     public get isFlippedY(): boolean;
+    /**
+     * returns the bounding box for this renderable
+     * @returns {Bounds} bounding box Rectangle object
+     */
+    getBounds(): Bounds;
     /**
      * get the renderable alpha channel value<br>
      * @returns {number} current opacity value between 0 and 1
@@ -327,14 +344,14 @@ export default class Renderable extends Rect {
     setOpacity(alpha: number): void;
     /**
      * flip the renderable on the horizontal axis (around the center of the renderable)
-     * @see Matrix2d#scaleX
+     * @see Matrix3d#scaleX
      * @param {boolean} [flip=true] - `true` to flip this renderable.
      * @returns {Renderable} Reference to this object for method chaining
      */
     flipX(flip?: boolean): Renderable;
     /**
      * flip the renderable on the vertical axis (around the center of the renderable)
-     * @see Matrix2d#scaleY
+     * @see Matrix3d#scaleY
      * @param {boolean} [flip=true] - `true` to flip this renderable.
      * @returns {Renderable} Reference to this object for method chaining
      */
@@ -342,10 +359,10 @@ export default class Renderable extends Rect {
     /**
      * multiply the renderable currentTransform with the given matrix
      * @see Renderable#currentTransform
-     * @param {Matrix2d} m - the transformation matrix
+     * @param {Matrix2d|Matrix3d} m - the transformation matrix
      * @returns {Renderable} Reference to this object for method chaining
      */
-    transform(m: Matrix2d): Renderable;
+    transform(m: Matrix2d | Matrix3d): Renderable;
     /**
      * return the angle to the specified target
      * @param {Renderable|Vector2d|Vector3d} target
@@ -366,11 +383,13 @@ export default class Renderable extends Rect {
     lookAt(target: Renderable | Vector2d | Vector3d): Renderable;
     /**
      * Rotate this renderable by the specified angle (in radians).
+     * When called with just an angle, rotates around the Z axis (2D rotation).
+     * When called with an angle and a Vector3d axis, rotates around that axis in 3D.
      * @param {number} angle - The angle to rotate (in radians)
-     * @param {Vector2d|ObservableVector2d} [v] - an optional point to rotate around
+     * @param {Vector3d} [v] - the axis to rotate around (defaults to Z axis for 2D)
      * @returns {Renderable} Reference to this object for method chaining
      */
-    rotate(angle: number, v?: Vector2d | ObservableVector2d): Renderable;
+    rotate(angle: number, v?: Vector3d): Renderable;
     /**
      * scale the renderable around his anchor point.  Scaling actually applies changes
      * to the currentTransform member which is used by the renderer to scale the object
@@ -379,15 +398,24 @@ export default class Renderable extends Rect {
      * member will be changed.
      * @param {number} x - a number representing the abscissa of the scaling vector.
      * @param {number} [y=x] - a number representing the ordinate of the scaling vector.
+     * @param {number} [z=1] - a number representing the depth of the scaling vector.
      * @returns {Renderable} Reference to this object for method chaining
      */
-    scale(x: number, y?: number): Renderable;
+    scale(x: number, y?: number, z?: number): Renderable;
     /**
      * scale the renderable around his anchor point
      * @param {Vector2d} v - scaling vector
      * @returns {Renderable} Reference to this object for method chaining
      */
     scaleV(v: Vector2d): Renderable;
+    /**
+     * Translate the renderable by the specified offset.
+     * @param {number} x - x offset
+     * @param {number} [y=0] - y offset
+     * @param {number} [z=0] - z offset
+     * @returns {Renderable} Reference to this object for method chaining
+     */
+    translate(x: number, y?: number, z?: number): Renderable;
     /**
      * update function (automatically called by melonJS).
      * @param {number} dt - time since the last update in milliseconds.
@@ -468,7 +496,7 @@ export default class Renderable extends Rect {
 }
 import { Rect } from "./../geometries/rectangle.ts";
 import { ObservablePoint } from "../geometries/observablePoint.ts";
-import type { Matrix2d } from "../math/matrix2d.ts";
+import { Matrix3d } from "../math/matrix3d.ts";
 import Body from "./../physics/body.js";
 import type Container from "./container.js";
 import type Entity from "./entity/entity.js";
@@ -476,9 +504,7 @@ import type { RoundRect } from "./../geometries/roundrect.ts";
 import type { Polygon } from "../geometries/polygon.ts";
 import type { Line } from "./../geometries/line.ts";
 import type { Ellipse } from "./../geometries/ellipse.ts";
-import { Color } from "./../math/color.ts";
 import type Application from "./../application/application.ts";
-import { Bounds } from "./../physics/bounds.ts";
 import type CanvasRenderer from "./../video/canvas/canvas_renderer.js";
 import type WebGLRenderer from "./../video/webgl/webgl_renderer.js";
 //# sourceMappingURL=renderable.d.ts.map

package/build/renderable/renderable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../src/renderable/renderable.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"renderable.d.ts","sourceRoot":"","sources":["../../src/renderable/renderable.js"],"names":[],"mappings":"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"}

package/build/renderable/sprite.d.ts

@@ -47,7 +47,7 @@ export default class Sprite extends Renderable {
      *     anchorPoint : new me.Vector2d(0.5, 0.5)
      * });
      * // scale the video sprite
-     * videoSprite.currentTransform.scale(2);
+     * videoSprite.scale(2);
      * // start playing the video (if video is preloaded with `autoplay` set to false)
      * videoSprite.play();
      */

package/build/renderable/text/bitmaptext.d.ts

@@ -119,12 +119,6 @@ export default class BitmapText extends Renderable {
      * @returns {BitmapText} this object for chaining
      */
     setText(value?: number | string | string[]): BitmapText;
-    /**
-     * update the bounding box for this Bitmap Text.
-     * @param {boolean} [absolute=true] - update the bounds size and position in (world) absolute coordinates
-     * @returns {Bounds} this Bitmap Text bounding box Rectangle object
-     */
-    updateBounds(absolute?: boolean): Bounds;
     /**
      * change the font display size
      * @param {number} scale - ratio
@@ -140,11 +134,8 @@ export default class BitmapText extends Renderable {
     /**
      * draw the bitmap font
      * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
-     * @param {string} [text]
-     * @param {number} [x]
-     * @param {number} [y]
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer, text?: string, x?: number, y?: number): void;
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
     /**
      * Destroy function
      * @ignore

package/build/renderable/text/bitmaptext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eA5BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EAsHF;IApGA;;;;;;OAMG;IACH,kBAHU,MAAM,CAG6B;IAE7C;;;;;;OAMG;IACH,qBAHU,MAAM,CAGkC;IAElD;;;;;;OAMG;IACH,mBAHU,MAAM,CAG4B;IAE5C;;;;;;OAMG;IACH,sBAHU,MAAM,CAGiC;IAEjD;;;OAGG;IACH,cAAe;IAEf;;;OAGG;IACH,kBAA2C;IAE3C;;;OAGG;IACH,kBAG2B;IAG1B;;;OAGG;IAEH,iBAAgE;IAgJlE,4BANU,KAAK,EAad;IAhBD;;;;;OAKG;IACH,wBAHU,KAAK,CAKd;IAnHA,qBAAoC;IAWrC;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAqBtB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,MAAM,CAgDlB;IAoBD;;;;OAIG;IACH,cAHW,MAAM,GACJ,UAAU,CAYtB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;;;;OAMG;IACH,eALW,cAAc,GAAC,aAAa,SAC5B,MAAM,MACN,MAAM,MACN,MAAM,QAyHhB;IAED;;;OAGG;IACH,gBAQC;CACD;uBAzasB,kBAAkB;sBAFnB,qBAAqB;wBAInB,kBAAkB"}
+{"version":3,"file":"bitmaptext.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptext.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eA5BW,MAAM,KACN,MAAM,YAEd;QAA+B,IAAI,EAA3B,MAAM,8DAAM;QACM,QAAQ;QACR,IAAI;QACE,SAAS;QACf,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EAsHF;IApGA;;;;;;OAMG;IACH,kBAHU,MAAM,CAG6B;IAE7C;;;;;;OAMG;IACH,qBAHU,MAAM,CAGkC;IAElD;;;;;;OAMG;IACH,mBAHU,MAAM,CAG4B;IAE5C;;;;;;OAMG;IACH,sBAHU,MAAM,CAGiC;IAEjD;;;OAGG;IACH,cAAe;IAEf;;;OAGG;IACH,kBAA2C;IAE3C;;;OAGG;IACH,kBAG2B;IAG1B;;;OAGG;IAEH,iBAAgE;IAgJlE,4BANU,KAAK,EAad;IAhBD;;;;;OAKG;IACH,wBAHU,KAAK,CAKd;IAnHA,qBAAoC;IAWrC;;;;;OAKG;IACH,eAJW,MAAM,UACN,MAAM,GACJ,UAAU,CAWtB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,UAAU,CAqBtB;IAyED;;;;OAIG;IACH,cAHW,MAAM,GACJ,UAAU,CAYtB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAwFtC;IAED;;;OAGG;IACH,gBAQC;CACD;uBArYsB,kBAAkB;sBAFnB,qBAAqB;wBAInB,kBAAkB"}

package/build/renderable/text/bitmaptextdata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bitmaptextdata.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptextdata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,YAAY,CAAC;AAgF/B;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IAClC,MAAM,EAAE,MAAM,CAAK;IACnB,QAAQ,EAAE,MAAM,CAAK;IACrB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,WAAW,EAAE,MAAM,CAAK;IACxB,cAAc,EAAE,MAAM,CAAK;IAC3B,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAM;gBAE1B,IAAI,EAAE,MAAM;IAIxB,KAAK,CAAC,QAAQ,EAAE,MAAM;CAuGtB;AAED,eAAO,MAAM,kBAAkB,yEAY7B,CAAC"}
+{"version":3,"file":"bitmaptextdata.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/bitmaptextdata.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,MAAM,YAAY,CAAC;AA8E/B;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,cAAc;IAClC,MAAM,EAAE,MAAM,CAAK;IACnB,QAAQ,EAAE,MAAM,CAAK;IACrB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,UAAU,EAAE,MAAM,CAAK;IACvB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE,MAAM,CAAK;IACpB,WAAW,EAAE,MAAM,CAAK;IACxB,cAAc,EAAE,MAAM,CAAK;IAC3B,MAAM,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAA;KAAE,CAAM;gBAE1B,IAAI,EAAE,MAAM;IAIxB,KAAK,CAAC,QAAQ,EAAE,MAAM;CAuGtB;AAED,eAAO,MAAM,kBAAkB,yEAY7B,CAAC"}

package/build/renderable/text/glyph.d.ts

@@ -19,7 +19,7 @@ export default class Glyph {
     yoffset: number;
     xadvance: number;
     fixedWidth: boolean;
-    kerning: {
+    kerning?: {
         [key: number]: {
             [key: number]: number;
         };

package/build/renderable/text/glyph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glyph.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/glyph.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACzB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAEtD;;OAEG;;IAiBH;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAU9B;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAW3C"}
+{"version":3,"file":"glyph.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/glyph.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,KAAK;IACzB;;OAEG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,CAAC,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;SAAE,CAAA;KAAE,CAAC;IAEvD;;OAEG;;IAiBH;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM;IAU9B;;OAEG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CAW3C"}

package/build/renderable/text/text.d.ts

@@ -122,27 +122,17 @@ export default class Text extends Renderable {
      * @returns {Text} this object for chaining
      */
     setText(value?: number | string | string[]): Text;
-    /**
-     * update the bounding box for this Text, accounting for textAlign and textBaseline.
-     * @param {boolean} [absolute=true] - update in absolute coordinates
-     * @returns {Bounds} this renderable's bounding box
-     */
-    updateBounds(absolute?: boolean): Bounds;
     /**
      * measure the given text size in pixels
-     * @param {CanvasRenderer|WebGLRenderer} renderer - reference to the active renderer
      * @param {string} [text] - the text to be measured
      * @returns {TextMetrics} a TextMetrics object defining the dimensions of the given piece of text
      */
-    measureText(renderer: CanvasRenderer | WebGLRenderer, text?: string): TextMetrics;
+    measureText(text?: string): TextMetrics;
     /**
      * draw a text at the specified coord
      * @param {CanvasRenderer|WebGLRenderer} renderer - Reference to the destination renderer instance
-     * @param {string} [text]
-     * @param {number} [x]
-     * @param {number} [y]
      */
-    draw(renderer: CanvasRenderer | WebGLRenderer, text?: string, x?: number, y?: number): void;
+    draw(renderer: CanvasRenderer | WebGLRenderer): void;
     /**
      * @ignore
      */

package/build/renderable/text/text.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;OAiBG;IACH,eAjBW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACW,SAAS;QACT,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EA2EF;IApEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,cAAe;IAMhB,cAAc;IACd,kDAqEC;IATA,8CAEE;IAGF,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAiChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAyDhB;IAED;;;;OAIG;IACH,wBAHW,OAAO,GACL,MAAM,CA8ClB;IAED;;;;;OAKG;IACH,sBAJW,cAAc,GAAC,aAAa,SAC5B,MAAM,GACJ,WAAW,CAIvB;IAED;;;;;;OAMG;IACH,eALW,cAAc,GAAC,aAAa,SAC5B,MAAM,MACN,MAAM,MACN,MAAM,QAyChB;IAED;;OAEG;IACH,4EAiBC;IAED;;;OAGG;IACH,gBAUC;CACD;uBA7csB,kBAAkB;sBAHR,qBAAqB;+BAEvB,gDAAgD;wBAEvD,kBAAkB"}
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["../../../src/renderable/text/text.js"],"names":[],"mappings":"AAmBA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;OAiBG;IACH,eAjBW,MAAM,KACN,MAAM,YAEd;QAAyB,IAAI,EAArB,MAAM;QACkB,IAAI,EAA5B,MAAM,GAAC,MAAM;QACW,SAAS;QACT,WAAW;QACjB,SAAS;QACT,SAAS;QACT,YAAY;QACZ,UAAU;QACR,WAAW;QACb,aAAa;QACF,IAAI;KACzC,EA2EF;IApEA;;;;OAIG;IACH,WAHU,KAAK,CAGwB;IAEvC;;;;OAIG;IACH,aAHU,KAAK,CAG0B;IAEzC;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,WAHU,MAAM,CAGO;IAEvB;;;;;OAKG;IACH,cAHU,MAAM,CAGS;IAEzB;;;;;OAKG;IACH,YAHU,MAAM,CAGK;IAErB;;;;;OAKG;IACH,eAHU,MAAM,CAGO;IAEvB;;;;OAIG;IACH,UAHU,MAAM,CAGE;IAElB;;;OAGG;IACH,cAAe;IAMhB,cAAc;IACd,kDAqEC;IATA,8CAEE;IAGF,iCAAoC;IAMrC;;;OAGG;IACH,QAFa,IAAI,CAWhB;IAJC,UAA+B;IAMjC;;;OAGG;IACH,UAFa,IAAI,CAWhB;IAED;;;;;;;;OAQG;IACH,cAPW,MAAM,SACN,MAAM,GAAC,MAAM,GACX,IAAI,CAiChB;IAED;;;;OAIG;IACH,gBAHW,MAAM,GAAC,MAAM,GAAC,MAAM,EAAE,GACpB,IAAI,CAyDhB;IAqDD;;;;OAIG;IACH,mBAHW,MAAM,GACJ,WAAW,CAIvB;IAED;;;OAGG;IACH,eAFW,cAAc,GAAC,aAAa,QAetC;IAED;;OAEG;IACH,4EAiBC;IAED;;;OAGG;IACH,gBAUC;CACD;uBA/asB,kBAAkB;sBAHR,qBAAqB;+BAEvB,gDAAgD;wBAEvD,kBAAkB"}

package/build/renderable/trail.d.ts

@@ -0,0 +1,120 @@
+/**
+ * @import {Color} from "../math/color.ts";
+ * @import {Vector2d} from "../math/vector2d.ts";
+ */
+/**
+ * A Trail renderable that draws a fading, tapering ribbon behind a moving object.
+ * Points are sampled from a target or added manually, and rendered as connected
+ * quads with interpolated width and color.
+ * @category Game Objects
+ * @example
+ * // simple single-color trail following a sprite
+ * const trail = new Trail({ target: player, color: "#44aaff", width: 20 });
+ * app.world.addChild(trail);
+ * @example
+ * // gradient trail following a sprite (fire effect)
+ * const trail = new Trail({
+ *     target: player,
+ *     width: 30,
+ *     gradient: ["#ffff00", "#ff4400", "#ff000000"],
+ * });
+ * app.world.addChild(trail);
+ * @example
+ * // rainbow trail with custom width curve
+ * const trail = new Trail({
+ *     target: player,
+ *     width: 40,
+ *     widthCurve: [1, 1, 0.8, 0.4, 0],
+ *     gradient: ["#ff0000", "#ff8800", "#ffff00", "#00ff00", "#0088ff", "#8800ff00"],
+ * });
+ * app.world.addChild(trail);
+ * @example
+ * // manual mode (e.g. sword slash)
+ * const slash = new Trail({ width: 24, lifetime: 200, color: "#ffffff" });
+ * app.world.addChild(slash);
+ * // call each frame during the attack animation
+ * slash.addPoint(swordTip.x, swordTip.y);
+ * @see {@link Renderable}
+ */
+export default class Trail extends Renderable {
+    /**
+     * @param {object} [options] - trail options
+     * @param {Renderable|Vector2d} [options.target] - auto-follow target
+     * @param {number} [options.length=20] - max number of points
+     * @param {number} [options.lifetime=500] - point lifetime in ms
+     * @param {number} [options.minDistance=4] - min distance between samples in px
+     * @param {number} [options.width=10] - max trail width in px
+     * @param {number[]} [options.widthCurve=[1, 0]] - width multiplier curve (0=head, 1=tail)
+     * @param {Color|string} [options.color="#ffffff"] - single trail color. Ignored if `gradient` is set.
+     * @param {(Color|string|{pos: number, color: Color|string})[]} [options.gradient] - color gradient. Overrides `color`.
+     * @param {number} [options.opacity=1.0] - trail opacity (0.0–1.0)
+     * @param {string} [options.blendMode="normal"] - blend mode
+     */
+    constructor(options?: {
+        target?: Vector2d | Renderable | undefined;
+        length?: number | undefined;
+        lifetime?: number | undefined;
+        minDistance?: number | undefined;
+        width?: number | undefined;
+        widthCurve?: number[] | undefined;
+        color?: string | Color | undefined;
+        gradient?: (string | Color | {
+            pos: number;
+            color: Color | string;
+        })[] | undefined;
+        opacity?: number | undefined;
+        blendMode?: string | undefined;
+    });
+    /** @type {Renderable|Vector2d|null} */
+    target: Renderable | Vector2d | null;
+    /** @type {number} */
+    maxPoints: number;
+    /** @type {number} */
+    lifetime: number;
+    /** @type {number} */
+    minDistance: number;
+    /** @type {number[]} */
+    widthCurve: number[];
+    /** @ignore */
+    _gradient: Gradient;
+    /** @ignore */
+    _points: any[];
+    /** @ignore */
+    _segmentColor: Color;
+    /** @ignore */
+    _n0: {
+        x: number;
+        y: number;
+    };
+    /** @ignore */
+    _n1: {
+        x: number;
+        y: number;
+    };
+    /**
+     * add a point to the trail
+     * @param {number} x - x position
+     * @param {number} y - y position
+     */
+    addPoint(x: number, y: number): void;
+    /** @ignore */
+    update(dt: any): boolean;
+    /** @ignore */
+    draw(renderer: any): void;
+    /** clear all trail points */
+    clear(): void;
+    /**
+     * Build a Gradient from trail constructor options.
+     * @param {object} options - trail constructor options
+     * @returns {Gradient}
+     * @ignore
+     */
+    _buildGradient(options: object): Gradient;
+    /** @ignore */
+    destroy(): void;
+}
+import Renderable from "./renderable.js";
+import type { Vector2d } from "../math/vector2d.ts";
+import { Gradient } from "../video/gradient.js";
+import type { Color } from "../math/color.ts";
+//# sourceMappingURL=trail.d.ts.map

package/build/renderable/trail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trail.d.ts","sourceRoot":"","sources":["../../src/renderable/trail.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IACC;;;;;;;;;;;;OAYG;IACH,sBAXG;QAAsC,MAAM;QACnB,MAAM;QACN,QAAQ;QACR,WAAW;QACX,KAAK;QACH,UAAU;QACN,KAAK;QACkC,QAAQ;iBAAlD,MAAM;mBAAS,KAAK,GAAC,MAAM;;QAC9B,OAAO;QACP,SAAS;KACpC,EAwCA;IApCA,uCAAuC;IACvC,QADW,UAAU,GAAC,QAAQ,GAAC,IAAI,CACC;IACpC,qBAAqB;IACrB,WADW,MAAM,CACoB;IACrC,qBAAqB;IACrB,UADW,MAAM,CACsB;IACvC,qBAAqB;IACrB,aADW,MAAM,CAC0B;IAG3C,uBAAuB;IACvB,YADW,MAAM,EAAE,CAIT;IAEV,cAAc;IACd,oBAA6C;IAC7C,cAAc;IACd,eAAiB;IACjB,cAAc;IACd,qBAAoC;IACpC,cAAc;IACd;;;MAAyB;IACzB,cAAc;IACd;;;MAAyB;IAa1B;;;;OAIG;IACH,YAHW,MAAM,KACN,MAAM,QAehB;IAED,cAAc;IACd,yBAsBC;IAED,cAAc;IACd,0BAiDC;IAED,6BAA6B;IAC7B,cAEC;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GACJ,QAAQ,CAgCpB;IAED,cAAc;IACd,gBAMC;CACD;uBAnPsB,iBAAiB;8BAIb,qBAAqB;yBALvB,sBAAsB;2BAIvB,kBAAkB"}

package/build/renderable/ui/uitextbutton.d.ts

@@ -16,10 +16,6 @@ interface UITextButtonSettings {
     textBaseline?: string;
     borderWidth?: number;
     borderHeight?: number;
-    /** @deprecated use hoverOffColor */
-    backgroundColor?: string;
-    /** @deprecated use hoverOnColor */
-    hoverColor?: string;
     [key: string]: any;
 }
 /**
@@ -85,8 +81,8 @@ export default class UITextButton extends UIBaseElement {
      *              // if you omit the next two, size is calculated by the size of the text
      *              borderWidth: 200,
      *              borderHeight: 20,
-     *              backgroundColor: '#00aa0080',
-     *              hoverColor: '#00ff00ff'
+     *              hoverOffColor: '#00aa0080',
+     *              hoverOnColor: '#00ff00ff'
      *          });
      *      }
      *

package/build/renderable/ui/uitextbutton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uitextbutton.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/uitextbutton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAC/C,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAE/C,UAAU,oBAAoB;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,oCAAoC;IACpC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,mCAAmC;IACnC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa;IACtD;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAEzB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IAEvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;gBACS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB;IAgDvD,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAYvC"}
+{"version":3,"file":"uitextbutton.d.ts","sourceRoot":"","sources":["../../../src/renderable/ui/uitextbutton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,+BAA+B,CAAC;AAC1D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,KAAK,QAAQ,MAAM,yBAAyB,CAAC;AACpD,OAAO,UAAU,MAAM,uBAAuB,CAAC;AAC/C,OAAO,aAAa,MAAM,oBAAoB,CAAC;AAE/C,UAAU,oBAAoB;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IAC1B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,YAAa,SAAQ,aAAa;IACtD;;OAEG;IACH,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IAEzB;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;OAEG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,iBAAiB,EAAE,MAAM,CAAC;IAE1B;;;;OAIG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;;;OAIG;IACH,YAAY,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,UAAU,EAAE,UAAU,CAAC;IAEvB;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,MAAM,EAAE,SAAS,CAAC;IAElB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;gBACS,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,QAAQ,EAAE,oBAAoB;IAyCvD,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;CAYvC"}