melonjs 20.2.0 → 20.4.0

package/build/video/effects/dropShadow.d.ts

@@ -3,19 +3,19 @@
  * Works by sampling the texture at an offset — if the offset position
  * has an opaque pixel but the current position doesn't, the shadow is drawn.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // dark shadow offset to the bottom-right
- * mySprite.shader = new DropShadowEffect(renderer, {
+ * mySprite.addPostEffect(new DropShadowEffect(renderer, {
  *     offsetX: 3.0,
  *     offsetY: 3.0,
  *     color: [0.0, 0.0, 0.0],
  *     opacity: 0.5,
- * });
+ * }));
  */
 export default class DropShadowEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.offsetX=2.0] - shadow x offset in texels
      * @param {number} [options.offsetY=2.0] - shadow y offset in texels
@@ -23,7 +23,7 @@ export default class DropShadowEffect extends ShaderEffect {
      * @param {number} [options.opacity=0.5] - shadow opacity (0.0–1.0)
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         offsetX?: number | undefined;
         offsetY?: number | undefined;
         color?: number[] | undefined;

package/build/video/effects/dropShadow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dropShadow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dropShadow.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;OAQG;IACH,qCANG;QAAyB,OAAO;QACP,OAAO;QACL,KAAK;QACP,OAAO;QACL,WAAW;KACxC,EA0CA;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAvHwB,mBAAmB"}
+{"version":3,"file":"dropShadow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dropShadow.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;OAQG;IACH,sBARW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,OAAO;QACP,OAAO;QACL,KAAK;QACP,OAAO;QACL,WAAW;KACxC,EA0CA;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAvHwB,mBAAmB"}

package/build/video/effects/flash.d.ts

@@ -4,11 +4,11 @@
  * The `intensity` uniform controls how much of the flash color is mixed in
  * (0.0 = original sprite, 1.0 = fully colored).
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // create a white flash effect
  * const flash = new FlashEffect(renderer);
- * mySprite.shader = flash;
+ * mySprite.addPostEffect(flash);
  *
  * // trigger the flash (e.g. on hit)
  * flash.setIntensity(1.0);
@@ -21,12 +21,12 @@
  */
 export default class FlashEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - flash color as [r, g, b] (0.0–1.0)
      * @param {number} [options.intensity=0.0] - initial flash intensity (0.0–1.0)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });

package/build/video/effects/flash.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flash.d.ts","sourceRoot":"","sources":["../../../src/video/effects/flash.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAA2B,KAAK;QACP,SAAS;KACpC,EAkBA;IAJA,kBAAyC;IAM1C;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA/EwB,mBAAmB"}
+{"version":3,"file":"flash.d.ts","sourceRoot":"","sources":["../../../src/video/effects/flash.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,SAAS;KACpC,EAkBA;IAJA,kBAAyC;IAM1C;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA/EwB,mBAAmB"}

package/build/video/effects/glow.d.ts

@@ -3,24 +3,24 @@
  * Similar to OutlineEffect but with a soft, blurred edge instead of a hard line.
  * Commonly used for power-ups, magic items, or selection highlights.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // blue glow for a magic item
- * mySprite.shader = new GlowEffect(renderer, {
+ * mySprite.addPostEffect(new GlowEffect(renderer, {
  *     color: [0.2, 0.5, 1.0],
  *     intensity: 1.5,
- * });
+ * }));
  */
 export default class GlowEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - glow color as [r, g, b] (0.0–1.0)
      * @param {number} [options.width=3.0] - glow spread in pixels
      * @param {number} [options.intensity=1.0] - glow brightness multiplier
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         color?: number[] | undefined;
         width?: number | undefined;
         intensity?: number | undefined;

package/build/video/effects/glow.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glow.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;OAOG;IACH,qCALG;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;QACP,WAAW;KACxC,EAsCA;IANA,kBAAyC;IAQ1C;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAtHwB,mBAAmB"}
+{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glow.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;QACP,WAAW;KACxC,EAsCA;IANA,kBAAyC;IAQ1C;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAtHwB,mBAAmB"}

package/build/video/effects/glsl_realization.d.ts

@@ -1,18 +1,2 @@
-/**
- * Assemble the complete GLSL program sources for a ShaderEffect fragment
- * body: parse the builtins, build the vertex variant, and wrap the user's
- * `apply()` with the texture-sampling boilerplate.
- * @param {string} fragmentBody - the user body (GLSL, `vec4 apply(vec4, vec2)` convention)
- * @returns {{vertex: string, fragment: string, screenTextures: Array<{name: string, repeat: string}>, noiseUV: boolean}} the assembled sources + builtin usage
- * @ignore
- */
-export function buildGLSLProgram(fragmentBody: string): {
-    vertex: string;
-    fragment: string;
-    screenTextures: Array<{
-        name: string;
-        repeat: string;
-    }>;
-    noiseUV: boolean;
-};
+
 //# sourceMappingURL=glsl_realization.d.ts.map

package/build/video/effects/glsl_realization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAiHA;;;;;;;GAOG;AACH,+CAJW,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CA6BvH"}
+{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAoHA;;;;;;;;GAQG;AACH,+CALW,MAAM,GACJ;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,cAAc,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC,CA8BvH"}

package/build/video/effects/hologram.d.ts

@@ -4,21 +4,21 @@
  * Commonly used for sci-fi UI, ghost/spirit characters, or tech displays.
  * The `time` uniform should be updated each frame for animation.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * const holo = new HologramEffect(renderer);
- * mySprite.shader = holo;
+ * mySprite.addPostEffect(holo);
  * // update each frame
  * holo.setTime(performance.now() / 1000);
  */
 export default class HologramEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[0.1, 0.7, 1.0]] - hologram tint color [r, g, b]
      * @param {number} [options.intensity=0.5] - effect intensity (0.0–1.0)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });

package/build/video/effects/hologram.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../src/video/effects/hologram.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA7EwB,mBAAmB"}
+{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../src/video/effects/hologram.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA7EwB,mBAAmB"}

package/build/video/effects/invert.d.ts

@@ -2,20 +2,20 @@
  * A shader effect that inverts the colors of the sprite.
  * Commonly used for damage feedback, negative image, or X-ray effects.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
- * mySprite.shader = new InvertEffect(renderer);
+ * mySprite.addPostEffect(new InvertEffect(renderer));
  * @example
  * // partial inversion
- * mySprite.shader = new InvertEffect(renderer, { intensity: 0.5 });
+ * mySprite.addPostEffect(new InvertEffect(renderer, { intensity: 0.5 }));
  */
 export default class InvertEffect extends ColorMatrixEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - inversion intensity (0.0 = original, 1.0 = fully inverted)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

package/build/video/effects/invert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../src/video/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,qCAFG;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAlC6B,kBAAkB"}
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../src/video/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAlC6B,kBAAkB"}

package/build/video/effects/outline.d.ts

@@ -4,26 +4,26 @@
  * current pixel is transparent, it draws the outline color.
  * Commonly used for selection highlights, hover states, or collectible glow.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // yellow outline for selection
- * mySprite.shader = new OutlineEffect(renderer, {
+ * mySprite.addPostEffect(new OutlineEffect(renderer, {
  *     color: [1.0, 1.0, 0.0],
  *     width: 2.0,
- * });
+ * }));
  * @example
  * // remove the effect
- * mySprite.shader = undefined;
+ * mySprite.removePostEffect(outline);
  */
 export default class OutlineEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - outline color as [r, g, b] (0.0–1.0)
      * @param {number} [options.width=1.0] - outline width in pixels
      * @param {number[]} [options.textureSize] - texture dimensions [width, height] (defaults to renderer size)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         color?: number[] | undefined;
         width?: number | undefined;
         textureSize?: number[] | undefined;

package/build/video/effects/outline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/outline.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,qCAJG;QAA2B,KAAK;QACP,KAAK;QACH,WAAW;KACxC,EAsCA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA1HwB,mBAAmB"}
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/outline.js"],"names":[],"mappings":"AAkCA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,KAAK;QACH,WAAW;KACxC,EAsCA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA1HwB,mBAAmB"}

package/build/video/effects/pixelate.d.ts

@@ -2,22 +2,22 @@
  * A shader effect that pixelates the sprite by snapping UV coordinates
  * to a grid. Commonly used for teleport effects, transitions, or retro styling.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // moderate pixelation
- * mySprite.shader = new PixelateEffect(renderer, { size: 8.0 });
+ * mySprite.addPostEffect(new PixelateEffect(renderer, { size: 8.0 }));
  * @example
  * // animate the pixelation (e.g. for teleport)
  * pixelate.setSize(pixelate.size + dt / 50);
  */
 export default class PixelateEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.size=4.0] - pixel size in texels (higher = more pixelated)
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         size?: number | undefined;
         textureSize?: number[] | undefined;
     });

package/build/video/effects/pixelate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pixelate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/pixelate.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH;IACC;;;;;OAKG;IACH,qCAHG;QAAyB,IAAI;QACF,WAAW;KACxC,EAoBA;IALA,aAA+B;IAOhC;;;OAGG;IACH,cAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA3EwB,mBAAmB"}
+{"version":3,"file":"pixelate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/pixelate.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;GAWG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,IAAI;QACF,WAAW;KACxC,EAoBA;IALA,aAA+B;IAOhC;;;OAGG;IACH,cAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA3EwB,mBAAmB"}

package/build/video/effects/radialGradient.d.ts

@@ -52,10 +52,10 @@
  * // Pickup highlight — attach to any Renderable so it renders inside
  * // the renderable's bounding rect (anchorPoint applies). Combine with
  * // `blendMode = "lighter"` for the additive glow look.
- * pickup.shader = new RadialGradientEffect(renderer, {
+ * pickup.addPostEffect(new RadialGradientEffect(renderer, {
  *     color: new Color(120, 255, 200), // mint green
  *     intensity: 0.8,
- * });
+ * }));
  * pickup.blendMode = "lighter";
  * @example
  * // Damage / impact indicator — short-lived elliptical flash on hit.
@@ -85,7 +85,6 @@ export default class RadialGradientEffect extends ShaderEffect {
         color?: Color | undefined;
         intensity?: number | undefined;
     });
-    _colorBuf: Float32Array<ArrayBuffer>;
     /**
      * Set the center color. RGB only — alpha is ignored (the radial
      * falloff supplies the per-pixel alpha).

package/build/video/effects/radialGradient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,+CAHG;QAAwB,KAAK;QACJ,SAAS;KACpC,EA2DA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBAtKwB,mBAAmB;2BAIlB,qBAAqB"}
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,+CAHG;QAAwB,KAAK;QACJ,SAAS;KACpC,EA+DA;IAhBA;;;OAGG;IACH,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBA1KwB,mBAAmB;2BAIlB,qBAAqB"}

package/build/video/effects/scanline.d.ts

@@ -2,27 +2,27 @@
  * A shader effect that overlays horizontal scanlines on the sprite.
  * Can optionally add barrel distortion and vignette for a full CRT monitor look.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // simple scanlines
- * mySprite.shader = new ScanlineEffect(renderer, { opacity: 0.3 });
+ * mySprite.addPostEffect(new ScanlineEffect(renderer, { opacity: 0.3 }));
  * @example
  * // full CRT look with curvature and vignette
- * mySprite.shader = new ScanlineEffect(renderer, {
+ * mySprite.addPostEffect(new ScanlineEffect(renderer, {
  *     opacity: 0.3,
  *     curvature: 0.02,
  *     vignetteStrength: 0.3,
- * });
+ * }));
  */
 export default class ScanlineEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.opacity=0.25] - scanline darkness (0.0 = invisible, 1.0 = fully black lines)
      * @param {number} [options.curvature=0.0] - barrel distortion strength (0.0 = flat, 0.02 = subtle CRT curve)
      * @param {number} [options.vignetteStrength=0.0] - edge darkening strength (0.0 = none, 0.3 = subtle)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         opacity?: number | undefined;
         curvature?: number | undefined;
         vignetteStrength?: number | undefined;

package/build/video/effects/scanline.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scanline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/scanline.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;OAMG;IACH,qCAJG;QAAyB,OAAO;QACP,SAAS;QACT,gBAAgB;KAC3C,EAyCA;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAIhB;CACD;yBAnIwB,mBAAmB"}
+{"version":3,"file":"scanline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/scanline.js"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,OAAO;QACP,SAAS;QACT,gBAAgB;KAC3C,EAyCA;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,8BAFW,MAAM,QAIhB;CACD;yBAnIwB,mBAAmB"}

package/build/video/effects/sepia.d.ts

@@ -1,20 +1,20 @@
 /**
  * A shader effect that applies a warm sepia (vintage photo) tone to the sprite.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
- * mySprite.shader = new SepiaEffect(renderer);
+ * mySprite.addPostEffect(new SepiaEffect(renderer));
  * @example
  * // partial sepia
- * mySprite.shader = new SepiaEffect(renderer, { intensity: 0.5 });
+ * mySprite.addPostEffect(new SepiaEffect(renderer, { intensity: 0.5 }));
  */
 export default class SepiaEffect extends ColorMatrixEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - sepia intensity (0.0 = original, 1.0 = full sepia)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

package/build/video/effects/sepia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../src/video/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,qCAFG;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../src/video/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}

package/build/video/effects/shadereffect.d.ts

@@ -69,7 +69,7 @@
  * @category Rendering
  * @example
  * // one effect, both backends: dual-language body
- * mySprite.shader = new ShaderEffect(renderer, {
+ * const fx = new ShaderEffect(renderer, {
  *     glsl: `
  *         uniform float uStrength;
  *         vec4 apply(vec4 color, vec2 uv) {
@@ -84,15 +84,16 @@
  *         }
  *     `,
  * });
- * mySprite.shader.setUniform("uStrength", 0.5); // sets either backend
+ * mySprite.addPostEffect(fx);
+ * fx.setUniform("uStrength", 0.5); // sets either backend
  * @example
  * // create a grayscale effect
- * mySprite.shader = new ShaderEffect(renderer, `
+ * mySprite.addPostEffect(new ShaderEffect(renderer, `
  *     vec4 apply(vec4 color, vec2 uv) {
  *         float gray = dot(color.rgb, vec3(0.299, 0.587, 0.114));
  *         return vec4(vec3(gray), color.a);
  *     }
- * `);
+ * `));
  * @example
  * // create an effect with a custom uniform
  * const pulse = new ShaderEffect(renderer, `
@@ -102,7 +103,7 @@
  *         return vec4(color.rgb * brightness, color.a);
  *     }
  * `);
- * mySprite.shader = pulse;
+ * mySprite.addPostEffect(pulse);
  * // update the uniform each frame
  * pulse.setUniform("uTime", time);
  * @example
@@ -169,55 +170,6 @@ export default class ShaderEffect {
      * @default false
      */
     shared: boolean;
-    /**
-     * the renderer this effect was created for — kept so destroy and
-     * context-loss can release the texture units reserved on its cache
-     * for extra samplers ({@link setTexture}), and so {@link clone} can
-     * compile an independent copy
-     * @ignore
-     */
-    _renderer: any;
-    /**
-     * the construction "recipe" (body + precision), kept VERBATIM so
-     * {@link clone} can compile an independent copy. Stored before the
-     * disabled-stub early return so cloning behaves consistently there too.
-     * @ignore
-     */
-    _fragmentBody: string | {
-        glsl?: string;
-        wgsl?: string;
-    };
-    /** @ignore */
-    _precision: string | undefined;
-    /**
-     * extra texture samplers bound via {@link setTexture}, keyed by the
-     * uniform name → `{ image, repeat, tex }` (`tex` is the uploaded GL
-     * texture, created lazily on first draw; unused on WebGPU, where the
-     * bind group is built lazily instead)
-     * @ignore
-     */
-    _extraTextures: Map<any, any> | undefined;
-    /**
-     * samplers annotated `: screen_texture` — the renderer checks this to
-     * know when to refresh the shared frame capture before the effect draws
-     * @type {Array<{name: string, repeat: string}>}
-     * @ignore
-     */
-    _screenTextureUniforms: Array<{
-        name: string;
-        repeat: string;
-    }>;
-    /** @ignore */
-    _hasNoiseUV: any;
-    /** @ignore */
-    _shader: GLShader | undefined;
-    /** @ignore */
-    wgslRealization: WGSLEffectRealization | undefined;
-    /** @private */
-    private _onContextLost;
-    _enabledBeforeSuspend: boolean | undefined;
-    /** @private */
-    private _onContextRestored;
     /**
      * Set the uniform to the given value
      * @param {string} name - the uniform name
@@ -243,48 +195,11 @@ export default class ShaderEffect {
      *     vec4 apply(vec4 color, vec2 uv) {
      *         return texture2D(uSampler, uv + vec2(uTime * 0.05, 0.0));
      *     }`);
-     * mySprite.shader = flow;
+     * mySprite.addPostEffect(flow);
      * // then in your Stage's update(dt):
      * flow.setTime(me.timer.getTime() / 1000);
      */
     setTime(seconds: number): ShaderEffect;
-    /**
-     * Feed the UV y-direction of the space `apply()` is about to run in:
-     * `+1` where `uv.y` grows downward (direct sprite sampling, and every
-     * WebGPU path), `-1` on the WebGL pooled-blit path, whose capture FBOs
-     * are bottom-up — there, y-directional UV arithmetic inside a body
-     * runs vertically mirrored unless compensated. Directional bodies
-     * (DropShadow) declare a `uUVYDir` uniform and multiply their y
-     * offsets with it, so "down" means down on every path of every
-     * backend. A silent no-op for bodies that don't declare the uniform.
-     * @param {number} dir - +1 (uv.y grows downward) or -1 (upward)
-     * @ignore
-     */
-    _setUVYDir(dir: number): void;
-    _uvYDir: any;
-    /**
-     * Feed the `noise_uv` builtin's frame rect for the object about to draw:
-     * the source texture dimensions, the destination (object) dimensions, and
-     * the frame's top-left UV origin. Called by the quad batchers per draw;
-     * a no-op unless this effect's fragment actually uses `noise_uv` (the
-     * `ME_*` uniforms only exist — and are only active — then).
-     * @param {number} sourceWidth - source texture width in pixels
-     * @param {number} sourceHeight - source texture height in pixels
-     * @param {number} objectWidth - destination (object) width in pixels
-     * @param {number} objectHeight - destination (object) height in pixels
-     * @param {number} u0 - the frame's left UV coordinate (flip-normalized)
-     * @param {number} v0 - the frame's top UV coordinate (flip-normalized)
-     * @ignore
-     */
-    _setNoiseUVRect(sourceWidth: number, sourceHeight: number, objectWidth: number, objectHeight: number, u0: number, v0: number): void;
-    /**
-     * Apply the wrap mode a `: screen_texture(<repeat>)` annotation asked for
-     * onto the live capture handle. The unit is force-activated first: the
-     * batcher's bind may have been skipped as redundant while the GL active
-     * unit points elsewhere.
-     * @ignore
-     */
-    _applyCaptureWrap(batcher: any, glTex: any, entry: any): void;
     /**
      * Bind an **extra** texture to a named `sampler2D` uniform in this shader, so
      * a custom effect can read a *second* texture — a noise map, mask, gradient,
@@ -312,22 +227,11 @@ export default class ShaderEffect {
      *         return texture2D(uSampler, uv + flow * 0.02);
      *     }`);
      * water.setTexture("uNoise", noise, "repeat");
-     * waterSprite.shader = water;
+     * waterSprite.addPostEffect(water);
      * // each frame, in your Stage's update(dt):
      * water.setTime(me.timer.getTime() / 1000);
      */
     setTexture(name: string, image: Texture2d | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, repeat?: "repeat" | "repeat-x" | "repeat-y" | "no-repeat"): ShaderEffect;
-    /**
-     * (Re)bind this effect's extra textures ({@link setTexture}) to reserved GL
-     * texture units and point their sampler uniforms at them. Called by the
-     * renderer right after this effect's shader is bound — for both the
-     * post-effect blit and the single-effect `customShader` sprite path — so the
-     * bindings survive the batcher's rotating color-texture pool.
-     * @param {object} batcher - the active batcher (owns the GL texture units)
-     * @ignore
-     */
-    _prepareTextures(batcher: object): void;
-    _textureOverflowWarned: boolean | undefined;
     /**
      * Create an independent copy of this effect, compiled as its own GL
      * program. Use it when several renderables need the same effect with
@@ -347,28 +251,13 @@ export default class ShaderEffect {
      * @returns {ShaderEffect} a new, caller-owned effect (`shared === false`)
      * @example
      * // the loader's shader is ONE shared program — one uniform state for all
-     * sprite.shader = loader.getShader("flash");
+     * sprite.addPostEffect(loader.getShader("flash"));
      * // the boss needs its own intensity — clone a private, caller-owned copy
-     * boss.shader = loader.getShader("flash").clone();
-     * boss.shader.setUniform("uIntensity", 0.9);
+     * const bossFlash = loader.getShader("flash").clone();
+     * boss.addPostEffect(bossFlash);
+     * bossFlash.setUniform("uIntensity", 0.9);
      */
     clone(): ShaderEffect;
-    /** @ignore */
-    bind(): void;
-    /** @ignore */
-    getAttribLocation(name: any): number;
-    /** @ignore */
-    setVertexAttributes(gl: any, attributes: any, stride: any): void;
-    /** @ignore */
-    get program(): WebGLProgram | null;
-    /** @ignore */
-    get vertex(): any;
-    /** @ignore */
-    get fragment(): any;
-    /** @ignore */
-    get attributes(): {};
-    /** @ignore */
-    get uniforms(): object;
     /**
      * destroy this shader effect. Idempotent — calling destroy twice
      * is safe. Unsubscribes from the renderer's context-lost / restored

package/build/video/effects/shadereffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4HG;AACH;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAqHhB;IA/JD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;OAMG;IACH,eAAyB;IAEzB;;;;;OAKG;IACH;eA1ByB,MAAM;eAAS,MAAM;MA0BrB;IACzB,cAAc;IACd,+BAA2B;IAoB3B;;;;;;OAMG;IACH,0CAA+B;IAQ9B;;;;;OAKG;IACH,wBAHU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAGK;IACpD,cAAc;IACd,iBAAkC;IAElC,cAAc;IACd,8BAKC;IAyBD,cAAc;IACd,mDAAkC;IAsBpC,eAAe;IACf,uBAkBC;IAbA,2CAAyC;IAe1C,eAAe;IACf,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAmB7B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAuCxB;IAED;;;;;;;;;;;OAWG;IACH,gBAHW,MAAM,QAqBhB;IATC,aAAkB;IAWpB;;;;;;;;;;;;;OAaG;IACH,6BARW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAoDhB;IAED;;;;;;OAMG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;OAQG;IACH,0BAHW,MAAM,QA2FhB;IA3DI,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,SARa,YAAY,CAqDxB;IAKD,cAAc;IACd,aAIC;IAED,cAAc;IACd,qCAIC;IAED,cAAc;IACd,iEAIC;IAED,cAAc;IACd,mCAEC;IAED,cAAc;IACd,kBAEC;IAED,cAAc;IACd,oBAEC;IAED,cAAc;IACd,qBAEC;IAED,cAAc;IACd,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBA34BoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6HG;AACH;IAiCC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,QAC3C,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAQrC,MAAM,EAqIhB;IA/KD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAed;;;;;;;OAOG;IACH,eAAyB;IAEzB;;;;;;OAMG;IACH;eA5ByB,MAAM;eAAS,MAAM;MA4BrB;IACzB;;;OAGG;IACH,+BAA2B;IAoB3B;;;;;;;OAOG;IACH,0CAA+B;IAQ9B;;;;;;OAMG;IACH,wBAJU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAIK;IACpD;;;OAGG;IACH,iBAAkC;IAElC;;;OAGG;IACH,8BAKC;IAyBD;;;OAGG;IACH,mDAAkC;IAsBpC;;;;OAIG;IACH,uBAsBC;IAjBA;;;OAGG;IACH,2CAAyC;IAe1C;;;;OAIG;IACH,2BAQC;IAED;;;;OAIG;IACH,iBAHW,MAAM,SACN,MAAM,GAAC,YAAY,QAmB7B;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAuCxB;IAED;;;;;;;;;;;;OAYG;IACH,gBAJW,MAAM,QA0BhB;IAbC;;;OAGG;IACH,aAAkB;IAWpB;;;;;;;;;;;;;;OAcG;IACH,6BATW,MAAM,gBACN,MAAM,eACN,MAAM,gBACN,MAAM,MACN,MAAM,MACN,MAAM,QAqDhB;IAED;;;;;;;OAOG;IACH,8DAaC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,iBAnBW,MAAM,SACN,SAAS,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,WACxE,QAAQ,GAAC,UAAU,GAAC,UAAU,GAAC,WAAW,GACxC,YAAY,CA0GxB;IAED;;;;;;;;;OASG;IACH,0BAJW,MAAM,QAgGhB;IA/DI;;;OAGG;IACH,4CAAkC;IA6DvC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,SATa,YAAY,CAsDxB;IAKD;;;OAGG;IACH,aAIC;IAED;;;OAGG;IACH,qCAIC;IAED;;;OAGG;IACH,iEAIC;IAED;;;OAGG;IACH,mCAEC;IAED;;;OAGG;IACH,kBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAyCC;CACD;qBA78BoB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}

package/build/video/effects/shine.d.ts

@@ -9,7 +9,7 @@
  *
  * The `time` uniform must be updated each frame for the animation.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // single diagonal sweep — classic "button shine"
  * const shine = new ShineEffect(renderer, {
@@ -36,7 +36,7 @@
  */
 export default class ShineEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number[]} [options.color=[1.0, 1.0, 1.0]] - shine color as [r, g, b] (0.0–1.0)
      * @param {number} [options.speed=0.5] - sweeps per second
@@ -47,7 +47,7 @@ export default class ShineEffect extends ShaderEffect {
      * @param {number} [options.pulseDepth=0.0] - subtle base-brightness pulse amplitude (0 disables the pulse)
      * @param {number} [options.pulseSpeed=3.0] - pulse oscillation rate (radians/second)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         color?: number[] | undefined;
         speed?: number | undefined;
         width?: number | undefined;

package/build/video/effects/shine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shine.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,qCATG;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAgEA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBA5LwB,mBAAmB"}
+{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shine.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EAgEA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;CACD;yBA5LwB,mBAAmB"}