@woosh/meep-engine 2.138.19 → 2.139.0

package/src/engine/physics/queries/PhysicsSurfacePoint.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Result of a {@link PhysicsSystem} query that resolves to a single surface
+ * contact — raycast hit, sphere overlap nearest-point, shape-cast first
+ * blocker, etc.
+ *
+ * The class is an *output parameter*: callers pre-allocate one (or pull one
+ * from a frame-pool) and pass it into the query. The query writes the fields
+ * on hit and returns `true`; on miss it returns `false` and leaves the
+ * fields untouched.
+ *
+ * Pre-allocation matters because a query that gets called every frame (a
+ * ground sensor, a hover beam) would otherwise drop a small object on the
+ * GC per call. Reusing the same `PhysicsSurfacePoint` keeps that allocation
+ * out of the hot path.
+ *
+ * Field layout chosen to match what gameplay code typically needs:
+ *   - `position` — world-space point on the surface
+ *   - `normal` — surface normal at that point (broadphase queries return
+ *     the AABB face normal as an approximation; narrowphase-refined queries
+ *     would return the true shape normal at the same call site)
+ *   - `t` — distance along the input ray, sphere-cast, etc. Useful when the
+ *     caller wants to interpolate or step along the query primitive
+ *     (`origin + t·direction` reconstructs the hit point exactly without
+ *     reading `position`, which the deferred-execution physics events bus
+ *     would otherwise need to copy).
+ *   - `entity` — entity id that owns the hit body
+ *   - `body_id` — packed body id (index << 8 | generation); stale after the
+ *     body is unlinked, so prefer `entity` for any cross-frame retention.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PhysicsSurfacePoint {
+    /**
+     * World-space point on the hit surface.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly position: Vector3;
+    /**
+     * Surface normal at {@link position}, unit length. For broadphase-only
+     * queries this is the AABB face normal (axis-aligned), which is exact
+     * for AABB-shaped colliders and a stable approximation otherwise.
+     * @readonly
+     * @type {Vector3}
+     */
+    readonly normal: Vector3;
+    /**
+     * Parametric distance from the query origin to {@link position}, in
+     * the same units as the input direction's magnitude (so for a unit-
+     * length ray direction this is metres).
+     * @type {number}
+     */
+    t: number;
+    /**
+     * Entity that owns the hit body, or `-1` if no body owns it.
+     * @type {number}
+     */
+    entity: number;
+    /**
+     * Packed body id (index << 8 | generation). Goes stale once the body
+     * is unlinked from the {@link PhysicsSystem}; prefer {@link entity}
+     * for any cross-frame use.
+     * @type {number}
+     */
+    body_id: number;
+    /**
+     * Reset to a "no hit" state. Optional — the query convention is that the
+     * fields are only meaningful when the call returns `true`, so callers
+     * that always branch on the return value don't need to reset. Useful for
+     * debugger inspection and for tests that want to verify the query
+     * doesn't accidentally touch the result on miss.
+     */
+    reset(): void;
+    /**
+     * Fast type-check marker.
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isPhysicsSurfacePoint: boolean;
+}
+import Vector3 from "../../../core/geom/Vector3.js";
+//# sourceMappingURL=PhysicsSurfacePoint.d.ts.map

package/src/engine/physics/queries/PhysicsSurfacePoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PhysicsSurfacePoint.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/PhysicsSurfacePoint.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAGQ;;;;OAIG;IACH,mBAFU,OAAO,CAEY;IAE7B;;;;;;OAMG;IACH,iBAFU,OAAO,CAEU;IAE3B;;;;;OAKG;IACH,GAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,SAFU,MAAM,CAEC;IAGrB;;;;;;OAMG;IACH,cAQC;IAGL;;;;OAIG;IACH,gCAFU,OAAO,CAEkC;CAPlD;oBA5FmB,+BAA+B"}

package/src/engine/physics/queries/PhysicsSurfacePoint.js

@@ -0,0 +1,100 @@
+import Vector3 from "../../../core/geom/Vector3.js";
+
+/**
+ * Result of a {@link PhysicsSystem} query that resolves to a single surface
+ * contact — raycast hit, sphere overlap nearest-point, shape-cast first
+ * blocker, etc.
+ *
+ * The class is an *output parameter*: callers pre-allocate one (or pull one
+ * from a frame-pool) and pass it into the query. The query writes the fields
+ * on hit and returns `true`; on miss it returns `false` and leaves the
+ * fields untouched.
+ *
+ * Pre-allocation matters because a query that gets called every frame (a
+ * ground sensor, a hover beam) would otherwise drop a small object on the
+ * GC per call. Reusing the same `PhysicsSurfacePoint` keeps that allocation
+ * out of the hot path.
+ *
+ * Field layout chosen to match what gameplay code typically needs:
+ *   - `position` — world-space point on the surface
+ *   - `normal` — surface normal at that point (broadphase queries return
+ *     the AABB face normal as an approximation; narrowphase-refined queries
+ *     would return the true shape normal at the same call site)
+ *   - `t` — distance along the input ray, sphere-cast, etc. Useful when the
+ *     caller wants to interpolate or step along the query primitive
+ *     (`origin + t·direction` reconstructs the hit point exactly without
+ *     reading `position`, which the deferred-execution physics events bus
+ *     would otherwise need to copy).
+ *   - `entity` — entity id that owns the hit body
+ *   - `body_id` — packed body id (index << 8 | generation); stale after the
+ *     body is unlinked, so prefer `entity` for any cross-frame retention.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PhysicsSurfacePoint {
+
+    constructor() {
+        /**
+         * World-space point on the hit surface.
+         * @readonly
+         * @type {Vector3}
+         */
+        this.position = new Vector3();
+
+        /**
+         * Surface normal at {@link position}, unit length. For broadphase-only
+         * queries this is the AABB face normal (axis-aligned), which is exact
+         * for AABB-shaped colliders and a stable approximation otherwise.
+         * @readonly
+         * @type {Vector3}
+         */
+        this.normal = new Vector3();
+
+        /**
+         * Parametric distance from the query origin to {@link position}, in
+         * the same units as the input direction's magnitude (so for a unit-
+         * length ray direction this is metres).
+         * @type {number}
+         */
+        this.t = 0;
+
+        /**
+         * Entity that owns the hit body, or `-1` if no body owns it.
+         * @type {number}
+         */
+        this.entity = -1;
+
+        /**
+         * Packed body id (index << 8 | generation). Goes stale once the body
+         * is unlinked from the {@link PhysicsSystem}; prefer {@link entity}
+         * for any cross-frame use.
+         * @type {number}
+         */
+        this.body_id = -1;
+    }
+
+    /**
+     * Reset to a "no hit" state. Optional — the query convention is that the
+     * fields are only meaningful when the call returns `true`, so callers
+     * that always branch on the return value don't need to reset. Useful for
+     * debugger inspection and for tests that want to verify the query
+     * doesn't accidentally touch the result on miss.
+     */
+    reset() {
+        const p = this.position;
+        const n = this.normal;
+        p[0] = 0; p[1] = 0; p[2] = 0;
+        n[0] = 0; n[1] = 0; n[2] = 0;
+        this.t = 0;
+        this.entity = -1;
+        this.body_id = -1;
+    }
+}
+
+/**
+ * Fast type-check marker.
+ * @readonly
+ * @type {boolean}
+ */
+PhysicsSurfacePoint.prototype.isPhysicsSurfacePoint = true;

package/src/engine/physics/queries/raycast.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Raycast against both broadphase trees (static + dynamic) of a
+ * {@link PhysicsSystem}, filling `result` with the nearest hit and returning
+ * `true` on hit, `false` on miss.
+ *
+ * Hit normal is the AABB face normal — exact for AABB-shaped colliders,
+ * a stable approximation for general convex shapes (an upcoming narrowphase
+ * refinement pass will replace this with the true shape normal at the same
+ * call site, no API change).
+ *
+ * @param {PhysicsSystem} system
+ * @param {Ray3} ray  origin + unit direction + `tMax`
+ * @param {PhysicsSurfacePoint} result  populated on hit; untouched on miss
+ * @param {(entity:number, collider:Collider)=>boolean} [filter] mandatory in
+ *   contract; defaults to {@link returnTrue} (accept everything). Called once
+ *   per BVH leaf that crosses the ray.
+ * @returns {boolean} true on hit, false on miss
+ */
+export function raycast(system: PhysicsSystem, ray: Ray3, result: PhysicsSurfacePoint, filter?: (entity: number, collider: Collider) => boolean): boolean;
+//# sourceMappingURL=raycast.d.ts.map

package/src/engine/physics/queries/raycast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"raycast.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/queries/raycast.js"],"names":[],"mappings":"AA2HA;;;;;;;;;;;;;;;;;GAiBG;AACH,yGALmB,MAAM,yBAAsB,OAAO,GAGzC,OAAO,CA6GnB"}

package/src/engine/physics/queries/raycast.js

@@ -0,0 +1,249 @@
+import { SCRATCH_UINT32_TRAVERSAL_STACK } from "../../../core/collection/SCRATCH_UINT32_TRAVERSAL_STACK.js";
+import {
+    COLUMN_CHILD_1,
+    COLUMN_CHILD_2,
+    COLUMN_USER_DATA,
+    ELEMENT_WORD_COUNT,
+    NULL_NODE,
+} from "../../../core/bvh2/bvh3/BVH.js";
+import { returnTrue } from "../../../core/function/returnTrue.js";
+import { aabb3_near_distance_to_intersection_ray_segment } from "../../../core/geom/3d/aabb/aabb3_near_distance_to_intersection_ray_segment.js";
+
+const stack = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ * Walk a single BVH along a ray and update the running nearest hit.
+ *
+ * Hit refinement is broadphase-only: the returned `t` is the distance to
+ * the inflated leaf AABB. Narrowphase shape refinement is a follow-up.
+ *
+ * @param {BVH} bvh
+ * @param {number} root
+ * @param {number} ox
+ * @param {number} oy
+ * @param {number} oz
+ * @param {number} dx
+ * @param {number} dy
+ * @param {number} dz
+ * @param {number} inv_dx
+ * @param {number} inv_dy
+ * @param {number} inv_dz
+ * @param {number} max_distance
+ * @param {{best_t:number, best_body:number, best_node:number, best_bvh:BVH|null}} acc
+ * @param {(body_id:number)=>boolean} test  per-leaf filter
+ */
+function bvh_raycast_nearest(
+    bvh, root,
+    ox, oy, oz,
+    dx, dy, dz,
+    inv_dx, inv_dy, inv_dz,
+    max_distance,
+    acc,
+    test
+) {
+    if (root === NULL_NODE) {
+        return;
+    }
+
+    const float32 = bvh.__data_float32;
+    const uint32 = bvh.__data_uint32;
+
+    let pointer = stack.pointer;
+    const stack_top = pointer;
+    stack[pointer++] = root;
+
+    while (pointer > stack_top) {
+        pointer--;
+        const node = stack[pointer];
+        const address = node * ELEMENT_WORD_COUNT;
+
+        const t_near = aabb3_near_distance_to_intersection_ray_segment(
+            float32[address], float32[address + 1], float32[address + 2],
+            float32[address + 3], float32[address + 4], float32[address + 5],
+            ox, oy, oz,
+            inv_dx, inv_dy, inv_dz,
+            0, max_distance
+        );
+
+        // No intersection or this subtree can't beat the best known hit — prune.
+        if (t_near >= acc.best_t) {
+            continue;
+        }
+
+        const child_1 = uint32[address + COLUMN_CHILD_1];
+        if (child_1 !== NULL_NODE) {
+            stack[pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack[pointer++] = child_1;
+        } else {
+            const body_id = uint32[address + COLUMN_USER_DATA];
+            if (test(body_id)) {
+                acc.best_t = t_near;
+                acc.best_body = body_id;
+                acc.best_node = node;
+                acc.best_bvh = bvh;
+            }
+        }
+    }
+
+    stack.pointer = stack_top;
+}
+
+/**
+ * Reusable nearest-hit accumulator. Module-scoped so {@link raycast} doesn't
+ * allocate per call. The physics step is single-threaded so contention isn't
+ * a concern.
+ * @type {{best_t:number, best_body:number, best_node:number, best_bvh:BVH|null}}
+ */
+const acc = { best_t: Infinity, best_body: 0, best_node: 0, best_bvh: null };
+
+/**
+ * Reusable closure bound to the current system + user filter so we don't
+ * allocate a new function object per call. Re-wired at the top of each
+ * {@link raycast} invocation. The BVH traversal sees a stable identity
+ * which helps V8 keep the call site monomorphic.
+ *
+ * Carries state via the module-scoped `bound_*` slots below.
+ * @type {(body_id:number)=>boolean}
+ */
+const bound_test = (body_id) => {
+    const system = bound_system;
+    const entity = system.entityOf(body_id);
+    if (entity < 0) return false;
+    // v1 limitation: when a multi-collider body's BVH leaf is hit, we pass
+    // the body's primary (first-attached) collider rather than the specific
+    // collider the ray actually crossed. Sufficient for entity-level
+    // filtering; per-collider filtering needs the BVH user_data scheme to
+    // encode collider index too — future work.
+    const collider = system.__primary_collider(system.__index_of(body_id));
+    return bound_filter(entity, collider);
+};
+
+let bound_system = null;
+let bound_filter = returnTrue;
+
+/**
+ * Raycast against both broadphase trees (static + dynamic) of a
+ * {@link PhysicsSystem}, filling `result` with the nearest hit and returning
+ * `true` on hit, `false` on miss.
+ *
+ * Hit normal is the AABB face normal — exact for AABB-shaped colliders,
+ * a stable approximation for general convex shapes (an upcoming narrowphase
+ * refinement pass will replace this with the true shape normal at the same
+ * call site, no API change).
+ *
+ * @param {PhysicsSystem} system
+ * @param {Ray3} ray  origin + unit direction + `tMax`
+ * @param {PhysicsSurfacePoint} result  populated on hit; untouched on miss
+ * @param {(entity:number, collider:Collider)=>boolean} [filter] mandatory in
+ *   contract; defaults to {@link returnTrue} (accept everything). Called once
+ *   per BVH leaf that crosses the ray.
+ * @returns {boolean} true on hit, false on miss
+ */
+export function raycast(system, ray, result, filter = returnTrue) {
+    const ox = ray.origin_x;
+    const oy = ray.origin_y;
+    const oz = ray.origin_z;
+    const dx = ray.direction_x;
+    const dy = ray.direction_y;
+    const dz = ray.direction_z;
+    const max_distance = ray.tMax;
+
+    acc.best_t = max_distance;
+    acc.best_body = 0;
+    acc.best_node = 0;
+    acc.best_bvh = null;
+
+    bound_system = system;
+    bound_filter = filter;
+
+    const inv_dx = 1 / dx;
+    const inv_dy = 1 / dy;
+    const inv_dz = 1 / dz;
+
+    bvh_raycast_nearest(
+        system.staticBvh, system.staticBvh.root,
+        ox, oy, oz,
+        dx, dy, dz,
+        inv_dx, inv_dy, inv_dz,
+        max_distance,
+        acc, bound_test
+    );
+
+    bvh_raycast_nearest(
+        system.dynamicBvh, system.dynamicBvh.root,
+        ox, oy, oz,
+        dx, dy, dz,
+        inv_dx, inv_dy, inv_dz,
+        max_distance,
+        acc, bound_test
+    );
+
+    if (acc.best_bvh === null || acc.best_t >= max_distance) {
+        return false;
+    }
+
+    const entity = system.entityOf(acc.best_body);
+    if (entity < 0) {
+        // Body was unlinked concurrently; treat as a miss.
+        return false;
+    }
+
+    // Hit position in world space.
+    const t = acc.best_t;
+    const hx = ox + dx * t;
+    const hy = oy + dy * t;
+    const hz = oz + dz * t;
+
+    // AABB face normal at the hit point. Read the best leaf's AABB back from
+    // its BVH; project the hit point into the AABB's normalised local space
+    // (centre = 0, faces = ±1); the dominant component is the entry-face
+    // axis, its sign gives the outward normal.
+    const bvh = acc.best_bvh;
+    const node_address = acc.best_node * ELEMENT_WORD_COUNT;
+    const f32 = bvh.__data_float32;
+    const aabb_min_x = f32[node_address];
+    const aabb_min_y = f32[node_address + 1];
+    const aabb_min_z = f32[node_address + 2];
+    const aabb_max_x = f32[node_address + 3];
+    const aabb_max_y = f32[node_address + 4];
+    const aabb_max_z = f32[node_address + 5];
+
+    const cx = (aabb_min_x + aabb_max_x) * 0.5;
+    const cy = (aabb_min_y + aabb_max_y) * 0.5;
+    const cz = (aabb_min_z + aabb_max_z) * 0.5;
+    // Multiplicative inverse of the half-extent saves one divide per axis.
+    // A degenerate AABB (zero extent on an axis) is impossible for live BVH
+    // leaves — physics shapes always have non-zero bounding extent.
+    const inv_half_x = 2 / (aabb_max_x - aabb_min_x);
+    const inv_half_y = 2 / (aabb_max_y - aabb_min_y);
+    const inv_half_z = 2 / (aabb_max_z - aabb_min_z);
+
+    const px = (hx - cx) * inv_half_x;
+    const py = (hy - cy) * inv_half_y;
+    const pz = (hz - cz) * inv_half_z;
+
+    const apx = px < 0 ? -px : px;
+    const apy = py < 0 ? -py : py;
+    const apz = pz < 0 ? -pz : pz;
+
+    let nx, ny, nz;
+    if (apx >= apy && apx >= apz) {
+        nx = px >= 0 ? 1 : -1; ny = 0; nz = 0;
+    } else if (apy >= apz) {
+        nx = 0; ny = py >= 0 ? 1 : -1; nz = 0;
+    } else {
+        nx = 0; ny = 0; nz = pz >= 0 ? 1 : -1;
+    }
+
+    // Fill result. Direct typed-array writes — Vector3 extends Float32Array,
+    // and there are no observers subscribed to a query-result vector.
+    const rp = result.position;
+    const rn = result.normal;
+    rp[0] = hx; rp[1] = hy; rp[2] = hz;
+    rn[0] = nx; rn[1] = ny; rn[2] = nz;
+    result.t = t;
+    result.entity = entity;
+    result.body_id = acc.best_body;
+
+    return true;
+}

package/src/engine/physics/solver/friction_cone.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Clamp a 2D friction impulse `(jt1, jt2)` to a disk of radius `max_magnitude`
+ * — the Coulomb friction cone projected onto the tangent plane.
+ *
+ * The 2-axis joint clamp avoids the "friction stronger along one tangent than
+ * along the other" anisotropy that comes from clamping each tangent axis
+ * independently. Standard Box2D / Bullet recipe.
+ *
+ * @param {number[]|Float64Array} out length >= 2; receives the clamped (jt1, jt2)
+ * @param {number} out_offset
+ * @param {number} jt1
+ * @param {number} jt2
+ * @param {number} max_magnitude must be >= 0
+ */
+export function friction_cone_clamp(out: number[] | Float64Array, out_offset: number, jt1: number, jt2: number, max_magnitude: number): void;
+//# sourceMappingURL=friction_cone.d.ts.map

package/src/engine/physics/solver/friction_cone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"friction_cone.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/friction_cone.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,yCANW,MAAM,EAAE,GAAC,YAAY,cACrB,MAAM,OACN,MAAM,OACN,MAAM,iBACN,MAAM,QAwBhB"}

package/src/engine/physics/solver/friction_cone.js

@@ -0,0 +1,37 @@
+/**
+ * Clamp a 2D friction impulse `(jt1, jt2)` to a disk of radius `max_magnitude`
+ * — the Coulomb friction cone projected onto the tangent plane.
+ *
+ * The 2-axis joint clamp avoids the "friction stronger along one tangent than
+ * along the other" anisotropy that comes from clamping each tangent axis
+ * independently. Standard Box2D / Bullet recipe.
+ *
+ * @param {number[]|Float64Array} out length >= 2; receives the clamped (jt1, jt2)
+ * @param {number} out_offset
+ * @param {number} jt1
+ * @param {number} jt2
+ * @param {number} max_magnitude must be >= 0
+ */
+export function friction_cone_clamp(out, out_offset, jt1, jt2, max_magnitude) {
+    if (max_magnitude <= 0) {
+        // No friction budget available (typical when normal impulse is zero):
+        // force the tangent impulse to zero so the solver doesn't add motion
+        // out of nothing.
+        out[out_offset] = 0;
+        out[out_offset + 1] = 0;
+        return;
+    }
+
+    const mag_sqr = jt1 * jt1 + jt2 * jt2;
+    const max_sqr = max_magnitude * max_magnitude;
+
+    if (mag_sqr <= max_sqr) {
+        out[out_offset] = jt1;
+        out[out_offset + 1] = jt2;
+        return;
+    }
+
+    const scale = max_magnitude / Math.sqrt(mag_sqr);
+    out[out_offset] = jt1 * scale;
+    out[out_offset + 1] = jt2 * scale;
+}

package/src/engine/physics/solver/solve_contacts.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Sequential-impulse contact solver. Partitions the touched contact set into
+ * islands (via {@link IslandBuilder}, owned by the PhysicsSystem and rebuilt
+ * upstream in the pipeline), then iterates each island independently.
+ *
+ * Per-island iteration matters for two reasons:
+ *  1. Impulse propagation converges inside an island without waiting for
+ *     unrelated bodies' Gauss-Seidel updates from previous outer loops.
+ *  2. Disconnected awake bodies don't pay each other's solver cost — adding
+ *     an unrelated active body to the scene scales O(island_size) rather than
+ *     O(global_active).
+ *
+ * Coulomb friction is applied as a disk clamp in the contact tangent plane.
+ * Position correction is folded into the velocity solve via Baumgarte bias.
+ *
+ * The `apply_warm_start` flag gates the warm-start impulse application.
+ * In a classic PGS call (one solve per tick), pass `true` (default) — the
+ * cached impulses from the previous tick get replayed onto the velocity,
+ * seeding the iterations near the converged answer. In TGS substepping,
+ * the PhysicsSystem calls this once per substep; only substep 0 should
+ * apply warm-start, because subsequent substeps continue from the solver
+ * state left by the previous substep (the impulses in `data` already
+ * reflect the current velocity, so re-applying them would double-count).
+ *
+ * Inertial: angular response uses the full world-frame inverse inertia
+ * `R · diag(I⁻¹_local) · R^T` via {@link world_inverse_inertia_apply},
+ * correct for arbitrary rotations + diagonal local inertia.
+ *
+ * @param {ManifoldStore} manifolds
+ * @param {PhysicsSystem} system  PhysicsSystem; reads `system.islands`.
+ * @param {number} dt step duration (full tick `dt` for PGS, sub-tick for TGS)
+ * @param {number} [iters]
+ * @param {boolean} [apply_warm_start]
+ */
+export function solve_contacts(manifolds: ManifoldStore, system: PhysicsSystem, dt: number, iters?: number, apply_warm_start?: boolean): void;
+//# sourceMappingURL=solve_contacts.d.ts.map

package/src/engine/physics/solver/solve_contacts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solve_contacts.d.ts","sourceRoot":"","sources":["../../../../../src/engine/physics/solver/solve_contacts.js"],"names":[],"mappings":"AAyQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oFAJW,MAAM,UACN,MAAM,qBACN,OAAO,QAoBjB"}