@woosh/meep-engine 3.15.0 → 3.17.0

package/src/shade/renderer/particles/runtime/ParticleEmitter.js

@@ -0,0 +1,425 @@
+import { assert } from "../../../../core/assert.js";
+import { is_typed_array_equals } from "../../../../core/collection/array/typed/is_typed_array_equals.js";
+import { float32_array_hash } from "../../../../core/collection/array/typed/float32_array_hash.js";
+import { hash_mix2 } from "../../../../core/math/hash/hash_mix2.js";
+import { hash_mix3 } from "../../../../core/math/hash/hash_mix3.js";
+import { computeHashFloat } from "../../../../core/primitives/numbers/computeHashFloat.js";
+import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
+import { Node3D } from "../../scene/Node3D.js";
+import { EMITTER_ATTRIBUTE_ABSENT, make_emitter_flags } from "../data/PARTICLE_EMITTER_STRUCT.js";
+
+/**
+ * Render channels an emitter can bind to one of its effect's per-particle attributes. The names
+ * match the `render_*` fields of {@link ../data/PARTICLE_EMITTER_STRUCT.js}.
+ *
+ * @type {string[]}
+ */
+export const EMITTER_RENDER_CHANNELS = Object.freeze([
+    "position", "size", "color", "rotation", "frame", "velocity",
+]);
+
+/**
+ * How many record words the render pass reads for each channel.
+ *
+ * A channel is read at a fixed width — `chunk_particle_billboard_vertex.js` takes four words for
+ * colour and three for position, whatever the attribute behind the offset happens to be. Binding one
+ * to a narrower attribute is therefore not a smaller read but a read into whatever the layout put
+ * next, and nothing downstream objects: the particles simply come out wrong.
+ *
+ * Binding is deliberately not made to enforce this — the offsets are the record's, and an author who
+ * knows what is packed where may mean it — but an editor has this table so it can say so.
+ *
+ * @type {Object<string, number>}
+ */
+export const EMITTER_RENDER_CHANNEL_COMPONENTS = Object.freeze({
+    position: 3,
+    size: 1,
+    color: 4,
+    rotation: 1,
+    frame: 1,
+    velocity: 3,
+});
+
+/**
+ * One particle emitter: a scene node that runs a compiled effect.
+ *
+ * Being a {@link Node3D} is what places it. Add it to a scene and it gets a row in the scene
+ * database's `transforms` table like any other node; parent it to a joint and the GPU hierarchy
+ * pass composes its world matrix from the joint's every frame, animation included, with nothing
+ * copied through the CPU. Remove it from the scene and the row goes with it — and so do its
+ * particles, within a frame, because the emitter's table row is retired with it and its particles
+ * carry that row's generation. There is no transform of its own to keep in step with anything.
+ *
+ * The rest is a description of an effect and nothing else: the attribute {@link layout} and the
+ * compiled {@link program}, the {@link texture} to draw with, spawn rate, blend / projection /
+ * feature flags, bounds sphere, render-attribute bindings and flipbook grid. Every one of those is
+ * the author's, means the same thing with no device present, and is what a saved effect is made of.
+ *
+ * **Nothing here is the GPU's.** Which table row the emitter was given, which tenancy of it, where
+ * its program was placed in the program heap, which `transforms` row its node ended up in, where
+ * its texture was packed into the atlas — all of that is
+ * {@link ./GPUParticleEmitterContext.js GPUParticleEmitterContext}, held by the
+ * {@link ./EmitterRegistry.js} that registered the emitter and reachable through
+ * {@link ./EmitterRegistry.js#context}. An emitter no registry holds has none, which is also how
+ * "is this emitter live?" is asked. Nor is anything the GPU integrates per frame here — spawn
+ * accumulator, age, sleep are {@link ../data/PARTICLE_EMITTER_STATE.js}, and they stay on the GPU.
+ *
+ * Fields are plain data with no setters. After changing any of them, set `needsUpdate = true` — the
+ * node's own change counter, the same one the renderer reads to decide whether a transform needs
+ * re-uploading — and {@link ./EmitterRegistry.js#flush} restages the row on its next flush. One
+ * counter rather than a setter per field because a row is restaged whole either way: one changed
+ * field and ten cost the same upload.
+ */
+export class ParticleEmitter extends Node3D {
+
+    /**
+     * The per-particle attribute schema: which named attributes a particle of this emitter has, how
+     * wide each is, and what word of the record it sits at.
+     *
+     * @type {import("../layout/ParticleLayout.js").ParticleLayout}
+     */
+    layout;
+
+    /**
+     * The compiled INIT/UPDATE bytecode run for every particle of this emitter.
+     *
+     * @type {import("../isa/ParticleProgram.js").ParticleProgram}
+     */
+    program;
+
+    /**
+     * Image to draw the particles with, by URL, or `null` to draw against the default atlas — a
+     * single white texel, so an untextured emitter is a flat quad of its colour.
+     *
+     * A URL rather than a texture, and no uv rect: the particle system packs every emitter's image
+     * into one sheet so that a hundred effects sharing a puff of smoke pay for one image, and where
+     * a given image lands in that sheet is the system's answer, not the author's — it changes on
+     * every repack, without the emitter changing. The resolved patch is
+     * {@link ./GPUParticleEmitterContext.js#atlas_region}.
+     *
+     * @type {string|null}
+     */
+    texture = null;
+
+    /**
+     * Base RNG seed.
+     *
+     * Two emitters running one program produce identical particles from identical seeds. `0` reads
+     * as "unset", and the row written for such an emitter takes its registration's generation
+     * instead, which no other emitter of that registry shares.
+     *
+     * @type {number}
+     */
+    seed = 0;
+
+    /**
+     * Continuous emission rate, particles per second. Integrated on the GPU by the emitter tick
+     * pass; the CPU never counts particles.
+     * @type {number}
+     */
+    spawn_rate = 0;
+
+    /**
+     * Packed feature / blend / projection bits — see {@link make_emitter_flags}.
+     * @type {number}
+     */
+    flags = 0;
+
+    /**
+     * Bounding sphere in emitter-local space, scaled and placed by the node's world matrix.
+     *
+     * Two passes read it: the optional simulation culling (a culled emitter sleeps), and the AVBOIT
+     * occupancy, which marks the depth slices this emitter's particles may reach. The second gives
+     * it teeth even for an emitter that does not opt into culling — a particle outside the sphere
+     * still draws, but its extinction lands in whatever physical slice the warp put nearest, so it
+     * occludes at slightly the wrong depth. Size it to hold the effect.
+     *
+     * Hold the *quads*, not the centres. A camera-facing billboard has almost no depth extent, but
+     * an axis-locked, world-oriented or velocity-stretched one reaches a particle size — or, when
+     * stretched, several — in front of and behind the particle it belongs to.
+     *
+     * @type {Float32Array}
+     */
+    bounds_center = new Float32Array(3);
+
+    /**
+     * @type {number}
+     */
+    bounds_radius = 1;
+
+    /**
+     * Flipbook grid: columns, rows, over whatever region {@link texture} was packed into. `[1, 1]`
+     * is a single frame.
+     * @type {Float32Array}
+     */
+    flipbook = new Float32Array([1, 1]);
+
+    /** @type {number} record word offset of world position, or {@link EMITTER_ATTRIBUTE_ABSENT} */
+    render_position = EMITTER_ATTRIBUTE_ABSENT;
+    /** @type {number} record word offset of size */
+    render_size = EMITTER_ATTRIBUTE_ABSENT;
+    /** @type {number} record word offset of rgba colour */
+    render_color = EMITTER_ATTRIBUTE_ABSENT;
+    /** @type {number} record word offset of roll angle, radians */
+    render_rotation = EMITTER_ATTRIBUTE_ABSENT;
+    /** @type {number} record word offset of flipbook frame index */
+    render_frame = EMITTER_ATTRIBUTE_ABSENT;
+    /** @type {number} record word offset of velocity, read by the STRETCHED projection */
+    render_velocity = EMITTER_ATTRIBUTE_ABSENT;
+
+    get type() {
+        return "ParticleEmitter";
+    }
+
+    /**
+     * Bind render channels to per-particle attributes of this emitter's effect, by attribute name.
+     * Channels left out of `channels` keep whatever they had; a channel that was never bound stays
+     * at {@link EMITTER_ATTRIBUTE_ABSENT}, which the passes read as "this emitter has no such
+     * attribute" — the render pass substitutes a default, the sort pass treats the particle as
+     * being at the origin.
+     *
+     * The record stores word offsets rather than names because that is what the render and sort
+     * passes index a particle record with; resolving here is the only place a name is involved.
+     *
+     * @param {Object<string,string>} channels channel name (see {@link EMITTER_RENDER_CHANNELS}) ->
+     *        attribute name in the effect's layout
+     */
+    bind_render(channels) {
+        assert.isObject(channels, 'channels');
+        assert.defined(this.layout, 'layout');
+
+        const layout = this.layout;
+
+        for (const channel of Object.keys(channels)) {
+            const offset = layout.offsetOf(channels[channel]);
+
+            switch (channel) {
+                case "position": this.render_position = offset; break;
+                case "size": this.render_size = offset; break;
+                case "color": this.render_color = offset; break;
+                case "rotation": this.render_rotation = offset; break;
+                case "frame": this.render_frame = offset; break;
+                case "velocity": this.render_velocity = offset; break;
+                default:
+                    throw new Error(
+                        `Unknown render channel '${channel}', expected one of ${EMITTER_RENDER_CHANNELS.join(', ')}`
+                    );
+            }
+        }
+
+        this.needsUpdate = true;
+    }
+
+    /**
+     * Structural equality over everything an emitter *is*: where it sits, what it runs, what it
+     * draws with, and how it is bound to the renderer. Two emitters that compare equal describe one
+     * effect in one place, and one row would serve both.
+     *
+     * The node's identity is not part of it — `id`, parent and children say where an emitter is in
+     * a scene, not what it is — and neither is anything the GPU assigned it, which is not here to
+     * be compared. {@link transform_global} is left out too, being derived from
+     * {@link transform_local} and the parent chain.
+     *
+     * @param {ParticleEmitter} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (this === other) {
+            return true;
+        }
+
+        return this.name === other.name
+            && this.texture === other.texture
+            && this.seed === other.seed
+            && this.spawn_rate === other.spawn_rate
+            && this.flags === other.flags
+            && this.bounds_radius === other.bounds_radius
+            && this.render_position === other.render_position
+            && this.render_size === other.render_size
+            && this.render_color === other.render_color
+            && this.render_rotation === other.render_rotation
+            && this.render_frame === other.render_frame
+            && this.render_velocity === other.render_velocity
+            && is_typed_array_equals(this.bounds_center, other.bounds_center)
+            && is_typed_array_equals(this.flipbook, other.flipbook)
+            && this.transform_local.equals(other.transform_local)
+            && this.layout.equals(other.layout)
+            && this.program.equals(other.program);
+    }
+
+    /**
+     * Hash over everything {@link equals} compares, in the same terms — the compiled program hashes
+     * by its own bytecode rather than by object identity, so two emitters separately compiled from
+     * one graph hash equally, as they compare equally.
+     *
+     * @returns {number} int32
+     */
+    hash() {
+        const bindings = hash_mix3(
+            hash_mix3(this.render_position, this.render_size, this.render_color),
+            hash_mix3(this.render_rotation, this.render_frame, this.render_velocity),
+            this.flags
+        );
+
+        const geometry = hash_mix3(
+            float32_array_hash(this.bounds_center, 0, this.bounds_center.length),
+            computeHashFloat(this.bounds_radius),
+            float32_array_hash(this.flipbook, 0, this.flipbook.length)
+        );
+
+        const appearance = hash_mix3(
+            computeStringHash(this.name),
+            computeStringHash(this.texture),
+            hash_mix2(this.seed, computeHashFloat(this.spawn_rate))
+        );
+
+        return hash_mix3(
+            hash_mix2(bindings, geometry),
+            hash_mix2(appearance, this.transform_local.hash()),
+            hash_mix2(this.layout.hash(), this.program.hash())
+        );
+    }
+
+    /**
+     * Make this emitter a copy of `other`: same effect, same settings, same placement.
+     *
+     * The layout and the compiled program are shared rather than duplicated — both are immutable
+     * once compiled, and sharing them is what puts two emitters of one effect on one program id in
+     * the program heap, hence in one simulation bucket.
+     *
+     * What is not copied is the node's identity and its place in a scene ({@link Node3D#id},
+     * parent, children), and anything a registry gave the original: a copy is a second emitter, not
+     * a second reference to the first one's table row.
+     *
+     * @param {ParticleEmitter} other
+     */
+    copy(other) {
+        super.copy(other);
+
+        this.name = other.name;
+
+        this.layout = other.layout;
+        this.program = other.program;
+        this.texture = other.texture;
+
+        this.seed = other.seed;
+        this.spawn_rate = other.spawn_rate;
+        this.flags = other.flags;
+
+        this.bounds_center.set(other.bounds_center);
+        this.bounds_radius = other.bounds_radius;
+        this.flipbook.set(other.flipbook);
+
+        this.render_position = other.render_position;
+        this.render_size = other.render_size;
+        this.render_color = other.render_color;
+        this.render_rotation = other.render_rotation;
+        this.render_frame = other.render_frame;
+        this.render_velocity = other.render_velocity;
+    }
+
+    /**
+     * A second emitter equal to this one, and registered with nothing. Its subtree is cloned the
+     * way {@link Node3D#clone} clones one — overridden only because the base builds a plain
+     * `Node3D`, which would keep the transform and drop the effect.
+     *
+     * @returns {ParticleEmitter}
+     */
+    clone() {
+        const r = new ParticleEmitter();
+
+        r.copy(this);
+
+        for (const child of this.children) {
+            const clone = child.clone();
+
+            clone.parent = r;
+
+            r.children.push(clone);
+        }
+
+        return r;
+    }
+
+    /**
+     * Build an emitter from a plain description. Every parameter is optional except the compiled
+     * effect — an emitter with no program has nothing to run.
+     *
+     * `layout` and `program` are the two halves of what {@link ./create_particle_effect.js} returns,
+     * so an effect goes in by spreading it: `ParticleEmitter.from({ ...effect, spawn_rate: 100 })`.
+     *
+     * @param {object} config
+     * @param {import("../layout/ParticleLayout.js").ParticleLayout} config.layout per-particle
+     *        attribute schema
+     * @param {import("../isa/ParticleProgram.js").ParticleProgram} config.program compiled INIT /
+     *        UPDATE bytecode
+     * @param {ArrayLike<number>} [config.position] local translation, `[x, y, z]`
+     * @param {string|null} [config.texture] image URL to draw with
+     * @param {number} [config.seed]
+     * @param {number} [config.spawn_rate] particles/second
+     * @param {object} [config.flags] passed to {@link make_emitter_flags}
+     * @param {{center?: ArrayLike<number>, radius?: number}} [config.bounds]
+     * @param {Object<string,string>} [config.render] render channel -> attribute name
+     * @param {ArrayLike<number>} [config.flipbook] [cols, rows]
+     * @param {string} [config.name]
+     * @returns {ParticleEmitter}
+     */
+    static from(config) {
+        assert.isObject(config, 'config');
+        assert.defined(config.layout, 'config.layout');
+        assert.defined(config.program, 'config.program');
+
+        const emitter = new ParticleEmitter();
+
+        emitter.layout = config.layout;
+        emitter.program = config.program;
+
+        if (config.name !== undefined) {
+            emitter.name = config.name;
+        }
+
+        if (config.texture !== undefined) {
+            emitter.texture = config.texture;
+        }
+
+        if (config.position !== undefined) {
+            emitter.transform_local.setTranslation(config.position[0], config.position[1], config.position[2]);
+            emitter.updateMatrices();
+        }
+
+        if (config.seed !== undefined) {
+            emitter.seed = config.seed;
+        }
+
+        if (config.spawn_rate !== undefined) {
+            emitter.spawn_rate = config.spawn_rate;
+        }
+
+        emitter.flags = make_emitter_flags(config.flags ?? {});
+
+        if (config.bounds !== undefined) {
+            if (config.bounds.center !== undefined) {
+                emitter.bounds_center.set(config.bounds.center);
+            }
+            if (config.bounds.radius !== undefined) {
+                emitter.bounds_radius = config.bounds.radius;
+            }
+        }
+
+        if (config.flipbook !== undefined) {
+            emitter.flipbook.set(config.flipbook);
+        }
+
+        if (config.render !== undefined) {
+            emitter.bind_render(config.render);
+        }
+
+        return emitter;
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ParticleEmitter.prototype.isParticleEmitter = true;

package/src/shade/renderer/particles/runtime/ProgramArena.d.ts

@@ -1,22 +1,77 @@
 /**
- * Packs many compiled {@link ../isa/ParticleProgram.js} programs into two shared buffers — one of
- * instruction words, one of constant words — and hands back the offsets each emitter records.
+ * Packs many compiled {@link ../isa/ParticleProgram.js} programs into one shared buffer — a header,
+ * every program's constant pool, then every program's instruction words — and hands back the
+ * offsets each emitter records.
+ *
+ * Data before code, behind a four-word header whose first word says where the code starts: the VM
+ * reads both sections through one binding (a storage buffer per stage is not free, and code and
+ * constants are read together), and an emitter's constant pool sits next to the pools of the
+ * programs it shares a wave with.
  *
  * Because VM instructions carry no absolute code addresses (control flow is branchless) and
- * constant references are program-local (the shader adds the emitter's `constant_offset`), programs
- * can be concatenated at any offset. SPAWN and UPDATE sections are laid out back-to-back per program.
+ * constant references are program-local (the VM adds the emitter's `constant_offset`), programs
+ * can be concatenated at any offset. INIT and UPDATE sections are laid out back-to-back per program.
  */
 export class ProgramArena {
-    /** @type {number[]} flat instruction words */
+    /**
+     * Flat instruction words, every program's INIT and UPDATE sections concatenated.
+     * @type {number[]}
+     */
     instruction_words: number[];
-    /** @type {number[]} flat constant words (f32 bit patterns) */
+    /**
+     * Flat constant words (f32 bit patterns), every program's pool concatenated.
+     * @type {number[]}
+     */
     constant_words: number[];
-    /** @type {number} running instruction index (SPAWN/UPDATE offsets are in these units) */
+    /**
+     * Running instruction index — INIT/UPDATE offsets are in these units.
+     * @type {number}
+     */
     instruction_count: number;
-    /** @type {number} running vec4 constant index */
-    constant_count: number;
-    /** @type {Map<string, object>} content key -> the placement the first identical program got */
-    programs: Map<string, object>;
+    /**
+     * Running constant word index — the pool is addressed by word, so a scalar literal costs one
+     * rather than the four a `vec4` entry used to.
+     * @type {number}
+     */
+    constant_word_count: number;
+    /**
+     * Slots the hungriest program in the arena needs — the maximum of every added program's
+     * `register_count`.
+     *
+     * This is the number that picks an interpreter. It is a property of the SET, not of a program:
+     * one program past {@link ../ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS} moves every
+     * pass in the system onto the wide register file, including the emitters whose programs would
+     * have fit. Per-program dispatch would be the other design, and a much larger one — two pipelines
+     * live at once, the coherence pass's buckets split along a second axis, and two indirect
+     * commands to size. This is a fallback for a case that should not arise, so it is the whole
+     * system or none of it.
+     *
+     * @type {number}
+     */
+    register_high_water: number;
+    /**
+     * Whether the arena holds a program the fast interpreter's register file cannot hold, and the
+     * system must therefore run on {@link ../vm/chunk_particle_vm_registers_wide.js}.
+     *
+     * Monotonic in practice: removing an emitter does not remove its program from the arena (ids are
+     * dense and buckets are keyed on them), so once the set has seen a wide program it stays wide
+     * until the arena itself is rebuilt.
+     *
+     * @returns {boolean}
+     */
+    get requires_wide_registers(): boolean;
+    /**
+     * Content key -> the placement the first identical program got.
+     * @type {Map<string, {init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}>}
+     */
+    programs: Map<string, {
+        init_offset: number;
+        init_count: number;
+        update_offset: number;
+        update_count: number;
+        constant_offset: number;
+        program_id: number;
+    }>;
     /**
      * Number of distinct programs in the arena — and therefore the number of buckets the
      * simulation-order pass histograms into. Program ids are dense in `[0, program_count)`.
@@ -37,20 +92,24 @@ export class ProgramArena {
      * which both wastes lanes and splits a run that was already program-coherent.
      *
      * @param {import("../isa/ParticleProgram.js").ParticleProgram} program
-     * @returns {{spawn_offset: number, spawn_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
+     * @returns {{init_offset: number, init_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
      */
     add(program: import("../isa/ParticleProgram.js").ParticleProgram): {
-        spawn_offset: number;
-        spawn_count: number;
+        init_offset: number;
+        init_count: number;
         update_offset: number;
         update_count: number;
         constant_offset: number;
         program_id: number;
     };
-    /** @returns {Uint32Array} the packed instruction buffer (at least length 1) */
-    build_instruction_buffer(): Uint32Array;
-    /** @returns {Uint32Array} the packed constant buffer (at least length 4 for one vec4) */
-    build_constant_buffer(): Uint32Array;
+    /**
+     * The packed buffer: `[header][constants][code]`. Word {@link PARTICLE_PROGRAM_CODE_BASE_WORD} of
+     * the header is the word index the code starts at, which moves every time a program's constants
+     * are appended — the emitter records never carry it, they carry offsets into each section.
+     *
+     * @returns {Uint32Array}
+     */
+    build_program_buffer(): Uint32Array;
     #private;
 }
 //# sourceMappingURL=ProgramArena.d.ts.map

package/src/shade/renderer/particles/runtime/ProgramArena.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProgramArena.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ProgramArena.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH;IAEQ,8CAA8C;IAC9C,mBADW,MAAM,EAAE,CACQ;IAC3B,8DAA8D;IAC9D,gBADW,MAAM,EAAE,CACK;IACxB,yFAAyF;IACzF,mBADW,MAAM,CACS;IAC1B,iDAAiD;IACjD,gBADW,MAAM,CACM;IACvB,+FAA+F;IAC/F,UADW,IAAI,MAAM,EAAE,MAAM,CAAC,CACL;IAG7B;;;;OAIG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,aAHW,OAAO,2BAA2B,EAAE,eAAe;sBAClC,MAAM;qBAAe,MAAM;uBAAiB,MAAM;sBAAgB,MAAM;yBAAmB,MAAM;oBAAc,MAAM;MAgChJ;IAUD,+EAA+E;IAC/E,4BADc,WAAW,CAGxB;IAED,yFAAyF;IACzF,yBADc,WAAW,CAGxB;;CACJ"}
+{"version":3,"file":"ProgramArena.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ProgramArena.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;OAGG;IACH,mBAFU,MAAM,EAAE,CAEK;IAEvB;;;OAGG;IACH,gBAFU,MAAM,EAAE,CAEE;IAEpB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;;;;;;;;;OAaG;IACH,qBAFU,MAAM,CAEQ;IAExB;;;;;;;;;OASG;IACH,uCAEC;IAED;;;OAGG;IACH,UAFU,IAAI,MAAM,EAAE;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAAC,CAErI;IAErB;;;;OAIG;IACH,4BAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH,aAHW,OAAO,2BAA2B,EAAE,eAAe;qBACnC,MAAM;oBAAc,MAAM;uBAAiB,MAAM;sBAAgB,MAAM;yBAAmB,MAAM;oBAAc,MAAM;MAkC9I;IAUD;;;;;;OAMG;IACH,wBAFa,WAAW,CAcvB;;CACJ"}