@woosh/meep-engine 3.58.0 → 3.60.0

package/editor/particles/effect/ParticleReferenceSimulation.d.ts

@@ -15,8 +15,8 @@ export class ParticleReferenceSimulation {
         capacity?: number;
     });
     /**
-     * Particle records, {@link PARTICLE_RECORD_WORD_COUNT} words each. Attribute values are f32 bits
-     * — the same reinterpretation the pool buffer uses on the GPU.
+     * Particle records, {@link PARTICLE_RECORD_WORD_COUNT} words each. Particle field values are
+     * f32 bits — the same reinterpretation the pool buffer uses on the GPU.
      * @type {Uint32Array}
      */
     pool: Uint32Array;
@@ -81,11 +81,20 @@ export class ParticleReferenceSimulation {
      * @param {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram} params.program
      * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout} params.layout
      * @param {object} params.emitter emitter settings, see {@link ParticleEffectDocument#emitter}
+     * @param {Uint32Array} [params.emitter_fields] the emitter's values for the effect's emitter
+     *   fields, as f32 bit patterns — the document's declared values
+     * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null} [params.global_layout]
+     *   the global fields the effect imports, laid out for the preview; the program is linked
+     *   against it, as placing it in a scene links it against the scene's
+     * @param {Uint32Array} [params.global_fields] their preview values, laid out by `global_layout`
      */
-    setEffect({ program, layout, emitter }: {
+    setEffect({ program, layout, emitter, emitter_fields, global_layout, global_fields }: {
         program: import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram;
         layout: import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout;
         emitter: object;
+        emitter_fields?: Uint32Array;
+        global_layout?: import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout | null;
+        global_fields?: Uint32Array;
     }): void;
     /**
      * @returns {number} live particles

package/editor/particles/effect/ParticleReferenceSimulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IA0HI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IA3ID;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;;OASG;IACH,MAFU,YAAY,CAEK;IAkEvB;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA4KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA2C7H;;CACJ"}
+{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AA6B9C;IAwII;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAzJD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;;OASG;IACH,MAFU,YAAY,CAEK;IAgFvB;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAV0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;QACe,cAAc,GAAnC,WAAW;QAE2F,aAAa,GAAnH,OAAO,gEAAgE,EAAE,cAAc,GAAC,IAAI;QAGvE,aAAa,GAAlC,WAAW;aAwBrB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IAgLD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA2C7H;;CACJ"}

package/editor/particles/effect/ParticleReferenceSimulation.js

@@ -1,13 +1,15 @@
 import { hash_mix2 } from "../../../src/core/math/hash/hash_mix2.js";
 import {
+    PARTICLE_GLOBAL_FIELD_WORDS,
     PARTICLE_RECORD_WORD_COUNT,
     PARTICLE_WARMUP_DT_JITTER,
 } from "../../../src/shade/renderer/particles/ParticleConstants.js";
+import { particle_link_global_fields } from "../../../src/shade/renderer/particles/isa/particle_link_global_fields.js";
 import {
     warmup_remaining,
     warmup_schedule,
 } from "../../../src/shade/renderer/particles/warmup/warmup_schedule.js";
-import { EMITTER_ATTRIBUTE_ABSENT } from "../../../src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js";
+import { PARTICLE_FIELD_ABSENT } from "../../../src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js";
 import { VM_BUILTIN } from "../../../src/shade/renderer/particles/isa/ParticleVMISA.js";
 import { execute_particle_vm } from "../../../src/shade/renderer/particles/vm/ParticleVMReference.js";
 
@@ -46,11 +48,38 @@ const EMITTER_UP = [0, 1, 0, 0];
  */
 export const PARTICLE_PREVIEW_CAPACITY = 4096;
 
+/**
+ * The program as the preview runs it: its global reads linked against the preview's layout of the
+ * effect's imports, on a copy, so the compiled program stays what the heap and a save hold.
+ *
+ * @param {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram} program
+ * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null} global_layout
+ * @returns {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram}
+ */
+function link_for_preview(program, global_layout) {
+    const imports = program.global_imports;
+
+    if (imports.length === 0) {
+        return program;
+    }
+
+    const offsets = imports.map(entry => (
+        global_layout !== null && global_layout.has(entry.name) ? global_layout.offsetOf(entry.name) : PARTICLE_GLOBAL_FIELD_WORDS
+    ));
+
+    const linked = program.clone();
+
+    particle_link_global_fields(linked.init, 0, linked.init.length, offsets);
+    particle_link_global_fields(linked.update, 0, linked.update.length, offsets);
+
+    return linked;
+}
+
 export class ParticleReferenceSimulation {
 
     /**
-     * Particle records, {@link PARTICLE_RECORD_WORD_COUNT} words each. Attribute values are f32 bits
-     * — the same reinterpretation the pool buffer uses on the GPU.
+     * Particle records, {@link PARTICLE_RECORD_WORD_COUNT} words each. Particle field values are
+     * f32 bits — the same reinterpretation the pool buffer uses on the GPU.
      * @type {Uint32Array}
      */
     pool;
@@ -74,7 +103,7 @@ export class ParticleReferenceSimulation {
     rng = new Uint32Array(0);
 
     /**
-     * {@link pool} reinterpreted as floats, for reading attribute values back out.
+     * {@link pool} reinterpreted as floats, for reading particle field values back out.
      * @type {Float32Array}
      */
     #pool_f32;
@@ -155,6 +184,19 @@ export class ParticleReferenceSimulation {
      */
     #layout = null;
 
+    /**
+     * The preview's one emitter's values for its emitter fields, as f32 bit patterns.
+     * @type {Uint32Array}
+     */
+    #emitter_fields = new Uint32Array(0);
+
+    /**
+     * The global fields the preview reads, as f32 bit patterns laid out by the effect's import
+     * layout — the program is linked against that layout as it is set.
+     * @type {Uint32Array}
+     */
+    #global_fields = new Uint32Array(0);
+
     /**
      * Emitter settings, in the shape {@link ParticleEffectDocument#emitter} holds them.
      * @type {object|null}
@@ -162,8 +204,9 @@ export class ParticleReferenceSimulation {
     #emitter = null;
 
     /**
-     * The attribute schema the live records were written under. A layout change invalidates every
-     * record in flight — the same words mean something else — so it is what a restart keys on.
+     * The particle field schema the live records were written under. A layout change invalidates
+     * every record in flight — the same words mean something else — so it is what a restart keys
+     * on.
      * @type {string}
      */
     #layout_signature = "";
@@ -181,9 +224,9 @@ export class ParticleReferenceSimulation {
         this.pool = new Uint32Array(capacity * PARTICLE_RECORD_WORD_COUNT);
         this.rng = new Uint32Array(capacity);
 
-        // The pool's words reinterpreted as floats, which is how attributes are stored — the same
-        // reinterpretation the GPU does on the pool buffer. Held rather than made per call: this is
-        // read once a frame.
+        // The pool's words reinterpreted as floats, which is how particle fields are stored — the
+        // same reinterpretation the GPU does on the pool buffer. Held rather than made per call:
+        // this is read once a frame.
         this.#pool_f32 = new Float32Array(this.pool.buffer, this.pool.byteOffset, this.pool.length);
 
         this.reset();
@@ -218,10 +261,16 @@ export class ParticleReferenceSimulation {
      * @param {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram} params.program
      * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout} params.layout
      * @param {object} params.emitter emitter settings, see {@link ParticleEffectDocument#emitter}
+     * @param {Uint32Array} [params.emitter_fields] the emitter's values for the effect's emitter
+     *   fields, as f32 bit patterns — the document's declared values
+     * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null} [params.global_layout]
+     *   the global fields the effect imports, laid out for the preview; the program is linked
+     *   against it, as placing it in a scene links it against the scene's
+     * @param {Uint32Array} [params.global_fields] their preview values, laid out by `global_layout`
      */
-    setEffect({ program, layout, emitter }) {
-        const signature = Array.from(layout.attributes.values())
-            .map(attribute => `${attribute.name}:${attribute.offset}:${attribute.components}`)
+    setEffect({ program, layout, emitter, emitter_fields = new Uint32Array(0), global_layout = null, global_fields = new Uint32Array(0) }) {
+        const signature = Array.from(layout.fields.values())
+            .map(particle_field => `${particle_field.name}:${particle_field.offset}:${particle_field.components}`)
             .join(",");
 
         const prewarm = emitter.prewarm ?? 0;
@@ -236,9 +285,11 @@ export class ParticleReferenceSimulation {
             this.reset();
         }
 
-        this.#program = program;
+        this.#program = link_for_preview(program, global_layout);
         this.#layout = layout;
         this.#emitter = emitter;
+        this.#emitter_fields = emitter_fields;
+        this.#global_fields = global_fields;
     }
 
     /**
@@ -350,6 +401,8 @@ export class ParticleReferenceSimulation {
                 register_count: this.#program.register_count,
                 record,
                 builtins: this.#builtins(dt, slot, count === 0 ? 0 : i / count),
+                emitter_fields: this.#emitter_fields,
+                global_fields: this.#global_fields,
                 rng_state: this.rng[slot],
                 sample_wind: this.#sample_wind,
             });
@@ -394,6 +447,8 @@ export class ParticleReferenceSimulation {
                 register_count: this.#program.register_count,
                 record: this.#record(slot),
                 builtins: this.#builtins(dt_particle, slot, 0),
+                emitter_fields: this.#emitter_fields,
+                global_fields: this.#global_fields,
                 rng_state: this.rng[slot],
                 sample_wind: this.#sample_wind,
             });
@@ -463,7 +518,7 @@ export class ParticleReferenceSimulation {
         const offset = channel => {
             const name = render[channel];
 
-            return name !== undefined && layout.has(name) ? layout.offsetOf(name) : EMITTER_ATTRIBUTE_ABSENT;
+            return name !== undefined && layout.has(name) ? layout.offsetOf(name) : PARTICLE_FIELD_ABSENT;
         };
 
         const position = offset("position");
@@ -478,18 +533,18 @@ export class ParticleReferenceSimulation {
         for (const slot of this.alive) {
             const base = slot * PARTICLE_RECORD_WORD_COUNT;
 
-            particle.x = position === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + position];
-            particle.y = position === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + position + 1];
-            particle.z = position === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + position + 2];
+            particle.x = position === PARTICLE_FIELD_ABSENT ? 0 : words[base + position];
+            particle.y = position === PARTICLE_FIELD_ABSENT ? 0 : words[base + position + 1];
+            particle.z = position === PARTICLE_FIELD_ABSENT ? 0 : words[base + position + 2];
 
-            particle.size = size === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + size];
+            particle.size = size === PARTICLE_FIELD_ABSENT ? 1 : words[base + size];
 
-            particle.r = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color];
-            particle.g = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 1];
-            particle.b = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 2];
-            particle.a = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 3];
+            particle.r = color === PARTICLE_FIELD_ABSENT ? 1 : words[base + color];
+            particle.g = color === PARTICLE_FIELD_ABSENT ? 1 : words[base + color + 1];
+            particle.b = color === PARTICLE_FIELD_ABSENT ? 1 : words[base + color + 2];
+            particle.a = color === PARTICLE_FIELD_ABSENT ? 1 : words[base + color + 3];
 
-            particle.frame = frame === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + frame];
+            particle.frame = frame === PARTICLE_FIELD_ABSENT ? 0 : words[base + frame];
 
             visitor(particle);
         }

package/editor/particles/effect/make_starter_particle_effect.js

@@ -79,7 +79,7 @@ function build_init(graph) {
 
     particle_wire(graph, position, "a", origin);
     particle_wire(graph, position, "b", ground);
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "position" }), "value", position);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "position" }), "value", position);
 
     // velocity = up + signed scatter, a draw per lane
     const rise = particle_node(graph, "const", { value: [0, 2.2, 0] });
@@ -93,9 +93,9 @@ function build_init(graph) {
 
     particle_wire(graph, velocity, "a", rise);
     particle_wire(graph, velocity, "b", turbulence_scaled);
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "velocity" }), "value", velocity);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "velocity" }), "value", velocity);
 
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "age" }), "value", [0]);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "age" }), "value", [0]);
 
     // lifetime = 1.1 .. 1.9s, one draw
     const life_random = particle_node(graph, "random", { components: 1 });
@@ -104,16 +104,16 @@ function build_init(graph) {
     particle_wire(graph, lifetime, "a", life_random);
     particle_wire(graph, lifetime, "b", [0.8]);
     particle_wire(graph, lifetime, "c", [1.1]);
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "lifetime" }), "value", lifetime);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "lifetime" }), "value", lifetime);
 
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "size" }), "value", [0.35]);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "size" }), "value", [0.35]);
 
-    // A `color` rather than a four-number literal, because the attribute it is written to is
+    // A `color` rather than a four-number literal, because the particle field it is written to is
     // declared a colour: the two ends agree, the swatch is the control, and the whole colour path
     // through the effect reads as one.
     const ember = particle_node(graph, "color", { value: [1.0, 0.55, 0.2, 1.0] });
 
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "color" }), "value", ember);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "color" }), "value", ember);
 }
 
 /**
@@ -123,15 +123,15 @@ function build_update(graph) {
     const dt = particle_node(graph, "builtin", { id: VM_BUILTIN.DELTA_TIME });
 
     // age += dt
-    const age = particle_node(graph, "attribute", { name: "age" });
+    const age = particle_node(graph, "particleField", { name: "age" });
     const aged = particle_node(graph, "add");
 
     particle_wire(graph, aged, "a", age);
     particle_wire(graph, aged, "b", dt);
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "age" }), "value", aged);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "age" }), "value", aged);
 
     // normalized age drives both the kill and the fade
-    const lifetime = particle_node(graph, "attribute", { name: "lifetime" });
+    const lifetime = particle_node(graph, "particleField", { name: "lifetime" });
     const normalized = particle_node(graph, "div");
 
     particle_wire(graph, normalized, "a", aged);
@@ -144,32 +144,32 @@ function build_update(graph) {
     particle_wire(graph, particle_node(graph, "kill"), "condition", spent);
 
     // position += velocity * dt
-    const velocity = particle_node(graph, "attribute", { name: "velocity" });
+    const velocity = particle_node(graph, "particleField", { name: "velocity" });
     const step = particle_node(graph, "scale");
 
     particle_wire(graph, step, "v", velocity);
     particle_wire(graph, step, "s", dt);
 
-    const position = particle_node(graph, "attribute", { name: "position" });
+    const position = particle_node(graph, "particleField", { name: "position" });
     const moved = particle_node(graph, "add");
 
     particle_wire(graph, moved, "a", position);
     particle_wire(graph, moved, "b", step);
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "position" }), "value", moved);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "position" }), "value", moved);
 
     // colour *= 1 - normalizedAge, so it fades out over its life. Scaling the whole vector fades
     // the emission with the alpha, which is what an additive plume wants. `age` and `lifetime` are
-    // one-component attributes, so `normalized` and `remaining` are scalars, and a scalar meeting
-    // the colour scales every lane of it.
+    // one-component particle fields, so `normalized` and `remaining` are scalars, and a scalar
+    // meeting the colour scales every lane of it.
     const remaining = particle_node(graph, "sub");
 
     particle_wire(graph, remaining, "a", [1]);
     particle_wire(graph, remaining, "b", normalized);
 
-    const colour = particle_node(graph, "attribute", { name: "color" });
+    const colour = particle_node(graph, "particleField", { name: "color" });
     const faded = particle_node(graph, "scale");
 
     particle_wire(graph, faded, "v", colour);
     particle_wire(graph, faded, "s", remaining);
-    particle_wire(graph, particle_node(graph, "setAttribute", { name: "color" }), "value", faded);
+    particle_wire(graph, particle_node(graph, "setParticleField", { name: "color" }), "value", faded);
 }

package/editor/view/particles/effect/ParticleEmitterInspectorView.d.ts

@@ -14,9 +14,9 @@ export class ParticleEmitterInspectorView extends View {
     /**
      * Re-read everything from the document.
      *
-     * Values are pushed into every control; the option lists and the attribute rows are rebuilt only
-     * when the attributes themselves changed, because that is the only thing their shape follows and
-     * rebuilding them on every edit would sweep away whatever an author was in the middle of.
+     * Values are pushed into every control; the option lists and the field rows are rebuilt only
+     * when the declarations they show changed, because that is the only thing their shape follows
+     * and rebuilding them on every edit would sweep away whatever an author was in the middle of.
      */
     refresh(): void;
     #private;

package/editor/view/particles/effect/ParticleEmitterInspectorView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitterInspectorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleEmitterInspectorView.js"],"names":[],"mappings":"AAwEA;IAkDI;;;OAGG;IACH;QAFyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;OAqC9F;IAhCG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IA2BxB;;;;;;OAMG;IACH,gBAiBC;;CAiZJ;iBAlkBgB,8BAA8B"}
+{"version":3,"file":"ParticleEmitterInspectorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleEmitterInspectorView.js"],"names":[],"mappings":"AAyEA;IA2EI;;;OAGG;IACH;QAFyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;OAqE9F;IAhEG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IA2DxB;;;;;;OAMG;IACH,gBAyCC;;CA4dJ;iBA/tBgB,8BAA8B"}