@woosh/meep-engine 3.15.0 → 3.16.0

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

@@ -0,0 +1,219 @@
+/**
+ * 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: string[];
+/**
+ * One emitter: a compiled effect bound to instance parameters — world transform, spawn rate,
+ * blend / projection / feature flags, bounds sphere, render-attribute bindings, atlas region and
+ * flipbook grid.
+ *
+ * This is the CPU model of exactly one row of the emitter table
+ * ({@link ../data/PARTICLE_EMITTER_STRUCT.js}); {@link to_record} is the whole of the translation
+ * between the two. Fields are plain data with no setters — after changing any of them, set
+ * {@link dirty} so {@link ../runtime/EmitterRegistry.js} restages the row on its next flush. The
+ * flag rather than a setter per field because a row is restaged whole either way: one changed field
+ * and ten cost the same upload.
+ *
+ * Instances are created by {@link EmitterRegistry#add}, which assigns {@link id} and resolves the
+ * program placement. Constructing one directly gives you an emitter no table knows about.
+ */
+export class Emitter {
+    /**
+     * Build an emitter from a plain description. Every parameter is optional except the effect —
+     * an emitter with no program has nothing to run.
+     *
+     * @param {object} config
+     * @param {{layout: object, program: object}} config.effect compiled effect, see
+     *        {@link ./create_particle_effect.js}
+     * @param {ArrayLike<number>} [config.transform] 16-element column-major local-to-world
+     * @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.atlas_region] [uvOffsetX, uvOffsetY, uvScaleX, uvScaleY]
+     * @param {ArrayLike<number>} [config.flipbook] [cols, rows]
+     * @param {object} [config.node] scene node to follow, see {@link attach_to}
+     * @returns {Emitter}
+     */
+    static from(config: {
+        effect: {
+            layout: object;
+            program: object;
+        };
+        transform?: ArrayLike<number>;
+        seed?: number;
+        spawn_rate?: number;
+        flags?: object;
+        bounds?: {
+            center?: ArrayLike<number>;
+            radius?: number;
+        };
+        render?: {
+            [x: string]: string;
+        };
+        atlas_region?: ArrayLike<number>;
+        flipbook?: ArrayLike<number>;
+        node?: object;
+    }): Emitter;
+    /**
+     * Row this emitter occupies in the emitter table. Stable for the emitter's whole life — it is
+     * what every live particle's record header stores, so it cannot be renumbered while particles
+     * are in flight. `-1` until the registry assigns one.
+     *
+     * @type {number}
+     */
+    id: number;
+    /**
+     * Compiled effect: the per-particle attribute layout plus the SPAWN/UPDATE bytecode.
+     *
+     * @type {{layout: import("../layout/ParticleLayout.js").ParticleLayout, program: import("../isa/ParticleProgram.js").ParticleProgram}}
+     */
+    effect: {
+        layout: import("../layout/ParticleLayout.js").ParticleLayout;
+        program: import("../isa/ParticleProgram.js").ParticleProgram;
+    };
+    /**
+     * Where this emitter's program sits in the shared arena, and the dense program id the
+     * simulation-order bucketing keys on. Assigned by {@link EmitterRegistry#add} from
+     * {@link ../runtime/ProgramArena.js}; emitters compiled from the same graph share one.
+     *
+     * @type {{spawn_offset: number, spawn_count: number, update_offset: number, update_count: number, constant_offset: number, program_id: number}}
+     */
+    placement: {
+        spawn_offset: number;
+        spawn_count: number;
+        update_offset: number;
+        update_count: number;
+        constant_offset: number;
+        program_id: number;
+    };
+    /**
+     * Local-to-world, column-major.
+     * @type {Float32Array}
+     */
+    transform: Float32Array;
+    /**
+     * Base RNG seed.
+     *
+     * Two emitters running one program produce identical particles from identical seeds, so leaving
+     * this at 0 is almost never what an author wants — {@link EmitterRegistry#add} reads 0 as
+     * "unset" and derives one from the row instead.
+     *
+     * @type {number}
+     */
+    seed: number;
+    /**
+     * Continuous emission rate, particles per second. Consumed on the CPU by
+     * {@link ./ParticleSpawnScheduler.js} and carried in the record for shaders that want it.
+     * @type {number}
+     */
+    spawn_rate: number;
+    /**
+     * Packed feature / blend / projection bits — see {@link make_emitter_flags}.
+     * @type {number}
+     */
+    flags: number;
+    /**
+     * Bounding sphere in emitter-local space, used by the optional simulation culling.
+     * @type {Float32Array}
+     */
+    bounds_center: Float32Array;
+    /**
+     * @type {number}
+     */
+    bounds_radius: number;
+    /**
+     * Atlas sub-rect: uv offset `.xy`, uv scale `.zw`. Mirrors meep's `AtlasPatch`.
+     * @type {Float32Array}
+     */
+    atlas_region: Float32Array;
+    /**
+     * Flipbook grid: columns, rows. `[1, 1]` is a single frame.
+     * @type {Float32Array}
+     */
+    flipbook: Float32Array;
+    /** @type {number} record word offset of world position, or {@link EMITTER_ATTRIBUTE_ABSENT} */
+    render_position: number;
+    /** @type {number} record word offset of size */
+    render_size: number;
+    /** @type {number} record word offset of rgba colour */
+    render_color: number;
+    /** @type {number} record word offset of roll angle, radians */
+    render_rotation: number;
+    /** @type {number} record word offset of flipbook frame index */
+    render_frame: number;
+    /** @type {number} record word offset of velocity, read by the STRETCHED projection */
+    render_velocity: number;
+    /**
+     * Scene node (bone) this emitter follows, if any. While set, the system copies the node's world
+     * matrix into {@link transform} every frame, so the emitter spawns and simulates wherever the
+     * bone currently is.
+     *
+     * @type {{transform_global: {matrix: ArrayLike<number>}}|undefined}
+     */
+    node: {
+        transform_global: {
+            matrix: ArrayLike<number>;
+        };
+    } | undefined;
+    /**
+     * Whether the table row is out of step with the fields above. Set it after changing anything;
+     * {@link EmitterRegistry#flush} clears it once the row has been staged for upload.
+     *
+     * @type {boolean}
+     */
+    dirty: boolean;
+    /**
+     * Point the emitter at a scene node, or at nothing.
+     *
+     * @param {{transform_global: {matrix: ArrayLike<number>}}} [node]
+     */
+    attach_to(node?: {
+        transform_global: {
+            matrix: ArrayLike<number>;
+        };
+    }): void;
+    /**
+     * Copy a world matrix into {@link transform} and mark the row for re-upload.
+     *
+     * @param {ArrayLike<number>} matrix 16-element column-major
+     */
+    set_transform(matrix: ArrayLike<number>): void;
+    /**
+     * 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: {
+        [x: string]: string;
+    }): void;
+    /**
+     * This emitter as the value the emitter table stores — every field of
+     * {@link ../data/PARTICLE_EMITTER_STRUCT.js}, none omitted.
+     *
+     * Omitting one would not write zeros: the serializer skips absent fields, and table pages are
+     * recycled buffers, so a skipped field keeps whatever the previous tenant of the slot left
+     * there.
+     *
+     * @returns {object}
+     */
+    to_record(): object;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isEmitter: boolean;
+}
+//# sourceMappingURL=Emitter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"Emitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/Emitter.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;;;GAcG;AACH;IAqNI;;;;;;;;;;;;;;;;;OAiBG;IACH;QAbqD,MAAM,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC;QAEN,SAAS,GAApC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,KAAK,GAArB,MAAM;QACiD,MAAM,GAA7D;YAAC,MAAM,CAAC,EAAE,UAAU,MAAM,CAAC,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAC;QACd,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,YAAY,GAAvC,UAAU,MAAM,CAAC;QACU,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACJ,OAAO,CAoDnB;IAvRD;;;;;;OAMG;IACH,IAFU,MAAM,CAER;IAER;;;;OAIG;IACH,QAFU;QAAC,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC;QAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,eAAe,CAAA;KAAC,CAE/H;IAEP;;;;;;OAMG;IACH,WAFU;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,aAAa,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAC,CAErI;IAEV;;;OAGG;IACH,WAFU,YAAY,CAEiB;IAEvC;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,eAFU,YAAY,CAEc;IAEpC;;OAEG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,cAFU,YAAY,CAEwB;IAE9C;;;OAGG;IACH,UAFU,YAAY,CAEc;IAEpC,+FAA+F;IAC/F,iBADW,MAAM,CAC0B;IAC3C,gDAAgD;IAChD,aADW,MAAM,CACsB;IACvC,uDAAuD;IACvD,cADW,MAAM,CACuB;IACxC,+DAA+D;IAC/D,iBADW,MAAM,CAC0B;IAC3C,gEAAgE;IAChE,cADW,MAAM,CACuB;IACxC,sFAAsF;IACtF,iBADW,MAAM,CAC0B;IAE3C;;;;;;OAMG;IACH,MAFU;QAAC,gBAAgB,EAAE;YAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAA;SAAC,CAAA;KAAC,GAAC,SAAS,CAE9D;IAEL;;;;;OAKG;IACH,OAFU,OAAO,CAEJ;IAEb;;;;OAIG;IACH,iBAFW;QAAC,gBAAgB,EAAE;YAAC,MAAM,EAAE,UAAU,MAAM,CAAC,CAAA;SAAC,CAAA;KAAC,QAIzD;IAED;;;;OAIG;IACH,sBAFW,UAAU,MAAM,CAAC,QAO3B;IAED;;;;;;;;;;;;OAYG;IACH;YAHkB,MAAM,GAAC,MAAM;aA2B9B;IAED;;;;;;;;;OASG;IACH,aAFa,MAAM,CAiClB;IAyEL;;;OAGG;IACH,oBAFU,OAAO,CAEU;CAN1B"}

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

@@ -1,74 +1,142 @@
 /**
- * CPU-side registry of emitters. Each emitter binds a compiled effect (from
- * {@link ./create_particle_effect.js}) to instance parameters — world transform, spawn rate, blend /
- * projection / feature flags, bounds, render-attribute binding, atlas region and flipbook grid.
+ * The emitter set: {@link ParticleEmitter} instances on the CPU, one GPU table row each.
  *
- * {@link build} produces the three upload-ready buffers the GPU passes consume: the packed emitter
- * records, the concatenated program instructions, and the constant pool. Emitters are few and
- * long-lived, so the whole set is repacked when it changes.
+ * Rows live in a {@link GPUDatabase} table ({@link ../data/PARTICLE_DATABASE_SPEC.js}), which is
+ * what makes the set editable at runtime. Adding an emitter stages one record; removing one frees
+ * its slot for the next add; changing one restages that record and nothing else. Rows are handed
+ * out by the table and are stable for an emitter's lifetime — they have to be, because every live
+ * particle's record header stores the row of the emitter that spawned it.
+ *
+ * Reuse of a freed row is made safe by the **generation**: every add takes the next value of one
+ * running counter, so no two emitters this registry has ever registered share one, and the
+ * particles of a removed emitter — which carry its generation — cannot be mistaken for the new
+ * tenant's. The simulate pass kills them on sight; see {@link ../data/particle_header.js}.
+ *
+ * The GPU-owned per-emitter state is the database's second table, claimed and released here at the
+ * emitter's row and never written by the CPU otherwise.
+ *
+ * Programs are the one thing NOT in the database: they are variable-length and shared, so they go
+ * into a packed {@link ProgramArena} buffer and the emitter record carries offsets into it. The arena is
+ * append-only and content-deduplicated — two emitters compiled from the same graph land on one
+ * program id, which is what the simulation-order bucketing buckets on. Removing an emitter does not
+ * reclaim its program: the dense `program_id`s are baked into every other emitter's record, so
+ * compacting them would mean rewriting the whole table to save a few hundred words.
  */
 export class EmitterRegistry {
-    /** @type {object[]} */
-    emitters: object[];
-    /** @returns {number} number of registered emitters */
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * @type {GPUDatabase}
+     */
+    database: GPUDatabase;
+    /**
+     * Packed instruction + constant buffers for every distinct program in the set.
+     * @type {ProgramArena}
+     */
+    arena: ProgramArena;
+    /**
+     * The live emitters, in no particular order — {@link ParticleEmitter#row} is the identity.
+     * @type {ParticleEmitter[]}
+     */
+    emitters: ParticleEmitter[];
+    /**
+     * The live emitters by table row. Sparse: a freed row reads `undefined` until it is reused.
+     * Rows are small dense integers handed out lowest-free-first, so an array is the right index.
+     *
+     * @type {ParticleEmitter[]}
+     */
+    by_row: ParticleEmitter[];
+    /**
+     * Whether {@link arena} has grown since the instruction/constant buffers were last built. Those
+     * two are monolithic (a program is variable-length, so there is no table to page them into), so
+     * a new program means re-uploading them whole — which is why the arena dedupes by content and
+     * why this is a separate flag from the per-row dirtiness the table tracks.
+     *
+     * @type {boolean}
+     */
+    programs_dirty: boolean;
+    /**
+     * The emitter table.
+     * @returns {GPUTypedTable}
+     */
+    get table(): GPUTypedTable;
+    /**
+     * The GPU-owned state table: one row per emitter, at the emitter's row, claimed and released
+     * here and otherwise the GPU's.
+     * @returns {GPUTypedTable}
+     */
+    get state_table(): GPUTypedTable;
+    /**
+     * @returns {number} number of live emitters
+     */
     get count(): number;
     /**
-     * Register an emitter.
+     * Number of distinct compiled programs — the number of buckets the simulation-order coherence
+     * pass histograms into.
+     *
+     * @returns {number}
+     */
+    get program_count(): number;
+    /**
+     * Register an emitter and give it a table row.
      *
-     * @param {object} config
-     * @param {{layout: object, program: object}} config.effect compiled effect
-     * @param {number[]} [config.transform] 16-element column-major local-to-world matrix
-     * @param {number} [config.seed]
-     * @param {number} [config.spawn_rate] particles/second
-     * @param {object} [config.flags] passed to {@link make_emitter_flags}
-     * @param {{center?: number[], radius?: number}} [config.bounds]
-     * @param {Object<string,string>} [config.render] map of render channel -> attribute name
-     * @param {number[]} [config.atlas_region] [uvOffsetX, uvOffsetY, uvScaleX, uvScaleY]
-     * @param {number[]} [config.flipbook] [cols, rows]
-     * @param {number} [config.attach_row] scene transforms row for bone attachment
-     * @returns {number} the emitter index
-     */
-    add(config: {
-        effect: {
-            layout: object;
-            program: object;
-        };
-        transform?: number[];
-        seed?: number;
-        spawn_rate?: number;
-        flags?: object;
-        bounds?: {
-            center?: number[];
-            radius?: number;
-        };
-        render?: {
-            [x: string]: string;
-        };
-        atlas_region?: number[];
-        flipbook?: number[];
-        attach_row?: number;
-    }): number;
-    /**
-     * Pack all emitters + their programs into upload-ready buffers.
+     * @param {ParticleEmitter|object} config a {@link ParticleEmitter}, or a description
+     *        {@link ParticleEmitter.from} accepts
+     * @param {number} [transform_row] the emitter node's row in the scene's `transforms` table, if
+     *        already known; {@link set_transform_row} sets it later otherwise
+     * @returns {ParticleEmitter}
+     */
+    add(config: ParticleEmitter | object, transform_row?: number): ParticleEmitter;
+    /**
+     * Unregister an emitter and free its table row.
      *
-     * `program_count` is the number of DISTINCT programs across the emitter set — the bucket count
-     * the simulation-order coherence pass histograms into. It is CPU-known and low-churn (it only
-     * changes when the emitter set does), which is why that pass can size its histogram, its cursor
-     * and its padding dispatch on the host without any of the per-frame counts ever leaving the GPU.
+     * Its particles are not touched here; they carry its generation, the row they will read is
+     * zero-filled (or a later tenant's, with a different generation), and the simulate pass frees
+     * them the next time it sees them. Retiring an emitter gently — spawn rate to zero, remove once
+     * its particles have died — remains available to an author who wants the tail to play out.
      *
-     * @returns {{ emitters: Uint32Array, program: Uint32Array, constants: Uint32Array, program_count: number }}
+     * @param {ParticleEmitter} emitter
      */
-    build(): {
-        emitters: Uint32Array;
-        program: Uint32Array;
-        constants: Uint32Array;
-        program_count: number;
-    };
+    remove(emitter: ParticleEmitter): void;
     /**
-     * The scene-node row an emitter is attached to (for bone attachment), or the "none" sentinel.
-     * @param {number} index
-     * @returns {number}
+     * Look up a live emitter by its table row.
+     *
+     * @param {number} row
+     * @returns {ParticleEmitter|undefined}
+     */
+    get(row: number): ParticleEmitter | undefined;
+    /**
+     * Point an emitter's record at its node's row in the scene's `transforms` table. The row is
+     * restaged on the next flush.
+     *
+     * @param {ParticleEmitter} emitter
+     * @param {number} transform_row
+     */
+    set_transform_row(emitter: ParticleEmitter, transform_row: number): void;
+    /**
+     * Restage the table rows of every emitter whose fields have moved since the last flush.
+     *
+     * Cheap to call every frame: an emitter that has not changed costs one boolean test, and the
+     * table coalesces repeated writes to one row within a frame anyway. Allocates nothing — every
+     * row goes through the one module-static staging record.
+     */
+    flush(): void;
+    /**
+     * The packed program buffer — header, constant pools, code — rebuilt whole.
+     *
+     * Call when {@link programs_dirty}; it clears the flag. The buffer is monolithic (a program is
+     * variable-length, so there is no table to page it into), so this is a full rebuild — the
+     * arena's content deduplication is what keeps it rare (it only grows when an effect the set has
+     * never seen is registered).
+     *
+     * @returns {Uint32Array}
      */
-    attachRow(index: number): number;
+    build_program(): Uint32Array;
+    #private;
 }
+import { GPUDatabase } from "../../buffer/table/GPUDatabase.js";
+import { ProgramArena } from "./ProgramArena.js";
+import { ParticleEmitter } from "./ParticleEmitter.js";
 //# sourceMappingURL=EmitterRegistry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"EmitterRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/EmitterRegistry.js"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH;IAEQ,uBAAuB;IACvB,UADW,MAAM,EAAE,CACD;IAGtB,sDAAsD;IACtD,oBAEC;IAED;;;;;;;;;;;;;;;OAeG;IACH;QAZqD,MAAM,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,OAAO,EAAE,MAAM,CAAA;SAAC;QACf,SAAS,GAA3B,MAAM,EAAE;QACQ,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,KAAK,GAArB,MAAM;QACwC,MAAM,GAApD;YAAC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;YAAC,MAAM,CAAC,EAAE,MAAM,CAAA;SAAC;QACL,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACF,YAAY,GAA9B,MAAM,EAAE;QACU,QAAQ,GAA1B,MAAM,EAAE;QACQ,UAAU,GAA1B,MAAM;QACJ,MAAM,CASlB;IAED;;;;;;;;;OASG;IACH;kBAFyB,WAAW;iBAAW,WAAW;mBAAa,WAAW;uBAAiB,MAAM;MAyCxG;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;CACJ"}
+{"version":3,"file":"EmitterRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/EmitterRegistry.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IA2CI;;OAEG;IACH,+BASC;IArDD;;OAEG;IACH,UAFU,WAAW,CAEZ;IAET;;;OAGG;IACH,OAFU,YAAY,CAEK;IAE3B;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,QAFU,eAAe,EAAE,CAEf;IAEZ;;;;;;;OAOG;IACH,gBAFU,OAAO,CAEK;IAsBtB;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,iCAEC;IAED;;OAEG;IACH,oBAEC;IAED;;;;;OAKG;IACH,4BAEC;IAED;;;;;;;;OAQG;IACH,YANW,eAAe,GAAC,MAAM,kBAEtB,MAAM,GAEJ,eAAe,CAwC3B;IAED;;;;;;;;;OASG;IACH,gBAFW,eAAe,QAwBzB;IAED;;;;;OAKG;IACH,SAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;;;OAMG;IACH,2BAHW,eAAe,iBACf,MAAM,QAWhB;IAED;;;;;;OAMG;IACH,cAeC;IAED;;;;;;;;;OASG;IACH,iBAFa,WAAW,CAMvB;;CACJ;4BA5R2B,mCAAmC;6BAUlC,mBAAmB;gCADO,sBAAsB"}