melonjs 20.3.0 → 20.4.0

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

@@ -12,46 +12,9 @@ export default class WebGLRenderer extends Renderer {
     readonly GPUVendor: string;
     /**
      * The WebGL context
-     * @name gl
      * @type {WebGLRenderingContext}
      */
     gl: WebGLRenderingContext;
-    _renderTargetPool: RenderTargetPool;
-    /**
-     * Saved projection matrix for begin/endPostEffect.
-     * @type {Matrix3d}
-     * @ignore
-     */
-    _effectProjectionStack: Matrix3d;
-    _effectPassDepth: number;
-    /**
-     * Advanced-blend state. The six CSS modes fixed-function cannot
-     * express are composited by capturing the destination, rendering the
-     * draw to an offscreen target, and blitting that through
-     * {@link BlendEffect}. All of it is created lazily — a game that
-     * never asks for an advanced mode pays nothing.
-     *
-     * `_advancedBlendBusy` is a DEPTH, not a flag: the bracket nests
-     * inside itself (the composite blit re-enters `setBatcher`, and
-     * `toFrameTexture` does too), so a boolean would be cleared by the
-     * inner scope while the outer one is still running.
-     * @ignore
-     */
-    _advancedBlendEffect: BlendEffect | undefined;
-    /** @ignore */
-    _advancedBlendCapture: any;
-    /** @ignore */
-    _advancedBlendTarget: WebGLRenderTarget | undefined;
-    /** @ignore */
-    _advancedBlendOpen: boolean;
-    /** @ignore */
-    _advancedBlendBusy: number;
-    /** @ignore */
-    _advancedBlendParent: import("../rendertarget/rendertarget.ts").default | null | undefined;
-    /** @ignore */
-    _advancedBlendStencil: boolean;
-    /** @ignore */
-    _advancedBlendWarned: Set<any>;
     /**
      * sets or returns the shape used to join two line segments where they meet.
      * Out of the three possible values for this property: "round", "bevel", and "miter", only "round" is supported for now in WebGL
@@ -64,64 +27,12 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLBuffer}
      */
     vertexBuffer: WebGLBuffer;
-    /**
-     * Sampler objects, deduplicated by state. GL bakes wrap/filter into the
-     * texture object; a bound sampler overrides that, so one texture can
-     * serve several variants at once — which is what lets residency be
-     * keyed by source alone. Renderer-owned so every batcher shares it.
-     * @type {GLSamplerCache}
-     * @ignore
-     */
-    samplerCache: GLSamplerCache;
-    /**
-     * Texture residency, keyed by SOURCE. The GL handle used to be
-     * reachable only through a batcher's per-unit array, so dropping a unit
-     * assignment destroyed the texture and the next draw rebuilt it from
-     * scratch — a full re-upload and mip regeneration per quad once past
-     * the batching limit. Owning it here, per renderer, means a texture
-     * that merely moves units costs a bind.
-     *
-     * Renderer-owned rather than batcher-owned on purpose: `init()` re-runs
-     * on context restore, so a batcher-owned store would be REPLACED there,
-     * orphaning every handle it tracked and leaking them on the next loss.
-     * @type {TextureStore}
-     * @ignore
-     */
-    textureStore: TextureStore;
     /**
      * Maximum number of texture unit supported under the current context
      * @type {number}
      * @readonly
      */
     readonly maxTextures: number;
-    /**
-     * Next free indexed `UNIFORM_BUFFER` binding point, handed out by
-     * {@link WebGLRenderer#reserveUniformBindingPoint}. Binding points are
-     * a context-wide namespace shared by every uniform block, so they are
-     * allocated here rather than picked as literals by whoever needs one —
-     * the same reason texture units go through `TextureCache.reserveUnit`.
-     * @type {number}
-     * @ignore
-     */
-    _nextUniformBindingPoint: number;
-    /**
-     * the default shader precision based on application settings
-     * @type {string}
-     * @ignore
-     */
-    shaderPrecision: string;
-    /**
-     * reusable scratch array for fillRect (2 triangles = 6 vertices)
-     * @ignore
-     */
-    _rectTriangles: {
-        x: number;
-        y: number;
-    }[];
-    _clipAABB: Bounds;
-    _polyVerts: any[];
-    _currentGradient: any;
-    _maskVisibleRef: number;
     /**
      * The current transformation matrix used for transformations on the overall scene
      * (alias to renderState.currentTransform for backward compatibility)
@@ -153,21 +64,11 @@ export default class WebGLRenderer extends Renderer {
      * @type {WebGLProgram|undefined}
      */
     get currentProgram(): WebGLProgram | undefined;
-    /**
-     * the GL texture unit currently active (`gl.activeTexture`) — global
-     * GL state, so tracked once per renderer and shared by every batcher
-     * through the `MaterialBatcher.currentTextureUnit` accessor. `-1`
-     * forces the next bind to re-issue `gl.activeTexture`.
-     * @type {number}
-     * @ignore
-     */
-    _activeTextureUnit: number;
     /**
      * The list of active batchers
      * @type {Map<WebGLBatcher>}
      */
     batchers: Map<WebGLBatcher, any>;
-    _scissorActive: boolean;
     cache: TextureCache;
     onGameReset: () => void;
     onContextRestoredInvalidate: (renderer: any) => void;
@@ -179,15 +80,6 @@ export default class WebGLRenderer extends Renderer {
      * @deprecated since 20.0.0 — the WebGL renderer is WebGL 2 only, this is always `2`
      */
     get WebGLVersion(): number;
-    _compressedTextureFormats: {
-        astc: any;
-        bptc: any;
-        s3tc: any;
-        s3tc_srgb: any;
-        pvrtc: any;
-        etc1: any;
-        etc2: any;
-    } | undefined;
     /**
      * Reset context state
      */
@@ -204,10 +96,6 @@ export default class WebGLRenderer extends Renderer {
      * @param {object} mesh - the mesh whose geometry should be freed
      */
     deleteMeshGeometry(mesh: object): void;
-    _lightShader: RadialGradientEffect | undefined;
-    _lightAtlas: TextureAtlas | undefined;
-    _frameTexture: any;
-    _orthogonalTMXGPURenderer: OrthogonalTMXLayerGPURenderer | null | undefined;
     /**
      * Draw a TMX tile layer through whichever path the layer's `renderMode`
      * resolves to. WebGL2-eligible layers (`renderMode === "shader"`) take
@@ -218,13 +106,6 @@ export default class WebGLRenderer extends Renderer {
      * @param {object} rect - the visible region in world coords
      */
     drawTileLayer(layer: object, rect: object): void;
-    /**
-     * Lazy-init the orientation-specific GPU tilemap renderer.
-     * @param {string} orientation
-     * @returns {object|undefined}
-     * @ignore
-     */
-    _getTMXGPURendererFor(orientation: string): object | undefined;
     /**
      * add a new batcher to this renderer
      * @param {WebGLBatcher} batcher - a batcher instance (must extend WebGLBatcher)
@@ -239,23 +120,6 @@ export default class WebGLRenderer extends Renderer {
      * @returns {WebGLBatcher} an instance to the current active batcher
      */
     setBatcher(name?: string, shader?: GLShader): WebGLBatcher;
-    /**
-     * Whether the device state right now is the scene's, so a deferred
-     * ground-shadow drain (#1515) would actually land where it is meant to.
-     *
-     * A batcher transition is normally the end of the mesh pass — but not
-     * every one is. `setMask` fills its shape through the primitive batcher
-     * with **colour writes off and `stencilOp(…, INCR)` armed**, so draining
-     * there both discards every blob and stamps their footprints into the mask
-     * being built. A transition inside a post-effect bracket is bound to the
-     * child's FBO, so the blobs would be captured into that effect chain and
-     * lost from the world. In either case the queue simply waits: the camera
-     * drains it at the end of the world walk, which is the point that is always
-     * correct.
-     * @returns {boolean} true when a drain is safe here
-     * @ignore
-     */
-    _canDrainShadows(): boolean;
     /**
      * Create a pattern with the specified repetition
      * @param {HTMLImageElement|SVGImageElement|HTMLVideoElement|HTMLCanvasElement|ImageBitmap|OffscreenCanvas|VideoFrame} image - Source image to be used as the pattern's image
@@ -269,96 +133,27 @@ export default class WebGLRenderer extends Renderer {
      * let basic      = renderer.createPattern(image, "no-repeat");
      */
     createPattern(image: HTMLImageElement | SVGImageElement | HTMLVideoElement | HTMLCanvasElement | ImageBitmap | OffscreenCanvas | VideoFrame, repeat?: string): TextureAtlas;
-    _lightUniformsScratch: import("./lighting/pack.ts").LightUniformScratch | undefined;
     /**
-     * Claim the next indexed `UNIFORM_BUFFER` binding point.
+     * Upload per-frame Light2d uniforms used by the lit sprite pipeline.
      *
-     * Binding points are context-wide: two uniform blocks sharing one silently
-     * overwrite each other, and the loser reads the winner's bytes as its own.
-     * Allocating them from here rather than hard-coding an integer per feature
-     * makes that collision impossible, and mirrors how texture units are
-     * claimed through {@link TextureCache#reserveUnit}.
+     * Packs the active lights into pre-allocated scratch buffers, then
+     * forwards to `LitQuadBatcher`. Light positions are translated from
+     * world-space (where `light.getBounds().centerX/Y` lives) into the
+     * renderer's pre-projection coords by subtracting `(translateX, translateY)`,
+     * matching what `Stage.drawLighting` does for the cutout pass — so
+     * the lit fragment's `lightPos - vWorldPos` math lines up with the
+     * camera's view.
      *
-     * Callers hold their point for the life of the batcher — a context restore
-     * re-runs `init()`, which must reuse the point it already has rather than
-     * claim another, or a long-lived session would leak through the budget.
-     * @returns {number} the claimed binding point
-     * @throws {Error} when the device's binding points are exhausted
-     * @ignore
-     */
-    reserveUniformBindingPoint(): number;
-    /**
-     * Lazy-init a shared 1×1 white `TextureAtlas` used as the source
-     * texture for `drawLight`'s procedural shader. The shader ignores
-     * the sampled color, but `addQuad`'s vertex format includes a
-     * texture-unit attribute so we still need a real texture; sharing
-     * one across every light keeps them on the same multi-texture slot
-     * (no flush on light switch).
-     * @returns {TextureAtlas}
-     * @ignore
-     */
-    _getLightAtlas(): TextureAtlas;
-    /** @ignore */
-    _toFrameTexture(options?: {}): any;
-    /**
-     * The renderer-owned shared frame-capture slot, minted lazily so it has a
-     * stable identity from the moment an effect is constructed — before the
-     * first actual capture fills it (`glTexture` stays `null` until then, and
-     * the live-sampler bind path skips unfilled captures). `ShaderEffect`
-     * wires `: screen_texture` annotated samplers to this object.
-     * @returns {FrameTexture} the shared capture slot
-     * @ignore
-     */
-    getSharedFrameTexture(): FrameTexture;
-    /**
-     * Forget the cached binding for GL texture `unit` on every batcher (except
-     * `except`). Call this whenever a texture is bound to a unit **directly** —
-     * bypassing the shared texture cache and its `GPU_TEXTURE_CACHE_RESET`
-     * coordination — as {@link WebGLRenderer#toFrameTexture}'s capture copy and
-     * {@link ShaderEffect#_prepareTextures}'s reserved extra samplers both do.
-     * Those binds land on the TOP of the unit range, which overlaps the lit quad
-     * batcher's normal-map units; without invalidation a later lit draw would
-     * assume its normal map is still resident there and skip re-binding it,
-     * sampling the directly-bound texture as a normal map (wrong lighting).
-     * @param {number} unit - the GL texture unit that was clobbered
-     * @param {WebGLBatcher} [except] - a batcher to skip (the one that just bound the
-     *   texture — its own cache is already accurate)
-     * @ignore
-     */
-    invalidateTextureUnit(unit: number, except?: WebGLBatcher): void;
-    /** @ignore */
-    endPostEffect(renderable: any): void;
-    /**
-     * Say once, per excluded path and mode, that an advanced blend mode is
-     * falling back to `"normal"`. A silent data-dependent fallback is exactly
-     * what the advanced-blend work exists to remove, so the exclusions are
-     * loud.
-     * @param {string} what - the excluded path, named for the message
-     * @ignore
-     */
-    _warnAdvancedBlendFallback(what: string): void;
-    /**
-     * Close a pending advanced-blend bracket, if one is open and we are not
-     * already inside the bracket machinery. The safe form to call from any
-     * path that is about to disturb the destination.
-     * @ignore
-     */
-    _drainAdvancedBlend(): void;
-    /**
-     * Open an advanced-blend bracket: capture the destination, then redirect
-     * this draw into an offscreen target. Closed by {@link _closeAdvancedBlend}
-     * at the next draw, flush or clear.
-     * @returns {boolean} false when the effect could not be realized, in which
-     * case the draw proceeds unbracketed (plain source-over)
-     * @ignore
-     */
-    _openAdvancedBlend(): boolean;
-    /**
-     * Close an advanced-blend bracket: drain the offscreen, return to the
-     * parent target, and composite through {@link BlendEffect}.
-     * @ignore
-     */
-    _closeAdvancedBlend(): void;
+     * Lights past `MAX_LIGHTS` are silently dropped. Also caches the
+     * active light count on the renderer so `drawImage` can dispatch
+     * normal-mapped sprites to the lit batcher only when there's
+     * something to light them with.
+     * @param {Iterable<object>} [lights] - active `Light2d` instances; falsy/empty no-ops the lit pipeline
+     * @param {object} [ambient] - ambient lighting color (0..255 RGB); defaults to black
+     * @param {number} [translateX=0] - world-to-screen X translate (matches `Camera2d.draw()`)
+     * @param {number} [translateY=0] - world-to-screen Y translate
+     */
+    setLightUniforms(lights?: Iterable<object>, ambient?: object, translateX?: number, translateY?: number): void;
     /**
      * Clears the gl context with the given color.
      * @param {Color|string} [color="#000000"] - CSS color.
@@ -403,38 +198,8 @@ export default class WebGLRenderer extends Renderer {
      * @see WebGLRenderer#createPattern
      */
     drawPattern(pattern: TextureAtlas, x: number, y: number, width: number, height: number): void;
-    /**
-     * Draw a textured triangle mesh.
-     * Enables hardware depth testing and backface culling for the
-     * duration of the draw, then restores the previous GL state. Large
-     * meshes are automatically chunked across multiple draw calls to
-     * fit the vertex/index buffer limits.
-     *
-     * Multi-material meshes (OBJ files with multiple `usemtl` groups +
-     * a bound MTL) don't add any per-material draw calls here — the
-     * per-material colors are baked into `mesh.vertexColors` at
-     * construction time and pushed through the batcher's per-vertex
-     * `aColor` attribute. `mesh.tint` still multiplies on top at draw
-     * time, so flash / fade / team-color via `setTint` work the same
-     * as single-material. (The chunking-for-buffer-limits behavior
-     * above still applies to multi-material meshes as well.)
-     * @param {Mesh} mesh - a Mesh renderable or compatible object
-     * @param {Matrix3d} [modelMatrix] - where the mesh sits in the world. When
-     * given, the mesh is drawn from persistent model-space geometry and placed
-     * entirely by uniforms; when omitted, its vertices are taken as already
-     * positioned and accumulated through the batcher (the 2D-camera path).
-     */
-    /**
-     * Draw one ground shadow per instance of an `InstancedMesh` (#1515), in a
-     * single call over the same instance buffer the mesh drew from.
-     * @param {InstancedMesh} mesh - the mesh casting the shadows
-     * @param {Matrix3d} shadowMatrix - the group matrix flattened onto the ground
-     * @param {object} quad - the shared shadow quad
-     * @ignore
-     */
-    drawInstancedShadow(mesh: InstancedMesh, shadowMatrix: Matrix3d, quad: object): void;
+    drawInstancedShadow(mesh: any, shadowMatrix: any, quad: any): void;
     drawMesh(mesh: any, modelMatrix: any): void;
-    _meshShaderWarned: boolean | undefined;
     /**
      * starts a new path by emptying the list of sub-paths. Call this method when you want to create a new path
      * @example
@@ -506,9 +271,9 @@ export default class WebGLRenderer extends Renderer {
      * @param {number} y - The y axis of the coordinate for the rectangle starting point.
      * @param {number} width - The rectangle's width.
      * @param {number} height - The rectangle's height.
-     * @param {number} radius - The corner radius.
+     * @param {number} radii - The corner radius.
      */
-    roundRect(x: number, y: number, width: number, height: number, radii: any): void;
+    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
@@ -568,24 +333,6 @@ export default class WebGLRenderer extends Renderer {
      */
     setBlendMode(mode?: string, premultipliedAlpha?: boolean): string;
     currentPremultipliedAlpha: any;
-    /**
-     * Map the backend-neutral default filter mode
-     * ({@link Renderer#getDefaultTextureFilter}) to the GL enum
-     * (`gl.LINEAR` / `gl.NEAREST`) used for textures that don't carry their own
-     * `texture.filter`. The neutral resolver lives on the base renderer so a
-     * future WebGPU backend reuses it and maps to `GPUFilterMode` instead.
-     * @returns {number} `gl.LINEAR` or `gl.NEAREST`
-     * @ignore
-     */
-    _glTextureFilter(): number;
-    /**
-     * Re-apply a min/mag filter to every currently-bound texture across all
-     * batchers (see https://github.com/melonjs/melonJS/issues/1279). Shared by
-     * {@link WebGLRenderer#setAntiAlias} and {@link WebGLRenderer#setTextureFilter}.
-     * @param {number} filter - `gl.LINEAR` or `gl.NEAREST`
-     * @ignore
-     */
-    _reapplyTextureFilter(filter: number): void;
     /**
      * Return the global alpha
      * @returns {number} global alpha value
@@ -684,25 +431,15 @@ export default class WebGLRenderer extends Renderer {
      * @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;
-    /**
-     * 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.
-     * (Note Mask are not preserved through renderer context save and restore and need so be manually cleared)
-     * @see CanvasRenderer#clearMask
-     * @param {Rect|RoundRect|Polygon|Line|Ellipse} [mask] - a shape defining the mask to be applied
-     * @param {boolean} [invert=false] - either the given shape should define what is visible (default) or the opposite
-     */
-    setMask(mask?: Rect | RoundRect | Polygon | Line | Ellipse, invert?: boolean): void;
-    _maskDepthWarned: boolean | undefined;
     #private;
 }
 import Renderer from "./../renderer.js";
 import RenderTargetPool from "../rendertarget/render_target_pool.js";
-import { Matrix3d } from "../../math/matrix3d.ts";
 import BlendEffect from "../effects/blendEffect.js";
 import WebGLRenderTarget from "../rendertarget/webglrendertarget.js";
 import { GLSamplerCache } from "./utils/samplercache.js";
 import { Bounds } from "../../physics/bounds.ts";
+import { Matrix3d } from "../../math/matrix3d.ts";
 import { WebGLBatcher } from "./batchers/batcher.js";
 import TextureCache from "./../texture/cache.js";
 import RadialGradientEffect from "../effects/radialGradient.js";

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

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

package/build/video/webgpu/batchers/lit_mesh_batcher.d.ts

@@ -29,12 +29,6 @@ export default class WebGPULitMeshBatcher extends WebGPUMeshBatcher {
         dynamicOffset: any;
         frameId: any;
     } | null | undefined;
-    /**
-     * build the light-block layout once per device (init drops it when the
-     * device changes)
-     * @ignore
-     */
-    ensureLightsLayout(): GPUBindGroupLayout;
 }
 import WebGPUMeshBatcher from "./mesh_batcher.js";
 //# sourceMappingURL=lit_mesh_batcher.d.ts.map

package/build/video/webgpu/batchers/lit_mesh_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;OAEG;IACH,kDAoBC;IAhBC,6CAA6B;IAU9B,iDAAiD;IACjD,qDAAqD;IAErD,2CAAgC;IAEhC;;;;yBAAwB;IA2CzB;;;;OAIG;IACH,yCAkBC;CA4JD;8BA7Q6B,mBAAmB"}
+{"version":3,"file":"lit_mesh_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/lit_mesh_batcher.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;GAgBG;AACH;IACC;;OAEG;IACH,kDAoBC;IAhBC,6CAA6B;IAU9B,iDAAiD;IACjD,qDAAqD;IAErD,2CAAgC;IAEhC;;;;yBAAwB;IAkDzB;;;;;OAKG;IACH,yCAkBC;CAoKD;8BA7R6B,mBAAmB"}

package/build/video/webgpu/batchers/lit_quad_batcher.d.ts

@@ -46,14 +46,6 @@ export default class WebGPULitQuadBatcher extends WebGPUQuadBatcher {
      * @returns {boolean} true when lit draws can bind a valid light block
      */
     hasCurrentLightBinding(frameId: number): boolean;
-    /**
-     * Resolve (and lazily upload) the resident texture for a normal-map
-     * source, re-uploading when its duck-typed `version` stamp advances.
-     * @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} source - the normal-map image
-     * @returns {object} {texture, view, version, width, height}
-     * @ignore
-     */
-    residentNormalMap(source: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): object;
     /**
      * Add a lit textured quad — the base contract plus the normal map the
      * segment shades with.

package/build/video/webgpu/batchers/lit_quad_batcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;OAEG;IACH,kDAmDC;IA9CA,uBAQE;IACF,kBAaE;IAcF,iDAA+C;IAE/C,2CAAgC;IAEhC;;;;yBAAwB;IAGxB,wCAA6B;IAE7B,0CAA+B;IAGhC;;;;OAIG;IACH,yBAFW,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gCAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;OAMG;IACH,0BAJW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAsDlB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAdW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,MAAM,QAyDhB;IAwBD;;;OAGG;IACH,uDASC;CAuBD;8BAnU6B,mBAAmB"}
+{"version":3,"file":"lit_quad_batcher.d.ts","sourceRoot":"","sources":["../../../../src/video/webgpu/batchers/lit_quad_batcher.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH;IACC;;OAEG;IACH,kDAmDC;IA9CA,uBAQE;IACF,kBAaE;IAcF,iDAA+C;IAE/C,2CAAgC;IAEhC;;;;yBAAwB;IAGxB,wCAA6B;IAE7B,0CAA+B;IAGhC;;;;OAIG;IACH,yBAFW,MAAM,QAuChB;IAED;;;;;;OAMG;IACH,gCAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,0BALW,gBAAgB,GAAC,iBAAiB,GAAC,eAAe,GAAC,WAAW,GAC5D,MAAM,CAuDlB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,0BAdW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QACN,MAAM,aACN,OAAO,cACP,MAAM,QAyDhB;IAyBD;;;OAGG;IACH,uDASC;CAuBD;8BArU6B,mBAAmB"}