melonjs 20.6.0 → 20.8.0

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

@@ -1 +1 @@
-{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;IACC,6CAyBC;IAvBA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAU7C,kCAA2C;IAG5C;;;;OAIG;IACH,cAEC;IAED;;;;OAIG;IACH,6BAEC;IAED;;;;;;;;;;;;OAYG;IACH,QAXW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,oBACN,MAAM,QA8BhB;IAED;;;;;;;OAOG;IACH,iBANW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAchB;IAED;;;;;;;;;OASG;IACH,kEAgBC;IAED;;;;;;OAMG;IACH,gGAoBC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;;;;OAOG;IACH,+DAMC;CACD"}
+{"version":3,"file":"vertex.d.ts","sourceRoot":"","sources":["../../../src/video/buffer/vertex.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;IACC,6CAyBC;IAvBA,gBAA4B;IAE5B,eAA0B;IAE1B,oBAAoB;IAGpB,oBAEC;IAED,qCAA8C;IAC9C,oCAA6C;IAU7C,kCAA2C;IAG5C;;;;OAIG;IACH,cAEC;IAED;;;;OAIG;IACH,6BAEC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,QAjBW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QACN,MAAM,cACN,MAAM,oBACN,MAAM,cACN,MAAM,QA4ChB;IAED;;;;;;;OAOG;IACH,iBANW,SAAS,CAAC,MAAM,CAAC,aACjB,MAAM,SACN,MAAM,QAchB;IAED;;;;;;;;;OASG;IACH,kEAgBC;IAED;;;;;;OAMG;IACH,gGAoBC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;;;;OAOG;IACH,+DAMC;CACD"}

package/build/video/canvas/canvas_renderer.d.ts

@@ -8,21 +8,45 @@
  * @import {Matrix2d} from "../../math/matrix2d.ts";
  * @import {Bounds} from "../../physics/bounds.ts";
  * @import {default as Texture2d} from "../texture/texture2d.ts";
+ * @import {Matrix3d} from "../../math/matrix3d.ts";
+ * @import Mesh from "../../renderable/mesh.js";
+ * @import {ApplicationSettings} from "../../application/settings.ts";
+ * @import {Box3d} from "../../geometries/box3d.ts";
+ * @import {Sphere} from "../../geometries/sphere.ts";
  */
 /**
  * a canvas renderer object
  * @category Rendering
  */
 export default class CanvasRenderer extends Renderer {
-    cache: TextureCache;
     onGameReset: () => void;
     /**
-     * set/change the current projection matrix.
-     * In Canvas mode, this applies the ortho projection as a canvas 2D transform
-     * (translate + scale) to map world coordinates to screen coordinates.
-     * @param {Matrix3d} matrix - the new projection matrix
+     * Capture the current frame into a {@link Texture2d} — the Canvas-renderer
+     * counterpart of {@link WebGLRenderer#toFrameTexture}, keeping the
+     * `toDataURL` / `toBlob` / `toImageBitmap` family renderer-complete. Backed
+     * by an offscreen `<canvas>` copy of the drawing buffer (Canvas rendering is
+     * immediate, so no flush is needed). Custom shaders don't run under the
+     * Canvas renderer, so the result is a plain drawable for CPU-side reuse
+     * rather than a live shader input.
+     * @param {object} [options]
+     * @param {Texture2d|null} [options.target] - controls the destination: omit
+     *   for the shared renderer slot (default); pass a capture previously
+     *   returned by this method to refresh it in place; pass `null` to mint a
+     *   fresh, caller-owned capture (mirrors {@link WebGLRenderer#toFrameTexture})
+     * @param {Bounds|{x: number, y: number, width: number, height: number}} [options.region] - capture
+     *   only this sub-region (canvas pixels, top-left origin). A {@link Bounds}
+     *   (or any `{x, y, width, height}`); from a {@link Rect} pass `rect.getBounds()`.
+     * @returns {Texture2d} a texture holding the captured frame
      */
-    setProjection(matrix: Matrix3d): void;
+    toFrameTexture(options?: {
+        target?: Texture2d | null | undefined;
+        region?: Bounds | {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        } | undefined;
+    }): Texture2d;
     /**
      * set the current blend mode for this renderer. <br>
      * This renderer supports every mode below except `"none"`: <br>
@@ -195,17 +219,6 @@ export default class CanvasRenderer extends Renderer {
      * @param {number} radii - The corner radius.
      */
     roundRect(x: number, y: number, width: number, height: number, radii: number): void;
-    /**
-     * stroke the given shape or the current defined path
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to stroke
-     * @param {boolean} [fill=false] - fill the shape with the current color if true
-     */
-    stroke(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds, fill?: boolean): void;
-    /**
-     * fill the given shape or the current defined path
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse|Bounds} [shape] - a shape object to fill
-     */
-    fill(shape?: Rect | RoundRect | Polygon | Line | Ellipse | Bounds): void;
     /**
      * add a straight line from the current point to the start of the current sub-path. If the shape has already been closed or has only one point, this function does nothing
      */
@@ -317,13 +330,11 @@ export default class CanvasRenderer extends Renderer {
     transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
 }
 import Renderer from "./../renderer.js";
-import TextureCache from "./../texture/cache.js";
+import type { default as Texture2d } from "../texture/texture2d.ts";
+import type { Bounds } from "../../physics/bounds.ts";
 import { Color } from "./../../math/color.ts";
-import type { Rect } from "./../../geometries/rectangle.ts";
-import type { RoundRect } from "./../../geometries/roundrect.ts";
+import type Mesh from "../../renderable/mesh.js";
 import type { Polygon } from "../../geometries/polygon.ts";
-import type { Line } from "./../../geometries/line.ts";
-import type { Ellipse } from "./../../geometries/ellipse.ts";
-import type { Bounds } from "../../physics/bounds.ts";
 import type { Matrix2d } from "../../math/matrix2d.ts";
+import type { Matrix3d } from "../../math/matrix3d.ts";
 //# sourceMappingURL=canvas_renderer.d.ts.map

package/build/video/canvas/canvas_renderer.d.ts.map

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

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

@@ -1,3 +1,2 @@
 export const wgslFragment: "\nstruct BlendUniforms {\n\tuBlendMode : f32,\n};\n@group(3) @binding(0) var<uniform> fx : BlendUniforms;\n@group(3) @binding(1) var backdrop : texture_2d<f32>;\n@group(3) @binding(2) var backdrop_sampler : sampler;\n\n// HardLight(Cb, Cs) \u2014 also the kernel for Overlay, which the W3C spec\n// defines as HardLight with the arguments swapped\nfn ME_hardLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet lo = 2.0 * b * s;\n\tlet hi = 1.0 - 2.0 * (1.0 - b) * (1.0 - s);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\nfn ME_softLight(b : vec3f, s : vec3f) -> vec3f {\n\tlet d = mix(((16.0 * b - 12.0) * b + 4.0) * b, sqrt(b), step(vec3f(0.25), b));\n\tlet lo = b - (1.0 - 2.0 * s) * b * (1.0 - b);\n\tlet hi = b + (2.0 * s - 1.0) * (d - b);\n\treturn mix(lo, hi, step(vec3f(0.5), s));\n}\n\n// Cb == 0 wins over Cs == 1, so it is applied last\nfn ME_colorDodge(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = min(vec3f(1.0), b / max(1.0 - s, vec3f(1e-4)));\n\tr = mix(r, vec3f(1.0), step(vec3f(1.0), s));\n\treturn mix(r, vec3f(0.0), step(b, vec3f(0.0)));\n}\n\n// Cb == 1 wins over Cs == 0, so it is applied last\nfn ME_colorBurn(b : vec3f, s : vec3f) -> vec3f {\n\tvar r = 1.0 - min(vec3f(1.0), (1.0 - b) / max(s, vec3f(1e-4)));\n\tr = mix(r, vec3f(0.0), step(s, vec3f(0.0)));\n\treturn mix(r, vec3f(1.0), step(vec3f(1.0), b));\n}\n\nfn ME_blend(b : vec3f, s : vec3f) -> vec3f {\n\tif (fx.uBlendMode < 0.5) { return abs(b - s); }\n\tif (fx.uBlendMode < 1.5) { return ME_hardLight(s, b); }\n\tif (fx.uBlendMode < 2.5) { return ME_hardLight(b, s); }\n\tif (fx.uBlendMode < 3.5) { return ME_colorDodge(b, s); }\n\tif (fx.uBlendMode < 4.5) { return ME_colorBurn(b, s); }\n\tif (fx.uBlendMode < 5.5) { return ME_softLight(b, s); }\n\tif (fx.uBlendMode < 6.5) { return min(b, s); }\n\treturn max(b, s);\n}\n\nfn apply(color : vec4f, uv : vec2f) -> vec4f {\n\t// sampled BEFORE any branch, so plain textureSampleLevel is safe here\n\tlet Cb = textureSampleLevel(backdrop, backdrop_sampler, screen_uv, 0.0).rgb;\n\tlet a = color.a;\n\tlet Cs = color.rgb / max(a, 1e-4);\n\tlet B = clamp(ME_blend(Cb, Cs), vec3f(0.0), vec3f(1.0));\n\treturn vec4f(a * B, a);\n}\n";
-import ShaderEffect from "./shadereffect.js";
 //# sourceMappingURL=blendEffect.d.ts.map

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

@@ -0,0 +1,72 @@
+/**
+ * A shader effect that adds a bloom: the bright parts of what it is applied to
+ * bleed light into the pixels around them.
+ *
+ * Reach for it on the CAMERA, where it works on the whole frame and makes
+ * emitters, neon, fire and specular highlights read as light rather than as
+ * bright paint. It works on a single renderable too, where it blooms only that
+ * sprite's own bright pixels.
+ *
+ * Not to be confused with {@link GlowEffect}, which draws an outline OUTSIDE a
+ * sprite's silhouette and does nothing at all on an opaque frame.
+ *
+ * `textureSize` must match what is being filtered, since the tap offsets are
+ * in texels; it defaults to the renderer's own size, which is what a camera
+ * effect wants. Call {@link BloomEffect#setTextureSize} from an
+ * {@link event.ONRESIZE} handler, or after applying it to something smaller.
+ * @category Effects
+ * @see {@link Renderable#addPostEffect} for usage
+ * @example
+ * // whole-frame bloom, the usual case
+ * game.viewport.addPostEffect(new BloomEffect(renderer));
+ *
+ * @example
+ * // only the brightest highlights, and a wide soft halo
+ * game.viewport.addPostEffect(
+ *     new BloomEffect(renderer, { threshold: 0.85, radius: 4, intensity: 1.4 })
+ * );
+ */
+export default class BloomEffect extends ShaderEffect {
+    /**
+     * @param {Renderer} renderer - the current renderer instance
+     * @param {object} [options] - effect options
+     * @param {number} [options.threshold=0.75] - luminance a pixel must pass before it blooms, `0` (everything blooms) to `1` (only white does)
+     * @param {number} [options.intensity=1.0] - how much of the gathered light is added back
+     * @param {number} [options.radius=2.0] - halo reach, in texels
+     * @param {number[]} [options.textureSize] - dimensions of what is being filtered, `[width, height]`; defaults to the renderer's size
+     */
+    constructor(renderer: Renderer, options?: {
+        threshold?: number | undefined;
+        intensity?: number | undefined;
+        radius?: number | undefined;
+        textureSize?: number[] | undefined;
+    });
+    threshold: number;
+    intensity: number;
+    radius: number;
+    /**
+     * set the luminance a pixel must pass before it contributes
+     * @param {number} threshold - `0` (everything blooms) to `1` (only white does)
+     */
+    setThreshold(threshold: number): void;
+    /**
+     * set how much of the gathered light is added back
+     * @param {number} intensity - `0` disables the effect without removing it
+     */
+    setIntensity(intensity: number): void;
+    /**
+     * set the halo reach
+     * @param {number} radius - reach in texels
+     */
+    setRadius(radius: number): void;
+    /**
+     * set the dimensions of what is being filtered. The tap offsets are in
+     * texels, so a stale size makes the halo the wrong width after a resize.
+     * @param {number} width - width in pixels
+     * @param {number} height - height in pixels
+     */
+    setTextureSize(width: number, height: number): void;
+}
+import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
+//# sourceMappingURL=bloom.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bloom.d.ts","sourceRoot":"","sources":["../../../src/video/effects/bloom.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IACC;;;;;;;OAOG;IACH,sBAPW,QAAQ,YAEhB;QAAyB,SAAS;QACT,SAAS;QACT,MAAM;QACJ,WAAW;KACxC,EAmBA;IAfA,kBAA0C;IAC1C,kBAAyC;IACzC,eAAmC;IAepC;;;OAGG;IACH,wBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,kBAFW,MAAM,QAKhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA3NwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -10,12 +10,12 @@
  */
 export default class BlurEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.strength=1.0] - blur strength in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         strength?: number | undefined;
         textureSize?: number[] | undefined;
     });
@@ -33,4 +33,5 @@ export default class BlurEffect extends ShaderEffect {
     setTextureSize(width: number, height: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=blur.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blur.js"],"names":[],"mappings":"AA4BA;;;;;;;;;GASG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,QAAQ;QACN,WAAW;KACxC,EA8BA;IALA,iBAAuC;IAOxC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBA7FwB,mBAAmB"}
+{"version":3,"file":"blur.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blur.js"],"names":[],"mappings":"AAmCA;;;;;;;;;GASG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAyB,QAAQ;QACN,WAAW;KACxC,EA8BA;IALA,iBAAuC;IAOxC;;;OAGG;IACH,sBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBApGwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -13,12 +13,12 @@
  */
 export default class ChromaticAberrationEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.offset=3.0] - channel offset in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         offset?: number | undefined;
         textureSize?: number[] | undefined;
     });
@@ -36,4 +36,5 @@ export default class ChromaticAberrationEffect extends ShaderEffect {
     setTextureSize(width: number, height: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=chromaticAberration.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"chromaticAberration.d.ts","sourceRoot":"","sources":["../../../src/video/effects/chromaticAberration.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,MAAM;QACJ,WAAW;KACxC,EAuBA;IALA,eAAmC;IAOpC;;;OAGG;IACH,kBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAlFwB,mBAAmB"}
+{"version":3,"file":"chromaticAberration.d.ts","sourceRoot":"","sources":["../../../src/video/effects/chromaticAberration.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;GAYG;AACH;IACC;;;;;OAKG;IACH,sBALW,QAAQ,YAEhB;QAAyB,MAAM;QACJ,WAAW;KACxC,EAuBA;IALA,eAAmC;IAOpC;;;OAGG;IACH,kBAFW,MAAM,QAKhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;CACD;yBAzFwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -15,11 +15,11 @@
  */
 export default class ColorMatrixEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {ColorMatrix} [options.matrix] - an initial color matrix. Defaults to identity.
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         matrix?: ColorMatrix | undefined;
     });
     /**
@@ -79,4 +79,5 @@ export default class ColorMatrixEffect extends ShaderEffect {
 }
 import ShaderEffect from "./shadereffect.js";
 import { ColorMatrix } from "../../math/color_matrix.ts";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=colorMatrix.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../src/video/effects/colorMatrix.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAA8B,MAAM;KACtC,EAmBA;IAPA;;;;OAIG;IACH,qBAAkD;IAInD;;;;OAIG;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;yBAnKwB,mBAAmB;4BADhB,4BAA4B"}
+{"version":3,"file":"colorMatrix.d.ts","sourceRoot":"","sources":["../../../src/video/effects/colorMatrix.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;OAIG;IACH,sBAJW,QAAQ,YAEhB;QAA8B,MAAM;KACtC,EAmBA;IAPA;;;;OAIG;IACH,qBAAkD;IAInD;;;;OAIG;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;yBA1KwB,mBAAmB;4BADhB,4BAA4B;0BAQ/B,gBAAgB"}

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

@@ -1,3 +1,10 @@
+/**
+ * additional import for TypeScript
+ * @import CanvasRenderer from "../canvas/canvas_renderer.js";
+ * @import WebGLRenderer from "../webgl/webgl_renderer.js";
+ * @import WebGPURenderer from "../webgpu/webgpu_renderer.js";
+ * @import Renderer from "../renderer.js";
+ */
 /**
  * A shader effect that desaturates (grayscales) the sprite.
  * Commonly used for disabled states, death effects, or petrification.
@@ -12,11 +19,11 @@
  */
 export default class DesaturateEffect extends ColorMatrixEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - desaturation intensity (0.0 = full color, 1.0 = grayscale)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;
@@ -27,4 +34,5 @@ export default class DesaturateEffect extends ColorMatrixEffect {
     setIntensity(value: number): void;
 }
 import ColorMatrixEffect from "./colorMatrix.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=desaturate.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAnC6B,kBAAkB"}
+{"version":3,"file":"desaturate.d.ts","sourceRoot":"","sources":["../../../src/video/effects/desaturate.js"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH;;;;;;;;;;;GAWG;AACH;IACC;;;;OAIG;IACH,sBAJW,QAAQ,YAEhB;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BA1C6B,kBAAkB;0BAOvB,gBAAgB"}

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

@@ -15,13 +15,13 @@
  */
 export default class DissolveEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.progress=0.0] - dissolve progress (0.0 = visible, 1.0 = dissolved)
      * @param {number[]} [options.edgeColor=[1.0, 0.5, 0.0]] - color of the dissolve edge
      * @param {number} [options.edgeWidth=0.1] - width of the colored edge (0.0–1.0)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         progress?: number | undefined;
         edgeColor?: number[] | undefined;
         edgeWidth?: number | undefined;
@@ -39,4 +39,5 @@ export default class DissolveEffect extends ShaderEffect {
     setEdgeColor(color: number[]): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=dissolve.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dissolve.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;OAMG;IACH,sBANW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;QAAyB,QAAQ;QACN,SAAS;QACX,SAAS;KACpC,EA0DA;IAPA,iBAAuC;IASxC;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAIlB;CACD;yBAhKwB,mBAAmB"}
+{"version":3,"file":"dissolve.d.ts","sourceRoot":"","sources":["../../../src/video/effects/dissolve.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;GAcG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;QAAyB,QAAQ;QACN,SAAS;QACX,SAAS;KACpC,EA0DA;IAPA,iBAAuC;IASxC;;;OAGG;IACH,mBAFW,MAAM,QAKhB;IAED;;;OAGG;IACH,oBAFW,MAAM,EAAE,QAIlB;CACD;yBAvKwB,mBAAmB;0BAOnB,gBAAgB"}

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

@@ -15,7 +15,7 @@
  */
 export default class DropShadowEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} 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: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         offsetX?: number | undefined;
         offsetY?: number | undefined;
         color?: number[] | undefined;
@@ -44,4 +44,5 @@ export default class DropShadowEffect extends ShaderEffect {
     setTextureSize(width: number, height: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=dropShadow.d.ts.map

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,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"}
+{"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"}

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

@@ -21,12 +21,12 @@
  */
 export default class FlashEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @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.intensity=0.0] - initial flash intensity (0.0–1.0)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });
@@ -43,4 +43,5 @@ export default class FlashEffect extends ShaderEffect {
     setColor(color: number[]): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=flash.d.ts.map

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,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"}
+{"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"}

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

@@ -13,14 +13,14 @@
  */
 export default class GlowEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @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.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: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
         width?: number | undefined;
         intensity?: number | undefined;
@@ -45,4 +45,5 @@ export default class GlowEffect extends ShaderEffect {
     setTextureSize(width: number, height: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=glow.d.ts.map

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,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"}
+{"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"}

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

@@ -13,12 +13,12 @@
  */
 export default class HologramEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @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.intensity=0.5] - effect intensity (0.0–1.0)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
         intensity?: number | undefined;
     });
@@ -29,4 +29,5 @@ export default class HologramEffect extends ShaderEffect {
     setColor(color: number[]): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=hologram.d.ts.map

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,sBALW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;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":"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"}

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

@@ -1,3 +1,10 @@
+/**
+ * additional import for TypeScript
+ * @import CanvasRenderer from "../canvas/canvas_renderer.js";
+ * @import WebGLRenderer from "../webgl/webgl_renderer.js";
+ * @import WebGPURenderer from "../webgpu/webgpu_renderer.js";
+ * @import Renderer from "../renderer.js";
+ */
 /**
  * A shader effect that inverts the colors of the sprite.
  * Commonly used for damage feedback, negative image, or X-ray effects.
@@ -11,11 +18,11 @@
  */
 export default class InvertEffect extends ColorMatrixEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} 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: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;
@@ -26,4 +33,5 @@ export default class InvertEffect extends ColorMatrixEffect {
     setIntensity(value: number): void;
 }
 import ColorMatrixEffect from "./colorMatrix.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=invert.d.ts.map

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,sBAJW,aAAa,GAAC,cAAc,GAAC,cAAc,YAEnD;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;;;;;;GAMG;AACH;;;;;;;;;;GAUG;AACH;IACC;;;;OAIG;IACH,sBAJW,QAAQ,YAEhB;QAAyB,SAAS;KACpC,EAMA;IAHA,kBACgE;IAIjE;;;OAGG;IACH,oBAFW,MAAM,QAKhB;CACD;8BAzC6B,kBAAkB;0BAOvB,gBAAgB"}

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

@@ -17,13 +17,13 @@
  */
 export default class OutlineEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @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.width=1.0] - outline width in pixels
      * @param {number[]} [options.textureSize] - texture dimensions [width, height] (defaults to renderer size)
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: number[] | undefined;
         width?: number | undefined;
         textureSize?: number[] | undefined;
@@ -46,4 +46,5 @@ export default class OutlineEffect extends ShaderEffect {
     setTextureSize(width: number, height: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=outline.d.ts.map

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,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"}
+{"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"}

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

@@ -12,12 +12,12 @@
  */
 export default class PixelateEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @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]
      */
-    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         size?: number | undefined;
         textureSize?: number[] | undefined;
     });
@@ -35,4 +35,5 @@ export default class PixelateEffect extends ShaderEffect {
     setTextureSize(width: number, height: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=pixelate.d.ts.map

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,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"}
+{"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"}

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

@@ -1,7 +1,11 @@
 /**
  * additional import for TypeScript
  * @import { Color } from "../../math/color.ts";
- * @import { default as WebGLRenderer } from "../webgl_renderer.js";
+ * @import { default as WebGLRenderer } from "../webgl/webgl_renderer.js";
+ * @import { default as WebGPURenderer } from "../webgpu/webgpu_renderer.js";
+ * @import { default as CanvasRenderer } from "../canvas/canvas_renderer.js";
+ * @import WebGLRenderer from "../webgl/webgl_renderer.js";
+ * @import Renderer from "../renderer.js";
  */
 /**
  * A procedural radial-gradient shader effect: solid color at the center
@@ -76,12 +80,12 @@
  */
 export default class RadialGradientEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer} renderer - the current renderer instance
+     * @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 {number} [options.intensity=1] - peak alpha at the center (0..1+)
      */
-    constructor(renderer: WebGLRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         color?: Color | undefined;
         intensity?: number | undefined;
     });
@@ -100,4 +104,5 @@ export default class RadialGradientEffect extends ShaderEffect {
 }
 import ShaderEffect from "./shadereffect.js";
 import type { Color } from "../../math/color.ts";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=radialGradient.d.ts.map

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,EA+DA;IAhBA;;;OAGG;IACH,qCAAoC;IAcrC;;;;OAIG;IACH,gBAFW,KAAK,QAOf;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAIhB;CACD;yBA1KwB,mBAAmB;2BAIlB,qBAAqB"}
+{"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"}

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

@@ -16,13 +16,13 @@
  */
 export default class ScanlineEffect extends ShaderEffect {
     /**
-     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
+     * @param {Renderer} 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: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
+    constructor(renderer: Renderer, options?: {
         opacity?: number | undefined;
         curvature?: number | undefined;
         vignetteStrength?: number | undefined;
@@ -44,4 +44,5 @@ export default class ScanlineEffect extends ShaderEffect {
     setVignetteStrength(strength: number): void;
 }
 import ShaderEffect from "./shadereffect.js";
+import type Renderer from "../renderer.js";
 //# sourceMappingURL=scanline.d.ts.map

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,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"}
+{"version":3,"file":"scanline.d.ts","sourceRoot":"","sources":["../../../src/video/effects/scanline.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;GAeG;AACH;IACC;;;;;;OAMG;IACH,sBANW,QAAQ,YAEhB;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;yBA1IwB,mBAAmB;0BAOnB,gBAAgB"}