melonjs 19.1.0 → 19.3.0

package/build/video/webgl/buffer/index.d.ts

@@ -1,54 +1,25 @@
 /**
- * A WebGL Index Buffer object.
- * Can be used for static patterns (e.g. quad indices) or dynamic indexed drawing.
+ * A WebGL Index Buffer — extends {@link IndexBuffer} with GL buffer binding and upload.
  * @ignore
  */
-export default class IndexBuffer {
+export default class WebGLIndexBuffer extends IndexBuffer {
     /**
      * @param {WebGLRenderingContext|WebGL2RenderingContext} gl - the WebGL context
      * @param {number} maxIndices - maximum number of indices this buffer can hold
      * @param {boolean} [useUint32=false] - use Uint32 indices (WebGL2) instead of Uint16 (WebGL1)
-     * @param {boolean} [dynamic=false] - if true, use STREAM_DRAW for frequent updates; if false, use STATIC_DRAW
      */
-    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, maxIndices: number, useUint32?: boolean, dynamic?: boolean);
+    constructor(gl: WebGLRenderingContext | WebGL2RenderingContext, maxIndices: number, useUint32?: boolean);
     gl: WebGLRenderingContext | WebGL2RenderingContext;
-    dynamic: boolean;
     type: 5123 | 5125;
-    data: Uint16Array<ArrayBuffer> | Uint32Array<ArrayBuffer>;
-    /**
-     * the current number of indices in the buffer
-     * @type {number}
-     */
-    length: number;
     buffer: WebGLBuffer;
-    /**
-     * Fill the buffer with a repeating quad index pattern [0,1,2, 2,1,3, 4,5,6, ...]
-     * and upload as a static buffer.
-     * @param {number} maxQuads - number of quads to generate indices for
-     */
-    fillQuadPattern(maxQuads: number): void;
-    /**
-     * Reset the index count (for dynamic buffers)
-     */
-    clear(): void;
-    /**
-     * Add indices to the buffer, rebased by the given vertex offset
-     * @param {number[]} indices - source indices to add
-     * @param {number} vertexOffset - value to add to each index (vertex count at time of insertion)
-     */
-    add(indices: number[], vertexOffset: number): void;
-    /**
-     * Add pre-computed absolute indices to the buffer (no rebasing)
-     * @param {number[]} indices - absolute index values to add
-     */
-    addRaw(indices: number[]): void;
     /**
      * Upload the current index data to the GPU (for dynamic buffers)
      */
     upload(): void;
     /**
-     * bind this index buffer
+     * Bind this index buffer
      */
     bind(): void;
 }
+import IndexBuffer from "../../buffer/index.js";
 //# sourceMappingURL=index.d.ts.map

package/build/video/webgl/buffer/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;IACC;;;;;OAKG;IACH,gBALW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,YACP,OAAO,EAqBjB;IAlBA,mDAAY;IACZ,iBAAsB;IAGrB,kBAA2B;IAC3B,0DAAuC;IAMxC;;;OAGG;IACH,QAFU,MAAM,CAED;IAEf,oBAA+B;IAGhC;;;;OAIG;IACH,0BAFW,MAAM,QAkBhB;IAED;;OAEG;IACH,cAEC;IAED;;;;OAIG;IACH,aAHW,MAAM,EAAE,gBACR,MAAM,QAOhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAOlB;IAED;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;CACD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/index.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IACC;;;;OAIG;IACH,gBAJW,qBAAqB,GAAC,sBAAsB,cAC5C,MAAM,cACN,OAAO,EAOjB;IAHA,mDAAY;IACZ,kBAA2D;IAC3D,oBAA+B;IAiBhC;;OAEG;IACH,eAOC;IAED;;OAEG;IACH,aAEC;CACD;wBApDuB,uBAAuB"}

package/build/video/webgl/effects/colorMatrix.d.ts

@@ -0,0 +1,92 @@
+/**
+ * A shader effect that applies a 4x4 color transformation matrix.
+ * Provides chainable color adjustment methods that automatically update the GPU uniform.
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // desaturate a sprite
+ * mySprite.shader = new ColorMatrixEffect(renderer).saturate(0.0);
+ * @example
+ * // combine brightness + contrast on a camera
+ * camera.shader = new ColorMatrixEffect(renderer).brightness(1.3).contrast(1.5);
+ * @example
+ * // update dynamically
+ * effect.reset().brightness(1.5).saturate(0.5);
+ */
+export default class ColorMatrixEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {ColorMatrix} [options.matrix] - an initial color matrix. Defaults to identity.
+     */
+    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+        matrix?: ColorMatrix | undefined;
+    });
+    /**
+     * the internal color matrix
+     * @ignore
+     */
+    _matrix: ColorMatrix;
+    /**
+     * Push the current matrix values to the GPU.
+     * @ignore
+     */
+    _syncUniform(): void;
+    /**
+     * Reset the color matrix to identity (no color change).
+     * @returns {this} this instance for chaining
+     */
+    reset(): this;
+    /**
+     * Apply a brightness adjustment.
+     * @param {number} amount - brightness multiplier (1.0 = normal, >1 brighter, <1 darker)
+     * @returns {this} this instance for chaining
+     */
+    brightness(amount: number): this;
+    /**
+     * Apply a contrast adjustment.
+     * @param {number} amount - contrast multiplier (1.0 = normal, >1 more contrast, <1 less)
+     * @returns {this} this instance for chaining
+     */
+    contrast(amount: number): this;
+    /**
+     * Apply a saturation adjustment.
+     * @param {number} amount - saturation level (0.0 = grayscale, 1.0 = normal, >1 over-saturated)
+     * @returns {this} this instance for chaining
+     */
+    saturate(amount: number): this;
+    /**
+     * Apply a hue rotation.
+     * @param {number} angle - rotation angle in radians
+     * @returns {this} this instance for chaining
+     */
+    hueRotate(angle: number): this;
+    /**
+     * Apply a sepia tone.
+     * @param {number} [amount=1.0] - sepia intensity (0.0 = original, 1.0 = full sepia)
+     * @returns {this} this instance for chaining
+     */
+    sepia(amount?: number): this;
+    /**
+     * Apply a color inversion.
+     * @param {number} [amount=1.0] - inversion amount (0.0 = original, 1.0 = fully inverted)
+     * @returns {this} this instance for chaining
+     */
+    invertColors(amount?: number): this;
+    /**
+     * Multiply the current matrix by another color matrix.
+     * @param {ColorMatrix} matrix - the matrix to multiply with
+     * @returns {this} this instance for chaining
+     */
+    multiply(matrix: ColorMatrix): this;
+    /**
+     * Multiplies the current matrix with a transform described by individual values.
+     * Accepts either 6 values (2D affine: a, b, c, d, e, f) or 16 values (full 4x4 column-major).
+     * @param {...number} args - 6 or 16 numeric values
+     * @returns {this} this instance for chaining
+     */
+    transform(...args: number[]): this;
+}
+import ShaderEffect from "../shadereffect.js";
+import { ColorMatrix } from "../../../math/color_matrix.ts";
+//# sourceMappingURL=colorMatrix.d.ts.map

package/build/video/webgl/effects/colorMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/colorMatrix.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAA8B,MAAM;KACtC,EAkBA;IANA;;;OAGG;IACH,qBAAkD;IAInD;;;OAGG;IACH,qBAEC;IAED;;;OAGG;IACH,SAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACJ,IAAI,CAMhB;IAED;;;;OAIG;IACH,iBAHW,WAAW,GACT,IAAI,CAMhB;IAED;;;;;OAKG;IACH,mBAHc,MAAM,EAAA,GACP,IAAI,CAMhB;CACD;yBApJwB,oBAAoB;4BADjB,+BAA+B"}

package/build/video/webgl/effects/desaturate.d.ts

@@ -1,7 +1,5 @@
 /**
  * A shader effect that desaturates (grayscales) the sprite.
- * The `intensity` uniform controls how much color is removed
- * (0.0 = full color, 1.0 = fully grayscale).
  * Commonly used for disabled states, death effects, or petrification.
  * @category Effects
  * @see {@link Renderable.shader} for usage
@@ -12,7 +10,7 @@
  * // partial desaturation (50%)
  * mySprite.shader = new DesaturateEffect(renderer, { intensity: 0.5 });
  */
-export default class DesaturateEffect extends ShaderEffect {
+export default class DesaturateEffect extends ColorMatrixEffect {
     /**
      * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
      * @param {object} [options] - effect options
@@ -28,5 +26,5 @@ export default class DesaturateEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ColorMatrixEffect from "./colorMatrix.js";
 //# sourceMappingURL=desaturate.d.ts.map

package/build/video/webgl/effects/desaturate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAgBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA/CwB,oBAAoB"}
+{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAnC6B,kBAAkB"}

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

@@ -9,7 +9,7 @@
  * // partial inversion
  * mySprite.shader = new InvertEffect(renderer, { intensity: 0.5 });
  */
-export default class InvertEffect extends ShaderEffect {
+export default class InvertEffect extends ColorMatrixEffect {
     /**
      * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
      * @param {object} [options] - effect options
@@ -25,5 +25,5 @@ export default class InvertEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ColorMatrixEffect from "./colorMatrix.js";
 //# sourceMappingURL=invert.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAgBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA5CwB,oBAAoB"}
+{"version":3,"file":"invert.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/invert.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAlC6B,kBAAkB"}

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

@@ -0,0 +1,105 @@
+/**
+ * additional import for TypeScript
+ * @import { Color } from "../../../math/color.ts";
+ * @import { default as WebGLRenderer } from "../webgl_renderer.js";
+ */
+/**
+ * A procedural radial-gradient shader effect: solid color at the center
+ * fading linearly to fully transparent at the edge of the host quad.
+ * The falloff is naturally elliptical for non-square quads.
+ *
+ * **UV-space caveat.** The `apply(color, uv)` function receives
+ * `vRegion` — the atlas UVs of the host quad. The falloff math
+ * (`length(uv * 2 - 1)`) assumes those UVs span `[0, 1] × [0, 1]`,
+ * which is true when the quad samples a full-rect texture (a
+ * dedicated 1×1 white pixel, a non-atlased Sprite, an FBO blit, or
+ * the engine-provided light atlas used by `WebGLRenderer.drawLight`).
+ * If you attach this effect to a Sprite that uses a *sub-region* of a
+ * larger atlas, `uv` will be in `[u0..u1] × [v0..v1]` and the radial
+ * center will be misplaced. For atlas-based renderables, set the
+ * effect's `uColor`/`uIntensity` and pair it with a Sprite whose
+ * texture covers a full atlas, or use a Sprite created from a
+ * standalone image.
+ *
+ * The falloff curve is **linear** (`f = clamp(1 - d, 0, 1)`) to match
+ * the Canvas 2D `createRadialGradient` two-stop output exactly. Output
+ * is premultiplied so the result composes correctly under additive
+ * (`"lighter"`) blending across overlapping quads.
+ *
+ * Color & intensity come from **two stacked sources**, multiplied
+ * together: the `uColor`/`uIntensity` uniforms (set per-effect via
+ * `setColor` / `setIntensity` — the natural API for a single-instance
+ * shader attached to a renderable) AND the per-vertex tint coming
+ * through `aColor` (used by `WebGLRenderer.drawLight` to encode each
+ * light's color + intensity in the vertex stream so multiple lights
+ * sharing this shader can batch into a single draw call). For typical
+ * standalone usage the per-vertex tint is `(1,1,1,1)` and the uniforms
+ * drive the look; for the Light2d batching path the uniforms stay at
+ * defaults and the tint carries everything.
+ * @category Effects
+ * @example
+ * // Soft white spot, 50% peak alpha at center
+ * const spot = new RadialGradientEffect(renderer, { intensity: 0.5 });
+ * @example
+ * // Tinted hotspot — orange center, full brightness, sized via the
+ * // host quad's bounds
+ * const hot = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 128, 64),
+ *     intensity: 1.0,
+ * });
+ * hot.setIntensity(2.0); // pulse brighter at runtime
+ * @example
+ * // 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, {
+ *     color: new Color(120, 255, 200), // mint green
+ *     intensity: 0.8,
+ * });
+ * pickup.blendMode = "lighter";
+ * @example
+ * // Damage / impact indicator — short-lived elliptical flash on hit.
+ * // The quad's width/height drive the falloff aspect for free.
+ * const flash = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 32, 32),
+ *     intensity: 1.5,
+ * });
+ * // animate intensity to fade out
+ * tween.to({ intensity: 0 }, 200).onUpdate((s) => flash.setIntensity(s.intensity));
+ * @example
+ * // Debug overlay — draw a soft circle wherever the player is to mark
+ * // a trigger zone, without baking a texture per zone.
+ * const zoneMarker = new RadialGradientEffect(renderer, {
+ *     color: new Color(80, 160, 255),
+ *     intensity: 0.4,
+ * });
+ */
+export default class RadialGradientEffect extends ShaderEffect {
+    /**
+     * @param {WebGLRenderer} renderer - the current renderer instance
+     * @param {object} [options] - initial uniform values
+     * @param {Color} [options.color] - center color (0..255 RGB); defaults to white
+     * @param {number} [options.intensity=1] - peak alpha at the center (0..1+)
+     */
+    constructor(renderer: WebGLRenderer, options?: {
+        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).
+     * @param {Color} color - 0..255 RGB color
+     */
+    setColor(color: Color): void;
+    /**
+     * Set the peak intensity. Acts as a brightness multiplier on the
+     * falloff curve; values above 1 over-saturate the center of the gradient.
+     * @param {number} intensity - 0..1+ multiplier
+     */
+    setIntensity(intensity: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+import type { Color } from "../../../math/color.ts";
+import type { default as WebGLRenderer } from "../webgl_renderer.js";
+//# sourceMappingURL=radialGradient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,YAErB;QAAwB,KAAK;QACJ,SAAS;KACpC,EA0CA;IAZA,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBArJwB,oBAAoB;2BAInB,wBAAwB;8CACL,sBAAsB"}

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

@@ -8,7 +8,7 @@
  * // partial sepia
  * mySprite.shader = new SepiaEffect(renderer, { intensity: 0.5 });
  */
-export default class SepiaEffect extends ShaderEffect {
+export default class SepiaEffect extends ColorMatrixEffect {
     /**
      * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
      * @param {object} [options] - effect options
@@ -24,5 +24,5 @@ export default class SepiaEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
 }
-import ShaderEffect from "../shadereffect.js";
+import ColorMatrixEffect from "./colorMatrix.js";
 //# sourceMappingURL=sepia.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAmBA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;yBA9CwB,oBAAoB"}
+{"version":3,"file":"sepia.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/sepia.js"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH;IACC;;;;OAIG;IACH,sBAJW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAjC6B,kBAAkB"}

package/build/video/webgl/effects/vignette.d.ts

@@ -0,0 +1,42 @@
+/**
+ * A shader effect that darkens the edges of the screen, drawing focus
+ * to the center. Commonly used for atmosphere, cinematic feel, or to
+ * naturally frame a camera viewport (e.g. minimap).
+ * @category Effects
+ * @see {@link Renderable.shader} for usage
+ * @example
+ * // subtle vignette on the main camera
+ * app.viewport.shader = new VignetteEffect(renderer);
+ * @example
+ * // stronger cinematic vignette
+ * app.viewport.shader = new VignetteEffect(renderer, {
+ *     strength: 0.3,
+ *     size: 20.0,
+ * });
+ */
+export default class VignetteEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number} [options.strength=0.15] - edge darkening power (lower = stronger darkening, higher = softer falloff)
+     * @param {number} [options.size=25.0] - vignette spread multiplier (higher = smaller dark area)
+     */
+    constructor(renderer: import("../webgl_renderer.js").default, options?: {
+        strength?: number | undefined;
+        size?: number | undefined;
+    });
+    strength: number;
+    size: number;
+    /**
+     * set the vignette strength
+     * @param {number} strength - edge darkening power (lower = stronger, higher = softer)
+     */
+    setStrength(strength: number): void;
+    /**
+     * set the vignette size
+     * @param {number} size - spread multiplier (higher = smaller dark area)
+     */
+    setSize(size: number): void;
+}
+import ShaderEffect from "../shadereffect.js";
+//# sourceMappingURL=vignette.d.ts.map

package/build/video/webgl/effects/vignette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vignette.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/effects/vignette.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;OAKG;IACH,sBALW,OAAO,sBAAsB,EAAE,OAAO,YAE9C;QAAyB,QAAQ;QACR,IAAI;KAC/B,EAoBA;IALA,iBAAwC;IACxC,aAAgC;IAMjC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,cAFW,MAAM,QAKhB;CACD;yBA/DwB,oBAAoB"}

package/build/video/webgl/glshader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAKf;IAED;;;OAGG;IACH,UAFU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,KAAK,EAAE,CAEiC;IAElD;;;OAGG;IACH,SAFU,YAAY,CAOrB;IAED;;;OAGG;IACH,UAFU,MAAM,CAE8B;IAM/C;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CASjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QAiB7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAsBhB;IAED;;OAEG;IACH,gBAQC;CACD"}
+{"version":3,"file":"glshader.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/glshader.js"],"names":[],"mappings":"AAOA;;;GAGG;AACH;IACC;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,gBA1BW,qBAAqB,UACrB,MAAM,YACN,MAAM,cACN,MAAM,EAyEhB;IAjDA;;;OAGG;IACH,IAFU,qBAAqB,CAEnB;IAEZ;;;OAGG;IACH,QAFU,MAAM,CAKf;IAED;;;OAGG;IACH,UAFU,MAAM,CAKf;IAED;;;OAGG;IACH,YAFU,KAAK,EAAE,CAEiC;IAElD;;;OAGG;IACH,SAFU,YAAY,CAOrB;IAED;;;OAGG;IACH,UAFU,MAAM,CAE8B;IAM/C;;OAEG;IACH,aAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACJ,KAAK,CASjB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,YAAY,QAiB7B;IAED;;;;;OAKG;IACH,wBAJW,qBAAqB,cACrB,MAAM,EAAE,UACR,MAAM,QAmBhB;IAED;;OAEG;IACH,gBAQC;CACD"}

package/build/video/webgl/lighting/constants.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Constants shared between the lit fragment shader (`multitexture-lit.js`),
+ * the lit batcher (`LitQuadBatcher`), and the uniform packer (`pack.ts`).
+ * Kept in a tiny standalone module so the three consumers don't depend on
+ * each other transitively for a single integer.
+ */
+/**
+ * Maximum number of `Light2d` instances the lit fragment shader supports
+ * concurrently per draw call. Lights past this index are ignored. Sized
+ * to keep the GLSL uniform arrays comfortably within WebGL1 limits.
+ */
+export declare const MAX_LIGHTS = 8;
+//# sourceMappingURL=constants.d.ts.map

package/build/video/webgl/lighting/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/constants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,eAAO,MAAM,UAAU,IAAI,CAAC"}

package/build/video/webgl/lighting/pack.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Per-frame scratch buffer for `packLights()`. Pre-allocates one entry
+ * per light slot so the per-camera-per-frame upload doesn't allocate.
+ */
+export interface LightUniformScratch {
+    positions: Float32Array;
+    colors: Float32Array;
+    heights: Float32Array;
+    ambient: number[];
+}
+/**
+ * Result of `packLights()` — typed-array views into the scratch plus the
+ * actual count. `WebGLRenderer.setLightUniforms` forwards this to
+ * `LitQuadBatcher.setLightUniforms` for upload.
+ */
+export interface LightUniforms extends LightUniformScratch {
+    count: number;
+}
+/**
+ * Allocate a fresh scratch buffer sized for `MAX_LIGHTS` slots. One per
+ * renderer is enough; reuse across frames.
+ */
+export declare function createLightUniformScratch(): LightUniformScratch;
+/**
+ * Light2d-shaped duck-type — anything `packLights()` reads from. Avoids
+ * importing `Light2d` directly (keeps this module renderer-agnostic).
+ */
+interface LightLike {
+    getBounds(): {
+        centerX: number;
+        centerY: number;
+        width: number;
+        height: number;
+    };
+    intensity: number;
+    color: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    lightHeight: number;
+}
+/** Color-shaped duck-type for the ambient floor. */
+interface ColorLike {
+    r: number;
+    g: number;
+    b: number;
+}
+/**
+ * Pack the active scene lights into the scratch buffer in a shape the
+ * lit fragment shader uploads directly.
+ *
+ * Light positions are translated from world-space (where
+ * `light.getBounds().centerX/Y` lives) into the renderer's
+ * pre-projection coords by subtracting `(translateX, translateY)` —
+ * the same translate `Camera2d.draw()` applies to the world container.
+ * This matches what `Stage.drawLighting` does for the cutout pass, so
+ * the lit fragment's `lightPos - vWorldPos` math lines up with the
+ * camera's view.
+ *
+ * Lights past `MAX_LIGHTS` (8) are silently dropped. Unused slots are
+ * zero-filled so stale data from a previous frame can't leak into the
+ * shader.
+ *
+ * Pure function: deterministic given the same inputs, no I/O, scratch
+ * is the only mutable target.
+ * @param lights - active lights iterable (e.g. `Stage._activeLights`); falsy treated as empty
+ * @param ambient - ambient floor color (0..255 RGB); falsy treated as black
+ * @param translateX - world-to-screen X translate (matches `Camera2d.draw()`)
+ * @param translateY - world-to-screen Y translate
+ * @param scratch - pre-allocated scratch (see `createLightUniformScratch`)
+ * @returns the scratch with `count` filled in
+ */
+export declare function packLights(lights: Iterable<LightLike> | null | undefined, ambient: ColorLike | null | undefined, translateX: number, translateY: number, scratch: LightUniformScratch): LightUniforms;
+export {};
+//# sourceMappingURL=pack.d.ts.map

package/build/video/webgl/lighting/pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pack.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/lighting/pack.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IACnC,SAAS,EAAE,YAAY,CAAC;IACxB,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,EAAE,YAAY,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAc,SAAQ,mBAAmB;IACzD,KAAK,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,mBAAmB,CAO/D;AAED;;;GAGG;AACH,UAAU,SAAS;IAClB,SAAS,IAAI;QACZ,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KACf,CAAC;IACF,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC3C,WAAW,EAAE,MAAM,CAAC;CACpB;AAED,oDAAoD;AACpD,UAAU,SAAS;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,UAAU,CACzB,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,IAAI,GAAG,SAAS,EAC9C,OAAO,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,EACrC,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,mBAAmB,GAC1B,aAAa,CA4Cf"}

package/build/video/webgl/shaders/multitexture-lit.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Generate the fragment shader for `LitQuadBatcher` — the SpriteIlluminator
+ * path that supports per-pixel normal-map lighting from up to `MAX_LIGHTS`
+ * point lights.
+ *
+ * Sprites without a `normalMap` push `aNormalTextureId = -1` and take the
+ * unlit fast path inside this same shader (sample color, multiply by
+ * vertex color, return) so lit and unlit sprites can share the lit batch
+ * when they coexist with active lights. The cost vs the truly-unlit
+ * `QuadBatcher` shader is one varying read + one comparison per fragment.
+ *
+ * The light's "height above the sprite plane" is encoded as a small
+ * fraction of the light's radius (default `0.075`) so that lights
+ * exactly at a fragment's screen position don't produce degenerate
+ * flat shading.
+ * @param {number} maxTextures - the number of color/normal texture units to support
+ * @returns {string} GLSL fragment shader source
+ * @ignore
+ */
+export function buildLitMultiTextureFragment(maxTextures: number): string;
+export { MAX_LIGHTS };
+import { MAX_LIGHTS } from "../lighting/constants.ts";
+//# sourceMappingURL=multitexture-lit.d.ts.map

package/build/video/webgl/shaders/multitexture-lit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multitexture-lit.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/shaders/multitexture-lit.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,0DAJW,MAAM,GACJ,MAAM,CAiFlB;;2BAjI0B,0BAA0B"}

package/build/video/webgl/webgl_renderer.d.ts

@@ -16,6 +16,12 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLRenderingContext}
      */
     gl: WebGLRenderingContext;
+    /**
+     * Saved projection matrix for begin/endPostEffect.
+     * @type {Matrix3d}
+     * @ignore
+     */
+    _savedEffectProjection: Matrix3d;
     /**
      * sets or returns the thickness of lines for shape drawing
      * @type {number}
@@ -54,6 +60,7 @@ export default class WebGLRenderer extends Renderer {
         x: number;
         y: number;
     }[];
+    _clipAABB: Bounds;
     _polyVerts: any[];
     _currentGradient: any;
     /**
@@ -85,6 +92,8 @@ export default class WebGLRenderer extends Renderer {
      * @default 1
      */
     get WebGLVersion(): number;
+    _lightShader: RadialGradientEffect | undefined;
+    _lightAtlas: TextureAtlas | undefined;
     /**
      * add a new batcher to this renderer
      * @param {Batcher} batcher - a batcher instance
@@ -116,14 +125,20 @@ export default class WebGLRenderer extends Renderer {
      * let basic      = renderer.createPattern(image, "no-repeat");
      */
     createPattern(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, repeat: string): TextureAtlas;
-    /**
-     * Sets the WebGL viewport, which specifies the affine transformation of x and y from normalized device coordinates to window coordinates
-     * @param {number} [x = 0] - x the horizontal coordinate for the lower left corner of the viewport origin
-     * @param {number} [y = 0] - y the vertical coordinate for the lower left corner of the viewport origin
-     * @param {number} [w = width of the canvas] - the width of viewport
-     * @param {number} [h = height of the canvas] - the height of viewport
+    _lightUniformsScratch: import("./lighting/pack.ts").LightUniformScratch | undefined;
+    /**
+     * Lazy-init a shared 1×1 white `TextureAtlas` used as the source
+     * texture for `drawLight`'s procedural shader. The shader ignores
+     * the sampled color, but `addQuad`'s vertex format includes a
+     * texture-unit attribute so we still need a real texture; sharing
+     * one across every light keeps them on the same multi-texture slot
+     * (no flush on light switch).
+     * @returns {TextureAtlas}
+     * @ignore
      */
-    setViewport(x?: number, y?: number, w?: number, h?: number): void;
+    _getLightAtlas(): TextureAtlas;
+    /** @ignore */
+    endPostEffect(renderable: any): void;
     /**
      * Clears the gl context with the given color.
      * @param {Color|string} [color="#000000"] - CSS color.
@@ -512,8 +527,10 @@ export default class WebGLRenderer extends Renderer {
 }
 import Renderer from "./../renderer.js";
 import { Matrix3d } from "../../math/matrix3d.ts";
+import { Bounds } from "../../physics/bounds.ts";
 import type { Batcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
+import RadialGradientEffect from "./effects/radialGradient.js";
 import { TextureAtlas } from "./../texture/atlas.js";
 import { Color } from "./../../math/color.ts";
 import type { Rect } from "./../../geometries/rectangle.ts";

package/build/video/webgl/webgl_renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/webgl_renderer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"webgl_renderer.d.ts","sourceRoot":"","sources":["../../../src/video/webgl/webgl_renderer.js"],"names":[],"mappings":"AAqDA;;;GAGG;AACH;IAQE;;;;;OAKG;IACH,oBAJU,MAAM,CAIU;IAU1B;;;;OAIG;IACH,IAFU,qBAAqB,CAEI;IAYnC;;;;OAIG;IACH,wBAHU,QAAQ,CAG0B;IAE5C;;;;OAIG;IACH,WAHU,MAAM,CAGE;IAElB;;;;;OAKG;IACH,UAHU,MAAM,CAGO;IAEvB;;;OAGG;IACH,cAFU,WAAW,CAEqB;IAE1C;;;;OAIG;IACH,sBAHU,MAAM,CAGwD;IAExE;;;;OAIG;IACH,iBAHU,MAAM,CAMf;IAED;;;OAGG;IACH;;;QAEE;IAIF,kBAA6B;IAG7B,kBAAoB;IAGpB,sBAA4B;IAE5B;;;;OAIG;IACH,kBAFU,QAAQ,CAEuC;IAEzD;;;OAGG;IACH,gBAFU,OAAO,CAEc;IAE/B;;;OAGG;IACH,gBAFU,YAAY,CAES;IAE/B;;;OAGG;IACH,4BAAyB;IAuBzB,wBAA2B;IAkB3B,oBAAqD;IAyCtD;;;;OAIG;IACH,oBAHU,MAAM,CAKf;IAkHC,+CAA6B;IAY7B,sCAA4B;IAI9B;;;;;OAKG;IACH,oBAJW,OAAO,SACP,MAAM,aACN,OAAO,QAYjB;IAED;;;;;OAKG;IACH,kBAJW,MAAM,WACN,QAAQ,GACN,OAAO,CA+CnB;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;;;;;OAWG;IACH,qBAVW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,UAC1G,MAAM,GACJ,YAAY,CA0CxB;IAiCC,oFAAwD;IA6E1D;;;;;;;;;OASG;IACH,kBAHa,YAAY,CAqBxB;IAyDD,cAAc;IACd,qCAsFC;IAuJD;;;;OAIG;IACH,mBAHW,KAAK,GAAC,MAAM,WACZ,OAAO,QAuBjB;IAED;;;;;;OAMG;IACH,aALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAOhB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,iBAjBW,gBAAgB,GAAC,eAAe,GAAC,gBAAgB,GAAC,iBAAiB,GAAC,WAAW,GAAC,eAAe,GAAC,UAAU,GAAC,eAAe,MAC1H,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAwFhB;IAED;;;;;;;;OAQG;IACH,qBAPW,YAAY,KACZ,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAkBhB;IA2DD;;;;;;;;;;;;;;;OAeG;IACH,kBAEC;IAED;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAIhB;IAED;;OAEG;IACH,6BAEC;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,OACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;;OASG;IACH,oBAPW,MAAM,QACN,MAAM,QACN,MAAM,QACN,MAAM,KACN,MAAM,KACN,MAAM,QAIhB;IAED;;;;;;;;OAQG;IACH,UANW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;OAMG;IACH,QALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QAIhB;IAED;;;;;;;OAOG;IACH,aANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,oBAKhB;IAED;;;;OAIG;IACH,eAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,SAC1C,OAAO,QA2BjB;IAED;;;OAGG;IACH,aAFW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,GAAC,MAAM,QAIpD;IAED;;OAEG;IACH,kBAEC;IAED;;;;OAIG;IACH,cAFa,qBAAqB,CAIjC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,oBAJW,MAAM,uBACN,OAAO,GACL,MAAM,CAgElB;IArDC,+BAAmD;IAuDrD;;;;;;;;;;;;OAYG;IACH,gBAmDC;IAED;;;;;;;;;;;;OAYG;IACH,aAGC;IAED;;;;;;;;;;;OAWG;IACH,cAVW,MAAM,QAYhB;IAED;;;;OAIG;IACH,SAHW,MAAM,KACN,MAAM,QAIhB;IA8BD;;;OAGG;IACH,sBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,kBAFa,MAAM,CAIlB;IAoBD;;;;;;;;;OASG;IACH,aARW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,SACP,OAAO,QAWjB;IAED;;;;;;;;OAQG;IACH,WAPW,MAAM,KACN,MAAM,UACN,MAAM,SACN,MAAM,OACN,MAAM,kBACN,OAAO,QAqCjB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,SACN,OAAO,QAWjB;IAED;;;;;;OAMG;IACH,eALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAwBhB;IAED;;;;;;OAMG;IACH,mBALW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAgBhB;IAED;;;;;;OAMG;IACH,iBALW,MAAM,UACN,MAAM,QACN,MAAM,QACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,oBAHW,OAAO,SACP,OAAO,QAkDjB;IAED;;;OAGG;IACH,kBAFW,OAAO,QAuDjB;IAED;;;;;;;OAOG;IACH,cANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,SACN,OAAO,QA2BjB;IAED;;;;;;OAMG;IACH,YALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QA2BhB;IAED;;;;;;;;OAQG;IACH,mBAPW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,SACN,OAAO,QAWjB;IAED;;;;;;;OAOG;IACH,iBANW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,UACN,MAAM,QA4FhB;IAED;;;;OAIG;IACH,eAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAgED;;;;;;;;;OASG;IACH,gBAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,KACxB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAKhB;IAED;;;;;;;;;OASG;IACH,aAPW,QAAQ,GAAC,QAAQ,GAAC,MAAM,KACxB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAmChB;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;OAUG;IACH,YALW,MAAM,KACN,MAAM,SACN,MAAM,UACN,MAAM,QA+EhB;IAED;;;;;;;OAOG;IACH,eAHW,IAAI,GAAC,SAAS,GAAC,OAAO,GAAC,IAAI,GAAC,OAAO,WACnC,OAAO,QA6CjB;;CAcD;qBA7yEoB,kBAAkB;yBAXd,wBAAwB;uBAC1B,yBAAyB;6BAqCtB,uBAAuB;yBAvBxB,uBAAuB;iCAUf,6BAA6B;6BAXpB,uBAAuB;sBAhBhC,uBAAuB;0BAiCjC,iCAAiC;+BAC5B,iCAAiC;6BACnC,6BAA6B;0BAChC,4BAA4B;6BACzB,+BAA+B;8BAC9B,wBAAwB"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "melonjs",
-	"version": "19.1.0",
+	"version": "19.3.0",
 	"description": "melonJS Game Engine",
 	"homepage": "http://www.melonjs.org/",
 	"type": "module",

package/build/video/webgl/buffer/vertex.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../../src/video/webgl/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;IACC,6CAeC;IAbA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAG9C;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;;;;;;OASG;IACH,QARW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,QAkBhB;IAED;;;;;;OAMG;IACH,iBALW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAahB;IAED;;;OAGG;IACH,kEAaC;IAED;;;OAGG;IACH,2DAMC;IAED;;;OAGG;IACH,yDAMC;CACD"}