@woosh/meep-engine 2.138.19 → 2.139.0

package/src/engine/physics/broadphase/aabb_transform_oriented.js

@@ -0,0 +1,93 @@
+/**
+ * Compute the world-space axis-aligned bounding box of a local AABB after a
+ * rigid transform (position + orientation).
+ *
+ * Math: an AABB transformed by a rotation `R` is bounded by another AABB whose
+ * centre is `R · c_local + t` and whose half-extent along each world axis `i`
+ * is `Σ_j |R_ij| · half_extent_local_j`. The element-wise-abs trick avoids
+ * rotating all 8 corners and projecting.
+ *
+ * Output layout matches existing AABB conventions: `[x0, y0, z0, x1, y1, z1]`
+ * with `(x0,y0,z0)` as the min corner.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number} lx0 local min x
+ * @param {number} ly0 local min y
+ * @param {number} lz0 local min z
+ * @param {number} lx1 local max x
+ * @param {number} ly1 local max y
+ * @param {number} lz1 local max z
+ * @param {number} px  translation x
+ * @param {number} py  translation y
+ * @param {number} pz  translation z
+ * @param {number} qx  quaternion x (unit)
+ * @param {number} qy  quaternion y
+ * @param {number} qz  quaternion z
+ * @param {number} qw  quaternion w
+ */
+export function aabb_transform_oriented(
+    result, result_offset,
+    lx0, ly0, lz0, lx1, ly1, lz1,
+    px, py, pz,
+    qx, qy, qz, qw
+) {
+    // local centre and half-extent
+    const cx = (lx0 + lx1) * 0.5;
+    const cy = (ly0 + ly1) * 0.5;
+    const cz = (lz0 + lz1) * 0.5;
+
+    const ex = (lx1 - lx0) * 0.5;
+    const ey = (ly1 - ly0) * 0.5;
+    const ez = (lz1 - lz0) * 0.5;
+
+    // Rotation matrix from unit quaternion.
+    const xx = qx * qx;
+    const yy = qy * qy;
+    const zz = qz * qz;
+    const xy = qx * qy;
+    const xz = qx * qz;
+    const yz = qy * qz;
+    const wx = qw * qx;
+    const wy = qw * qy;
+    const wz = qw * qz;
+
+    const r00 = 1 - 2 * (yy + zz);
+    const r01 = 2 * (xy - wz);
+    const r02 = 2 * (xz + wy);
+
+    const r10 = 2 * (xy + wz);
+    const r11 = 1 - 2 * (xx + zz);
+    const r12 = 2 * (yz - wx);
+
+    const r20 = 2 * (xz - wy);
+    const r21 = 2 * (yz + wx);
+    const r22 = 1 - 2 * (xx + yy);
+
+    // World centre = R · c + t
+    const wcx = r00 * cx + r01 * cy + r02 * cz + px;
+    const wcy = r10 * cx + r11 * cy + r12 * cz + py;
+    const wcz = r20 * cx + r21 * cy + r22 * cz + pz;
+
+    // World half-extent = |R| · e
+    const ar00 = r00 < 0 ? -r00 : r00;
+    const ar01 = r01 < 0 ? -r01 : r01;
+    const ar02 = r02 < 0 ? -r02 : r02;
+    const ar10 = r10 < 0 ? -r10 : r10;
+    const ar11 = r11 < 0 ? -r11 : r11;
+    const ar12 = r12 < 0 ? -r12 : r12;
+    const ar20 = r20 < 0 ? -r20 : r20;
+    const ar21 = r21 < 0 ? -r21 : r21;
+    const ar22 = r22 < 0 ? -r22 : r22;
+
+    const wex = ar00 * ex + ar01 * ey + ar02 * ez;
+    const wey = ar10 * ex + ar11 * ey + ar12 * ez;
+    const wez = ar20 * ex + ar21 * ey + ar22 * ez;
+
+    result[result_offset] = wcx - wex;
+    result[result_offset + 1] = wcy - wey;
+    result[result_offset + 2] = wcz - wez;
+    result[result_offset + 3] = wcx + wex;
+    result[result_offset + 4] = wcy + wey;
+    result[result_offset + 5] = wcz + wez;
+}

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Compute the inflated world AABB of a shape under a pose, padded by both a
+ * constant slack and a velocity-proportional swept extent. The output is the
+ * thing to hand to `BVH#node_move_aabb`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape
+ * @param {Transform} transform
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function compute_fat_world_aabb(result: number[] | Float32Array | Float64Array, result_offset: number, shape: AbstractShape3D, transform: Transform, vx: number, vy: number, vz: number, dt: number): void;
+//# sourceMappingURL=compute_fat_world_aabb.d.ts.map

package/src/engine/physics/broadphase/compute_fat_world_aabb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compute_fat_world_aabb.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/compute_fat_world_aabb.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;GAaG;AACH,+CATW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,oDAGN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA6BhB"}

package/src/engine/physics/broadphase/compute_fat_world_aabb.js

@@ -0,0 +1,61 @@
+import { aabb_transform_oriented } from "./aabb_transform_oriented.js";
+
+const scratch_local = new Float64Array(6);
+
+/**
+ * Constant inflation applied to a world AABB so a small motion doesn't churn
+ * the broadphase. Tuned to Box2D / Bullet conventions.
+ * @type {number}
+ */
+const FAT_LINEAR = 0.05;
+
+/**
+ * Per-second-of-velocity inflation. Two seconds of motion is a generous look-ahead
+ * — `node_move_aabb` only re-inserts when the inflated AABB no longer encloses
+ * the actual one, so this is a hint, not an upper bound.
+ * @type {number}
+ */
+const FAT_VELOCITY_MULTIPLIER = 2;
+
+/**
+ * Compute the inflated world AABB of a shape under a pose, padded by both a
+ * constant slack and a velocity-proportional swept extent. The output is the
+ * thing to hand to `BVH#node_move_aabb`.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {AbstractShape3D} shape
+ * @param {Transform} transform
+ * @param {number} vx world linear velocity x
+ * @param {number} vy world linear velocity y
+ * @param {number} vz world linear velocity z
+ * @param {number} dt step size
+ */
+export function compute_fat_world_aabb(
+    result, result_offset,
+    shape, transform,
+    vx, vy, vz, dt
+) {
+    shape.compute_bounding_box(scratch_local);
+
+    const p = transform.position;
+    const q = transform.rotation;
+
+    aabb_transform_oriented(
+        result, result_offset,
+        scratch_local[0], scratch_local[1], scratch_local[2],
+        scratch_local[3], scratch_local[4], scratch_local[5],
+        p.x, p.y, p.z,
+        q.x, q.y, q.z, q.w
+    );
+
+    const speed = Math.sqrt(vx * vx + vy * vy + vz * vz);
+    const pad = FAT_LINEAR + FAT_VELOCITY_MULTIPLIER * speed * dt;
+
+    result[result_offset] -= pad;
+    result[result_offset + 1] -= pad;
+    result[result_offset + 2] -= pad;
+    result[result_offset + 3] += pad;
+    result[result_offset + 4] += pad;
+    result[result_offset + 5] += pad;
+}

package/src/engine/physics/broadphase/generate_pairs.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Iterate every awake body, query both BVHs from each of its attached
+ * collider leaves, dedupe via the {@link ManifoldStore}, optionally gate
+ * each candidate through a user-supplied filter, and append each surviving
+ * body-pair to `pair_list_out`.
+ *
+ * Compound-body aware: a body with multiple colliders has multiple BVH
+ * leaves (one per collider). Each leaf's AABB query may turn up the same
+ * other-body multiple times (across the multiple leaves on either side)
+ * but the per-slot touched flag collapses those into one entry in the
+ * canonical `(min, max)` pair list — narrowphase then resolves the
+ * collider-cross-product internally.
+ *
+ * Determinism: pair encounter order is fully determined by the awake-list
+ * order × per-body collider-list order × BVH leaf traversal order. All
+ * three are deterministic functions of the link/unlink sequence and the
+ * BVH state, so two worlds with the same scene history produce identical
+ * pair lists.
+ *
+ * @param {BodyStorage} storage
+ * @param {BVH} dynamic_bvh
+ * @param {BVH} static_bvh
+ * @param {ManifoldStore} manifolds
+ * @param {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>} body_collider_lists
+ * @param {PairList} pair_list_out cleared and filled
+ * @param {((idA: number, idB: number) => boolean) | null} pair_filter optional
+ *        gate. Returning `false` rejects the pair entirely — no manifold
+ *        slot, no narrowphase, no contact events. Existing cached
+ *        manifolds for a rejected pair time out naturally via the
+ *        manifold-store grace counter.
+ */
+export function generate_pairs(storage: BodyStorage, dynamic_bvh: BVH, static_bvh: BVH, manifolds: ManifoldStore, body_collider_lists: Array<Array<{
+    collider: Collider;
+    transform: Transform;
+    entity: number;
+    bvhNode: number;
+}>>, pair_list_out: PairList, pair_filter?: (idA: number, idB: number) => boolean): void;
+//# sourceMappingURL=generate_pairs.d.ts.map

package/src/engine/physics/broadphase/generate_pairs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_pairs.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/broadphase/generate_pairs.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,uIARW,MAAM,MAAM;IAAC,QAAQ,WAAW;IAAC,SAAS,YAAY;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAAC,CAAC,+CAElF,MAAM,OAAO,MAAM,KAAK,OAAO,QAsEhD"}

package/src/engine/physics/broadphase/generate_pairs.js

@@ -0,0 +1,101 @@
+import { bvh_query_user_data_overlaps_aabb } from "../../../core/bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
+
+const scratch_aabb = new Float64Array(6);
+const candidates = new Uint32Array(1024);
+
+/**
+ * Iterate every awake body, query both BVHs from each of its attached
+ * collider leaves, dedupe via the {@link ManifoldStore}, optionally gate
+ * each candidate through a user-supplied filter, and append each surviving
+ * body-pair to `pair_list_out`.
+ *
+ * Compound-body aware: a body with multiple colliders has multiple BVH
+ * leaves (one per collider). Each leaf's AABB query may turn up the same
+ * other-body multiple times (across the multiple leaves on either side)
+ * but the per-slot touched flag collapses those into one entry in the
+ * canonical `(min, max)` pair list — narrowphase then resolves the
+ * collider-cross-product internally.
+ *
+ * Determinism: pair encounter order is fully determined by the awake-list
+ * order × per-body collider-list order × BVH leaf traversal order. All
+ * three are deterministic functions of the link/unlink sequence and the
+ * BVH state, so two worlds with the same scene history produce identical
+ * pair lists.
+ *
+ * @param {BodyStorage} storage
+ * @param {BVH} dynamic_bvh
+ * @param {BVH} static_bvh
+ * @param {ManifoldStore} manifolds
+ * @param {Array<Array<{collider: Collider, transform: Transform, entity: number, bvhNode: number}>>} body_collider_lists
+ * @param {PairList} pair_list_out cleared and filled
+ * @param {((idA: number, idB: number) => boolean) | null} pair_filter optional
+ *        gate. Returning `false` rejects the pair entirely — no manifold
+ *        slot, no narrowphase, no contact events. Existing cached
+ *        manifolds for a rejected pair time out naturally via the
+ *        manifold-store grace counter.
+ */
+export function generate_pairs(
+    storage,
+    dynamic_bvh,
+    static_bvh,
+    manifolds,
+    body_collider_lists,
+    pair_list_out,
+    pair_filter = null
+) {
+    pair_list_out.clear();
+
+    const awake_count = storage.awake_count;
+
+    for (let i = 0; i < awake_count; i++) {
+        const body_idx = storage.awake_at(i);
+        const list = body_collider_lists[body_idx];
+        if (list === undefined || list.length === 0) continue;
+
+        const gen = storage.generation_at(body_idx);
+        const my_packed = (body_idx << 8) | gen;
+
+        for (let k = 0; k < list.length; k++) {
+            const node = list[k].bvhNode;
+            dynamic_bvh.node_get_aabb(node, scratch_aabb);
+
+            // Dynamic ↔ Dynamic.
+            let n = bvh_query_user_data_overlaps_aabb(
+                candidates, 0,
+                dynamic_bvh,
+                scratch_aabb
+            );
+            for (let c = 0; c < n; c++) {
+                const other = candidates[c];
+                if (other === my_packed) continue;
+
+                const idA = my_packed < other ? my_packed : other;
+                const idB = my_packed < other ? other : my_packed;
+
+                const existing = manifolds.find(idA, idB);
+                if (existing !== -1 && manifolds.is_touched(existing)) continue;
+                if (pair_filter !== null && !pair_filter(idA, idB)) continue;
+                manifolds.acquire(idA, idB);
+                pair_list_out.push(idA, idB);
+            }
+
+            // Dynamic ↔ Static.
+            n = bvh_query_user_data_overlaps_aabb(
+                candidates, 0,
+                static_bvh,
+                scratch_aabb
+            );
+            for (let c = 0; c < n; c++) {
+                const other = candidates[c];
+                const idA = my_packed < other ? my_packed : other;
+                const idB = my_packed < other ? other : my_packed;
+
+                const existing = manifolds.find(idA, idB);
+                if (existing !== -1 && manifolds.is_touched(existing)) continue;
+                if (pair_filter !== null && !pair_filter(idA, idB)) continue;
+                manifolds.acquire(idA, idB);
+                pair_list_out.push(idA, idB);
+            }
+        }
+    }
+}

package/src/engine/physics/contact/ManifoldStore.d.ts

@@ -0,0 +1,226 @@
+/**
+ * Maximum contact points per manifold. Four is the universal industry choice
+ * (Bullet's btPersistentManifold, Box2D, Jolt) — enough to express stable
+ * face-on-face contact, small enough to fit inertia-driven solver passes.
+ * @type {number}
+ */
+export const MAX_CONTACTS_PER_MANIFOLD: number;
+/**
+ * Per-contact field stride in the data Float64Array.
+ *
+ * Layout per contact (all world-space):
+ *   0..2  : world_a   (contact point on body A's surface)
+ *   3..5  : world_b   (contact point on body B's surface)
+ *   6..8  : normal_w  (from B toward A)
+ *   9     : depth     (positive = penetration, negative = speculative gap)
+ *   10    : j_n       (accumulated normal impulse, warm-start)
+ *   11    : j_t1      (accumulated tangent impulse, axis 1)
+ *   12    : j_t2      (accumulated tangent impulse, axis 2)
+ *
+ * Solver uses `(world_a + world_b) * 0.5` as the application point; storing
+ * both surface points keeps the door open for richer warm-start matching
+ * across frames in a follow-up slice.
+ *
+ * @type {number}
+ */
+export const CONTACT_STRIDE: number;
+/**
+ * Per-slot Float64 stride: room for {@link MAX_CONTACTS_PER_MANIFOLD} contacts.
+ * @type {number}
+ */
+export const SLOT_DATA_STRIDE: number;
+/**
+ * Sentinel for "no slot".
+ * @type {number}
+ */
+export const MANIFOLD_SLOT_ABSENT: number;
+/**
+ * Persistent contact-manifold cache keyed by canonical body-id pairs.
+ *
+ * Owns:
+ *  - the SoA `Float64Array` of contact points (per-slot stride 52),
+ *  - the small meta `Uint32Array` (bodyA, bodyB, packed flags + count),
+ *  - a {@link PairUint32Map} from `(idA, idB)` to slot id,
+ *  - a dense `__live_slots` array of currently-allocated slot ids,
+ *  - a min-heap-free-stack of released slot ids so reuse is deterministic.
+ *
+ * Lifecycle per simulation step:
+ *  1. Broadphase calls {@link acquire} for every encountered pair, which marks
+ *     each touched slot as "fresh this frame".
+ *  2. Narrowphase fills in contact points via {@link set_contact} /
+ *     {@link clear_contacts}.
+ *  3. End-of-step calls {@link advance_frame} to roll touched → prev_touched
+ *     and evict slots that have been untouched for {@link DEFAULT_GRACE}
+ *     consecutive frames.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ManifoldStore {
+    /**
+     * @param {number} [initial_capacity] slots
+     */
+    constructor(initial_capacity?: number);
+    __capacity: number;
+    __high_water: number;
+    __data: Float64Array;
+    __meta: Uint32Array;
+    __pair_index: PairUint32Map;
+    __live_slots: Uint32Array;
+    __live_pos: Int32Array;
+    __live_count: number;
+    __free_heap: Uint32Array;
+    __free_count: number;
+    /**
+     * @returns {number} number of currently-live slots
+     */
+    get count(): number;
+    /**
+     * @returns {number} total allocated slot capacity
+     */
+    get capacity(): number;
+    /**
+     * Look up a slot by canonical pair. Caller is responsible for ordering
+     * `(idA, idB)` such that the same pair always hashes the same way.
+     *
+     * @param {number} idA
+     * @param {number} idB
+     * @returns {number} slot id or {@link MANIFOLD_SLOT_ABSENT}
+     */
+    find(idA: number, idB: number): number;
+    /**
+     * Acquire a slot for the pair, creating one if absent, and mark it
+     * "touched this frame". Returns the slot id. Calling `acquire` twice in
+     * the same step on the same pair is a no-op for the second call.
+     *
+     * @param {number} idA
+     * @param {number} idB
+     * @returns {number} slot id
+     */
+    acquire(idA: number, idB: number): number;
+    /**
+     * @param {number} slot
+     * @returns {number} body A id stored at this slot
+     */
+    bodyA(slot: number): number;
+    /**
+     * @param {number} slot
+     * @returns {number}
+     */
+    bodyB(slot: number): number;
+    /**
+     * @param {number} slot
+     * @returns {number} 0..MAX_CONTACTS_PER_MANIFOLD
+     */
+    contact_count(slot: number): number;
+    /**
+     * @param {number} slot
+     * @returns {boolean}
+     */
+    is_touched(slot: number): boolean;
+    /**
+     * @param {number} slot
+     * @returns {boolean}
+     */
+    was_touched_prev(slot: number): boolean;
+    /**
+     * Iterate the dense list of currently-live slots without going through
+     * the pair map. `i` ranges `[0, count)`.
+     * @param {number} i
+     * @returns {number}
+     */
+    live_at(i: number): number;
+    /**
+     * Clear the contact list for a slot (counts go to zero, warm-start
+     * impulses also reset). Used when narrowphase determines the pair is
+     * separated this frame.
+     * @param {number} slot
+     */
+    clear_contacts(slot: number): void;
+    /**
+     * Write a contact point into a slot. Increments contact_count if `idx`
+     * exceeds the current count.
+     *
+     * @param {number} slot
+     * @param {number} idx contact index in `[0, MAX_CONTACTS_PER_MANIFOLD)`
+     * @param {number} lax
+     * @param {number} lay
+     * @param {number} laz
+     * @param {number} lbx
+     * @param {number} lby
+     * @param {number} lbz
+     * @param {number} nx normal world x (B toward A)
+     * @param {number} ny
+     * @param {number} nz
+     * @param {number} depth
+     */
+    set_contact(slot: number, idx: number, lax: number, lay: number, laz: number, lbx: number, lby: number, lbz: number, nx: number, ny: number, nz: number, depth: number): void;
+    /**
+     * Read a contact point. Writes 10 floats: lax, lay, laz, lbx, lby, lbz, nx, ny, nz, depth.
+     * @param {number} slot
+     * @param {number} idx
+     * @param {number[]|Float64Array} out
+     * @param {number} out_offset
+     */
+    get_contact(slot: number, idx: number, out: number[] | Float64Array, out_offset: number): void;
+    /**
+     * Get the contact-normal world x component for a given contact.
+     * Provided for testability without exposing the raw Float64Array view.
+     * @param {number} slot
+     * @param {number} idx
+     * @returns {number}
+     */
+    contact_normal_x(slot: number, idx: number): number;
+    /** @param {number} slot @param {number} idx @returns {number} */
+    contact_normal_y(slot: number, idx: number): number;
+    /** @param {number} slot @param {number} idx @returns {number} */
+    contact_normal_z(slot: number, idx: number): number;
+    /** @param {number} slot @param {number} idx @returns {number} */
+    contact_depth(slot: number, idx: number): number;
+    /**
+     * Raw contact-point buffer. Hot-path solver code dereferences this
+     * directly via {@link slot_data_offset} + {@link CONTACT_STRIDE} to avoid
+     * per-field accessor overhead. Buffer identity is stable until grow.
+     * @returns {Float64Array}
+     */
+    get data_buffer(): Float64Array;
+    /**
+     * Word offset into {@link data_buffer} where the first contact of `slot`
+     * begins. Subsequent contacts within the slot are at
+     * `offset + c * CONTACT_STRIDE`.
+     * @param {number} slot
+     * @returns {number}
+     */
+    slot_data_offset(slot: number): number;
+    /**
+     * Advance touched flags by one frame and evict slots that have been
+     * untouched for {@link DEFAULT_GRACE} consecutive frames.
+     */
+    advance_frame(): void;
+    /**
+     * @private
+     * @returns {number} newly-allocated slot id
+     */
+    private __allocate_slot;
+    /**
+     * @private
+     * @param {number} slot
+     */
+    private __release_slot;
+    /**
+     * @private
+     */
+    private __grow;
+    /**
+     * @private
+     * @param {number} v
+     */
+    private __heap_push;
+    /**
+     * @private
+     * @returns {number}
+     */
+    private __heap_pop;
+}
+import { PairUint32Map } from "../../../core/collection/PairUint32Map.js";
+//# sourceMappingURL=ManifoldStore.d.ts.map

package/src/engine/physics/contact/ManifoldStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManifoldStore.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/contact/ManifoldStore.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;;;;;;;;;GAiBG;AACH,6BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,+BAFU,MAAM,CAE2D;AAyB3E;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAIvC;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAEI;;OAEG;IACH,+BAFW,MAAM,EAqBhB;IAjBG,mBAA+C;IAC/C,qBAAqB;IAErB,qBAAkE;IAClE,oBAAiE;IAEjE,4BAA0D;IAG1D,0BAAoD;IACpD,uBAAiD;IAEjD,qBAAqB;IAGrB,yBAAmD;IACnD,qBAAqB;IAGzB;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,UAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,aAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAwBlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,YAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;OAKG;IACH,WAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,qBAFW,MAAM,QAQhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,kBAbW,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,SACN,MAAM,QAqBhB;IAED;;;;;;OAMG;IACH,kBALW,MAAM,OACN,MAAM,OACN,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,uBAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAIlB;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,uBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED,iEAAiE;IACjE,oBADY,MAAM,OAAe,MAAM,GAAgB,MAAM,CAG5D;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,sBA6BC;IAED;;;OAGG;IACH,wBAcC;IAED;;;OAGG;IACH,uBAkBC;IAED;;OAEG;IACH,eA8BC;IAED;;;OAGG;IACH,oBAaC;IAED;;;OAGG;IACH,mBAqBC;CACJ;8BAjfqD,2CAA2C"}