melonjs 20.10.1 → 20.11.0

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":"AAyCA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;;;OAQG;IACH,sBARW,QAAQ,YAEhB;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;yBA9HwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"dropShadow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dropShadow.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;;;;OAQG;IACH,sBARW,QAAQ,YAEhB;QAAyB,OAAO;QACP,OAAO;QACL,KAAK;QACP,OAAO;QACL,WAAW;KACxC,EA0CA;IAED;;;;OAIG;IACH,aAHW,MAAM,KACN,MAAM,QAIhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA/IwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -18,12 +18,16 @@
  * @example
  * // red flash
  * const flash = new FlashEffect(renderer, { color: [1.0, 0.0, 0.0] });
+ * @example
+ * // a hit flash that only half covers the sprite, even at full intensity
+ * const hit = new FlashEffect(renderer, { color: [1.0, 1.0, 1.0, 0.5] });
+ * hit.setIntensity(1.0);
  */
 export default class FlashEffect extends ShaderEffect {
     /**
      * @param {Renderer} 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.color=[1.0, 1.0, 1.0]] - flash color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the intensity
      * @param {number} [options.intensity=0.0] - initial flash intensity (0.0–1.0)
      */
     constructor(renderer: Renderer, options?: {
@@ -38,7 +42,7 @@ export default class FlashEffect extends ShaderEffect {
     setIntensity(value: number): void;
     /**
      * set the flash color
-     * @param {number[]} color - flash color as [r, g, b] (0.0–1.0)
+     * @param {number[]} color - flash color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the intensity
      */
     setColor(color: number[]): void;
 }

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":"AAuBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAA2B,KAAK;QACP,SAAS;KACpC,EAkBA;IAJA,kBAAyC;IAM1C;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAtFwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"flash.d.ts","sourceRoot":"","sources":["../../../src/video/effects/flash.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAA2B,KAAK;QACP,SAAS;KACpC,EAmBA;IAJA,kBAAyC;IAM1C;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBA5FwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -0,0 +1,48 @@
+/**
+ * Keeping an effect's samples inside the sprite's own frame.
+ *
+ * A sprite drawn from an atlas or a tileset shows one frame of a bigger
+ * texture, and the texture goes on past that frame into the neighbouring
+ * ones. An effect that samples away from the fragment it shades (a glow, an
+ * outline, a blur, a shadow, a distortion) reads those neighbours along the
+ * frame's edge, and draws them. `frameTexel()` reads a texel of the frame
+ * the effect draws, `ME_frame` (its UV rect: left, top, right, bottom):
+ * transparent outside it, and kept half a texel (`ME_frame_half`, in UV)
+ * inside it, so filtering never reaches over the edge. Only where another
+ * frame could be: a side of the frame that is the texture's own edge is
+ * left unbounded, and so is a pass over a whole texture (a render target
+ * blit, a mesh). There, sampling is what it always was.
+ *
+ * On a sprite, `ME_frame` comes with the quad: every sprite vertex carries
+ * the UV of its quad's opposite corner (`aFrame`), and the effect's vertex
+ * stage turns it into the frame. Sprites drawn from different frames
+ * through the same effect so share one draw. Only `ME_frame_half`, which
+ * changes with the texture, is a uniform (`ShaderEffect#_setFrameTexel`).
+ * On a mesh, which carries no frame, `ME_frame` is a uniform, left
+ * unbounded.
+ * @ignore
+ */
+/**
+ * the frame, the half texel and `frameTexel()`, for a GLSL effect body. The
+ * sprite program defines `ME_SPRITE_FRAME` and computes the varying in its
+ * vertex stage (see glsl_realization.js); a mesh hosting the body reads the
+ * uniform
+ * @ignore
+ */
+export const FRAME_GLSL: "\n#ifdef ME_SPRITE_FRAME\nvarying vec4 ME_frame;\n#else\nuniform vec4 ME_frame;\n#endif\nuniform vec2 ME_frame_half;\nvec4 frameTexel(vec2 p) {\n\tvec2 inside = step(ME_frame.xy, p) * step(p, ME_frame.zw);\n\tvec2 q = clamp(p, ME_frame.xy + ME_frame_half, ME_frame.zw - ME_frame_half);\n\treturn texture2D(uSampler, q) * (inside.x * inside.y);\n}\n";
+/**
+ * the members to add to a WGSL effect's uniform struct, which `frameTexel()`
+ * reads through the effect's `fx` binding. On a sprite the scaffold reads
+ * the frame from the quad instead of `fx.ME_frame` (see wgsl/scaffold.js),
+ * which a mesh hosting the body still reads
+ * @ignore
+ */
+export const FRAME_WGSL_MEMBERS: "\n\tME_frame : vec4f,\n\tME_frame_half : vec2f,";
+/**
+ * `frameTexel()` for a WGSL effect body, sampling with implicit derivatives
+ * (uniform control flow only), and `frameTexelLevel()`, sampling level 0,
+ * which works anywhere
+ * @ignore
+ */
+export const FRAME_WGSL: "\nfn frameUV(p : vec2f) -> vec2f {\n\treturn clamp(p, fx.ME_frame.xy + fx.ME_frame_half, fx.ME_frame.zw - fx.ME_frame_half);\n}\nfn frameInside(p : vec2f) -> f32 {\n\tlet inside = step(fx.ME_frame.xy, p) * step(p, fx.ME_frame.zw);\n\treturn inside.x * inside.y;\n}\nfn frameTexel(p : vec2f) -> vec4f {\n\treturn textureSample(uTexture, uSampler, frameUV(p)) * frameInside(p);\n}\nfn frameTexelLevel(p : vec2f) -> vec4f {\n\treturn textureSampleLevel(uTexture, uSampler, frameUV(p), 0.0) * frameInside(p);\n}\n";
+//# sourceMappingURL=frame.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../../src/video/effects/frame.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;GAMG;AACH,wXAYE;AAEF;;;;;;GAMG;AACH,mFAEyB;AAEzB;;;;;GAKG;AACH,yhBAcE"}

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

@@ -10,15 +10,18 @@
  *     color: [0.2, 0.5, 1.0],
  *     intensity: 1.5,
  * }));
+ * @example
+ * // a faint white halo: the color's alpha is the halo's opacity
+ * mySprite.addPostEffect(new GlowEffect(renderer, { color: [1.0, 1.0, 1.0, 0.5] }));
  */
 export default class GlowEffect extends ShaderEffect {
     /**
      * @param {Renderer} 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.color=[1.0, 1.0, 1.0]] - glow color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha is the halo's opacity
      * @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]
+     * @param {number[]} [options.textureSize] - the size, `[width, height]`, of the texture its spread is measured in; by default the texture it draws (a sprite's own, the screen for a camera's effect)
      */
     constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
@@ -29,7 +32,7 @@ export default class GlowEffect extends ShaderEffect {
     intensity: number;
     /**
      * set the glow color
-     * @param {number[]} color - glow color as [r, g, b] (0.0–1.0)
+     * @param {number[]} color - glow color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha is the halo's opacity
      */
     setColor(color: number[]): void;
     /**
@@ -38,7 +41,8 @@ export default class GlowEffect extends ShaderEffect {
      */
     setIntensity(value: number): void;
     /**
-     * set the texture size
+     * Measure the effect's spread in the texels of a texture of this size,
+     * rather than of the texture it draws (the default)
      * @param {number} width - texture width in pixels
      * @param {number} height - texture height in pixels
      */

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":"AAuCA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,QAAQ,YAEhB;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;yBA7HwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"glow.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glow.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;QACP,WAAW;KACxC,EAyCA;IAPA,kBAAyC;IAS1C;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAtIwB,mBAAmB;0BAOnB,gBAAgB"}

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":"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,CAoCvH"}
+{"version":3,"file":"glsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/glsl_realization.js"],"names":[],"mappings":"AAmJA;;;;;;;;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,CAsCvH"}

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

@@ -10,12 +10,15 @@
  * mySprite.addPostEffect(holo);
  * // update each frame
  * holo.setTime(performance.now() / 1000);
+ * @example
+ * // a faint cyan tint, the scan lines and flicker unchanged
+ * mySprite.addPostEffect(new HologramEffect(renderer, { color: [0.1, 0.7, 1.0, 0.4] }));
  */
 export default class HologramEffect extends ShaderEffect {
     /**
      * @param {Renderer} 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.color=[0.1, 0.7, 1.0]] - hologram tint color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the intensity
      * @param {number} [options.intensity=0.5] - effect intensity (0.0–1.0)
      */
     constructor(renderer: Renderer, options?: {
@@ -24,7 +27,7 @@ export default class HologramEffect extends ShaderEffect {
     });
     /**
      * set the hologram tint color
-     * @param {number[]} color - color as [r, g, b] (0.0–1.0)
+     * @param {number[]} color - color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the intensity
      */
     setColor(color: number[]): void;
 }

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":"AA+BA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAA2B,KAAK;QACP,SAAS;KACpC,EAyBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBApFwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"hologram.d.ts","sourceRoot":"","sources":["../../../src/video/effects/hologram.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAA2B,KAAK;QACP,SAAS;KACpC,EA0BA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAzFwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -12,6 +12,9 @@
  *     width: 2.0,
  * }));
  * @example
+ * // a half-transparent white outline
+ * mySprite.addPostEffect(new OutlineEffect(renderer, { color: [1, 1, 1, 0.5] }));
+ * @example
  * // remove the effect
  * mySprite.removePostEffect(outline);
  */
@@ -19,9 +22,9 @@ export default class OutlineEffect extends ShaderEffect {
     /**
      * @param {Renderer} 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.color=[1.0, 1.0, 1.0]] - outline color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha is the outline's opacity
      * @param {number} [options.width=1.0] - outline width in pixels
-     * @param {number[]} [options.textureSize] - texture dimensions [width, height] (defaults to renderer size)
+     * @param {number[]} [options.textureSize] - the size, `[width, height]`, of the texture its width is measured in; by default the texture it draws (a sprite's own, the screen for a camera's effect)
      */
     constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
@@ -30,7 +33,7 @@ export default class OutlineEffect extends ShaderEffect {
     });
     /**
      * set the outline color
-     * @param {number[]} color - outline color as [r, g, b] (0.0–1.0)
+     * @param {number[]} color - outline color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha is the outline's opacity
      */
     setColor(color: number[]): void;
     /**
@@ -39,7 +42,8 @@ export default class OutlineEffect extends ShaderEffect {
      */
     setWidth(width: number): void;
     /**
-     * set the texture size for accurate outline width calculation
+     * Measure the effect's width in the texels of a texture of this size,
+     * rather than of the texture it draws (the default)
      * @param {number} width - texture width in pixels
      * @param {number} height - texture height in pixels
      */

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":"AAyCA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;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;yBAjIwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"outline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/outline.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACH,WAAW;KACxC,EA4CA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA7IwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -15,7 +15,7 @@ export default class PixelateEffect extends ShaderEffect {
      * @param {Renderer} 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]
+     * @param {number[]} [options.textureSize] - the size, `[width, height]`, of the texture its pixel size is measured in; by default the texture it draws (a sprite's own, the screen for a camera's effect)
      */
     constructor(renderer: Renderer, options?: {
         size?: number | undefined;
@@ -28,7 +28,8 @@ export default class PixelateEffect extends ShaderEffect {
      */
     setSize(size: number): void;
     /**
-     * set the texture size
+     * Measure the effect's pixel size in the texels of a texture of this size,
+     * rather than of the texture it draws (the default)
      * @param {number} width - texture width in pixels
      * @param {number} height - texture height in pixels
      */

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":"AAyBA;;;;;;;;;;;GAWG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAyB,IAAI;QACF,WAAW;KACxC,EAoBA;IALA,aAA+B;IAOhC;;;OAGG;IACH,cAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAlFwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"pixelate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/pixelate.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;GAWG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAyB,IAAI;QACF,WAAW;KACxC,EAqBA;IALA,aAA+B;IAOhC;;;OAGG;IACH,cAFW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBApFwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -77,12 +77,17 @@
  *     color: new Color(80, 160, 255),
  *     intensity: 0.4,
  * });
+ * @example
+ * // a half-strength warm spot: the Color's alpha scales the whole gradient
+ * const dim = new RadialGradientEffect(renderer, {
+ *     color: new Color(255, 220, 120, 0.5),
+ * });
  */
 export default class RadialGradientEffect extends ShaderEffect {
     /**
      * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - initial uniform values
-     * @param {Color} [options.color] - center color (0..255 RGB); defaults to white
+     * @param {Color} [options.color] - center color (0..255 RGB, and its alpha scales the gradient); defaults to opaque white
      * @param {number} [options.intensity=1] - peak alpha at the center (0..1+)
      */
     constructor(renderer: Renderer, options?: {
@@ -90,9 +95,9 @@ export default class RadialGradientEffect extends ShaderEffect {
         intensity?: number | undefined;
     });
     /**
-     * Set the center color. RGB only — alpha is ignored (the radial
-     * falloff supplies the per-pixel alpha).
-     * @param {Color} color - 0..255 RGB color
+     * Set the center color. Its alpha scales the whole gradient, on top of
+     * the falloff, so a half-transparent color gives a half-strength spot.
+     * @param {Color} color - 0..255 RGB color, with its alpha
      */
     setColor(color: Color): void;
     /**

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;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsEG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAwB,KAAK;QACJ,SAAS;KACpC,EA+DA;IAhBA;;;OAGG;IACH,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBA9KwB,mBAAmB;2BAIlB,qBAAqB;0BAKtB,gBAAgB"}
+{"version":3,"file":"radialGradient.d.ts","sourceRoot":"","sources":["../../../src/video/effects/radialGradient.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAwB,KAAK;QACJ,SAAS;KACpC,EAmEA;IAjBA;;;OAGG;IACH,qCAAoC;IAerC;;;;OAIG;IACH,gBAFW,KAAK,QAQf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBAxLwB,mBAAmB;2BAIlB,qBAAqB;0BAKtB,gBAAgB"}

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=rgba.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rgba.d.ts","sourceRoot":"","sources":["../../../src/video/effects/rgba.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,4BALW,MAAM,EAAE,GAAC,YAAY,GACnB,YAAY,CAgBxB"}

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

@@ -59,12 +59,25 @@ export default class ShaderEffect {
      * vectors and matrices take an array, a `Float32Array`, or any object
      * exposing `toArray()` — which is every {@link Vector2d},
      * {@link Vector3d}, {@link Color} and {@link Matrix3d}.
+     *
+     * Sprites drawn one after the other through the same effect share one
+     * draw call. A new value draws the sprites queued before it first, so
+     * each sprite draws with the values it was given; the value it already
+     * has changes nothing, and keeps the draw shared.
      * @example
      * // a scalar the body declares as `uniform float uStrength;`
      * fx.setUniform("uStrength", 0.5);
      * // a vec3 — an array, or anything with toArray()
      * fx.setUniform("uTint", [1.0, 0.82, 0.55]);
      * fx.setUniform("uOrigin", new me.Vector2d(0.5, 0.5));
+     * @example
+     * // one outline shared by every enemy: drawn in a single call. Marked
+     * // shared, so the first enemy destroyed does not destroy it for the rest
+     * const outline = new me.OutlineEffect(renderer, { color: [1, 1, 1] });
+     * outline.shared = true;
+     * for (const enemy of enemies) {
+     *     enemy.addPostEffect(outline);
+     * }
      */
     setUniform(name: string, value: number | boolean | number[] | Float32Array | object): void;
     /**

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":"AAwJA;IAiCC;;;;;;;;;;;;;;;;;;OAkBG;IACH,sBAlBW,QAAQ,QACR,MAAM,GAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAC,cAerC,MAAM,EAgLhB;IAjOD;;;;;;OAMG;IACH,SAFU,OAAO,CAED;IAEhB;;;;;;;OAOG;IACH,oBAHU,OAAO,CAGC;IAElB;;;;;;;;;;OAUG;IACH,QAHU,OAAO,CAGF;IAsBd;;;;;;;OAOG;IACH,oBAAyB;IAEzB;;;;;;OAMG;IACH;eAnCyB,MAAM;eAAS,MAAM;MAmCrB;IACzB;;;OAGG;IACH,+BAA2B;IAE3B;;;;;;;;;;;;OAYG;IACH,cAJU;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAC,CAIE;IAoBlC;;;;;;;OAOG;IACH,0CAA+B;IAE/B;;;;;OAKG;IACH,0CAA+B;IAE/B;;;;OAIG;IACH,8BAAgC;IAQ/B;;;;;;OAMG;IACH,wBAJU,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAIK;IACpD;;;OAGG;IACH,iBAAkC;IAClC;;;;;;OAMG;IACH,eAA6B;IAC7B;;;OAGG;IACH,mBAAqC;IAErC;;;OAGG;IACH,8BAKC;IAyBD;;;OAGG;IACH,mDAAkC;IAsBpC;;;;OAIG;IACH,uBAsBC;IAjBA;;;OAGG;IACH,2CAAyC;IAe1C;;;;OAIG;IACH,2BAQC;IAED;;;;;;;;;;;;;;OAcG;IACH,iBAbW,MAAM,SACN,MAAM,GAAC,OAAO,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,MAAM,QAsCrD;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,iBAbW,MAAM,GACJ,YAAY,CAoDxB;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;0BAriCwB,gBAAgB;qBATpB,sBAAsB;kCAET,uBAAuB;sBAHnC,yBAAyB"}
+{"version":3,"file":"shadereffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shadereffect.js"],"names":[],"mappings":"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"}

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

@@ -33,12 +33,15 @@
  *
  * // update each frame
  * coinShine.setTime(timer.getTime() / 1000);
+ * @example
+ * // a gentler glint: the color's alpha scales its strength
+ * mySprite.addPostEffect(new ShineEffect(renderer, { color: [1.0, 1.0, 1.0, 0.4] }));
  */
 export default class ShineEffect extends ShaderEffect {
     /**
      * @param {Renderer} 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.color=[1.0, 1.0, 1.0]] - shine color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the glint
      * @param {number} [options.speed=0.5] - sweeps per second
      * @param {number} [options.width=0.15] - glint half-width as a fraction of one tile (0.0–1.0)
      * @param {number} [options.intensity=0.5] - maximum highlight strength
@@ -59,7 +62,7 @@ export default class ShineEffect extends ShaderEffect {
     });
     /**
      * set the shine color
-     * @param {number[]} color - shine color as [r, g, b] (0.0–1.0)
+     * @param {number[]} color - shine color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the glint
      */
     setColor(color: number[]): void;
     /**

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":"AAkDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,QAAQ,YAEhB;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;yBAnMwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"shine.d.ts","sourceRoot":"","sources":["../../../src/video/effects/shine.js"],"names":[],"mappings":"AAoDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IACC;;;;;;;;;;;OAWG;IACH,sBAXW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACL,KAAK;QACL,SAAS;QACT,KAAK;QACL,KAAK;QACL,UAAU;QACV,UAAU;KACrC,EA8DA;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;yBArMwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -1 +1 @@
-{"version":3,"file":"squish.d.ts","sourceRoot":"","sources":["../../../src/video/effects/squish.js"],"names":[],"mappings":"AAoCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IACC;;;;OAIG;IACH,sBAJW,QAAQ,YAEhB;QAAyB,KAAK;KAChC,EA6CA;IAjBA;;;;OAIG;IACH,eAAe;IAEf;;;;;OAKG;IACH,kCAA4C;IAM7C;;;OAGG;IACH,gBAFW,MAAM,QAWhB;IAED;;;;;;;OAOG;IACH,kHAcC;IAED;;;OAGG;IACH,SAFa,YAAY,CAOxB;CACD;yBA5LwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"squish.d.ts","sourceRoot":"","sources":["../../../src/video/effects/squish.js"],"names":[],"mappings":"AAwCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IACC;;;;OAIG;IACH,sBAJW,QAAQ,YAEhB;QAAyB,KAAK;KAChC,EAoDA;IAjBA;;;;OAIG;IACH,eAAe;IAEf;;;;;OAKG;IACH,kCAA4C;IAM7C;;;OAGG;IACH,gBAFW,MAAM,QAWhB;IAED;;;;;;;OAOG;IACH,kHAcC;IAED;;;OAGG;IACH,SAFa,YAAY,CAOxB;CACD;yBAtMwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -0,0 +1,64 @@
+/**
+ * A shader effect that leans a sprite from side to side, as if a breeze went
+ * through it: each row is drawn a little to the left or right by a sine of
+ * the time, and by more the further above its anchor row it is, so the top
+ * sways most and everything from the anchor down stays put. For grass, trees,
+ * reeds or a whole background layer: anything planted at its bottom.
+ *
+ * It is a {@link WaveEffect} with an anchor and sway-sized defaults, so it
+ * shares its shader rather than adding one. The difference is the time:
+ * {@link SwayEffect#setTime} wraps the phase to one turn on the CPU before
+ * the shader sees it. A raw clock grows without bound, and a medium-precision
+ * float, the default on most phones, runs out of digits a few minutes into a
+ * session and the sway starts to stutter; a wrapped phase never grows.
+ * @category Effects
+ * @see {@link Renderable#addPostEffect} for usage
+ * @example
+ * // a tree whose trunk is planted at 90% of its height
+ * const sway = new SwayEffect(renderer, { strength: 0.02, anchor: 0.9 });
+ * tree.addPostEffect(sway);
+ * // each frame
+ * sway.setTime(timer.getTime() / 1000);
+ */
+export default class SwayEffect extends WaveEffect {
+    /**
+     * @param {Renderer} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number} [options.strength=0.02] - how far the top moves each way, as a fraction of the texture's width
+     * @param {number} [options.anchor=1.0] - the row that stays put, as a fraction of the height from the top (1 = the bottom row)
+     * @param {number} [options.speed=1.5] - how fast it sways, in radians per second
+     * @param {number} [options.frequency=3.0] - how much the sway bends along the height: low values lean the whole sprite as one, high ones ripple it
+     */
+    constructor(renderer: Renderer, options?: {
+        strength?: number | undefined;
+        anchor?: number | undefined;
+        speed?: number | undefined;
+        frequency?: number | undefined;
+    });
+    /**
+     * how fast it sways, in radians per second
+     * @type {number}
+     */
+    speed: number;
+    /**
+     * advance the sway to a moment in time
+     * @param {number} seconds - the time, in seconds (any clock: only its rate matters)
+     * @returns {SwayEffect} this effect for chaining
+     */
+    setTime(seconds: number): SwayEffect;
+    /**
+     * set how far the top moves each way
+     * @param {number} strength - a fraction of the texture's width
+     */
+    setStrength(strength: number): void;
+    /**
+     * Create an independent copy of this effect, swaying the same way. A
+     * plain {@link ShaderEffect#clone} would copy the uniforms but not the
+     * speed, nor the wrapping of the time that keeps the sway smooth.
+     * @returns {SwayEffect} a new effect
+     */
+    clone(): SwayEffect;
+}
+import WaveEffect from "./wave.js";
+import type Renderer from "../renderer.js";
+//# sourceMappingURL=sway.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sway.d.ts","sourceRoot":"","sources":["../../../src/video/effects/sway.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,QAAQ,YAEhB;QAAyB,QAAQ;QACR,MAAM;QACN,KAAK;QACL,SAAS;KACpC,EAeA;IALA;;;OAGG;IACH,OAFU,MAAM,CAEiB;IAGlC;;;;OAIG;IACH,iBAHW,MAAM,GACJ,UAAU,CAKtB;IAED;;;OAGG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,SAFa,UAAU,CAetB;CACD;uBA/FsB,WAAW;0BAIT,gBAAgB"}

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

@@ -14,12 +14,15 @@
  *
  * // update each frame
  * poison.setTime(timer.getTime() / 1000);
+ * @example
+ * // a subtle pulse: the color's alpha caps how far it tints
+ * mySprite.addPostEffect(new TintPulseEffect(renderer, { color: [1.0, 0.8, 0.0, 0.35] }));
  */
 export default class TintPulseEffect extends ShaderEffect {
     /**
      * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
-     * @param {number[]} [options.color=[1.0, 0.0, 0.0]] - pulse color as [r, g, b] (0.0–1.0)
+     * @param {number[]} [options.color=[1.0, 0.0, 0.0]] - pulse color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the intensity
      * @param {number} [options.speed=2.0] - pulse speed (oscillations per second)
      * @param {number} [options.intensity=0.3] - maximum tint strength (0.0–1.0)
      */
@@ -30,7 +33,7 @@ export default class TintPulseEffect extends ShaderEffect {
     });
     /**
      * set the pulse color
-     * @param {number[]} color - pulse color as [r, g, b] (0.0–1.0)
+     * @param {number[]} color - pulse color as [r, g, b] or [r, g, b, a] (0.0–1.0); the alpha scales the intensity
      */
     setColor(color: number[]): void;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"tintPulse.d.ts","sourceRoot":"","sources":["../../../src/video/effects/tintPulse.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;KACpC,EAqBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBAhFwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"tintPulse.d.ts","sourceRoot":"","sources":["../../../src/video/effects/tintPulse.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAA2B,KAAK;QACP,KAAK;QACL,SAAS;KACpC,EAsBA;IAED;;;OAGG;IACH,gBAFW,MAAM,EAAE,QAIlB;CACD;yBArFwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -2,6 +2,12 @@
  * A shader effect that applies a sine wave distortion to the sprite.
  * Commonly used for underwater, heat haze, or dream sequence effects.
  * The `time` uniform should be updated each frame for animation.
+ *
+ * With an `anchor`, the wave fades out toward a row instead of moving the
+ * whole sprite: full at the top, nothing at the anchor and below. That is
+ * how {@link SwayEffect} leans a sprite while its feet stay planted. Rows
+ * are measured across the texture the effect samples, so on a sprite cut
+ * from an atlas the anchor is a row of the atlas.
  * @category Effects
  * @see {@link Renderable#addPostEffect} for usage
  * @example
@@ -9,6 +15,10 @@
  * mySprite.addPostEffect(wave);
  * // update each frame
  * wave.setTime(performance.now() / 1000);
+ * @example
+ * // seaweed: the tips wave, the roots on the bottom row stay planted
+ * const seaweed = new WaveEffect(renderer, { amplitude: 0.02, frequency: 6.0, anchor: 1.0 });
+ * mySprite.addPostEffect(seaweed);
  */
 export default class WaveEffect extends ShaderEffect {
     /**
@@ -17,11 +27,13 @@ export default class WaveEffect extends ShaderEffect {
      * @param {number} [options.amplitude=0.01] - wave displacement strength (in UV space, 0.01 = subtle)
      * @param {number} [options.frequency=10.0] - number of waves across the sprite
      * @param {number} [options.speed=2.0] - wave animation speed
+     * @param {number} [options.anchor=0] - the row the wave fades out at, as a fraction of the height from the top (0..1); 0 waves every row alike
      */
     constructor(renderer: Renderer, options?: {
         amplitude?: number | undefined;
         frequency?: number | undefined;
         speed?: number | undefined;
+        anchor?: number | undefined;
     });
     /**
      * set the wave amplitude
@@ -33,6 +45,11 @@ export default class WaveEffect extends ShaderEffect {
      * @param {number} frequency - number of waves
      */
     setFrequency(frequency: number): void;
+    /**
+     * set the row the wave fades out at
+     * @param {number} anchor - a fraction of the height from the top (0..1); 0 waves every row alike
+     */
+    setAnchor(anchor: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
 import type Renderer from "../renderer.js";

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

@@ -1 +1 @@
-{"version":3,"file":"wave.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wave.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;GAWG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAAyB,SAAS;QACT,SAAS;QACT,KAAK;KAChC,EAqBA;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;CACD;yBApFwB,mBAAmB;0BAOnB,gBAAgB"}
+{"version":3,"file":"wave.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wave.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,QAAQ,YAEhB;QAAyB,SAAS;QACT,SAAS;QACT,KAAK;QACL,MAAM;KACjC,EA0BA;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAIhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAIhB;CACD;yBA/GwB,mBAAmB;0BAOnB,gBAAgB"}

package/build/video/effects/wgsl/scaffold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/scaffold.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;GASG;AACH,8CANW,MAAM,GACJ;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAC,CA2BxG;AAED;;;;;;;;GAQG;AACH,sCAPW,MAAM,UACN,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA0G5C"}
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../../../src/video/effects/wgsl/scaffold.js"],"names":[],"mappings":"AA4BA;;;;;;;;;GASG;AACH,8CANW,MAAM,GACJ;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,mBAAmB,EAAE,MAAM,CAAA;CAAC,CA2BxG;AAED;;;;;;;;GAQG;AACH,sCAPW,MAAM,UACN,MAAM,GACJ;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA6I5C"}

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

@@ -1 +1 @@
-{"version":3,"file":"wgsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wgsl_realization.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;OAIG;IACH,kBAFW,MAAM,EA2EhB;IAtEA;;;OAGG;IACH,OAFU,OAAO,CAEc;IAC/B,0BAA0B;IAC1B,OADW,MAAM,GAAC,IAAI,CAC+B;IAMrD;;;;OAIG;IACH,MAFU,MAAM,CAEA;IAChB,wEAAwE;IACxE,2BAAoB;IACpB,iEAAiE;IACjE,YAA2B;IAC3B,4DAA4D;IAC5D,gBAAmC;IACnC,iDAAiD;IACjD,cAA+B;IAC/B,0BAA0B;IAC1B,cAA+B;IAG/B,8CAA8C;IAC9C,yBAAuB;IACvB,mEAAmE;IACnE,oCAAsC;IAEtC;;;;;OAKG;IACH,uCAA4B;IAG5B,6BAAwD;IACxD,2CAAqC;IACrC,yCAAmC;IACnC,0CAAoC;IAIpC,gDAAmC;IAEnC;;;;OAIG;IACH,QAFU,GAAG,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,CAAC,CAEf;IAIvB,6BAAuB;IAEvB;;;;OAIG;IACH,KAFU,MAAM,GAAC,IAAI,CAEN;IAGhB;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC;QAAC,GAAG,EAAE,YAAY,CAAA;KAAC,GAE9C,OAAO,CAwDnB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;;;;;;;;;OAWG;IACH,uBALW,MAAM,GACJ,MAAM,CAWlB;CACD"}
+{"version":3,"file":"wgsl_realization.d.ts","sourceRoot":"","sources":["../../../src/video/effects/wgsl_realization.js"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;OAIG;IACH,kBAFW,MAAM,EAwFhB;IAnFA;;;OAGG;IACH,OAFU,OAAO,CAEc;IAC/B,0BAA0B;IAC1B,OADW,MAAM,GAAC,IAAI,CAC+B;IAMrD;;;;OAIG;IACH,MAFU,MAAM,CAEA;IAChB,wEAAwE;IACxE,2BAAoB;IACpB,iEAAiE;IACjE,YAA2B;IAC3B,4DAA4D;IAC5D,gBAAmC;IACnC,iDAAiD;IACjD,cAA+B;IAC/B,0BAA0B;IAC1B,cAA+B;IAG/B,8CAA8C;IAC9C,yBAAuB;IACvB,mEAAmE;IACnE,oCAAsC;IAEtC;;;;;OAKG;IACH,uCAA4B;IAG5B,6BAAwD;IACxD,2CAAqC;IACrC,yCAAmC;IACnC,0CAAoC;IAIpC,gDAAmC;IAEnC;;;;OAIG;IACH,QAFU,GAAG,CAAC,MAAM,EAAE,MAAM,GAAC,MAAM,EAAE,CAAC,CAEf;IAIvB,6BAAuB;IAEvB;;;;OAIG;IACH,KAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;;;OAUG;IACH,iBAJU,CAAC,MAAM,IAAI,CAAC,GAAC,IAAI,CAIA;IAG5B;;;;;;OAMG;IACH,iBALW,MAAM,SACN,MAAM,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC;QAAC,GAAG,EAAE,YAAY,CAAA;KAAC,GAE9C,OAAO,CA8DnB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAEC;IAED;;;;;;;;;;;OAWG;IACH,uBALW,MAAM,GACJ,MAAM,CAWlB;CACD"}

package/build/video/gpu/frame.d.ts

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=frame.d.ts.map

package/build/video/gpu/frame.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame.d.ts","sourceRoot":"","sources":["../../../src/video/gpu/frame.js"],"names":[],"mappings":"AAmBA;;;;;;;;GAQG;AACH,kCALW;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAC,GACf,OAAO,CAOnB;AAaD;;;;;;;;;;GAUG;AACH,yCALW;IAAC,QAAQ,EAAE;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAC,CAAC;IAAC,YAAY,CAAC,EAAE,OAAO,CAAC;IAAC,uBAAuB,CAAC,EAAE,MAAM,MAAM,CAAA;CAAC,GAClG,MAAM,CAelB;AAlED;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,8BAA+B,CAAC,GAAG,CAAC;AAgBpC;;;;;;;;GAQG;AACH;;;;GAA0E"}