@woosh/meep-engine 2.163.11 → 2.164.0

package/src/engine/sound/simulation/ecs/AcousticVolume.js

@@ -0,0 +1,74 @@
+import { SphereShape3D } from "../../../../core/geom/3d/shape/SphereShape3D.js";
+import { AcousticMedium } from "../core/AcousticMedium.js";
+
+/**
+ * ECS component marking a region of space with a propagation {@link AcousticMedium} (air absorption,
+ * …). Its `shape` (centred on the entity's `Transform`) defines the region; `transition` is the boundary
+ * blend band over which it fades into the surrounding medium. Overlapping volumes blend (see
+ * `VolumeField`), so e.g. a "cave" volume and the open-air default cross-fade smoothly at the mouth.
+ *
+ * Plain serializable data; the live region lives in the `AcousticSimulator`, fed by
+ * `AcousticVolumeSystem`. (Reverb is NOT a volume property — it is the P6 probe-baked / geometry-traced
+ * output.)
+ */
+export class AcousticVolume {
+    /**
+     * Region shape, centred at the entity's local origin (sphere, box, …).
+     * @type {AbstractShape3D}
+     */
+    shape = SphereShape3D.from(10);
+
+    /**
+     * Boundary blend band in metres: the region's influence fades to zero over this distance just inside
+     * the surface. 0 = a hard edge.
+     * @type {number}
+     */
+    transition = 1;
+
+    /**
+     * The medium inside this region.
+     * @type {AcousticMedium}
+     */
+    medium = new AcousticMedium();
+
+    /**
+     * @param {AbstractShape3D} [shape]
+     * @param {number} [transition]
+     * @param {AcousticMedium} [medium]
+     * @returns {AcousticVolume}
+     */
+    static from(shape, transition, medium) {
+        const v = new AcousticVolume();
+
+        if (shape !== undefined) {
+            v.shape = shape;
+        }
+        if (transition !== undefined) {
+            v.transition = transition;
+        }
+        if (medium !== undefined) {
+            v.medium = medium;
+        }
+
+        return v;
+    }
+
+    toJSON() {
+        // shape is attached from the scene/editor's shape layer (polymorphic); the acoustic params persist here
+        return {
+            transition: this.transition,
+            medium: this.medium.toJSON()
+        };
+    }
+
+    /**
+     * @param {{transition:number, medium:object}} json
+     */
+    fromJSON(json) {
+        this.transition = json.transition;
+        this.medium = new AcousticMedium();
+        this.medium.fromJSON(json.medium);
+    }
+}
+
+AcousticVolume.typeName = "AcousticVolume";

package/src/engine/sound/simulation/ecs/AcousticVolumeSerializationAdapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Binary (de)serialization for the {@link AcousticVolume} component: the `transition` band and the region's
+ * {@link AcousticMedium} (delegated). The `shape` is OMITTED — like the component's `toJSON`, it is reattached
+ * from the entity's shape layer (it is polymorphic and owned elsewhere); only the acoustic parameters persist
+ * here.
+ */
+export class AcousticVolumeSerializationAdapter extends BinaryClassSerializationAdapter<any> {
+    constructor();
+    klass: typeof AcousticVolume;
+    version: number;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticVolume} value
+     */
+    serialize(buffer: BinaryBuffer, value: AcousticVolume): void;
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticVolume} value mutated in place (its `transition` + `medium`; `shape` left untouched)
+     */
+    deserialize(buffer: BinaryBuffer, value: AcousticVolume): void;
+    #private;
+}
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AcousticVolume } from "./AcousticVolume.js";
+//# sourceMappingURL=AcousticVolumeSerializationAdapter.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticVolumeSerializationAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticVolumeSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticVolumeSerializationAdapter.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH;;IACI,6BAAuB;IACvB,gBAAY;IAOZ;;;OAGG;IACH,uCAFW,cAAc,QAKxB;IAED;;;OAGG;IACH,yCAFW,cAAc,QAKxB;;CACJ;gDApC+C,gEAAgE;+BAEjF,qBAAqB"}

package/src/engine/sound/simulation/ecs/AcousticVolumeSerializationAdapter.js

@@ -0,0 +1,37 @@
+import { BinaryClassSerializationAdapter } from "../../../ecs/storage/binary/BinaryClassSerializationAdapter.js";
+import { AcousticMediumSerializationAdapter } from "../core/AcousticMediumSerializationAdapter.js";
+import { AcousticVolume } from "./AcousticVolume.js";
+
+/**
+ * Binary (de)serialization for the {@link AcousticVolume} component: the `transition` band and the region's
+ * {@link AcousticMedium} (delegated). The `shape` is OMITTED — like the component's `toJSON`, it is reattached
+ * from the entity's shape layer (it is polymorphic and owned elsewhere); only the acoustic parameters persist
+ * here.
+ */
+export class AcousticVolumeSerializationAdapter extends BinaryClassSerializationAdapter {
+    klass = AcousticVolume;
+    version = 0;
+
+    /**
+     * @type {AcousticMediumSerializationAdapter}
+     */
+    #medium = new AcousticMediumSerializationAdapter();
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticVolume} value
+     */
+    serialize(buffer, value) {
+        buffer.writeFloat32(value.transition);
+        this.#medium.serialize(buffer, value.medium);
+    }
+
+    /**
+     * @param {BinaryBuffer} buffer
+     * @param {AcousticVolume} value mutated in place (its `transition` + `medium`; `shape` left untouched)
+     */
+    deserialize(buffer, value) {
+        value.transition = buffer.readFloat32();
+        this.#medium.deserialize(buffer, value.medium);
+    }
+}

package/src/engine/sound/simulation/ecs/AcousticVolumeSystem.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Feeds {@link AcousticVolume} medium regions into the shared {@link AcousticSimulator}. On link it
+ * registers a region holding the entity's `Transform.position` BY REFERENCE — so a moving volume is
+ * tracked live each sample, with no subscription (the region reads the shared vector). On unlink it
+ * removes the region.
+ */
+export class AcousticVolumeSystem extends System<any, any, any, any, any> {
+    /**
+     * @param {AcousticSimulator} simulator the shared simulation engine
+     */
+    constructor(simulator: AcousticSimulator);
+    dependencies: (typeof Transform | typeof AcousticVolume)[];
+    /**
+     * entity -> the registered region.
+     * @type {AcousticVolumeRegion[]}
+     */
+    data: AcousticVolumeRegion[];
+    /**
+     * @type {AcousticSimulator}
+     */
+    simulator: AcousticSimulator;
+    /**
+     * @param {AcousticVolume} volume
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(volume: AcousticVolume, transform: Transform, entity: number): void;
+    /**
+     * @param {AcousticVolume} volume
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(volume: AcousticVolume, transform: Transform, entity: number): void;
+}
+import { System } from "../../../ecs/System.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { AcousticVolume } from "./AcousticVolume.js";
+import { AcousticVolumeRegion } from "../core/AcousticVolumeRegion.js";
+//# sourceMappingURL=AcousticVolumeSystem.d.ts.map

package/src/engine/sound/simulation/ecs/AcousticVolumeSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticVolumeSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/ecs/AcousticVolumeSystem.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH;IASI;;OAEG;IACH,0CASC;IApBD,2DAA2C;IAE3C;;;OAGG;IACH,MAFU,oBAAoB,EAAE,CAEtB;IASN;;OAEG;IACH,6BAA0B;IAI9B;;;;OAIG;IACH,aAJW,cAAc,aACd,SAAS,UACT,MAAM,QAUhB;IAED;;;;OAIG;IACH,eAJW,cAAc,aACd,SAAS,UACT,MAAM,QAYhB;CACJ;uBAjEsB,wBAAwB;0BACrB,qCAAqC;+BAEhC,qBAAqB;qCADf,iCAAiC"}

package/src/engine/sound/simulation/ecs/AcousticVolumeSystem.js

@@ -0,0 +1,66 @@
+import { System } from "../../../ecs/System.js";
+import { Transform } from "../../../ecs/transform/Transform.js";
+import { AcousticVolumeRegion } from "../core/AcousticVolumeRegion.js";
+import { AcousticVolume } from "./AcousticVolume.js";
+
+/**
+ * Feeds {@link AcousticVolume} medium regions into the shared {@link AcousticSimulator}. On link it
+ * registers a region holding the entity's `Transform.position` BY REFERENCE — so a moving volume is
+ * tracked live each sample, with no subscription (the region reads the shared vector). On unlink it
+ * removes the region.
+ */
+export class AcousticVolumeSystem extends System {
+    dependencies = [AcousticVolume, Transform];
+
+    /**
+     * entity -> the registered region.
+     * @type {AcousticVolumeRegion[]}
+     */
+    data = [];
+
+    /**
+     * @param {AcousticSimulator} simulator the shared simulation engine
+     */
+    constructor(simulator) {
+        super();
+
+
+        /**
+         * @type {AcousticSimulator}
+         */
+        this.simulator = simulator;
+
+    }
+
+    /**
+     * @param {AcousticVolume} volume
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    link(volume, transform, entity) {
+        const region = new AcousticVolumeRegion(
+            volume.shape, transform.position, volume.transition, volume.medium
+        );
+
+        this.simulator.addRegion(region);
+
+        this.data[entity] = region;
+    }
+
+    /**
+     * @param {AcousticVolume} volume
+     * @param {Transform} transform
+     * @param {number} entity
+     */
+    unlink(volume, transform, entity) {
+        const region = this.data[entity];
+
+        if (region === undefined) {
+            return;
+        }
+
+        delete this.data[entity];
+
+        this.simulator.removeRegion(region);
+    }
+}

package/src/engine/sound/simulation/probe/AcousticProbeField.d.ts

@@ -0,0 +1,245 @@
+/**
+ * The baked probe volume: the set of acoustic probes covering a scene, plus the connectivity between them.
+ * Carries everything an offline bake produces about the field and everything the runtime reads back from
+ * it — per-band reverb, BVH nearest-probe lookup, and (optionally) the probe-visibility graph that sound
+ * routes through. Serializable (the bake is offline; the field loads as an asset). Pure data + graph
+ * search; no WebAudio.
+ *
+ * Probe data lives in a flat {@link Float32Array} ({@link STRIDE} floats per probe: x, y, z, per-band
+ * reverbDecay, per-band arrival direction) indexed by `i*STRIDE` — no per-probe object, no table
+ * indirection. The per-band arrival direction is the FOA / first-order anisotropy vector a directional
+ * reverb renderer steers the wet field by. Nearest-probe lookup is
+ * BVH-accelerated: a {@link BVH} over the probe points (leaf user-data = probe index) is built lazily and
+ * queried with {@link bvh_query_user_data_nearest_to_point}, so a per-frame listener query is O(log n)
+ * rather than a full scan.
+ *
+ * Connectivity is an inherent property of the field: once `bakeVisibility` has connected the probes with
+ * mutual line-of-sight ({@link setVisibilityGraph}), {@link shortestPath} routes sound around obstacles —
+ * through doorways and around corners — independent of walkability (air-visibility, not a navmesh). The
+ * mutable, per-listener exit-field solve lives in a separate {@link ProbeFieldPathingSolution} — this baked
+ * field stays immutable data + the graph it owns.
+ */
+export class AcousticProbeField {
+    /**
+     * @returns {number} number of probes
+     */
+    get size(): number;
+    /**
+     * Whether a visibility graph has been baked into this field (i.e. pathing is available).
+     * @returns {boolean}
+     */
+    get hasVisibility(): boolean;
+    /**
+     * The baked probe-visibility graph, or null if none has been baked. The substrate that
+     * {@link shortestPath} and a {@link ProbeFieldPathingSolution} search.
+     * @returns {CSRGraph|null}
+     */
+    get visibilityGraph(): any;
+    /**
+     * Whether reflector lobes (the directional transfer) have been baked into this field.
+     * @returns {boolean}
+     */
+    get hasTransfer(): boolean;
+    /**
+     * Number of reflector lobes baked for probe `i` (0 if no transfer is baked, or an open-air probe).
+     * @param {number} i probe index
+     * @returns {number}
+     */
+    probeLobeCount(i: number): number;
+    /**
+     * Set probe `index`'s position. When `index === size` this APPENDS a new probe (zero reverb + zero
+     * direction) — so a field is built by writing indices 0, 1, 2, … in order; when `index < size` it moves
+     * an existing probe. Either way the nearest-lookup BVH is invalidated (positions changed).
+     * PRECONDITION: 0 ≤ index ≤ size.
+     * @param {number} index
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     */
+    setProbePosition(index: number, x: number, y: number, z: number): void;
+    /**
+     * Set probe `index`'s per-band reverb decay (seconds). Does not move the probe, so the BVH is
+     * untouched.
+     * PRECONDITION: 0 ≤ index < size.
+     * @param {number} index
+     * @param {number} low
+     * @param {number} mid
+     * @param {number} high
+     */
+    setProbeReverbDecay(index: number, low: number, mid: number, high: number): void;
+    /**
+     * Set probe `index`'s per-band arrival direction (the FOA anisotropy vectors, band-major xyz, length 9:
+     * `[lowX,lowY,lowZ, midX,midY,midZ, highX,highY,highZ]`). Each band's magnitude is 0…1 (0 = diffuse,
+     * →1 = strongly directional). Does not move the probe, so the BVH is untouched.
+     * PRECONDITION: 0 ≤ index < size.
+     * @param {number} index
+     * @param {Float32Array|number[]} directions band-major xyz, length 9
+     */
+    setProbeReverbDirections(index: number, directions: Float32Array | number[]): void;
+    /**
+     * @param {number} i probe index
+     * @returns {number}
+     */
+    probeX(i: number): number;
+    /**
+     * @param {number} i probe index
+     * @returns {number}
+     */
+    probeY(i: number): number;
+    /**
+     * @param {number} i probe index
+     * @returns {number}
+     */
+    probeZ(i: number): number;
+    /**
+     * Per-band baked RT60 (seconds) of probe `i`.
+     * @param {number} i probe index
+     * @param {number} band 0 = low, 1 = mid, 2 = high
+     * @returns {number}
+     */
+    reverbBand(i: number, band: number): number;
+    /**
+     * Per-band arrival direction of probe `i` (xyz) written into `out`. Magnitude 0…1 (0 = diffuse, →1 =
+     * the reverb arrives predominantly from this direction).
+     * @param {number} i probe index
+     * @param {number} band 0 = low, 1 = mid, 2 = high
+     * @param {Float32Array|number[]} out at least length 3
+     */
+    reverbDirection(i: number, band: number, out: Float32Array | number[]): void;
+    /**
+     * Broadband baked RT60 (seconds) of probe `i` — the mean of its three bands (the scalar render path).
+     * @param {number} i probe index
+     * @returns {number}
+     */
+    reverbDecay(i: number): number;
+    /**
+     * Index of the nearest probe to a world point, or -1 if the field is empty.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    nearestIndex(x: number, y: number, z: number): number;
+    /**
+     * Index of the nearest probe a world point can SEE — line-of-sight unobstructed by `occluderIndex` — or
+     * -1 if the field is empty or NO probe is visible. Unlike {@link nearestIndex} this never snaps to a
+     * probe behind a wall or below a floor (a different acoustic region), which would make a runtime
+     * listener/source route a spurious cross-occluder detour through the visibility graph (or find none). The
+     * runtime pathing snaps with this. Cost: the branch-and-bound nearest search with one visibility raycast
+     * per leaf nearer than the current best — typically one or two, since the nearest probe is usually
+     * visible.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {AcousticOccluderIndex} occluderIndex the scene line-of-sight is tested against
+     * @returns {number} nearest visible probe index, or -1
+     */
+    nearestVisibleIndex(x: number, y: number, z: number, occluderIndex: AcousticOccluderIndex): number;
+    /**
+     * Indices of all probes within `radius` of a world point, written into `result` starting at
+     * `result_offset`; returns how many were written. Built on the same nearest-lookup BVH — used by the
+     * visibility-graph bake to find spatially-local candidate pairs (island bridging, shortcut augmentation)
+     * without an all-pairs scan. The probe leaves are points, so a hit means centre-within-radius (the BVH
+     * may return a few extra near the boundary; re-test the exact distance if you need a hard cutoff).
+     * PRECONDITION: `result` has room for the local probe count near the query (size it to the field's
+     * densest neighbourhood).
+     * @param {number[]|Uint32Array} result
+     * @param {number} result_offset
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {number} radius
+     * @returns {number} number of probe indices written
+     */
+    probesWithinRadius(result: number[] | Uint32Array, result_offset: number, x: number, y: number, z: number, radius: number): number;
+    /**
+     * Broadband reverb decay (seconds) at a world point — the nearest probe's mean RT60, or 0 if no
+     * probes.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @returns {number}
+     */
+    reverbDecayAt(x: number, y: number, z: number): number;
+    /**
+     * Per-band reverb decay (seconds) at a world point — the nearest probe's `[low, mid, high]` RT60s
+     * written into `out`, or all-zero if no probes.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {Float32Array|number[]} out at least length 3
+     */
+    reverbBandsAt(x: number, y: number, z: number, out: Float32Array | number[]): void;
+    /**
+     * Per-band arrival directions at a world point — the nearest probe's 9 floats (band-major xyz) written
+     * into `out`, or all-zero if no probes.
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {Float32Array|number[]} out at least length 9
+     */
+    reverbDirectionsAt(x: number, y: number, z: number, out: Float32Array | number[]): void;
+    /**
+     * Attach the baked probe-visibility graph (from `bakeVisibility`), enabling {@link shortestPath} and
+     * {@link ProbeFieldPathingSolution}.
+     * PRECONDITION: the graph's vertex set is this field's probes (vertex v = probe v); bake it AFTER the
+     * field's probes are final.
+     * @param {CSRGraph} graph visibility adjacency over this field's probes
+     */
+    setVisibilityGraph(graph: CSRGraph): void;
+    /**
+     * Attach the baked reflector lobes (from `bakeProbeReflectors`), enabling {@link probeTransfer}.
+     * PRECONDITION: `offsets` has length `size + 1` (probe v's lobes are `offsets[v]…offsets[v+1]`) and `data`
+     * holds `offsets[size]` lobes (LOBE_STRIDE floats each). Bake AFTER the probes are final.
+     * @param {Uint32Array} offsets per-probe lobe-range offsets (length size+1)
+     * @param {Float32Array} data flat lobe array
+     */
+    setLobes(offsets: Uint32Array, data: Float32Array): void;
+    /**
+     * The directional transfer T(ω_in, ω_out) at probe `i`, per band, written into `out[0..2]` (see
+     * {@link acoustic_probe_transfer}). With no lobes baked (or an open-air probe) it is the forward /
+     * passthrough term alone. Directions are unit PROPAGATION directions.
+     * @param {Float32Array|number[]} out length ≥ 3
+     * @param {number} i probe index
+     * @param {number} inx @param {number} iny @param {number} inz   ω_in
+     * @param {number} outx @param {number} outy @param {number} outz ω_out
+     */
+    probeTransfer(out: Float32Array | number[], i: number, inx: number, iny: number, inz: number, outx: number, outy: number, outz: number): void;
+    /**
+     * Shortest path (Dijkstra) from probe `from` to probe `to`, as a list of probe indices (inclusive of
+     * both ends), or null if they are not connected.
+     * PRECONDITION: a visibility graph is attached ({@link hasVisibility}).
+     * @param {number} from
+     * @param {number} to
+     * @returns {number[]|null}
+     */
+    shortestPath(from: number, to: number): number[] | null;
+    toJSON(): {
+        probes: {
+            x: number;
+            y: number;
+            z: number;
+            reverbDecay: number[];
+            reverbDirection: number[];
+        }[];
+    };
+    /**
+     * Replace this field's probes from serialized form. The visibility graph is NOT serialized (re-bake it
+     * with `bakeVisibility` after loading), so any prior graph is dropped.
+     * @param {{probes:{x:number,y:number,z:number,reverbDecay:number[],reverbDirection:number[]}[]}} json
+     */
+    fromJSON(json: {
+        probes: {
+            x: number;
+            y: number;
+            z: number;
+            reverbDecay: number[];
+            reverbDirection: number[];
+        }[];
+    }): void;
+    #private;
+}
+export namespace AcousticProbeField {
+    let typeName: string;
+}
+//# sourceMappingURL=AcousticProbeField.d.ts.map

package/src/engine/sound/simulation/probe/AcousticProbeField.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AcousticProbeField.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/simulation/probe/AcousticProbeField.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAmDI;;OAEG;IACH,mBAEC;IAED;;;OAGG;IACH,6BAEC;IAED;;;;OAIG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAwBD;;;;;;;;;OASG;IACH,wBALW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAsBhB;IAED;;;;;;;;OAQG;IACH,2BALW,MAAM,OACN,MAAM,OACN,MAAM,QACN,MAAM,QAShB;IAED;;;;;;;OAOG;IACH,gCAHW,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,QAS/B;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,UAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,cAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,QACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAS/B;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,gBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;OAaG;IACH,uBANW,MAAM,KACN,MAAM,KACN,MAAM,yCAEJ,MAAM,CAyBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,2BARW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;OAOG;IACH,iBALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAe/B;IAED;;;;;;;OAOG;IACH,sBALW,MAAM,KACN,MAAM,KACN,MAAM,OACN,YAAY,GAAC,MAAM,EAAE,QAkB/B;IAmCD;;;;;;OAMG;IACH,0CAEC;IAED;;;;;;OAMG;IACH,kBAHW,WAAW,QACX,YAAY,QAKtB;IAED;;;;;;;;OAQG;IACH,mBALW,YAAY,GAAC,MAAM,EAAE,KACrB,MAAM,OACN,MAAM,OAAc,MAAM,OAAc,MAAM,QAC9C,MAAM,QAAe,MAAM,QAAe,MAAM,QAQ1D;IAED;;;;;;;OAOG;IACH,mBAJW,MAAM,MACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAQzB;IAED;;;;;;;;MA0BC;IAED;;;;OAIG;IACH;gBAFmB;YAAC,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,CAAC,EAAC,MAAM,CAAC;YAAA,WAAW,EAAC,MAAM,EAAE,CAAC;YAAA,eAAe,EAAC,MAAM,EAAE,CAAA;SAAC,EAAE;aAoB9F;;CACJ"}