@woosh/meep-engine 3.37.0 → 3.39.0

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.37.0",
+  "version": "3.39.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/binary/BinaryBuffer.d.ts

@@ -353,6 +353,17 @@ export class BinaryBuffer {
      * @param {Float32Array|number[]} source
      */
     writeFloat32Array(source: Float32Array | number[], source_offset: number, length: number): void;
+    /**
+     * Write `length` numbers from `source` as Float64, in order. Byte for byte what as many
+     * {@link writeFloat64} calls would write, with no number handed to a call on the way: a caller
+     * that would otherwise pass each number to writeFloat64 has each of them boxed into a heap object
+     * wherever V8 does not inline that call.
+     *
+     * @param {Float64Array|number[]|ArrayLike<number>} source
+     * @param {number} source_offset starting index in the source array
+     * @param {number} length number of elements to write
+     */
+    writeFloat64Array(source: Float64Array | number[] | ArrayLike<number>, source_offset: number, length: number): void;
     /**
      *
      * @param {number} source_offset starting index in the source array

package/src/core/binary/BinaryBuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BinaryBuffer.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"BinaryBuffer.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BinaryBuffer.js"],"names":[],"mappings":"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"}

package/src/core/binary/BinaryBuffer.js

@@ -625,6 +625,36 @@ export class BinaryBuffer {
         }
     }
 
+    /**
+     * Write `length` numbers from `source` as Float64, in order. Byte for byte what as many
+     * {@link writeFloat64} calls would write, with no number handed to a call on the way: a caller
+     * that would otherwise pass each number to writeFloat64 has each of them boxed into a heap object
+     * wherever V8 does not inline that call.
+     *
+     * @param {Float64Array|number[]|ArrayLike<number>} source
+     * @param {number} source_offset starting index in the source array
+     * @param {number} length number of elements to write
+     */
+    writeFloat64Array(source, source_offset, length) {
+        assert.isArrayLike(source, 'source');
+        assert.greaterThanOrEqual(source.length, source_offset + length, "source underflow");
+
+        const end = this.position + 8 * length;
+        this.ensureCapacity(end);
+
+        const data_view = this.dataView;
+        const endianness = this.endianness;
+
+        let position = this.position;
+
+        for (let i = 0; i < length; i++) {
+            data_view.setFloat64(position, source[source_offset + i], endianness);
+            position += 8;
+        }
+
+        this.position = end;
+    }
+
     /**
      *
      * @param {number} source_offset starting index in the source array

package/src/core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bvh_query_user_data_intersects_aabb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,4DALW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,kBAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAAM,UAoElD"}
+{"version":3,"file":"bvh_query_user_data_intersects_aabb.d.ts","sourceRoot":"","sources":["../../../../../../src/core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH,4DALW,MAAM,EAAE,GAAC,WAAW,iBACpB,MAAM,kBAEN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAAM,UAyFlD"}

package/src/core/bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js

@@ -1,6 +1,6 @@
 //
+import { assert } from "../../../assert.js";
 import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
-import { aabb3_intersects_aabb3 } from "../../../geom/3d/aabb/aabb3_intersects_aabb3.js";
 import { NULL_NODE } from "../BVH.js";
 
 const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
@@ -26,6 +26,29 @@ export function bvh_query_user_data_intersects_aabb(
         return 0;
     }
 
+    // The query box, read once. The overlap test below is written out rather than a call to
+    // aabb3_intersects_aabb3: a call passing twelve numbers boxes each into a new heap object whenever
+    // it is not inlined, and the node accessors' asserts spend this function's inlining budget, so it
+    // was not — twelve allocations per node visited, in every broadphase query.
+    const x0 = aabb[0];
+    const y0 = aabb[1];
+    const z0 = aabb[2];
+    const x1 = aabb[3];
+    const y1 = aabb[4];
+    const z1 = aabb[5];
+
+    // The six are handed to assert.isNumber only when one is not a number. Called every time, the
+    // calls were left out of line for the same budget, and each boxed the number it was passed.
+    if (typeof x0 !== 'number' || typeof y0 !== 'number' || typeof z0 !== 'number'
+        || typeof x1 !== 'number' || typeof y1 !== 'number' || typeof z1 !== 'number') {
+        assert.isNumber(x0, 'x0');
+        assert.isNumber(y0, 'y0');
+        assert.isNumber(z0, 'z0');
+        assert.isNumber(x1, 'x1');
+        assert.isNumber(y1, 'y1');
+        assert.isNumber(z1, 'z1');
+    }
+
     /**
      *
      * @type {number}
@@ -48,12 +71,10 @@ export function bvh_query_user_data_intersects_aabb(
         // test node against the ray
         bvh.node_get_aabb(node, scratch_aabb);
 
-        const intersection_exists = aabb3_intersects_aabb3(
-            scratch_aabb[0], scratch_aabb[1], scratch_aabb[2],
-            scratch_aabb[3], scratch_aabb[4], scratch_aabb[5],
-            aabb[0], aabb[1], aabb[2],
-            aabb[3], aabb[4], aabb[5]
-        )
+        // touching counts as intersecting, as in aabb3_intersects_aabb3
+        const intersection_exists = scratch_aabb[3] >= x0 && x1 >= scratch_aabb[0]
+            && scratch_aabb[4] >= y0 && y1 >= scratch_aabb[1]
+            && scratch_aabb[5] >= z0 && z1 >= scratch_aabb[2];
 
         if (!intersection_exists) {
             // fully outside

package/src/core/geom/3d/aabb/aabb3_transform_oriented.d.ts

@@ -27,4 +27,19 @@
  * @param {number} qw  quaternion w
  */
 export function aabb3_transform_oriented(result: number[] | Float32Array | Float64Array, result_offset: number, lx0: number, ly0: number, lz0: number, lx1: number, ly1: number, lz1: number, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number): void;
+/**
+ * {@link aabb3_transform_oriented} with the local box and the pose read from arrays, and the one place
+ * its arithmetic lives: a call V8 does not inline boxes each number passed to it into a new heap
+ * object, thirteen here, once per collider per step in the broadphase update and per pair in the
+ * narrowphase.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} aabb local box `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} aabb_offset
+ * @param {number[]|Float64Array} pose translation then orientation (unit quaternion):
+ *   `[px, py, pz, qx, qy, qz, qw]`
+ * @param {number} pose_offset
+ */
+export function aabb3_transform_oriented_array(result: number[] | Float32Array | Float64Array, result_offset: number, aabb: number[] | Float32Array | Float64Array, aabb_offset: number, pose: number[] | Float64Array, pose_offset: number): void;
 //# sourceMappingURL=aabb3_transform_oriented.d.ts.map

package/src/core/geom/3d/aabb/aabb3_transform_oriented.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_transform_oriented.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAhBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkEhB"}
+{"version":3,"file":"aabb3_transform_oriented.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,iDAhBW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAkBhB;AAMD;;;;;;;;;;;;;GAaG;AACH,uDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,eAClC,MAAM,QACN,MAAM,EAAE,GAAC,YAAY,eAErB,MAAM,QAuEhB"}

package/src/core/geom/3d/aabb/aabb3_transform_oriented.js

@@ -32,6 +32,47 @@ export function aabb3_transform_oriented(
     px, py, pz,
     qx, qy, qz, qw
 ) {
+    const aabb = scratch_aabb;
+    const pose = scratch_pose;
+
+    aabb[0] = lx0; aabb[1] = ly0; aabb[2] = lz0;
+    aabb[3] = lx1; aabb[4] = ly1; aabb[5] = lz1;
+
+    pose[0] = px; pose[1] = py; pose[2] = pz;
+    pose[3] = qx; pose[4] = qy; pose[5] = qz; pose[6] = qw;
+
+    aabb3_transform_oriented_array(result, result_offset, aabb, 0, pose, 0);
+}
+
+/** Where {@link aabb3_transform_oriented} packs its box and its pose. */
+const scratch_aabb = new Float64Array(6);
+const scratch_pose = new Float64Array(7);
+
+/**
+ * {@link aabb3_transform_oriented} with the local box and the pose read from arrays, and the one place
+ * its arithmetic lives: a call V8 does not inline boxes each number passed to it into a new heap
+ * object, thirteen here, once per collider per step in the broadphase update and per pair in the
+ * narrowphase.
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} result_offset
+ * @param {number[]|Float32Array|Float64Array} aabb local box `[x0, y0, z0, x1, y1, z1]`
+ * @param {number} aabb_offset
+ * @param {number[]|Float64Array} pose translation then orientation (unit quaternion):
+ *   `[px, py, pz, qx, qy, qz, qw]`
+ * @param {number} pose_offset
+ */
+export function aabb3_transform_oriented_array(
+    result, result_offset,
+    aabb, aabb_offset,
+    pose, pose_offset
+) {
+    const lx0 = aabb[aabb_offset], ly0 = aabb[aabb_offset + 1], lz0 = aabb[aabb_offset + 2];
+    const lx1 = aabb[aabb_offset + 3], ly1 = aabb[aabb_offset + 4], lz1 = aabb[aabb_offset + 5];
+
+    const px = pose[pose_offset], py = pose[pose_offset + 1], pz = pose[pose_offset + 2];
+    const qx = pose[pose_offset + 3], qy = pose[pose_offset + 4], qz = pose[pose_offset + 5], qw = pose[pose_offset + 6];
+
     // local centre and half-extent
     const cx = (lx0 + lx1) * 0.5;
     const cy = (ly0 + ly1) * 0.5;

package/src/core/geom/3d/aabb/aabb3_transform_oriented_inverse.d.ts

@@ -34,4 +34,16 @@
  * @param {number} rot_w
  */
 export function aabb3_transform_oriented_inverse(out: Float64Array, out_offset: number, world_aabb: Float64Array | number[], pos_x: number, pos_y: number, pos_z: number, rot_x: number, rot_y: number, rot_z: number, rot_w: number): void;
+/**
+ * {@link aabb3_transform_oriented_inverse} with the pose read from an array, and the one place its
+ * arithmetic lives: a call V8 does not inline boxes each number passed to it into a new heap object.
+ *
+ * @param {Float64Array} out 6-float min/max in body-local frame
+ * @param {number} out_offset
+ * @param {Float64Array|number[]} world_aabb 6-float min/max in world frame
+ * @param {number[]|Float64Array} pose body world position then rotation (unit quaternion):
+ *   `[px, py, pz, qx, qy, qz, qw]`
+ * @param {number} pose_offset
+ */
+export function aabb3_transform_oriented_inverse_array(out: Float64Array, out_offset: number, world_aabb: Float64Array | number[], pose: number[] | Float64Array, pose_offset: number): void;
 //# sourceMappingURL=aabb3_transform_oriented_inverse.d.ts.map

package/src/core/geom/3d/aabb/aabb3_transform_oriented_inverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aabb3_transform_oriented_inverse.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented_inverse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,sDAXW,YAAY,cACZ,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,SACrB,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAwChB"}
+{"version":3,"file":"aabb3_transform_oriented_inverse.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/aabb/aabb3_transform_oriented_inverse.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,sDAXW,YAAY,cACZ,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,SACrB,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAchB;AAKD;;;;;;;;;;GAUG;AACH,4DAPW,YAAY,cACZ,MAAM,cACN,YAAY,GAAC,MAAM,EAAE,QACrB,MAAM,EAAE,GAAC,YAAY,eAErB,MAAM,QAuChB"}

package/src/core/geom/3d/aabb/aabb3_transform_oriented_inverse.js

@@ -47,6 +47,33 @@ export function aabb3_transform_oriented_inverse(
     pos_x, pos_y, pos_z,
     rot_x, rot_y, rot_z, rot_w
 ) {
+    const pose = scratch_pose;
+
+    pose[0] = pos_x; pose[1] = pos_y; pose[2] = pos_z;
+    pose[3] = rot_x; pose[4] = rot_y; pose[5] = rot_z; pose[6] = rot_w;
+
+    aabb3_transform_oriented_inverse_array(out, out_offset, world_aabb, pose, 0);
+}
+
+/** Where {@link aabb3_transform_oriented_inverse} packs its pose. */
+const scratch_pose = new Float64Array(7);
+
+/**
+ * {@link aabb3_transform_oriented_inverse} with the pose read from an array, and the one place its
+ * arithmetic lives: a call V8 does not inline boxes each number passed to it into a new heap object.
+ *
+ * @param {Float64Array} out 6-float min/max in body-local frame
+ * @param {number} out_offset
+ * @param {Float64Array|number[]} world_aabb 6-float min/max in world frame
+ * @param {number[]|Float64Array} pose body world position then rotation (unit quaternion):
+ *   `[px, py, pz, qx, qy, qz, qw]`
+ * @param {number} pose_offset
+ */
+export function aabb3_transform_oriented_inverse_array(out, out_offset, world_aabb, pose, pose_offset) {
+    const pos_x = pose[pose_offset], pos_y = pose[pose_offset + 1], pos_z = pose[pose_offset + 2];
+    const rot_x = pose[pose_offset + 3], rot_y = pose[pose_offset + 4];
+    const rot_z = pose[pose_offset + 5], rot_w = pose[pose_offset + 6];
+
     let min_x = Infinity, min_y = Infinity, min_z = Infinity;
     let max_x = -Infinity, max_y = -Infinity, max_z = -Infinity;
 

package/src/core/geom/3d/gjk/gjk.js

@@ -75,7 +75,7 @@ function gjk_core(simplex, shape_a, shape_b, dir) {
     minkowski_support(
         simplex, 6,
         shape_a, shape_b,
-        dir[0], dir[1], dir[2]
+        dir, 0
     );
 
     // Search toward the origin from C
@@ -89,7 +89,7 @@ function gjk_core(simplex, shape_a, shape_b, dir) {
     }
 
     // Get second support point (simplex point B)
-    minkowski_support(simplex, 3, shape_a, shape_b, dir[0], dir[1], dir[2]);
+    minkowski_support(simplex, 3, shape_a, shape_b, dir, 0);
 
     // B didn't pass the origin — no intersection possible
     if (v3_dot(simplex[3], simplex[4], simplex[5], dir[0], dir[1], dir[2]) < 0) {
@@ -131,7 +131,7 @@ function gjk_core(simplex, shape_a, shape_b, dir) {
 
     for (let iterations = 0; iterations < GJK_MAX_ITERATIONS; iterations++) {
         // Get new support point A
-        minkowski_support(simplex, 0, shape_a, shape_b, dir[0], dir[1], dir[2]);
+        minkowski_support(simplex, 0, shape_a, shape_b, dir, 0);
 
         const a_x = simplex[0];
         const a_y = simplex[1];

package/src/core/geom/3d/gjk/gjk_distance.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Move every live vertex of `simplex` as shape B moves by `(dx, dy, dz)`, so it stays a valid warm
+ * start: a support point of a translated shape is the old one, translated.
+ *
+ * @param {GJKSimplex} simplex
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ */
+export function gjk_simplex_translate_b(simplex: GJKSimplex, dx: number, dy: number, dz: number): void;
+/**
+ * Distance between convex shapes `shape_a` and `shape_b`, posed in world space.
+ *
+ * `out` receives:
+ * - `[0..2]` the closest point on A, `[3..5]` the closest point on B;
+ * - `[6..8]` the unit normal from A toward B — the direction B would move to separate further;
+ * - `[9]` a lower bound on the distance: every point of B lies at least this far beyond A along the
+ *   normal. Within {@link GJK_DISTANCE_RELATIVE_GAP} of the distance on convergence (or within
+ *   `gap_tolerance`), and a true bound regardless.
+ *
+ * When the shapes overlap or touch, the distance and the lower bound are 0, the normal is zero, and
+ * the two points coincide at a point the shapes share. A positive lower bound comes with a plane
+ * that separates the shapes. A search that runs out of {@link MAX_ITERATIONS} before finding any
+ * such plane establishes neither: it reports the closest it came — a distance no less than the
+ * true one, along the witness points' own direction — with a lower bound of 0, and
+ * `simplex.converged` false. Overlap is reported only by a search that ended on its own terms.
+ *
+ * @param {Float64Array} out at least 10 floats
+ * @param {GJKSimplex} simplex workspace, and warm start when its `count` is non-zero (see
+ *   {@link GJKSimplex}); holds the final simplex afterwards
+ * @param {{support:function(Float64Array, number, Float64Array, number):void}} shape_a support in
+ *   world space, unit direction ({@link AbstractShape3D#support}'s contract)
+ * @param {{support:function(Float64Array, number, Float64Array, number):void}} shape_b
+ * @param {number} gap_tolerance the search also stops once a support plane separates the shapes
+ *   and lies within this distance of the closest point, so the distance and its lower bound are
+ *   within it of the true distance. A curved pair's gap closes linearly, and chasing
+ *   {@link GJK_DISTANCE_RELATIVE_GAP} ran a sphere's queries to {@link MAX_ITERATIONS} a third of
+ *   the time; a caller that only steps by the bound needs no finer answer. The normal is no better
+ *   than the gap, though: off by up to `sqrt(2 · gap_tolerance / R)` for a pair whose surfaces
+ *   curve with a combined radius `R` (half a degree for a 5 cm sphere at 2.5e-6). 0 leaves
+ *   {@link GJK_DISTANCE_RELATIVE_GAP} as the only stop
+ * @returns {number} the distance, `|point on B − point on A|`
+ */
+export function gjk_distance(out: Float64Array, simplex: GJKSimplex, shape_a: {
+    support: (arg0: Float64Array, arg1: number, arg2: Float64Array, arg3: number) => void;
+}, shape_b: {
+    support: (arg0: Float64Array, arg1: number, arg2: Float64Array, arg3: number) => void;
+}, gap_tolerance: number): number;
+/**
+ * The search stops when the support plane lies within this fraction of the closest point's distance
+ * — the closest point is then within it of the true distance. A caller that needs less can stop it
+ * sooner with an absolute tolerance of its own (see {@link gjk_distance}).
+ * @type {number}
+ */
+export const GJK_DISTANCE_RELATIVE_GAP: number;
+/**
+ * The simplex a {@link gjk_distance} query builds, and what it reports beyond the result array.
+ * Reusable: one per caller, re-filled by every query.
+ *
+ * A query starts from whatever vertices `count` says are live (zero for a cold start), so a caller
+ * repeating a query on the same pair can hand the last simplex back — Box3D's simplex cache. Those
+ * vertices must still be support points of the shapes as they are posed now:
+ * {@link gjk_simplex_translate_b} keeps them so across a translation of B.
+ */
+export class GJKSimplex {
+    /**
+     * Four vertices of {@link VERTEX_STRIDE} floats: the support point on A, the one on B, `B − A`.
+     * @type {Float64Array}
+     */
+    vertices: Float64Array;
+    /**
+     * Barycentric weight of each live vertex in the closest point.
+     * @type {Float64Array}
+     */
+    weights: Float64Array;
+    /**
+     * Live vertices, 0 to 4.
+     * @type {number}
+     */
+    count: number;
+    /**
+     * Whether the last query terminated on its own terms (a duplicate support, a closed gap, no
+     * further progress, an overlap) rather than on {@link MAX_ITERATIONS}. Its result is the best
+     * found either way, and its lower bound holds either way.
+     * @type {boolean}
+     */
+    converged: boolean;
+    /**
+     * Iterations the last query ran.
+     * @type {number}
+     */
+    iterations: number;
+}
+//# sourceMappingURL=gjk_distance.d.ts.map

package/src/core/geom/3d/gjk/gjk_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gjk_distance.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_distance.js"],"names":[],"mappings":"AA2GA;;;;;;;;GAQG;AACH,iDALW,UAAU,MACV,MAAM,MACN,MAAM,MACN,MAAM,QAShB;AA8YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,kCAhBW,YAAY,WACZ,UAAU,WAEV;IAAC,OAAO,SAAU,YAAY,QAAE,MAAM,QAAE,YAAY,QAAE,MAAM,KAAE,IAAI,CAAA;CAAC,WAEnE;IAAC,OAAO,SAAU,YAAY,QAAE,MAAM,QAAE,YAAY,QAAE,MAAM,KAAE,IAAI,CAAA;CAAC,iBACnE,MAAM,GAQJ,MAAM,CAqOlB;AAtuBD;;;;;GAKG;AACH,wCAFU,MAAM,CAE+B;AAmB/C;;;;;;;;GAQG;AACH;IACI;;;OAGG;IACH,UAFU,YAAY,CAEyB;IAE/C;;;OAGG;IACH,SAFU,YAAY,CAEQ;IAE9B;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;OAKG;IACH,WAFU,OAAO,CAEA;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAED;CAClB"}