@woosh/meep-engine 2.169.1 → 2.169.2

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js

@@ -1,272 +1,281 @@
-import { v3_distance_sqr } from "../../../vec3/v3_distance_sqr.js";
-import { v3_dot } from "../../../vec3/v3_dot.js";
-import { array_get_index_in_range } from "../../../../collection/array/array_get_index_in_range.js";
-import { EPSILON } from "../../../../math/EPSILON.js";
-import { min2 } from "../../../../math/min2.js";
-import { query_edge_is_boundary } from "../query/query_edge_is_boundary.js";
-import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
-import { tm_edge_kill } from "../tm_edge_kill.js";
-import { tm_vertex_compute_normal } from "../tm_vertex_compute_normal.js";
-import { tm_edge_collapse } from "./edge_collapse_quadratic.js";
-import { compute_edge_collapse_cost_quadric } from "./quadratic/compute_edge_collapse_cost_quadric.js";
-import { tm_edge_collapse_is_degenerate_flip } from "./tm_edge_collapse_is_degenerate_flip.js";
-
-/**
- *
- * @type {TopoEdge[]}
- */
-const scratch_edges = [];
-
-
-const scratch_v3_0 = [];
-const scratch_v3_1 = [];
-
-/**
- *
- * @param {TopoVertex} v
- * @returns {number}
- */
-function edge_collapse_vertex_removal_cost(v) {
-    let result = 0;
-
-    const edges = v.edges;
-    const edge_count = edges.length;
-
-    for (let i = 0; i < edge_count; i++) {
-        const edge = edges[i];
-
-        if (query_edge_is_boundary(edge)) {
-            // prefer to preserve boundary
-            result += 100;
-        } else {
-            // prefer not to remove vertices that have lots of faces attached. This is to prevent cases where more and more faces are aggregated around a single vertex
-            result += 1;
-        }
-    }
-
-    return result;
-}
-
-/**
- *
- * @param {TopoEdge} edge
- * @returns {TopoVertex}
- */
-export function pick_lowest_cost_edge_collapse_vertex(edge) {
-    const v0 = edge.v0;
-    const v1 = edge.v1;
-
-    if (edge_collapse_vertex_removal_cost(v0) > edge_collapse_vertex_removal_cost(v1)) {
-        return v0;
-    } else {
-        return v1;
-    }
-}
-
-/**
- *
- * @param {TopoEdge} edge
- * @param {Set<number>} restricted_vertices locked vertices
- * @returns {TopoVertex|undefined}
- */
-export function edge_collapse_pick_target_vertex(edge, restricted_vertices) {
-
-    const v0 = edge.v0;
-    const v1 = edge.v1;
-
-    const v0_restricted = restricted_vertices.has(v0.index);
-    const v1_restricted = restricted_vertices.has(v1.index);
-
-    let expected_target;
-
-    if (v0_restricted && v1_restricted) {
-        return;
-    } else if (v0_restricted) {
-        if (tm_edge_collapse_is_degenerate_flip(edge, v0)) {
-            return;
-        } else {
-            expected_target = v0;
-        }
-    } else if (v1_restricted) {
-
-        if (tm_edge_collapse_is_degenerate_flip(edge, v1)) {
-            return;
-        } else {
-            expected_target = v1;
-        }
-    } else {
-        const v0_degenerate = tm_edge_collapse_is_degenerate_flip(edge, v0);
-        const v1_degenerate = tm_edge_collapse_is_degenerate_flip(edge, v1);
-        if (v0_degenerate && v1_degenerate) {
-            return;
-        } else if (v1_degenerate) {
-            expected_target = v0;
-        } else if (v0_degenerate) {
-            expected_target = v1;
-        } else {
-            expected_target = pick_lowest_cost_edge_collapse_vertex(edge);
-        }
-    }
-
-    return expected_target;
-}
-
-/**
- *
- * @param {TopoEdge} edge
- * @returns {number}
- */
-function build_edge_cost_squared_topology(edge) {
-    tm_vertex_compute_normal(scratch_v3_0, 0, edge.v0);
-    tm_vertex_compute_normal(scratch_v3_1, 0, edge.v1);
-
-    const distance_sqr = v3_distance_sqr(edge.v0.x, edge.v0.y, edge.v0.z, edge.v1.x, edge.v1.y, edge.v1.z);
-
-    let cost = Math.abs(v3_dot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2], scratch_v3_1[0], scratch_v3_1[1], scratch_v3_1[2]))
-        / min2(-distance_sqr, -EPSILON);
-
-    return cost;
-
-}
-
-
-/**
- *
- * @param {TopoEdge} edge
- * @param {Map<number,Quadric3>} quadratics
- * @param {Set<number>} restricted_vertices
- */
-export function compute_edge_collapse_cost(edge, quadratics, restricted_vertices) {
-    const expected_target = edge_collapse_pick_target_vertex(edge, restricted_vertices);
-
-    if (expected_target === undefined) {
-        return Number.POSITIVE_INFINITY;
-    }
-
-
-    const v0 = edge.v0;
-    const v1 = edge.v1;
-
-    let cost = compute_edge_collapse_cost_quadric(v0, v1, expected_target, quadratics);
-
-    // fallback to topology if quadratics are noise
-    if (cost < 1e-5) {
-        // subtracting cost to introduce minor possible variation in cost, to produce stable order
-        cost = build_edge_cost_squared_topology(edge) - cost;
-    }
-
-    return cost;
-}
-
-/**
- *
- * @param {TopoEdge} edge
- * @param {Map<number,Quadric3>} quadratics
- * @param {Uint32Heap} heap
- * @param {Set<number>} restricted_vertices
- */
-function tm_build_cost(edge, quadratics, heap, restricted_vertices) {
-    const index_in_heap = heap.find_index_by_id(edge.index);
-    if (index_in_heap === -1) {
-        // not in heap
-        return;
-    }
-
-    let cost = compute_edge_collapse_cost(edge, quadratics, restricted_vertices);
-
-    heap.__update_score_by_index(index_in_heap, cost);
-
-}
-
-/**
- *
- * @param {TopoMesh} mesh
- * @param {TopoEdge}edge
- * @param {TopoVertex} target
- * @param {Map<number,Quadric3>} quadratics
- * @param {Uint32Heap} heap
- * @param {Set<number>} restricted_vertices
- * @returns {boolean}
- */
-export function decimate_edge_collapse_snap(
-    mesh,
-    edge,
-    target,
-    quadratics,
-    heap,
-    restricted_vertices
-) {
-
-    if (!edge.isLinked()) {
-        // edge is not part of topology, this should never happen in practice
-        return false;
-    }
-
-    if (edge.v0 === edge.v1) {
-        // degenerate edge, don't touch
-        return false;
-    }
-
-    if (tm_edge_collapse_is_degenerate_flip(edge, target)) {
-        // re-insert into heap with very high cost
-        heap.insert(edge.index, Number.POSITIVE_INFINITY);
-        return false;
-    }
-
-    // update quadratics
-    const victim_vertex = query_edge_other_vertex(edge, target);
-
-    if (!tm_edge_collapse(mesh, edge, target)) {
-        // failed collapse
-        // re-insert into heap with very high cost
-        heap.insert(edge.index, Number.POSITIVE_INFINITY);
-        return false;
-    }
-
-
-    const q_a = quadratics.get(victim_vertex.index);
-    const q_b = quadratics.get(target.index);
-    q_b.add(q_a);
-
-    // TODO we can probably discount all original faces around the target vertex
-    // record affected edges
-    const attached_faces = target.faces;
-    const attached_face_count = attached_faces.length;
-
-    let dirty_edge_count = 0;
-
-    for (let i = 0; i < attached_face_count; i++) {
-        const face = attached_faces[i];
-
-        const edges = face.edges;
-        const edge_count = edges.length;
-
-        for (let j = 0; j < edge_count; j++) {
-
-            const topoEdge = edges[j];
-
-            if (array_get_index_in_range(scratch_edges, topoEdge, 0, dirty_edge_count - 1) === -1) {
-                scratch_edges[dirty_edge_count++] = topoEdge;
-            }
-        }
-
-    }
-
-    // update costs
-    for (let i = 0; i < dirty_edge_count; i++) {
-        const dirty_edge = scratch_edges[i];
-
-        if (dirty_edge.isDegenerateEdge()) {
-            heap.remove(dirty_edge.index);
-
-            tm_edge_kill(mesh, dirty_edge);
-
-        } else {
-
-            tm_build_cost(dirty_edge, quadratics, heap, restricted_vertices);
-
-        }
-    }
-
-    return true;
-}
+import { v3_distance_sqr } from "../../../vec3/v3_distance_sqr.js";
+import { v3_dot } from "../../../vec3/v3_dot.js";
+import { array_get_index_in_range } from "../../../../collection/array/array_get_index_in_range.js";
+import { EPSILON } from "../../../../math/EPSILON.js";
+import { min2 } from "../../../../math/min2.js";
+import { query_edge_is_boundary } from "../query/query_edge_is_boundary.js";
+import { query_edge_other_vertex } from "../query/query_edge_other_vertex.js";
+import { tm_edge_kill } from "../tm_edge_kill.js";
+import { tm_vertex_compute_normal } from "../tm_vertex_compute_normal.js";
+import { tm_edge_collapse } from "./edge_collapse_quadratic.js";
+import { compute_edge_collapse_cost_quadric } from "./quadratic/compute_edge_collapse_cost_quadric.js";
+import { tm_edge_collapse_is_degenerate_flip } from "./tm_edge_collapse_is_degenerate_flip.js";
+
+/**
+ *
+ * @type {TopoEdge[]}
+ */
+const scratch_edges = [];
+
+
+const scratch_v3_0 = [];
+const scratch_v3_1 = [];
+
+/**
+ *
+ * @param {TopoVertex} v
+ * @returns {number}
+ */
+function edge_collapse_vertex_removal_cost(v) {
+    let result = 0;
+
+    const edges = v.edges;
+    const edge_count = edges.length;
+
+    for (let i = 0; i < edge_count; i++) {
+        const edge = edges[i];
+
+        if (query_edge_is_boundary(edge)) {
+            // prefer to preserve boundary
+            result += 100;
+        } else {
+            // prefer not to remove vertices that have lots of faces attached. This is to prevent cases where more and more faces are aggregated around a single vertex
+            result += 1;
+        }
+    }
+
+    return result;
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @returns {TopoVertex}
+ */
+export function pick_lowest_cost_edge_collapse_vertex(edge) {
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    if (edge_collapse_vertex_removal_cost(v0) > edge_collapse_vertex_removal_cost(v1)) {
+        return v0;
+    } else {
+        return v1;
+    }
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Set<number>} restricted_vertices locked vertices
+ * @returns {TopoVertex|undefined}
+ */
+export function edge_collapse_pick_target_vertex(edge, restricted_vertices) {
+
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    const v0_restricted = restricted_vertices.has(v0.index);
+    const v1_restricted = restricted_vertices.has(v1.index);
+
+    let expected_target;
+
+    if (v0_restricted && v1_restricted) {
+        return;
+    } else if (v0_restricted) {
+        if (tm_edge_collapse_is_degenerate_flip(edge, v0)) {
+            return;
+        } else {
+            expected_target = v0;
+        }
+    } else if (v1_restricted) {
+
+        if (tm_edge_collapse_is_degenerate_flip(edge, v1)) {
+            return;
+        } else {
+            expected_target = v1;
+        }
+    } else {
+        const v0_degenerate = tm_edge_collapse_is_degenerate_flip(edge, v0);
+        const v1_degenerate = tm_edge_collapse_is_degenerate_flip(edge, v1);
+        if (v0_degenerate && v1_degenerate) {
+            return;
+        } else if (v1_degenerate) {
+            expected_target = v0;
+        } else if (v0_degenerate) {
+            expected_target = v1;
+        } else {
+            expected_target = pick_lowest_cost_edge_collapse_vertex(edge);
+        }
+    }
+
+    return expected_target;
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @returns {number}
+ */
+function build_edge_cost_squared_topology(edge) {
+    tm_vertex_compute_normal(scratch_v3_0, 0, edge.v0);
+    tm_vertex_compute_normal(scratch_v3_1, 0, edge.v1);
+
+    const distance_sqr = v3_distance_sqr(edge.v0.x, edge.v0.y, edge.v0.z, edge.v1.x, edge.v1.y, edge.v1.z);
+
+    let cost = Math.abs(v3_dot(scratch_v3_0[0], scratch_v3_0[1], scratch_v3_0[2], scratch_v3_1[0], scratch_v3_1[1], scratch_v3_1[2]))
+        / min2(-distance_sqr, -EPSILON);
+
+    return cost;
+
+}
+
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Map<number,Quadric3>} quadratics
+ * @param {Set<number>} restricted_vertices
+ */
+export function edge_collapse_cost_with_topology_fallback(edge, quadratics, restricted_vertices) {
+    const expected_target = edge_collapse_pick_target_vertex(edge, restricted_vertices);
+
+    if (expected_target === undefined) {
+        return Number.POSITIVE_INFINITY;
+    }
+
+
+    const v0 = edge.v0;
+    const v1 = edge.v1;
+
+    let cost = compute_edge_collapse_cost_quadric(v0, v1, expected_target, quadratics);
+
+    // fallback to topology if quadratics are noise
+    if (cost < 1e-5) {
+        // subtracting cost to introduce minor possible variation in cost, to produce stable order
+        cost = build_edge_cost_squared_topology(edge) - cost;
+    }
+
+    return cost;
+}
+
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Map<number,Quadric3>} quadratics
+ * @param {Uint32Heap} heap
+ * @param {Set<number>} restricted_vertices
+ */
+function tm_build_cost(edge, quadratics, heap, restricted_vertices) {
+    const index_in_heap = heap.find_index_by_id(edge.index);
+    if (index_in_heap === -1) {
+        // not in heap
+        return;
+    }
+
+    let cost = edge_collapse_cost_with_topology_fallback(edge, quadratics, restricted_vertices);
+
+    heap.__update_score_by_index(index_in_heap, cost);
+
+}
+
+/**
+ *
+ * @param {TopoMesh} mesh
+ * @param {TopoEdge}edge
+ * @param {TopoVertex} target
+ * @param {Map<number,Quadric3>} quadratics
+ * @param {Uint32Heap} heap
+ * @param {Set<number>} restricted_vertices
+ * @returns {boolean}
+ */
+export function decimate_edge_collapse_snap(
+    mesh,
+    edge,
+    target,
+    quadratics,
+    heap,
+    restricted_vertices
+) {
+
+    if (!edge.isLinked()) {
+        // edge is not part of topology, this should never happen in practice
+        return false;
+    }
+
+    if (edge.v0 === edge.v1) {
+        // degenerate edge, don't touch
+        return false;
+    }
+
+    if (tm_edge_collapse_is_degenerate_flip(edge, target)) {
+        // re-insert into heap with very high cost
+        heap.insert(edge.index, Number.POSITIVE_INFINITY);
+        return false;
+    }
+
+    // update quadratics
+    const victim_vertex = query_edge_other_vertex(edge, target);
+
+    if (!tm_edge_collapse(mesh, edge, target)) {
+        // failed collapse
+        // re-insert into heap with very high cost
+        heap.insert(edge.index, Number.POSITIVE_INFINITY);
+        return false;
+    }
+
+
+    const q_a = quadratics.get(victim_vertex.index);
+    const q_b = quadratics.get(target.index);
+    q_b.add(q_a);
+
+    // TODO we can probably discount all original faces around the target vertex
+    // record affected edges
+    const attached_faces = target.faces;
+    const attached_face_count = attached_faces.length;
+
+    let dirty_edge_count = 0;
+
+    for (let i = 0; i < attached_face_count; i++) {
+        const face = attached_faces[i];
+
+        const edges = face.edges;
+        const edge_count = edges.length;
+
+        for (let j = 0; j < edge_count; j++) {
+
+            const topoEdge = edges[j];
+
+            if (array_get_index_in_range(scratch_edges, topoEdge, 0, dirty_edge_count - 1) === -1) {
+                scratch_edges[dirty_edge_count++] = topoEdge;
+            }
+        }
+
+    }
+
+    // update costs
+    for (let i = 0; i < dirty_edge_count; i++) {
+        const dirty_edge = scratch_edges[i];
+
+        if (dirty_edge.isDegenerateEdge()) {
+            heap.remove(dirty_edge.index);
+
+            tm_edge_kill(mesh, dirty_edge);
+
+        } else {
+
+            tm_build_cost(dirty_edge, quadratics, heap, restricted_vertices);
+
+        }
+    }
+
+    return true;
+}
+
+/**
+ * @deprecated Renamed to {@link edge_collapse_cost_with_topology_fallback}. The old name collided with the
+ * unrelated {@link compute_edge_collapse_cost} exported by the sibling `compute_edge_collapse_cost.js`,
+ * which uses a different cost model and a different signature — importing "the" collapse cost from this
+ * package resolved to whichever path you happened to type. Kept for backward compatibility (meep is a
+ * library; old names are public surface).
+ */
+export const compute_edge_collapse_cost = edge_collapse_cost_with_topology_fallback;

package/src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadrics.js"],"names":[],"mappings":"AA+BA;;;;;;GAMG;AACH,qHAwDC"}
+{"version":3,"file":"build_vertex_quadrics.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadrics.js"],"names":[],"mappings":"AA8BA;;;;;;GAMG;AACH,qHAwDC"}

package/src/core/geom/3d/topology/simplify/quadratic/build_vertex_quadrics.js

@@ -1,3 +1,4 @@
+import { quadric3_set_from_plane_through_point } from "./quadric3_set_from_plane_through_point.js";
 import { v3_dot } from "../../../../vec3/v3_dot.js";
 import { query_edge_is_boundary } from "../../query/query_edge_is_boundary.js";
 import { tm_face_area } from "../../tm_face_area.js";
@@ -20,13 +21,11 @@ function quadric_set_from_face(quadric, face) {
     const normal_y = face.normal[1];
     const normal_z = face.normal[2];
 
-    const plane_constant = -v3_dot(
+    quadric3_set_from_plane_through_point(
+        quadric,
         normal_x, normal_y, normal_z,
-
         v0.x, v0.y, v0.z
     );
-
-    quadric.setFromVector4(normal_x, normal_y, normal_z, plane_constant);
 }
 
 /**

package/src/core/geom/3d/topology/simplify/quadratic/quadric3_set_from_plane_through_point.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Set a quadric to the fundamental error quadric of the plane with normal `(nx, ny, nz)` passing through
+ * `(px, py, pz)` — that is, `K_p = p p^T` for the plane `(n, d)` with `d = -(n . point)`.
+ *
+ * This is the shared tail of every "accumulate a face's plane onto its vertices" loop. Only this part is
+ * shared deliberately: callers derive the normal differently and legitimately (a cached `face.normal` on
+ * the object mesh, `tri3_compute_normal` on the typed-array mesh), so the normal computation stays with
+ * the caller while the plane-offset convention lives here once.
+ *
+ * @param {Quadric3} quadric destination, overwritten
+ * @param {number} nx plane normal x
+ * @param {number} ny plane normal y
+ * @param {number} nz plane normal z
+ * @param {number} px a point on the plane, x
+ * @param {number} py a point on the plane, y
+ * @param {number} pz a point on the plane, z
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_set_from_plane_through_point(quadric: Quadric3, nx: number, ny: number, nz: number, px: number, py: number, pz: number): void;
+//# sourceMappingURL=quadric3_set_from_plane_through_point.d.ts.map

package/src/core/geom/3d/topology/simplify/quadratic/quadric3_set_from_plane_through_point.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quadric3_set_from_plane_through_point.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/topology/simplify/quadratic/quadric3_set_from_plane_through_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,6EAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAShB"}

package/src/core/geom/3d/topology/simplify/quadratic/quadric3_set_from_plane_through_point.js

@@ -0,0 +1,27 @@
+import { v3_dot } from "../../../../vec3/v3_dot.js";
+
+/**
+ * Set a quadric to the fundamental error quadric of the plane with normal `(nx, ny, nz)` passing through
+ * `(px, py, pz)` — that is, `K_p = p p^T` for the plane `(n, d)` with `d = -(n . point)`.
+ *
+ * This is the shared tail of every "accumulate a face's plane onto its vertices" loop. Only this part is
+ * shared deliberately: callers derive the normal differently and legitimately (a cached `face.normal` on
+ * the object mesh, `tri3_compute_normal` on the typed-array mesh), so the normal computation stays with
+ * the caller while the plane-offset convention lives here once.
+ *
+ * @param {Quadric3} quadric destination, overwritten
+ * @param {number} nx plane normal x
+ * @param {number} ny plane normal y
+ * @param {number} nz plane normal z
+ * @param {number} px a point on the plane, x
+ * @param {number} py a point on the plane, y
+ * @param {number} pz a point on the plane, z
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_set_from_plane_through_point(quadric, nx, ny, nz, px, py, pz) {
+    const plane_constant = -v3_dot(nx, ny, nz, px, py, pz);
+
+    quadric.setFromVector4(nx, ny, nz, plane_constant);
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Walk an unordered set of boundary edges forming a single closed cycle into traversal order, starting at
+ * `start_vertex`.
+ *
+ * Writes the cycle's vertices into `out_vertices[0..n-1]` and, at each index, the edge LEAVING that vertex
+ * into `out_edges[0..n-1]` — so `out_edges[i]` joins `out_vertices[i]` to `out_vertices[(i + 1) % n]`.
+ *
+ * PRECONDITION: `cycle` is a single closed loop in which every vertex has exactly two incident edges. That
+ * is what the boundary-extraction pass produces; a figure-of-eight or an open chain would walk off.
+ *
+ * Shared by {@link bt_mesh_close_boundary_holes} and {@link bt_mesh_fill_small_holes}, which each carried
+ * a byte-identical copy.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[]|Uint32Array} cycle unordered boundary edge ids
+ * @param {number} start_vertex vertex to begin the walk at; must be an endpoint of some edge in `cycle`
+ * @param {number[]|Uint32Array} out_vertices destination, at least `cycle.length` long
+ * @param {number[]|Uint32Array} out_edges destination, at least `cycle.length` long
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function bt_boundary_loop_order_from(mesh: BinaryTopology, cycle: number[] | Uint32Array, start_vertex: number, out_vertices: number[] | Uint32Array, out_edges: number[] | Uint32Array): void;
+//# sourceMappingURL=bt_boundary_loop.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_boundary_loop.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_boundary_loop.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yEARW,MAAM,EAAE,GAAC,WAAW,gBACpB,MAAM,gBACN,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,EAAE,GAAC,WAAW,QAuD9B"}