@woosh/meep-engine 2.164.0 → 2.165.0

package/src/core/geom/3d/atlas/data/atlas_build_edge_dihedrals.js

@@ -0,0 +1,62 @@
+import { v3_dot } from "../../../vec3/v3_dot.js";
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+
+/**
+ * Sentinel value for an edge that does not have two adjacent faces (mesh
+ * boundary, wire edge, or unallocated). Chosen outside the valid cosine range
+ * [-1, 1] so it is unambiguous. xatlas uses FLT_MAX for the same purpose.
+ * @type {number}
+ */
+export const EDGE_DIHEDRAL_BOUNDARY = 2;
+
+const n1 = new Float32Array(3);
+const n2 = new Float32Array(3);
+
+/**
+ * Per-edge dihedral measure: the dot product of the two adjacent (unit) face
+ * normals. 1 = coplanar/flat, 0 = 90 degree fold, -1 = fully folded back.
+ * Boundary/wire/unallocated edges get {@link EDGE_DIHEDRAL_BOUNDARY}.
+ *
+ * For a non-manifold edge (>2 incident faces) the first radial pair is used.
+ *
+ * Precondition: face normals are populated (call
+ * {@link bt_mesh_compute_face_normals} first).
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Float32Array} length mesh.edges.size
+ */
+export function atlas_build_edge_dihedrals(mesh) {
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+    const out = new Float32Array(edge_count);
+
+    for (let e = 0; e < edge_count; e++) {
+        if (!edges.is_allocated(e)) {
+            out[e] = EDGE_DIHEDRAL_BOUNDARY;
+            continue;
+        }
+
+        const l1 = mesh.edge_read_loop(e);
+        if (l1 === NULL_POINTER) {
+            out[e] = EDGE_DIHEDRAL_BOUNDARY;
+            continue;
+        }
+
+        const l2 = mesh.loop_read_radial_next(l1);
+        if (l2 === l1) {
+            // single radial loop -> boundary edge
+            out[e] = EDGE_DIHEDRAL_BOUNDARY;
+            continue;
+        }
+
+        mesh.face_read_normal(n1, 0, mesh.loop_read_face(l1));
+        mesh.face_read_normal(n2, 0, mesh.loop_read_face(l2));
+
+        out[e] = v3_dot(
+            n1[0], n1[1], n1[2],
+            n2[0], n2[1], n2[2]
+        );
+    }
+
+    return out;
+}

package/src/core/geom/3d/atlas/data/atlas_build_edge_lengths.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Per-edge length, indexed by edge id. Unallocated edges are left at 0.
+ * Mirrors xatlas `AtlasData::edgeLengths`.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Float32Array} length mesh.edges.size
+ */
+export function atlas_build_edge_lengths(mesh: BinaryTopology): Float32Array;
+//# sourceMappingURL=atlas_build_edge_lengths.d.ts.map

package/src/core/geom/3d/atlas/data/atlas_build_edge_lengths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_build_edge_lengths.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/data/atlas_build_edge_lengths.js"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,gEAFa,YAAY,CAsBxB"}

package/src/core/geom/3d/atlas/data/atlas_build_edge_lengths.js

@@ -0,0 +1,33 @@
+import { v3_distance_sqr } from "../../../vec3/v3_distance_sqr.js";
+
+const v1 = new Float32Array(3);
+const v2 = new Float32Array(3);
+
+/**
+ * Per-edge length, indexed by edge id. Unallocated edges are left at 0.
+ * Mirrors xatlas `AtlasData::edgeLengths`.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Float32Array} length mesh.edges.size
+ */
+export function atlas_build_edge_lengths(mesh) {
+    const edges = mesh.edges;
+    const edge_count = edges.size;
+    const out = new Float32Array(edge_count);
+
+    for (let e = 0; e < edge_count; e++) {
+        if (!edges.is_allocated(e)) {
+            continue;
+        }
+
+        mesh.vertex_read_coordinate(v1, 0, mesh.edge_read_vertex1(e));
+        mesh.vertex_read_coordinate(v2, 0, mesh.edge_read_vertex2(e));
+
+        out[e] = Math.sqrt(v3_distance_sqr(
+            v1[0], v1[1], v1[2],
+            v2[0], v2[1], v2[2]
+        ));
+    }
+
+    return out;
+}

package/src/core/geom/3d/atlas/data/atlas_build_face_areas.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Per-face 3D surface area, indexed by face id. Non-triangular and unallocated
+ * faces are left at 0. Mirrors xatlas `AtlasData::faceAreas`.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Float32Array} length mesh.faces.size
+ */
+export function atlas_build_face_areas(mesh: BinaryTopology): Float32Array;
+//# sourceMappingURL=atlas_build_face_areas.d.ts.map

package/src/core/geom/3d/atlas/data/atlas_build_face_areas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_build_face_areas.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/data/atlas_build_face_areas.js"],"names":[],"mappings":"AAOA;;;;;;GAMG;AACH,8DAFa,YAAY,CAqCxB"}

package/src/core/geom/3d/atlas/data/atlas_build_face_areas.js

@@ -0,0 +1,50 @@
+import { tri3_area } from "../../triangle/tri3_area.js";
+import { NULL_POINTER } from "../../topology/struct/binary/BinaryTopology.js";
+
+const a = new Float32Array(3);
+const b = new Float32Array(3);
+const c = new Float32Array(3);
+
+/**
+ * Per-face 3D surface area, indexed by face id. Non-triangular and unallocated
+ * faces are left at 0. Mirrors xatlas `AtlasData::faceAreas`.
+ *
+ * @param {BinaryTopology} mesh
+ * @returns {Float32Array} length mesh.faces.size
+ */
+export function atlas_build_face_areas(mesh) {
+    const faces = mesh.faces;
+    const face_count = faces.size;
+    const out = new Float32Array(face_count);
+
+    for (let f = 0; f < face_count; f++) {
+        if (!faces.is_allocated(f)) {
+            continue;
+        }
+
+        const l0 = mesh.face_read_loop(f);
+        if (l0 === NULL_POINTER) {
+            continue;
+        }
+
+        const l1 = mesh.loop_read_next(l0);
+        const l2 = mesh.loop_read_next(l1);
+
+        // triangle only
+        if (mesh.loop_read_next(l2) !== l0) {
+            continue;
+        }
+
+        mesh.vertex_read_coordinate(a, 0, mesh.loop_read_vertex(l0));
+        mesh.vertex_read_coordinate(b, 0, mesh.loop_read_vertex(l1));
+        mesh.vertex_read_coordinate(c, 0, mesh.loop_read_vertex(l2));
+
+        out[f] = tri3_area(
+            a[0], a[1], a[2],
+            b[0], b[1], b[2],
+            c[0], c[1], c[2]
+        );
+    }
+
+    return out;
+}

package/src/core/geom/3d/atlas/io/atlas_mesh_weld_colocals.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Condition a mesh for charting by welding spatially-coincident topology:
+ *
+ *  1. fuse coincident vertex positions so neighbouring triangles share a vertex
+ *     id ({@link bt_merge_vertices_by_distance});
+ *  2. fuse the resulting duplicate edges so neighbours share an edge id too —
+ *     this is what radial/loop neighbour queries (segmentation flood-fill,
+ *     dihedral, boundary detection) rely on ({@link bt_mesh_fuse_duplicate_edges});
+ *  3. resolve T-junctions (a face corner landing on another face's edge leaves
+ *     them touching at a single vertex, invisible to edge-based adjacency), then
+ *     re-merge/re-fuse.
+ *
+ * This is the same sequence the navmesh builder uses; xatlas `createColocals` +
+ * boundary fixup is the conceptual equivalent. Duplicate vertices left unlinked
+ * by the merge are harmless to charting (they are simply unreferenced).
+ *
+ * @param {BinaryTopology} mesh mutated in place
+ * @param {number} [max_distance]
+ */
+export function atlas_mesh_weld_colocals(mesh: BinaryTopology, max_distance?: number): void;
+/**
+ * Default colocal-merge distance. Positions closer than this are treated as the
+ * same point.
+ * @type {number}
+ */
+export const ATLAS_WELD_EPSILON: number;
+//# sourceMappingURL=atlas_mesh_weld_colocals.d.ts.map

package/src/core/geom/3d/atlas/io/atlas_mesh_weld_colocals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_mesh_weld_colocals.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/io/atlas_mesh_weld_colocals.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;GAkBG;AACH,8EAFW,MAAM,QAUhB;AAlCD;;;;GAIG;AACH,iCAFU,MAAM,CAEuB"}

package/src/core/geom/3d/atlas/io/atlas_mesh_weld_colocals.js

@@ -0,0 +1,39 @@
+import { bt_mesh_resolve_t_junctions } from "../../topology/struct/binary/io/bt_mesh_resolve_t_junctions.js";
+import { bt_mesh_fuse_duplicate_edges } from "../../topology/struct/binary/io/edge/bt_mesh_fuse_duplicate_edges.js";
+import { bt_merge_vertices_by_distance } from "../../topology/struct/binary/io/vertex/bt_merge_vertices_by_distance.js";
+
+/**
+ * Default colocal-merge distance. Positions closer than this are treated as the
+ * same point.
+ * @type {number}
+ */
+export const ATLAS_WELD_EPSILON = 1e-6;
+
+/**
+ * Condition a mesh for charting by welding spatially-coincident topology:
+ *
+ *  1. fuse coincident vertex positions so neighbouring triangles share a vertex
+ *     id ({@link bt_merge_vertices_by_distance});
+ *  2. fuse the resulting duplicate edges so neighbours share an edge id too —
+ *     this is what radial/loop neighbour queries (segmentation flood-fill,
+ *     dihedral, boundary detection) rely on ({@link bt_mesh_fuse_duplicate_edges});
+ *  3. resolve T-junctions (a face corner landing on another face's edge leaves
+ *     them touching at a single vertex, invisible to edge-based adjacency), then
+ *     re-merge/re-fuse.
+ *
+ * This is the same sequence the navmesh builder uses; xatlas `createColocals` +
+ * boundary fixup is the conceptual equivalent. Duplicate vertices left unlinked
+ * by the merge are harmless to charting (they are simply unreferenced).
+ *
+ * @param {BinaryTopology} mesh mutated in place
+ * @param {number} [max_distance]
+ */
+export function atlas_mesh_weld_colocals(mesh, max_distance = ATLAS_WELD_EPSILON) {
+    bt_merge_vertices_by_distance(mesh, max_distance);
+    bt_mesh_fuse_duplicate_edges(mesh);
+
+    if (bt_mesh_resolve_t_junctions(mesh, max_distance * 100) > 0) {
+        bt_merge_vertices_by_distance(mesh, max_distance);
+        bt_mesh_fuse_duplicate_edges(mesh);
+    }
+}

package/src/core/geom/3d/atlas/io/bt_loop_uv.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Ensure the mesh has a loop_data pool sized for UV storage. Idempotent.
+ * Call once after the mesh topology is final and before writing UVs.
+ *
+ * @param {BinaryTopology} mesh
+ */
+export function bt_loop_uv_init(mesh: BinaryTopology): void;
+/**
+ * @param {BinaryTopology} mesh must have had {@link bt_loop_uv_init} called
+ * @param {number} loop_id
+ * @param {number} u
+ * @param {number} v
+ */
+export function bt_loop_write_uv(mesh: BinaryTopology, loop_id: number, u: number, v: number): void;
+/**
+ * @param {Float32Array|number[]} out
+ * @param {number} out_offset
+ * @param {BinaryTopology} mesh must have had {@link bt_loop_uv_init} called
+ * @param {number} loop_id
+ */
+export function bt_loop_read_uv(out: Float32Array | number[], out_offset: number, mesh: BinaryTopology, loop_id: number): void;
+//# sourceMappingURL=bt_loop_uv.d.ts.map

package/src/core/geom/3d/atlas/io/bt_loop_uv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_loop_uv.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/io/bt_loop_uv.js"],"names":[],"mappings":"AAeA;;;;;GAKG;AACH,4DAOC;AAED;;;;;GAKG;AACH,gEAJW,MAAM,KACN,MAAM,KACN,MAAM,QAQhB;AAED;;;;;GAKG;AACH,qCALW,YAAY,GAAC,MAAM,EAAE,cACrB,MAAM,iCAEN,MAAM,QAQhB"}

package/src/core/geom/3d/atlas/io/bt_loop_uv.js

@@ -0,0 +1,57 @@
+/**
+ * Per-corner (per-loop) UV storage on a {@link BinaryTopology}, backed by the
+ * optional loop_data pool. UVs live on loops (not vertices) so that one
+ * geometric vertex shared by several charts carries a distinct UV per chart —
+ * which is exactly how a seam is represented. Two floats per loop: (u, v).
+ *
+ * Related: [[project_xatlas_port]] output channel.
+ */
+
+/**
+ * Bytes per loop UV record: two float32 (u, v).
+ * @type {number}
+ */
+const UV_ITEM_BYTES = 8;
+
+/**
+ * Ensure the mesh has a loop_data pool sized for UV storage. Idempotent.
+ * Call once after the mesh topology is final and before writing UVs.
+ *
+ * @param {BinaryTopology} mesh
+ */
+export function bt_loop_uv_init(mesh) {
+    if (mesh.loop_data === null) {
+        mesh.create_loop_data(UV_ITEM_BYTES);
+    }
+    // Raw addressing (element_word) requires the float buffer to span every
+    // loop id; the data pool is not driven through its allocator here.
+    mesh.loop_data.ensure_capacity(mesh.loops.capacity);
+}
+
+/**
+ * @param {BinaryTopology} mesh must have had {@link bt_loop_uv_init} called
+ * @param {number} loop_id
+ * @param {number} u
+ * @param {number} v
+ */
+export function bt_loop_write_uv(mesh, loop_id, u, v) {
+    const pool = mesh.loop_data;
+    const w = pool.element_word(loop_id);
+    const f = pool.data_float32;
+    f[w] = u;
+    f[w + 1] = v;
+}
+
+/**
+ * @param {Float32Array|number[]} out
+ * @param {number} out_offset
+ * @param {BinaryTopology} mesh must have had {@link bt_loop_uv_init} called
+ * @param {number} loop_id
+ */
+export function bt_loop_read_uv(out, out_offset, mesh, loop_id) {
+    const pool = mesh.loop_data;
+    const w = pool.element_word(loop_id);
+    const f = pool.data_float32;
+    out[out_offset] = f[w];
+    out[out_offset + 1] = f[w + 1];
+}

package/src/core/geom/3d/atlas/pack/ChartPlacement.d.ts

@@ -0,0 +1,36 @@
+/**
+ * One chart's placement record during {@link atlas_pack_charts}: its texel-space
+ * transform, its padding-inflated rect size, the coverage masks for the bitmap
+ * packer, and the page / position / rotation chosen by the packer. Built per
+ * density attempt by `build_packs` and mutated in place by the placement passes.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ChartPlacement {
+    /** The chart being placed. @type {Chart} */
+    chart: Chart;
+    /** Texels per UV unit for this chart. @type {number} */
+    scale: number;
+    /** Min u of the chart's UV bbox (subtracted before scaling). @type {number} */
+    min_u: number;
+    /** Min v of the chart's UV bbox. @type {number} */
+    min_v: number;
+    /** Padding-inflated rect width, texels. @type {number} */
+    w: number;
+    /** Padding-inflated rect height, texels. @type {number} */
+    h: number;
+    /** Coverage mask for the bitmap packer; null for the skyline packer. @type {BitImage2|null} */
+    mask: BitImage2 | null;
+    /** Transposed coverage mask (90-degree orientation); null if rotation off / skyline. @type {BitImage2|null} */
+    mask_t: BitImage2 | null;
+    /** Atlas page the chart was placed onto. @type {number} */
+    page: number;
+    /** Placement x within the page, texels. @type {number} */
+    x: number;
+    /** Placement y within the page, texels. @type {number} */
+    y: number;
+    /** Placement rotation: 0 = unrotated, 1 = 90 degrees. @type {number} */
+    rot: number;
+}
+//# sourceMappingURL=ChartPlacement.d.ts.map

package/src/core/geom/3d/atlas/pack/ChartPlacement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChartPlacement.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/pack/ChartPlacement.js"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH;IACI,4CAA4C;IAC5C,aAAa;IAEb,wDAAwD;IACxD,OAD8C,MAAM,CAC1C;IAEV,+EAA+E;IAC/E,OADqE,MAAM,CACjE;IAEV,mDAAmD;IACnD,OADyC,MAAM,CACrC;IAEV,0DAA0D;IAC1D,GADgD,MAAM,CAChD;IAEN,2DAA2D;IAC3D,GADiD,MAAM,CACjD;IAEN,+FAA+F;IAC/F,MAD6E,YAAU,IAAI,CAC/E;IAEZ,+GAA+G;IAC/G,QAD6F,YAAU,IAAI,CAC7F;IAEd,2DAA2D;IAC3D,MADiD,MAAM,CAC9C;IAET,0DAA0D;IAC1D,GADgD,MAAM,CAChD;IAEN,0DAA0D;IAC1D,GADgD,MAAM,CAChD;IAEN,wEAAwE;IACxE,KAD8D,MAAM,CAC5D;CACX"}

package/src/core/geom/3d/atlas/pack/ChartPlacement.js

@@ -0,0 +1,46 @@
+/**
+ * One chart's placement record during {@link atlas_pack_charts}: its texel-space
+ * transform, its padding-inflated rect size, the coverage masks for the bitmap
+ * packer, and the page / position / rotation chosen by the packer. Built per
+ * density attempt by `build_packs` and mutated in place by the placement passes.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class ChartPlacement {
+    /** The chart being placed. @type {Chart} */
+    chart = null;
+
+    /** Texels per UV unit for this chart. @type {number} */
+    scale = 0;
+
+    /** Min u of the chart's UV bbox (subtracted before scaling). @type {number} */
+    min_u = 0;
+
+    /** Min v of the chart's UV bbox. @type {number} */
+    min_v = 0;
+
+    /** Padding-inflated rect width, texels. @type {number} */
+    w = 0;
+
+    /** Padding-inflated rect height, texels. @type {number} */
+    h = 0;
+
+    /** Coverage mask for the bitmap packer; null for the skyline packer. @type {BitImage2|null} */
+    mask = null;
+
+    /** Transposed coverage mask (90-degree orientation); null if rotation off / skyline. @type {BitImage2|null} */
+    mask_t = null;
+
+    /** Atlas page the chart was placed onto. @type {number} */
+    page = 0;
+
+    /** Placement x within the page, texels. @type {number} */
+    x = 0;
+
+    /** Placement y within the page, texels. @type {number} */
+    y = 0;
+
+    /** Placement rotation: 0 = unrotated, 1 = 90 degrees. @type {number} */
+    rot = 0;
+}

package/src/core/geom/3d/atlas/pack/atlas_pack_charts.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pack parameterized charts into one or more atlas pages (xatlas `PackCharts`),
+ * mutating each chart in place: its `uv` becomes final atlas-space [0,1]
+ * coordinates and `atlas_page`/`atlas_x`/`atlas_y`/`atlas_rotated` record its
+ * placement. Charts are pre-rotated to their min-area box and may be placed
+ * 90-degrees rotated for density.
+ *
+ * This works purely at the {@link Chart} level — no mesh — so charts from several
+ * different meshes can be packed into a single shared atlas. To write the packed
+ * UVs back onto a mesh, call {@link atlas_write_chart_uvs} (once per source mesh).
+ *
+ * Placement strategy is chosen by atlas size: small atlases use the exact
+ * bitmap shifted-OR `canBlit` packer (tight, non-rectangular interlocking);
+ * large atlases use the fast O(n) skyline rectangle packer (so packing scales).
+ * `bruteForce: true` forces the bitmap packer regardless of size.
+ *
+ * Page modes:
+ *  - `maxResolution = 0` (default): a single page that grows by powers of two.
+ *  - `maxResolution > 0`, `maxPages = 1` (default): one fixed-size page with
+ *    **elastic density** — density shrinks until the charts fit.
+ *  - `maxResolution > 0`, `maxPages > 1`: spill into up to `maxPages` fixed-size
+ *    pages at fixed density (`maxPages = Infinity` = pure fixed-density spill).
+ *
+ * @param {Chart[]} charts from {@link atlas_compute_charts} (mutated: `uv` + placement)
+ * @param {object} [options]
+ * @param {number} [options.padding] gutter texels (default 1)
+ * @param {number} [options.resolution] start/target size for the growing page; 0 = auto
+ * @param {number} [options.texelsPerUnit] texel density; 0 = auto
+ * @param {number} [options.maxResolution] fixed page size; 0 = unbounded growing page (default 0)
+ * @param {number} [options.maxPages] page cap; density is elastic to honour it (default 1)
+ * @param {boolean} [options.bruteForce] force the exact bitmap packer (default false)
+ * @param {boolean} [options.rotateChartsToAxis] align charts to their OBB (default true)
+ * @param {boolean} [options.rotateCharts] allow 90-degree placement (default true)
+ * @returns {{pages: Array<{width:number, height:number, occupied_texels:number, utilization:number}>,
+ *   page_count:number, atlas_width:number, atlas_height:number, utilization:number,
+ *   occupied_texels:number, mask_texels_total:number, charts:Chart[]}}
+ */
+export function atlas_pack_charts(charts: Chart[], options?: {
+    padding?: number;
+    resolution?: number;
+    texelsPerUnit?: number;
+    maxResolution?: number;
+    maxPages?: number;
+    bruteForce?: boolean;
+    rotateChartsToAxis?: boolean;
+    rotateCharts?: boolean;
+}): {
+    pages: Array<{
+        width: number;
+        height: number;
+        occupied_texels: number;
+        utilization: number;
+    }>;
+    page_count: number;
+    atlas_width: number;
+    atlas_height: number;
+    utilization: number;
+    occupied_texels: number;
+    mask_texels_total: number;
+    charts: Chart[];
+};
+//# sourceMappingURL=atlas_pack_charts.d.ts.map

package/src/core/geom/3d/atlas/pack/atlas_pack_charts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atlas_pack_charts.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/atlas/pack/atlas_pack_charts.js"],"names":[],"mappings":"AA4XA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,0CAdW,OAAO;IAEU,OAAO,GAAxB,MAAM;IACW,UAAU,GAA3B,MAAM;IACW,aAAa,GAA9B,MAAM;IACW,aAAa,GAA9B,MAAM;IACW,QAAQ,GAAzB,MAAM;IACY,UAAU,GAA5B,OAAO;IACW,kBAAkB,GAApC,OAAO;IACW,YAAY,GAA9B,OAAO;;WACG,MAAM;QAAC,KAAK,EAAC,MAAM,CAAC;QAAC,MAAM,EAAC,MAAM,CAAC;QAAC,eAAe,EAAC,MAAM,CAAC;QAAC,WAAW,EAAC,MAAM,CAAA;KAAC,CAAC;gBACrF,MAAM;iBAAc,MAAM;kBAAe,MAAM;iBAAc,MAAM;qBAC9D,MAAM;uBAAoB,MAAM;YAAS,OAAO;EAuIpE"}