@woosh/meep-engine 3.38.0 → 3.40.0

package/src/engine/physics/narrowphase/compute_penetration.js

@@ -6,6 +6,10 @@ import { tri3_closest_point_barycentric } from "../../../core/geom/3d/triangle/t
 import { TRIANGLE_FLOAT_STRIDE } from "./decomposition/triangle_buffer_layout.js";
 import { deepest_pair_penetration } from "./narrowphase_step.js";
 import { PosedShape3D } from "../../../core/geom/3d/shape/PosedShape3D.js";
+import { Triangle3D } from "../../../core/geom/3d/shape/Triangle3D.js";
+import { gjk } from "../../../core/geom/3d/gjk/gjk.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
+import { rigid_subject_pose } from "./rigid_subject_pose.js";
 
 /**
  * Module-scoped scratch — same single-thread re-entrancy assumption as
@@ -14,6 +18,14 @@ import { PosedShape3D } from "../../../core/geom/3d/shape/PosedShape3D.js";
  */
 const posed_b = new PosedShape3D();
 
+/**
+ * The recovery path's contact test for a mesh triangle: one flyweight triangle, rebound per
+ * candidate and posed as the concave shape, and the GJK simplex scratch.
+ */
+const triangle_shape = new Triangle3D();
+const triangle_posed = new PosedShape3D();
+const simplex_buf = new Float64Array(12);
+
 /**
  * Scratch normal written by the primary {@link deepest_pair_penetration} query.
  * Copied to the caller's `out_direction` only when the depth clears
@@ -33,19 +45,44 @@ const scratch_v3 = new Float64Array(3);
 const scratch_rot = new Float64Array(3);
 const scratch_bary = new Float64Array(2);
 
+/** The world direction the convex's support is asked along. */
+const scratch_direction = new Float64Array(3);
+
+/**
+ * The world pose of the mesh or heightmap a rigid TransformedShape3D wraps ({@link rigid_subject_pose}),
+ * and the same as the arrays the recovery path reads a pose from.
+ */
+const subject_pose = new Transform64();
+const subject_position = new Float64Array(3);
+const subject_rotation = new Float64Array(4);
+
 /**
- * Per-pair triangle decomposition cap for the recovery path. Same rationale as
- * `narrowphase_step.MAX_TRIANGLES_PER_PAIR`: the query AABB is bounded by the
- * convex shape's envelope, so a single pair yields tens of triangles — though
- * a heightmap's count scales O(N²) with its `tessellation` (still inside the
- * buffer for a bounded query at moderate tessellation). The enumerators return
- * the TRUE overlap count and drop overflow writes (typed-array OOB semantics);
- * the consume loop clamps the count to this cap so it never reads past the
- * buffer.
+ * Most triangles the recovery path tests one pair against: the bound on
+ * {@link triangle_buffer}'s growth. Same as `narrowphase_step`'s
+ * `MAX_TRIANGLES_PER_PAIR`, for the same reason — the count is the convex
+ * shape's footprint over the surface's triangle density. Under the old fixed
+ * 1,024 a body sunk through a finely meshed floor reported no penetration:
+ * recovery accepts only the triangle the body's centre stands under, and in
+ * index order that one lay past the first thousand.
  * @type {number}
  */
-const MAX_TRIANGLES_PER_PAIR = 1024;
-const triangle_buffer = new Float64Array(MAX_TRIANGLES_PER_PAIR * TRIANGLE_FLOAT_STRIDE);
+const MAX_TRIANGLES_PER_PAIR = 1 << 16;
+
+/**
+ * Recovery-path triangle scratch. Grows by doubling (re-enumerating once) up
+ * to {@link MAX_TRIANGLES_PER_PAIR}; the high-water mark is kept. The
+ * enumerators return the TRUE overlap count and drop overflow writes
+ * (typed-array OOB semantics), so the consume loop never reads past it.
+ * @type {Float64Array}
+ */
+let triangle_buffer = new Float64Array(1024 * TRIANGLE_FLOAT_STRIDE);
+
+/**
+ * Whether a pair overlapping more than {@link MAX_TRIANGLES_PER_PAIR}
+ * triangles has been reported (once per process).
+ * @type {boolean}
+ */
+let triangle_overflow_reported = false;
 
 /**
  * Penetration depths below this are treated as no contact. The narrowphase
@@ -94,18 +131,24 @@ const CONTACT_EPSILON = 1e-4;
  *     resting on a large box reports the few-cm overlap through the near face
  *     rather than the metres-deep "exit through the far side" a centroid-seeded
  *     MPR portal used to return.
- *   - **general convex pairs** (anything without a closed form) → GJK + EPA,
- *     which is exact for polytopes and is only ever reached by polytope-like
- *     shapes here, since every curved primitive (sphere, capsule) has a closed
- *     form above.
+ *   - **convex hull pairs** → a hull against a hull or a box takes the GJK +
+ *     EPA axis and the hull face clip; against a sphere, a closed form.
+ *   - **every other convex pair** (a cylinder against anything, a capsule
+ *     against a hull, a scaling TransformedShape3D) → GJK + EPA for the axis
+ *     and depth, the contacts from the two shapes' supporting features. EPA is
+ *     exact for polytopes; on a curved support (the cylinder's side, the
+ *     capsule's ends) its depth is good to its convergence tolerance. A rigid
+ *     TransformedShape3D is collided as its subject, so it takes whichever of
+ *     these its subject does.
  *   - **convex vs concave** (one of heightmap / mesh) → triangle decomposition
  *     over the convex AABB + the closed-form per-triangle solvers
- *     (`sphere_triangle`, `box_triangle`, `capsule_triangle`), deepest wins.
+ *     (`sphere_triangle`, `box_triangle`, `capsule_triangle`), or GJK + EPA and
+ *     the supporting features for any other convex shape, deepest wins.
  *     These are bounded to each triangle's true 2-D extent, so the historical
  *     over-report on closed-mesh side faces (infinite-plane extrapolation) is
  *     gone.
  *
- * ## Convex-vs-concave recovery (fully-tunnelled bodies)
+ * ## Convex-vs-concave recovery (tunnelled bodies)
  *
  * The per-triangle closed-form solvers are intentionally one-sided: a convex
  * shape that has crossed to the *inner* side of a surface produces no
@@ -115,8 +158,19 @@ const CONTACT_EPSILON = 1e-4;
  * back out. When the primary dispatch finds no contact for a convex-vs-concave
  * pair, this function falls back to a half-space test
  * ({@link concave_recovery_penetration}) that reports the outward push-out
- * vector. This is exact for heightmap terrain and a valid (if not strictly
- * minimal) recovery direction for closed meshes.
+ * vector. What that recovers depends on what the concave shape is:
+ *
+ *   - A **heightmap** is solid everywhere under its surface, so a convex behind
+ *     one of its triangles is in it, crossing the surface or wholly below it,
+ *     and is pushed back up.
+ *   - A **mesh** is a surface. Only a convex that crosses one of its triangles
+ *     is recovered, through the triangle it crosses. A convex wholly behind a
+ *     mesh triangle without touching it — under a roof, beneath an open sheet,
+ *     wholly past a one-sided face it tunnelled through, or wholly inside a
+ *     closed mesh — is reported as not penetrating (0). This path used to push
+ *     such a convex out through the plane of any triangle near it, which
+ *     recovered a body sealed inside a closed mesh but also pushed a mover up
+ *     through a roof it was standing under.
  *
  * Concave-vs-concave throws — the M×N triangle-pair cost is out of scope (and
  * is also refused by the narrowphase for dynamic pairs).
@@ -125,9 +179,10 @@ const CONTACT_EPSILON = 1e-4;
  *
  * Every pose component is consumed as `position[0..2]` / `rotation[0..3]` —
  * here in the recovery path, and inside the {@link deepest_pair_penetration}
- * dispatch this hands them to. A `Transform64`'s `translation` / `rotation`
- * (`Float64Array` views — what the ECS callers pass), a `Vector3` /
- * `Quaternion` (both `Float64Array` subclasses) and plain `[x, y, z]` /
+ * dispatch this hands them to. A retained `Float64Array` the caller copied a
+ * Transform64's pose into (its `translation` / `rotation` accessors allocate
+ * a view per read), a `Vector3` / `Quaternion` (both `Float64Array`
+ * subclasses) and plain `[x, y, z]` /
  * `[x, y, z, w]` arrays all satisfy that; an `{x, y, z}` / `{x, y, z, w}`
  * object does NOT. Its components read as `undefined`, which trips
  * `Transform64.setTranslation`'s `assert.isNumber` in development — but
@@ -194,8 +249,8 @@ export function compute_penetration(
 
 /**
  * Recovery fallback for a convex shape that has tunnelled to the inner side of
- * a concave surface (heightmap / mesh), where the one-sided per-triangle
- * solvers report no contact.
+ * a heightmap, or crosses a mesh triangle from behind, where the one-sided
+ * per-triangle solvers report no contact.
  *
  * Per-triangle half-space test, deepest-wins:
  *   1. Face normal of the triangle in world frame (outward by winding).
@@ -204,12 +259,15 @@ export function compute_penetration(
  *   3. Signed distance of that point to the triangle's plane. If positive the
  *      convex is fully outside this face → skip. If negative, its magnitude is
  *      the depth and the face normal is the contact axis.
+ *   4. For a mesh, the convex must also cross the triangle itself (GJK against
+ *      it). A mesh is a surface: a convex behind one of its triangles is not
+ *      inside anything by itself, so one that crosses none of them — wholly
+ *      past a one-sided face, wholly inside a closed mesh, under a roof — gets
+ *      no depth here. A heightmap is solid under its surface and skips this.
  *
- * Exact for heightmaps (adjacent triangles cover the boundary); for closed
- * meshes the infinite-plane extrapolation can over-report on side faces, but
- * deepest-wins gives a valid outward push that resolves over iterations — and
- * this path only runs once a body is already inside the solid, where any
- * outward direction is progress.
+ * Exact for heightmaps (adjacent triangles cover the boundary). For a mesh the
+ * crossed triangle's plane is the push: a valid outward direction for a closed
+ * mesh, if not always the minimal one.
  *
  * @private
  */
@@ -218,10 +276,27 @@ function concave_recovery_penetration(
     shape_a, position_a, rotation_a,
     shape_b, position_b, rotation_b
 ) {
-    const concave_shape = isConcaveA ? shape_a : shape_b;
-    const concave_pos   = isConcaveA ? position_a : position_b;
-    const concave_rot   = isConcaveA ? rotation_a : rotation_b;
+    let concave_shape = isConcaveA ? shape_a : shape_b;
+    let concave_pos   = isConcaveA ? position_a : position_b;
+    let concave_rot   = isConcaveA ? rotation_a : rotation_b;
     const convex_shape  = isConcaveA ? shape_b : shape_a;
+
+    // A mesh or heightmap a rigid TransformedShape3D wraps is that surface at the composed pose, as
+    // the primary dispatch collides it. A wrapper that scales is not unwrapped, and has no
+    // enumerator, here as there.
+    if (concave_shape.isTransformedShape3D === true) {
+        let px = concave_pos[0], py = concave_pos[1], pz = concave_pos[2];
+        let qx = concave_rot[0], qy = concave_rot[1], qz = concave_rot[2], qw = concave_rot[3];
+        while (concave_shape.isTransformedShape3D === true && rigid_subject_pose(subject_pose, concave_shape, px, py, pz, qx, qy, qz, qw)) {
+            concave_shape = concave_shape.subject;
+            px = subject_pose.translation_x; py = subject_pose.translation_y; pz = subject_pose.translation_z;
+            qx = subject_pose.rotation_x; qy = subject_pose.rotation_y; qz = subject_pose.rotation_z; qw = subject_pose.rotation_w;
+        }
+        subject_position[0] = px; subject_position[1] = py; subject_position[2] = pz;
+        subject_rotation[0] = qx; subject_rotation[1] = qy; subject_rotation[2] = qz; subject_rotation[3] = qw;
+        concave_pos = subject_position;
+        concave_rot = subject_rotation;
+    }
     const convex_pos    = isConcaveA ? position_b : position_a;
     const convex_rot    = isConcaveA ? rotation_b : rotation_a;
 
@@ -243,13 +318,34 @@ function concave_recovery_penetration(
         concave_rot[0], concave_rot[1], concave_rot[2], concave_rot[3]
     );
 
-    // ── 3. Decompose to triangles (clamp: TRUE count may exceed the buffer) ─
+    // ── 3. Decompose to triangles (TRUE count may exceed the buffer: grow
+    //       and enumerate again, deterministic so once suffices) ─────────
     let tri_count = decompose_to_triangles(
         triangle_buffer, 0, concave_shape,
         concave_query_aabb[0], concave_query_aabb[1], concave_query_aabb[2],
         concave_query_aabb[3], concave_query_aabb[4], concave_query_aabb[5]
     );
-    if (tri_count > MAX_TRIANGLES_PER_PAIR) tri_count = MAX_TRIANGLES_PER_PAIR;
+    let tri_capacity = triangle_buffer.length / TRIANGLE_FLOAT_STRIDE;
+    if (tri_count > tri_capacity && tri_capacity < MAX_TRIANGLES_PER_PAIR) {
+        tri_capacity = Math.min(MAX_TRIANGLES_PER_PAIR, Math.max(tri_count, tri_capacity * 2));
+        triangle_buffer = new Float64Array(tri_capacity * TRIANGLE_FLOAT_STRIDE);
+        tri_count = decompose_to_triangles(
+            triangle_buffer, 0, concave_shape,
+            concave_query_aabb[0], concave_query_aabb[1], concave_query_aabb[2],
+            concave_query_aabb[3], concave_query_aabb[4], concave_query_aabb[5]
+        );
+    }
+    if (tri_count > tri_capacity) {
+        // Past the bound — never read the dropped writes.
+        if (!triangle_overflow_reported) {
+            triangle_overflow_reported = true;
+            console.warn(
+                `compute_penetration: a ${convex_shape.constructor.name} overlaps ${tri_count} triangles of a`
+                + ` ${concave_shape.constructor.name}; recovery tests ${tri_capacity} and not the rest.`
+            );
+        }
+        tri_count = tri_capacity;
+    }
     if (tri_count === 0) return 0;
 
     // ── 4. Setup convex PosedShape3D (we'll call support on it per tri) ─
@@ -267,6 +363,19 @@ function concave_recovery_penetration(
     const c_pos_y = concave_pos[1];
     const c_pos_z = concave_pos[2];
 
+    // A heightmap is solid under its surface, so a convex behind one of its triangles is in it; a
+    // mesh is not (see the contact test in the loop).
+    const behind_is_inside = concave_shape.isHeightMapShape3D === true;
+
+    if (!behind_is_inside) {
+        // posed once; the triangle it holds is rebound per candidate
+        triangle_posed.setup_components(
+            triangle_shape,
+            concave_pos[0], concave_pos[1], concave_pos[2],
+            concave_rot[0], concave_rot[1], concave_rot[2], concave_rot[3]
+        );
+    }
+
     // ── 5. Per-triangle half-space test, deepest-wins ──────────────
     let best_depth = 0;
     let best_fnx_w = 0, best_fny_w = 0, best_fnz_w = 0;
@@ -311,7 +420,10 @@ function concave_recovery_penetration(
         const cent_wz = scratch_rot[2] + c_pos_z;
 
         // Deepest inward point of convex along -face_normal.
-        posed_b.support(scratch_v3, 0, -fnx_w, -fny_w, -fnz_w);
+        scratch_direction[0] = -fnx_w;
+        scratch_direction[1] = -fny_w;
+        scratch_direction[2] = -fnz_w;
+        posed_b.support(scratch_v3, 0, scratch_direction, 0);
 
         // Signed distance from that point to the triangle plane along
         // the face normal: > 0 ⇒ convex is fully on outward side,
@@ -365,6 +477,17 @@ function concave_recovery_penetration(
         const LATERAL_TOL_SQR = 1e-6; // FP slack only; seams are covered by the neighbouring triangle
         if (lateral_sqr > LATERAL_TOL_SQR) continue;
 
+        // Behind a heightmap's triangle is inside the heightmap: it is solid everywhere under its
+        // surface. Behind a mesh's triangle is not inside anything by itself — a mesh is a surface,
+        // and a convex can be under a roof or beneath an open sheet, clear of both. A capsule under
+        // a sloped roof that cleared its head by 7.8 cm read 1.55 m deep here, and a mover that
+        // grazed the same mesh's floor was pushed up through the roof. So a mesh's triangle counts
+        // only where the convex actually crosses it.
+        if (!behind_is_inside) {
+            triangle_shape.bind(triangle_buffer, tri_offset);
+            if (!gjk(simplex_buf, posed_b, triangle_posed)) continue;
+        }
+
         if (depth > best_depth) {
             best_depth = depth;
             best_fnx_w = fnx_w;

package/src/engine/physics/narrowphase/convex_convex_manifold.d.ts

@@ -89,5 +89,81 @@ export function convex_hull_clip(out: Float64Array | number[], A: {
     z;
     w;
 }, nx: number, ny: number, nz: number): boolean;
+/**
+ * {@link convex_hull_clip} with the axis read from `axis[axis_offset ..+2]`: the hull-pair contact
+ * routine does not inline the call, and handed the axis as three numbers it boxed each.
+ *
+ * @param {Float64Array|number[]} out length ≥ CONVEX_CONVEX_OUT_LENGTH
+ * @param {{vertices,face_offsets,face_loops}} A
+ * @param {{x,y,z}} posA
+ * @param {{x,y,z,w}} rotA
+ * @param {{vertices,face_offsets,face_loops}} B
+ * @param {{x,y,z}} posB
+ * @param {{x,y,z,w}} rotB
+ * @param {Float64Array} axis unit axis as returned by {@link gjk_epa_penetration}, either sign
+ * @param {number} axis_offset
+ * @returns {boolean} always true
+ */
+export function convex_hull_clip_array(out: Float64Array | number[], A: {
+    vertices;
+    face_offsets;
+    face_loops;
+}, posA: {
+    x;
+    y;
+    z;
+}, rotA: {
+    x;
+    y;
+    z;
+    w;
+}, B: {
+    vertices;
+    face_offsets;
+    face_loops;
+}, posB: {
+    x;
+    y;
+    z;
+}, rotB: {
+    x;
+    y;
+    z;
+    w;
+}, axis: Float64Array, axis_offset: number): boolean;
+/**
+ * Sutherland–Hodgman: keep polygon points where (P − a)·s ≤ 0, with crossings.
+ * Capacity-guarded on BOTH emit branches: `m` must never pass `dst`'s capacity
+ * or the dropped OOB writes leave stale/NaN points that later reads consume
+ * (the buffers are pre-sized to inc_len + ref_len, so the guard is a backstop
+ * for degenerate input, not the normal bound).
+ *
+ * Shared with {@link feature_manifold}, which clips support features the same way.
+ *
+ * @param {Float64Array} src polygon, flat `(x, y, z)` per point
+ * @param {number} n point count in `src`
+ * @param {Float64Array} dst receives the clipped polygon; `src` and `dst` must not overlap
+ * @param {number} sx clip plane normal x (points with positive side are cut)
+ * @param {number} sy
+ * @param {number} sz
+ * @param {number} ax a point on the clip plane, x
+ * @param {number} ay
+ * @param {number} az
+ * @returns {number} point count written to `dst`
+ */
+export function clip_poly(src: Float64Array, n: number, dst: Float64Array, sx: number, sy: number, sz: number, ax: number, ay: number, az: number): number;
+/**
+ * {@link clip_poly} with the plane read from `plane[plane_offset ..+5]`: the normal `s`, then a point
+ * `a` on the plane. For a caller that cannot have the call inlined, where passing the plane's six
+ * numbers would box each into a new heap object, once per side plane of every face clip.
+ *
+ * @param {Float64Array} src polygon, flat `(x, y, z)` per point
+ * @param {number} n point count in `src`
+ * @param {Float64Array} dst receives the clipped polygon; `src` and `dst` must not overlap
+ * @param {Float64Array} plane `[sx, sy, sz, ax, ay, az]`
+ * @param {number} plane_offset
+ * @returns {number} point count written to `dst`
+ */
+export function clip_poly_array(src: Float64Array, n: number, dst: Float64Array, plane: Float64Array, plane_offset: number): number;
 export const CONVEX_CONVEX_OUT_LENGTH: number;
 //# sourceMappingURL=convex_convex_manifold.d.ts.map

package/src/engine/physics/narrowphase/convex_convex_manifold.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convex_convex_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_convex_manifold.js"],"names":[],"mappings":"AA+QA;;;;;;;;;;;;GAYG;AACH,4CATW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KACT;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,GACP,OAAO,CAiEnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCAdW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAClC;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KACT;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAClC;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,MACT,MAAM,MAGN,MAAM,MACN,MAAM,GACJ,OAAO,CAuCnB;AAlWD,8CAA0E"}
+{"version":3,"file":"convex_convex_manifold.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/narrowphase/convex_convex_manifold.js"],"names":[],"mappings":"AA4RA;;;;;;;;;;;;GAYG;AACH,4CATW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KACT;IAAC,QAAQ,EAAC,YAAY,CAAC;IAAC,YAAY,EAAC,WAAW,CAAC;IAAC,UAAU,EAAC,WAAW,CAAA;CAAC,QACzE;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,GACP,OAAO,CAmEnB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sCAdW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAClC;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KACT;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAClC;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,MACT,MAAM,MAGN,MAAM,MACN,MAAM,GACJ,OAAO,CAUnB;AAKD;;;;;;;;;;;;;;GAcG;AACH,4CAXW,YAAY,GAAC,MAAM,EAAE,KACrB;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAClC;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,KACT;IAAC,QAAQ,CAAC;IAAA,YAAY,CAAC;IAAA,UAAU,CAAA;CAAC,QAClC;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACP;IAAC,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAC;IAAA,CAAC,CAAA;CAAC,QACT,YAAY,eACZ,MAAM,GACJ,OAAO,CAyCnB;AA6TD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,+BAXW,YAAY,KACZ,MAAM,OACN,YAAY,MACZ,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAalB;AAQD;;;;;;;;;;;GAWG;AACH,qCAPW,YAAY,KACZ,MAAM,OACN,YAAY,SACZ,YAAY,gBACZ,MAAM,GACJ,MAAM,CAyBlB;AAtxBD,8CAA0E"}