@woosh/meep-engine 2.155.0 → 2.156.0

package/src/core/geom/3d/sphere/sphere_raycast.js

@@ -0,0 +1,47 @@
+/**
+ * Ray ↔ sphere intersection in the sphere's LOCAL frame: the sphere is centred
+ * at the origin with radius `r`, and the ray is expressed in that frame. Returns
+ * the hit distance `t` along the ray and writes the outward unit surface normal
+ * into `outNormal[outOffset .. outOffset+2]`.
+ *
+ * Conventions (shared with {@link box3_raycast} / {@link capsule_raycast}):
+ *  - the ray direction is assumed UNIT length, so `t` is a true distance;
+ *  - the first surface crossing at or after the origin within `tMax` is
+ *    returned; a ray starting INSIDE the sphere returns its exit crossing;
+ *  - on a miss the function returns `Infinity` and leaves `outNormal` untouched.
+ *
+ * Distinct from {@link sphere_intersects_ray}, which is a boolean predicate;
+ * this yields the distance and the surface normal — what a raycast query /
+ * narrowphase needs.
+ *
+ * @param {Float64Array|number[]} outNormal destination for the unit normal
+ * @param {number} outOffset offset into `outNormal` (3 floats are written)
+ * @param {number} ox ray origin x (local)
+ * @param {number} oy ray origin y (local)
+ * @param {number} oz ray origin z (local)
+ * @param {number} dx ray direction x (local, unit)
+ * @param {number} dy ray direction y (local, unit)
+ * @param {number} dz ray direction z (local, unit)
+ * @param {number} tMax maximum ray distance
+ * @param {number} r sphere radius
+ * @returns {number} hit distance `t`, or `Infinity` on a miss
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function sphere_raycast(outNormal, outOffset, ox, oy, oz, dx, dy, dz, tMax, r) {
+    // |o + t·d|² = r², d unit → t² + 2(o·d)t + (|o|² − r²) = 0.
+    const b = ox * dx + oy * dy + oz * dz;
+    const c = ox * ox + oy * oy + oz * oz - r * r;
+    const disc = b * b - c;
+    if (disc < 0) return Infinity;
+    const sq = Math.sqrt(disc);
+    let t = -b - sq;             // near root (entry)
+    if (t < 0) t = -b + sq;      // origin inside the sphere → far root (exit)
+    if (t < 0 || t > tMax) return Infinity;
+    const inv = 1 / r;
+    outNormal[outOffset] = (ox + dx * t) * inv;
+    outNormal[outOffset + 1] = (oy + dy * t) * inv;
+    outNormal[outOffset + 2] = (oz + dz * t) * inv;
+    return t;
+}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_tet_get_neighbours.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Write the face-adjacent neighbour tetrahedra of `tet_id` into `out`,
+ * non-allocating, and return how many were written.
+ *
+ * A tetrahedron has up to four neighbours — one across each face — and a face on
+ * the mesh surface has none. {@link TetrahedralMesh} stores this adjacency
+ * directly: neighbour slot `i` is the tet across the face opposite vertex `i`,
+ * encoded as `[tet_id:30][opposite_corner:2]` (or {@link INVALID_NEIGHBOUR} for a
+ * surface face). This decodes the tet ids (`encoded >>> 2`, an UNSIGNED shift so
+ * 30-bit ids near the top of the range survive) and skips surface faces, packing
+ * the survivors contiguously from `out_offset`.
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Int32Array|Uint32Array|number[]} out destination for neighbour tet ids
+ *   (needs room for up to 4 entries from `out_offset`)
+ * @param {number} out_offset offset into `out` at which to start writing
+ * @param {number} tet_id tetrahedron whose neighbours to read
+ * @returns {number} number of neighbours written (0..4); surface faces are skipped
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tetrahedral_mesh_tet_get_neighbours(mesh: TetrahedralMesh, out: Int32Array | Uint32Array | number[], out_offset: number, tet_id: number): number;
+//# sourceMappingURL=tetrahedral_mesh_tet_get_neighbours.d.ts.map

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_tet_get_neighbours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tetrahedral_mesh_tet_get_neighbours.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_tet_get_neighbours.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,gFATW,UAAU,GAAC,WAAW,GAAC,MAAM,EAAE,cAE/B,MAAM,UACN,MAAM,GACJ,MAAM,CAkBlB"}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_tet_get_neighbours.js

@@ -0,0 +1,39 @@
+import { assert } from "../../../assert.js";
+import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
+
+/**
+ * Write the face-adjacent neighbour tetrahedra of `tet_id` into `out`,
+ * non-allocating, and return how many were written.
+ *
+ * A tetrahedron has up to four neighbours — one across each face — and a face on
+ * the mesh surface has none. {@link TetrahedralMesh} stores this adjacency
+ * directly: neighbour slot `i` is the tet across the face opposite vertex `i`,
+ * encoded as `[tet_id:30][opposite_corner:2]` (or {@link INVALID_NEIGHBOUR} for a
+ * surface face). This decodes the tet ids (`encoded >>> 2`, an UNSIGNED shift so
+ * 30-bit ids near the top of the range survive) and skips surface faces, packing
+ * the survivors contiguously from `out_offset`.
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {Int32Array|Uint32Array|number[]} out destination for neighbour tet ids
+ *   (needs room for up to 4 entries from `out_offset`)
+ * @param {number} out_offset offset into `out` at which to start writing
+ * @param {number} tet_id tetrahedron whose neighbours to read
+ * @returns {number} number of neighbours written (0..4); surface faces are skipped
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function tetrahedral_mesh_tet_get_neighbours(mesh, out, out_offset, tet_id) {
+    assert.defined(mesh, 'mesh');
+    assert.equal(mesh.isTetrahedralMesh, true, 'mesh.isTetrahedralMesh !== true');
+
+    let count = 0;
+    for (let f = 0; f < 4; f++) {
+        const encoded = mesh.getNeighbour(tet_id, f);
+        if (encoded !== INVALID_NEIGHBOUR) {
+            out[out_offset + count] = encoded >>> 2;
+            count++;
+        }
+    }
+    return count;
+}

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trace_triangular_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,mDATW,WAAW,iBACX,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,gCA2GhB"}
+{"version":3,"file":"trace_triangular_depth_map.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js"],"names":[],"mappings":"AAOA;;;;;;;;;;GAUG;AACH,mDATW,WAAW,iBACX,MAAM,UACN,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,gCA6GhB"}

package/src/core/geom/3d/tetrahedra/triangle/trace_triangular_depth_map.js

@@ -112,8 +112,10 @@ export function trace_triangular_depth_map(
 
             const depth_normalized = depth / distance_to_target;
 
-            // depth is quantized to closer value to be conservative
-            const depth_quantized = Math.floor(depth_normalized / 255);
+            // depth (normalized to [0,1]) is quantized to an 8-bit value, flooring to stay conservative (bias
+            // toward the closer occluder). Multiply by 255 to map into the [0,255] byte range, and clamp to guard
+            // against floating-point overshoot of 1.0 which would otherwise spill bits into the adjacent byte.
+            const depth_quantized = Math.min(255, Math.max(0, Math.floor(depth_normalized * 255)));
 
             result[result_offset + encoded_index_0] |= depth_quantized << (encoded_index_1 * 8);
         }

package/src/core/geom/3d/topology/bounds/computeTriangleClusterNormalBoundingCone.js

@@ -19,7 +19,7 @@ export function computeTriangleClusterNormalBoundingCone(result, faces) {
     for (let face of faces) {
 
         const face_normal = face.normal;
-        if (face_normal[0] === 0 && face_normal[1] === 0 && face_normal[1] === 0) {
+        if (face_normal[0] === 0 && face_normal[1] === 0 && face_normal[2] === 0) {
             // skip
             continue;
         }
@@ -70,8 +70,8 @@ export function computeTriangleClusterNormalBoundingCone(result, faces) {
         const i3 = i * 3;
 
         const normal_x = normal_data[i3];
-        const normal_y = normal_data[i3];
-        const normal_z = normal_data[i3];
+        const normal_y = normal_data[i3 + 1];
+        const normal_z = normal_data[i3 + 2];
 
         const angle = v3_angle_between(
             normal_x, normal_y, normal_z,

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

@@ -244,7 +244,7 @@ export function decimate_edge_collapse_snap(
 
             const topoEdge = edges[j];
 
-            if (array_get_index_in_range(scratch_edges, topoEdge, 0, dirty_edge_count) === -1) {
+            if (array_get_index_in_range(scratch_edges, topoEdge, 0, dirty_edge_count - 1) === -1) {
                 scratch_edges[dirty_edge_count++] = topoEdge;
             }
         }

package/src/core/geom/3d/topology/tm_vertex_compute_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tm_vertex_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/tm_vertex_compute_normal.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,iDAJW,MAAM,EAAE,iBACR,MAAM,4BAgChB"}
+{"version":3,"file":"tm_vertex_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/topology/tm_vertex_compute_normal.js"],"names":[],"mappings":"AAOA;;;;;GAKG;AACH,iDAJW,MAAM,EAAE,iBACR,MAAM,4BAkChB"}

package/src/core/geom/3d/topology/tm_vertex_compute_normal.js

@@ -30,8 +30,10 @@ export function tm_vertex_compute_normal(result, result_offset, vertex) {
         _z += scratch_v3_0[2];
     }
 
-    // re-normalize
-    const len_inv = v3_length(_x,_y,_z);
+    // re-normalize: divide by length (multiply by its reciprocal), not by the length itself.
+    // Guard the fully-cancelling case (sum of face normals == 0) to avoid NaN.
+    const len = v3_length(_x, _y, _z);
+    const len_inv = len !== 0 ? 1 / len : 0;
 
     _x *= len_inv;
     _y *= len_inv;

package/src/core/geom/3d/util/make_justified_point_grid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_justified_point_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/util/make_justified_point_grid.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iEAJW,MAAM,kBAEJ,MAAM,CAyBlB"}
+{"version":3,"file":"make_justified_point_grid.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/util/make_justified_point_grid.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,iEAJW,MAAM,kBAEJ,MAAM,CAiClB"}

package/src/core/geom/3d/util/make_justified_point_grid.js

@@ -10,17 +10,25 @@ import { max2 } from "../../../math/max2.js";
  */
 export function make_justified_point_grid(aabb3, spacing, callback) {
 
-    const steps_x = max2(1, Math.ceil(aabb3.getExtentsX() / spacing));
-    const steps_y = max2(1, Math.ceil(aabb3.getExtentsY() / spacing));
-    const steps_z = max2(1, Math.ceil(aabb3.getExtentsZ() / spacing));
+    // `ceil(extent / spacing)` is the number of INTERVALS needed for the actual spacing to stay <= the
+    // requested upper-bound spacing. We then place intervals + 1 points and divide the extent by the interval
+    // count. The old code treated this value as a point count and divided by (count - 1), which made the actual
+    // spacing exceed the requested upper bound (e.g. extent/spacing = 3.2 -> spacing of 1.067*spacing).
+    const intervals_x = max2(1, Math.ceil(aabb3.getExtentsX() / spacing));
+    const intervals_y = max2(1, Math.ceil(aabb3.getExtentsY() / spacing));
+    const intervals_z = max2(1, Math.ceil(aabb3.getExtentsZ() / spacing));
 
-    const spacing_x = aabb3.getExtentsX() / max2(1, steps_x - 1);
-    const spacing_y = aabb3.getExtentsY() / max2(1, steps_y - 1);
-    const spacing_z = aabb3.getExtentsZ() / max2(1, steps_z - 1);
+    const points_x = intervals_x + 1;
+    const points_y = intervals_y + 1;
+    const points_z = intervals_z + 1;
 
-    for (let i = 0; i < steps_x; i++) {
-        for (let j = 0; j < steps_y; j++) {
-            for (let k = 0; k < steps_z; k++) {
+    const spacing_x = aabb3.getExtentsX() / intervals_x;
+    const spacing_y = aabb3.getExtentsY() / intervals_y;
+    const spacing_z = aabb3.getExtentsZ() / intervals_z;
+
+    for (let i = 0; i < points_x; i++) {
+        for (let j = 0; j < points_y; j++) {
+            for (let k = 0; k < points_z; k++) {
                 const x = i * spacing_x + aabb3.x0;
                 const y = j * spacing_y + aabb3.y0;
                 const z = k * spacing_z + aabb3.z0;
@@ -30,5 +38,5 @@ export function make_justified_point_grid(aabb3, spacing, callback) {
         }
     }
 
-    return steps_x * steps_y * steps_z;
+    return points_x * points_y * points_z;
 }

package/src/core/geom/ConicRay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConicRay.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/ConicRay.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH;IAkLI;;;;;;;OAOG;IACH,sBANW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,GACJ,QAAQ,CAkBpB;IAxMD;;;;OAIG;IACH,oBAFU,OAAO,CAEgB;IAEjC;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAMnB;IAED;;;;;OAKG;IACH,qBAJW,QAAQ,cACR,MAAM,GACJ,OAAO,CAKnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAOjB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAKlB;IAED;;;;OAIG;IACH,4BAHW,OAAO,GACL,OAAO,CAMnB;IAED;;;;;OAKG;IACH,gDAFW,OAAO,QAsEjB;IA6BL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B;;kBAUS,MAAM;;oBA/NI,cAAc"}
+{"version":3,"file":"ConicRay.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/ConicRay.js"],"names":[],"mappings":"AASA;;;;;;GAMG;AACH;IAgLI;;;;;;;OAOG;IACH,sBANW,MAAM,KACN,MAAM,KACN,MAAM,cACN,MAAM,GACJ,QAAQ,CAkBpB;IAtMD;;;;OAIG;IACH,oBAFU,OAAO,CAEgB;IAEjC;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;MAKC;IAED,0BAGC;IAED;;;OAGG;IACH,2CAGC;IAED;;;OAGG;IACH,6CAMC;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAMnB;IAED;;;;;OAKG;IACH,qBAJW,QAAQ,cACR,MAAM,GACJ,OAAO,CAKnB;IAED;;;OAGG;IACH,QAFY,MAAM,CAOjB;IAED;;;OAGG;IACH,YAFW,QAAQ,QAKlB;IAED;;;;OAIG;IACH,4BAHW,OAAO,GACL,OAAO,CAMnB;IAED;;;;;OAKG;IACH,gDAFW,OAAO,QAoEjB;IA6BL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B;;kBAUS,MAAM;;oBA7NI,cAAc"}

package/src/core/geom/ConicRay.js

@@ -161,27 +161,25 @@ export class ConicRay {
         const dY = direction.y;
         const dZ = direction.z;
 
-        //compute u
-        //compute rotation angle
-        const rot = Math.acos(dZ);
-
-
-        // Convert rotation axis and angle to 3x3 rotation matrix [2]
-        // [2] See https://en.wikipedia.org/wiki/Rotation_matrix#Rotation_matrix_from_axis_and_angle
+        // Build the rotation that maps the north pole (0,0,1) onto `direction`, expressed as a 3x3 matrix.
+        // This uses the k = 1/(1+dZ) form of that rotation. The previous code used t = 1 - dZ together with
+        // spurious sin() factors on the off-diagonal terms, producing a non-orthonormal matrix that did not
+        // actually rotate (0,0,1) to `direction`.
 
         //write matrix
         const c = dZ;
-        const s = Math.sin(rot);
-        const t = 1 - c;
-        const tx = -t * dY;
-        const ty = t * dX;
+        // NOTE: singular at dZ === -1 (the antipode). The (0,0,1) case is handled by the early return above and
+        // cone sampling here keeps dZ > -1.
+        const k = 1 / (1 + dZ);
+        const tx = -k * dY;
+        const ty = k * dX;
 
         //build relevant terms of the matrix
         const n11 = c - tx * dY;
         const n12 = tx * dX;
         const n22 = ty * dX + c;
-        const n13 = s * dX;
-        const n32 = -s * dY;
+        const n13 = dX;
+        const n32 = -dY;
 
 
         // Rotate [x; y; z] from north pole to `coneDir`.

package/src/core/geom/packing/max-rect/removeRedundantBoxes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"removeRedundantBoxes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/removeRedundantBoxes.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,gEAgEC"}
+{"version":3,"file":"removeRedundantBoxes.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/packing/max-rect/removeRedundantBoxes.js"],"names":[],"mappings":"AAAA;;;GAGG;AACH,gEA+EC"}

package/src/core/geom/packing/max-rect/removeRedundantBoxes.js

@@ -4,7 +4,14 @@
  */
 export function removeRedundantBoxes(boxes) {
     const removals = [];
+    const removalSet = new Set();
 
+    function scheduleRemoval(box) {
+        if (!removalSet.has(box)) {
+            removalSet.add(box);
+            removals.push(box);
+        }
+    }
 
     let datum;
 
@@ -18,6 +25,14 @@ export function removeRedundantBoxes(boxes) {
             return;
         }
 
+        // A box already scheduled for removal must not, in turn, cause other boxes to be removed. This is what
+        // makes two IDENTICAL boxes resolve to exactly one survivor: whichever is seen first schedules the
+        // other for removal, and when the removed one is later visited as `datum` we bail here instead of
+        // scheduling its (equal) container too — otherwise both equal boxes would be removed.
+        if (removalSet.has(datum)) {
+            return;
+        }
+
         const ax0 = intersection.x0;
         const ay0 = intersection.y0;
         const ax1 = intersection.x1;
@@ -30,11 +45,11 @@ export function removeRedundantBoxes(boxes) {
 
         //question is now whether it is containment
         if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
-            //b contains a
-            removals.push(intersection);
+            //b (datum) contains a (intersection)
+            scheduleRemoval(intersection);
         } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
-            //a contains b
-            removals.push(datum);
+            //a (intersection) contains b (datum)
+            scheduleRemoval(datum);
 
             //scheduled removal of the datum, prevent further traversal
             return false;

package/src/core/geom/vec3/v3_orthonormal_matrix_from_normal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_orthonormal_matrix_from_normal.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_orthonormal_matrix_from_normal.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,uDANW,MAAM,EAAE,cACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QAsChB"}

package/src/{engine/graphics/sh3/path_tracer/sampling → core/geom/vec3}/v3_orthonormal_matrix_from_normal.js

@@ -1,4 +1,4 @@
-import { v3_length } from "../../../../../core/geom/vec3/v3_length.js";
+import { v3_length } from "./v3_length.js";
 
 /**
  * Build orthonormal matrix from direction vector

package/src/core/graph/coloring/colorizeGraph.js

@@ -26,9 +26,9 @@ function graphToMatrix(graph) {
     for (let i = 0; i < vertexCount; i++) {
         const node = nodes[i];
 
-        const attachedEdges = graph.getAttachedEdges(node);
+        const attachedEdges = [];
 
-        const nAttachedEdges = attachedEdges.length;
+        const nAttachedEdges = graph.getAttachedEdges(attachedEdges, node);
 
         for (let j = 0; j < nAttachedEdges; j++) {
             const edge = attachedEdges[j];

package/src/core/graph/csr/CSRGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IAsPI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IAjRD;;;;OAIG;IACH,0BAJW,MAAM,oBACN,MAAM,EA8DhB;IAvDG,qBAAqB;IACrB,cADW,MAAM,CACe;IAChC,qBAAqB;IACrB,kBADW,MAAM,CACuB;IAOxC;;;;OAIG;IACH,sBAA4D;IAI5D;;;;OAIG;IACH,gBAFU,WAAW,CAEmE;IAGxF;;;OAGG;IACH,WAFU,WAAW,CAE8D;IAGnF;;;OAGG;IACH,cAFU,WAAW,CAEiE;IAGtF;;;;;OAKG;IACH,gBAFU,WAAW,CAE+D;IAGpF;;;OAGG;IACH,qBAFU,MAAM,CAEuB;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAUlB;IAED;;OAEG;IACH,oCAQC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAFW,MAAM,QA6ChB;IAED;;;;;;;;;OASG;IACH,YAFW,QAAQ,QASlB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAMpB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAsBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAUlB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}
+{"version":3,"file":"CSRGraph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/csr/CSRGraph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH;IA4PI;;;;;;;;;;;;;OAaG;IACH,gCAPW,MAAM,kBACN,UAAU,MAAM,CAAC,aACjB,UAAU,MAAM,CAAC,gBACjB,UAAU,MAAM,CAAC,mBACjB,UAAU,MAAM,CAAC,GACf,QAAQ,CAgBpB;IAvRD;;;;OAIG;IACH,0BAJW,MAAM,oBACN,MAAM,EA8DhB;IAvDG,qBAAqB;IACrB,cADW,MAAM,CACe;IAChC,qBAAqB;IACrB,kBADW,MAAM,CACuB;IAOxC;;;;OAIG;IACH,sBAA4D;IAI5D;;;;OAIG;IACH,gBAFU,WAAW,CAEmE;IAGxF;;;OAGG;IACH,WAFU,WAAW,CAE8D;IAGnF;;;OAGG;IACH,cAFU,WAAW,CAEiE;IAGtF;;;;;OAKG;IACH,gBAFU,WAAW,CAE+D;IAGpF;;;OAGG;IACH,qBAFU,MAAM,CAEuB;IAG3C;;;;OAIG;IACH,+BAEC;IAED;;;;OAIG;IACH,kBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,CAUlB;IAED;;OAEG;IACH,oCAQC;IAED;;;;;;;;;;;;;;;OAeG;IACH,yCAFW,MAAM,QA6ChB;IAED;;;;;;;;;OASG;IACH,YAFW,QAAQ,QASlB;IAED;;;OAGG;IACH,SAFa,QAAQ,CAMpB;IAED;;;;OAIG;IACH,cAHW,QAAQ,GACN,OAAO,CAyBnB;IAED;;;;;OAKG;IACH,QAFa,MAAM,CAalB;IAiCL;;;;;OAKG;IACH,qBAFU,OAAO,CAEY;CAR5B"}