melonjs 20.1.1 → 20.3.0

package/build/system/platform.d.ts

@@ -8,6 +8,7 @@
  * android2 `true` if the device is an Android 2.x platform (deprecated)
  * linux `true` if the device is a Linux platform
  * chromeOS `true` if the device is running on ChromeOS.
+ * appleVendor `true` if the browser reports an Apple vendor (Safari)
  * wp `true` if the device is a Windows Phone platform (deprecated)
  * BlackBerry `true` if the device is a BlackBerry platform (deprecated)
  * Kindle `true` if the device is a Kindle platform (deprecated)
@@ -19,6 +20,13 @@
  */
 export declare const ua: string;
 export declare const iOS: boolean;
+/**
+ * `true` when the browser reports an Apple vendor string — Safari on
+ * macOS or iOS. Distinct from {@link iOS}: a Mac running Safari is
+ * `appleVendor` but not `iOS`, and Chrome on iOS is `iOS` but not
+ * `appleVendor`.
+ */
+export declare const appleVendor: boolean;
 export declare const android: boolean;
 /**
  * @deprecated since 19.7.0 — Android 2.x predates 2012. Will be removed in 20.x.
@@ -35,7 +43,19 @@ export declare const wp: boolean;
  */
 export declare const BlackBerry: boolean;
 /**
- * @deprecated since 19.7.0 — Kindle has a negligible market share and behaves like Android. Will be removed in 20.x.
+ * `true` on Amazon devices — Fire tablets (which report the Silk browser) and
+ * legacy Kindle e-readers.
+ *
+ * The previous pattern required `Silk` followed by `Mobile Safari`, which no
+ * current Fire tablet sends: Chromium-based Silk ends its user agent with
+ * `Safari/537.36`, so every modern Fire tablet went undetected. Silk is
+ * Amazon-only, so matching the `Silk/` token directly is both narrower and
+ * correct.
+ *
+ * Note these devices are ordinary Android: {@link android} is `true` for all of
+ * them, and nothing in the engine branches on this constant.
+ * @deprecated since 19.7.0 — Kindle behaves like Android and {@link android}
+ *   already covers it. Will be removed in a future release.
  */
 export declare const Kindle: boolean;
 export declare const ejecta: boolean;

package/build/system/platform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/system/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,eAAO,MAAM,EAAE,QAGT,CAAC;AAuCP,eAAO,MAAM,GAAG,SAAsD,CAAC;AACvE,eAAO,MAAM,OAAO,SAAsB,CAAC;AAC3C;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAwB,CAAC;AAC9C,eAAO,MAAM,KAAK,SAAoB,CAAC;AACvC,eAAO,MAAM,QAAQ,SAAkB,CAAC;AACxC;;GAEG;AACH,eAAO,MAAM,EAAE,SAA4B,CAAC;AAC5C;;GAEG;AACH,eAAO,MAAM,UAAU,SAAyB,CAAC;AACjD;;GAEG;AACH,eAAO,MAAM,MAAM,SAAyC,CAAC;AAC7D,eAAO,MAAM,MAAM,SAAyB,CAAC;AAC7C,eAAO,MAAM,QAAQ,SAA6B,CAAC;AAOnD,eAAO,MAAM,MAAM,SAGW,CAAC;AAO/B,eAAO,MAAM,QAAQ,SAAqC,CAAC;AAC3D,eAAO,MAAM,MAAM,SAK2C,CAAC"}
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/system/platform.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,eAAO,MAAM,EAAE,QAGT,CAAC;AA0DP,eAAO,MAAM,GAAG,SAAsD,CAAC;AACvE;;;;;GAKG;AACH,eAAO,MAAM,WAAW,SAAyB,CAAC;AAClD,eAAO,MAAM,OAAO,SAAsB,CAAC;AAC3C;;GAEG;AACH,eAAO,MAAM,QAAQ,SAAwB,CAAC;AAC9C,eAAO,MAAM,KAAK,SAAoB,CAAC;AACvC,eAAO,MAAM,QAAQ,SAAkB,CAAC;AACxC;;GAEG;AACH,eAAO,MAAM,EAAE,SAA4B,CAAC;AAC5C;;GAEG;AACH,eAAO,MAAM,UAAU,SAAyB,CAAC;AACjD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,MAAM,SAA4B,CAAC;AAChD,eAAO,MAAM,MAAM,SAAyB,CAAC;AAC7C,eAAO,MAAM,QAAQ,SAA6B,CAAC;AAOnD,eAAO,MAAM,MAAM,SAGW,CAAC;AAO/B,eAAO,MAAM,QAAQ,SAAqC,CAAC;AAC3D,eAAO,MAAM,MAAM,SAK2C,CAAC"}

package/build/utils/fetchdata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchdata.d.ts","sourceRoot":"","sources":["../../src/utils/fetchdata.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAKnB;AA2DD;;;;;;;;;;;;;;;GAeG;AACH,+BAdW,MAAM,gBACN,MAAM,aACN,MAAM,gBAkDhB"}

package/build/video/blendmodes.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Whether a blend mode needs the shader path rather than fixed-function state.
+ * @param {string} mode - the blend mode to test
+ * @returns {boolean} true when the mode needs the shader path
+ * @ignore
+ */
+export function isAdvancedBlendMode(mode: string): boolean;
+/**
+ * The `uBlendMode` uniform value for an advanced blend mode.
+ * @param {string} mode - the blend mode
+ * @returns {number} the shader's mode index, or -1 when not an advanced mode
+ * @ignore
+ */
+export function advancedBlendModeIndex(mode: string): number;
+/**
+ * Normalize a user-facing blend-mode string to its canonical token: `add` and
+ * `lighter` are spellings of `additive`, and anything unrecognized collapses
+ * to `normal`.
+ *
+ * The advanced modes normalize to `"normal"` on purpose — that is their
+ * PIPELINE state, since the geometry really does rasterize under ordinary
+ * source-over before the shader composites it. Use {@link isAdvancedBlendMode}
+ * to ask the other question, and {@link reportedBlendMode} for what
+ * `setBlendMode` should tell the caller.
+ * @param {string} mode - blend mode as set through `setBlendMode`
+ * @returns {string} the canonical token
+ * @ignore
+ */
+export function normalizeBlendMode(mode: string): string;
+/**
+ * Whether the engine can honour this blend mode at all, by either route.
+ * @param {string} mode - the blend mode to test
+ * @returns {boolean} false only for a mode no backend implements
+ * @ignore
+ */
+export function isSupportedBlendMode(mode: string): boolean;
+/**
+ * What `setBlendMode` reports back as applied.
+ *
+ * The return value is a capability probe: callers compare it against their
+ * request, and a mismatch means the renderer could not honour the mode. So a
+ * mode that WAS honoured must report itself verbatim — including an alias
+ * like `add`, which shares a pipeline with `additive` but must not come back
+ * under that name — while anything unimplemented reports `"normal"`.
+ * @param {string} mode - the requested blend mode
+ * @returns {string} the mode actually applied
+ * @ignore
+ */
+export function reportedBlendMode(mode: string): string;
+/**
+ * The blend state for a mode, in WebGPU's vocabulary — the neutral form each
+ * backend translates from.
+ *
+ * `srcFactor` depends on whether sources carry premultiplied alpha: a
+ * premultiplied source has already been scaled, so it takes `one` where a
+ * straight one takes `src-alpha`.
+ *
+ * Every mode here is EXACT for a translucent source as well as an opaque one
+ * — `multiply`, `screen` and `exclusion` were long commented as
+ * "approximate", but the algebra works out and measurement agrees. The two
+ * that genuinely could not be expressed this way, `darken` and `lighten`,
+ * moved to the shader path instead of staying approximate.
+ * @param {string} mode - a canonical mode from {@link normalizeBlendMode}
+ * @param {boolean} premultipliedAlpha - whether sources are premultiplied
+ * @returns {{operation: string, srcFactor: string, dstFactor: string}|undefined} the
+ * blend state, or `undefined` for `"none"`, which means replace (no blending)
+ * @ignore
+ */
+export function blendStateFor(mode: string, premultipliedAlpha: boolean): {
+    operation: string;
+    srcFactor: string;
+    dstFactor: string;
+} | undefined;
+/**
+ * The engine's blend-mode registry — one definition of every mode, shared by
+ * all three renderers.
+ *
+ * Blending is described here in **backend-neutral** terms and translated by
+ * each backend: WebGPU consumes these tokens directly (they are its own
+ * vocabulary), WebGL maps them onto `gl.*` enums, and Canvas ignores them
+ * entirely in favour of `globalCompositeOperation`.
+ *
+ * Keeping the table in one place is not tidiness. The two GPU backends
+ * previously each carried their own copy — a `switch` of `blendEquation` /
+ * `blendFunc` calls on one side and a `GPUBlendState` table on the other —
+ * which meant a mode added, removed or corrected on one backend could
+ * silently disagree with the other, and `video.AUTO` would then render the
+ * same scene differently depending on which backend it happened to pick.
+ */
+/**
+ * The CSS blend modes that cannot be expressed as `src * sfactor + dst * dfactor`.
+ *
+ * Fixed-function blending computes one multiply-add per channel, which covers
+ * `multiply`, `screen`, `additive` and `exclusion` — exactly, translucent
+ * sources included. The modes below cannot be reached that way: most need a
+ * per-pixel branch, a division or a `sqrt` on the DESTINATION, and `darken` /
+ * `lighten` need a term the `min` / `max` operations leave no room for.
+ * Neither GPU backend can read the destination in a fragment shader, so all of
+ * them are implemented by capturing the destination to a texture and
+ * compositing in `BlendEffect`.
+ *
+ * The array ORDER is the wire format: the index is the `uBlendMode` uniform
+ * value the shader branches on, so reordering it silently remaps every mode.
+ * @ignore
+ */
+export const ADVANCED_BLEND_MODES: string[];
+//# sourceMappingURL=blendmodes.d.ts.map

package/build/video/blendmodes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blendmodes.d.ts","sourceRoot":"","sources":["../../src/video/blendmodes.js"],"names":[],"mappings":"AAkDA;;;;;GAKG;AACH,0CAJW,MAAM,GACJ,OAAO,CAKnB;AAED;;;;;GAKG;AACH,6CAJW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;;;;GAaG;AACH,yCAJW,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;GAKG;AACH,2CAJW,MAAM,GACJ,OAAO,CASnB;AAED;;;;;;;;;;;GAWG;AACH,wCAJW,MAAM,GACJ,MAAM,CAKlB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,oCANW,MAAM,sBACN,OAAO,GACL;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,GAAC,SAAS,CAwC/E;AA1LD;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,4CAeE"}

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

@@ -27,7 +27,7 @@ export default class CanvasRenderer extends Renderer {
     setProjection(matrix: Matrix3d): void;
     /**
      * set the current blend mode for this renderer. <br>
-     * All renderers support: <br>
+     * This renderer supports every mode below except `"none"`: <br>
      * - "normal" : draws new content on top of the existing content <br>
      * <img src="../images/normal-blendmode.png" width="180"/> <br>
      * - "add", "additive", or "lighter" : color values are added together <br>
@@ -36,26 +36,33 @@ export default class CanvasRenderer extends Renderer {
      * <img src="../images/multiply-blendmode.png" width="180"/> <br>
      * - "screen" : pixels are inverted, multiplied, and inverted again (opposite of multiply) <br>
      * <img src="../images/screen-blendmode.png" width="180"/> <br>
-     * Canvas (browser-dependent) and WebGL2: <br>
      * - "darken" : retains the darkest pixels of both layers <br>
      * <img src="../images/darken-blendmode.png" width="180"/> <br>
      * - "lighten" : retains the lightest pixels of both layers <br>
      * <img src="../images/lighten-blendmode.png" width="180"/> <br>
-     * Canvas only, browser-dependent (falls back to "normal" if unsupported or in WebGL): <br>
-     * - "overlay" <br>
+     * - "overlay" : multiplies or screens, depending on the backdrop <br>
      * <img src="../images/overlay-blendmode.png" width="180"/> <br>
-     * - "color-dodge" <br>
-     * <img src="../images/color-dodge-blendmode.png" width="180"/> <br>
-     * - "color-burn" <br>
-     * <img src="../images/color-burn-blendmode.png" width="180"/> <br>
-     * - "hard-light" <br>
+     * - "hard-light" : overlay with the layers swapped — a harsh spotlight <br>
      * <img src="../images/hard-light-blendmode.png" width="180"/> <br>
-     * - "soft-light" <br>
+     * - "soft-light" : a diffused spotlight, gentler than hard-light <br>
      * <img src="../images/soft-light-blendmode.png" width="180"/> <br>
-     * - "difference" <br>
+     * - "color-dodge" : brightens the backdrop to reflect the source <br>
+     * <img src="../images/color-dodge-blendmode.png" width="180"/> <br>
+     * - "color-burn" : darkens the backdrop to reflect the source <br>
+     * <img src="../images/color-burn-blendmode.png" width="180"/> <br>
+     * - "difference" : the absolute difference of the two layers <br>
      * <img src="../images/difference-blendmode.png" width="180"/> <br>
-     * - "exclusion" <br>
+     * - "exclusion" : like difference, but lower in contrast <br>
      * <img src="../images/exclusion-blendmode.png" width="180"/> <br>
+     * - "none" : blending disabled — the source replaces the destination
+     * outright, alpha included. **GPU backends only**: there is no
+     * `globalCompositeOperation` that disables blending for the drawn area
+     * alone (`"copy"` clears the rest of the surface), so this renderer falls
+     * back to "normal" and reports it <br>
+     * A few draw types cannot honour every mode — 3D meshes, and fills using
+     * a {@link Gradient} — and fall back to "normal" with a one-time console
+     * warning. `setBlendMode` returns what it actually applied, so comparing
+     * the result against your request detects that case.
      * @see https://developer.mozilla.org/en-US/docs/Web/API/CanvasRenderingContext2D/globalCompositeOperation
      * @param {string} [mode="normal"] - blend mode
      * @returns {string} the blend mode actually applied (may differ if the requested mode is unsupported)
@@ -301,24 +308,24 @@ export default class CanvasRenderer extends Renderer {
      * Reset (overrides) the renderer transformation matrix to the
      * identity one, and then apply the given transformation matrix.
      * @param {Matrix2d|Matrix3d|number} a - a matrix to transform by, or the a component to multiply the current matrix by
-     * @param {number} b - the b component to multiply the current matrix by
-     * @param {number} c - the c component to multiply the current matrix by
-     * @param {number} d - the d component to multiply the current matrix by
-     * @param {number} e - the e component to multiply the current matrix by
-     * @param {number} f - the f component to multiply the current matrix by
+     * @param {number} [b] - the b component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [c] - the c component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [d] - the d component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [e] - the e component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
-    setTransform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
+    setTransform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
     /**
      * Multiply given matrix into the renderer tranformation matrix
      * @see {@link CanvasRenderer.setTransform} which will reset the current transform matrix prior to performing the new transformation
      * @param {Matrix2d|Matrix3d|number} a - a matrix to transform by, or the a component to multiply the current matrix by
-     * @param {number} b - the b component to multiply the current matrix by
-     * @param {number} c - the c component to multiply the current matrix by
-     * @param {number} d - the d component to multiply the current matrix by
-     * @param {number} e - the e component to multiply the current matrix by
-     * @param {number} f - the f component to multiply the current matrix by
+     * @param {number} [b] - the b component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [c] - the c component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [d] - the d component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [e] - the e component to multiply the current matrix by; omitted when `a` is a matrix
+     * @param {number} [f] - the f component to multiply the current matrix by; omitted when `a` is a matrix
      */
-    transform(a: Matrix2d | Matrix3d | number, b: number, c: number, d: number, e: number, f: number): void;
+    transform(a: Matrix2d | Matrix3d | number, b?: number, c?: number, d?: number, e?: number, f?: number): void;
     /**
      * A mask limits rendering elements to the shape and position of the given mask object.
      * If the drawing or rendering area is larger than the mask, only the intersecting part of the renderable will be visible.

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

@@ -0,0 +1,57 @@
+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";
+/**
+ * The compositing shader behind the six CSS blend modes that fixed-function
+ * blending cannot express: `overlay`, `hard-light`, `color-dodge`,
+ * `color-burn`, `soft-light` and `difference`.
+ *
+ * Internal — owned by the renderer, one instance per renderer, never
+ * constructed or configured by user code. A game selects a mode the ordinary
+ * way (`sprite.blendMode = "overlay"`, or `renderer.setBlendMode("overlay")`)
+ * and the renderer drives this effect from there.
+ *
+ * ### How it composites
+ *
+ * The renderer captures the destination, renders the draw to an offscreen
+ * target, then blits that target through this effect. Everything arriving in
+ * `color` is PREMULTIPLIED (the offscreen was drawn source-over into a
+ * transparent clear), while the W3C formulas are defined on straight colour —
+ * so the body un-premultiplies, blends, and re-premultiplies.
+ *
+ * Emitting premultiplied and letting ordinary source-over run the composite
+ * yields `as*B + (1-as)*Cb` and a correct output alpha for free. It also keeps
+ * the premultiplied invariant `rgb <= a` — a texel with `rgb > a` is undefined
+ * and diverges across browsers — which is why `B` is clamped even though all
+ * six formulas land in `[0,1]` analytically.
+ *
+ * The backdrop is treated as opaque (`ab = 1`). The GL capture is an RGB
+ * texture so that is true by construction there; the WebGPU capture preserves
+ * alpha and is deliberately ignored, so the two backends agree.
+ *
+ * ### Why not the `: screen_texture` builtin
+ *
+ * That annotation wires the sampler to the renderer's SHARED capture slot,
+ * which `drawImage` already refreshes on behalf of any custom shader that
+ * samples the screen. A renderable carrying an advanced blend mode AND a
+ * screen-sampling {@link ShaderEffect} would then have the two fighting over
+ * one texture. This declares a plain sampler instead and the renderer binds
+ * its own capture, so the two are independent. Referencing `screen_uv` still
+ * activates that varying on its own.
+ * @see {@link https://www.w3.org/TR/compositing-1/#blending}
+ * @ignore
+ */
+export default class BlendEffect extends ShaderEffect {
+    /**
+     * @param {import("../webgl/webgl_renderer.js").default|import("../webgpu/webgpu_renderer.js").default} renderer - the renderer that owns this effect
+     */
+    constructor(renderer: import("../webgl/webgl_renderer.js").default | import("../webgpu/webgpu_renderer.js").default);
+    /**
+     * Select which of the six formulas the shader evaluates.
+     * @param {string} mode - one of the modes in {@link ADVANCED_BLEND_MODES}
+     * @returns {boolean} false when the mode is not an advanced blend mode, in
+     * which case the uniform is left untouched
+     * @ignore
+     */
+    setBlendMode(mode: string): boolean;
+}
+import ShaderEffect from "./shadereffect.js";
+//# sourceMappingURL=blendEffect.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"blendEffect.d.ts","sourceRoot":"","sources":["../../../src/video/effects/blendEffect.js"],"names":[],"mappings":"AAgBA,soEAwDE;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH;IACC;;OAEG;IACH,sBAFW,OAAO,4BAA4B,EAAE,OAAO,GAAC,OAAO,8BAA8B,EAAE,OAAO,EA4DrG;IAED;;;;;;OAMG;IACH,mBALW,MAAM,GACJ,OAAO,CAWnB;CACD;yBAhMwB,mBAAmB"}

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

@@ -3,19 +3,19 @@
  * Commonly used for background defocus, depth-of-field simulation,
  * or UI backdrop blur.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // moderate blur
- * mySprite.shader = new BlurEffect(renderer, { strength: 2.0 });
+ * mySprite.addPostEffect(new BlurEffect(renderer, { strength: 2.0 }));
  */
 export default class BlurEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.strength=1.0] - blur strength in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         strength?: number | undefined;
         textureSize?: number[] | undefined;
     });

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,qCAHG;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":"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"}

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

@@ -3,22 +3,22 @@
  * chromatic aberration (color fringe) effect. Commonly used for
  * impact feedback, glitch effects, or damage indicators.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // subtle chromatic aberration
- * mySprite.shader = new ChromaticAberrationEffect(renderer, { offset: 2.0 });
+ * mySprite.addPostEffect(new ChromaticAberrationEffect(renderer, { offset: 2.0 }));
  * @example
  * // strong glitch effect
- * mySprite.shader = new ChromaticAberrationEffect(renderer, { offset: 5.0 });
+ * mySprite.addPostEffect(new ChromaticAberrationEffect(renderer, { offset: 5.0 }));
  */
 export default class ChromaticAberrationEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.offset=3.0] - channel offset in texels
      * @param {number[]} [options.textureSize=[256, 256]] - texture dimensions [width, height]
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         offset?: number | undefined;
         textureSize?: number[] | undefined;
     });

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,qCAHG;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":"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"}

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

@@ -2,24 +2,24 @@
  * 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
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // desaturate a sprite
- * mySprite.shader = new ColorMatrixEffect(renderer).saturate(0.0);
+ * mySprite.addPostEffect(new ColorMatrixEffect(renderer).saturate(0.0));
  * @example
  * // combine brightness + contrast on a camera
- * camera.shader = new ColorMatrixEffect(renderer).brightness(1.3).contrast(1.5);
+ * camera.addPostEffect(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 {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {ColorMatrix} [options.matrix] - an initial color matrix. Defaults to identity.
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         matrix?: ColorMatrix | undefined;
     });
     /**

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,qCAFG;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;yBAjKwB,mBAAmB;4BADhB,4BAA4B"}
+{"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,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;yBAjKwB,mBAAmB;4BADhB,4BAA4B"}

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

@@ -2,21 +2,21 @@
  * A shader effect that desaturates (grayscales) the sprite.
  * Commonly used for disabled states, death effects, or petrification.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // full grayscale
- * mySprite.shader = new DesaturateEffect(renderer);
+ * mySprite.addPostEffect(new DesaturateEffect(renderer));
  * @example
  * // partial desaturation (50%)
- * mySprite.shader = new DesaturateEffect(renderer, { intensity: 0.5 });
+ * mySprite.addPostEffect(new DesaturateEffect(renderer, { intensity: 0.5 }));
  */
 export default class DesaturateEffect extends ColorMatrixEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.intensity=1.0] - desaturation intensity (0.0 = full color, 1.0 = grayscale)
      */
-    constructor(renderer: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         intensity?: number | undefined;
     });
     intensity: number;

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,qCAFG;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;;;;;;;;;;;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"}

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

@@ -4,24 +4,24 @@
  * `progress` value increases from 0 to 1.
  * Commonly used for death, spawn, or teleport effects.
  * @category Effects
- * @see {@link Renderable.shader} for usage
+ * @see {@link Renderable#addPostEffect} for usage
  * @example
  * // create a dissolve effect
  * const dissolve = new DissolveEffect(renderer);
- * mySprite.shader = dissolve;
+ * mySprite.addPostEffect(dissolve);
  *
  * // animate the dissolve (0 = fully visible, 1 = fully dissolved)
  * dissolve.setProgress(0.5);
  */
 export default class DissolveEffect extends ShaderEffect {
     /**
-     * @param {import("../webgl_renderer.js").default} renderer - the current renderer instance
+     * @param {WebGLRenderer|WebGPURenderer|CanvasRenderer} renderer - the current renderer instance
      * @param {object} [options] - effect options
      * @param {number} [options.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: any, options?: {
+    constructor(renderer: WebGLRenderer | WebGPURenderer | CanvasRenderer, options?: {
         progress?: number | undefined;
         edgeColor?: number[] | undefined;
         edgeWidth?: number | undefined;

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,qCAJG;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":"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"}

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

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

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

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

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

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

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

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

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

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

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

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