@woosh/meep-engine 2.155.0 → 2.157.0

package/src/core/graph/layout/CircleLayout.js

@@ -68,10 +68,12 @@ function doLayerLayout(circles) {
 
             const r = circle.r;
 
-            circle.x0 = offsetX + r;
-            circle.y0 = offsetY + r;
+            // write the real circle fields (x/y), not phantom x0/y0 which nothing reads — that made the
+            // layered initial layout silently discarded.
+            circle.x = offsetX + r;
+            circle.y = offsetY + r;
 
-            offsetX += r;
+            offsetX += 2 * r; // advance by the diameter so circles in a layer don't overlap
 
             layerHeight = Math.max(r, layerHeight);
         }
@@ -734,9 +736,9 @@ function resolveCircleLineOverlap(circle, c0, c1) {
             //Impale
             const mid = (t1 + t2) / 2;
 
-            //find closest point on the line to the circle center
-            const nX = x1 + mid * dX;
-            const nY = y1 + mid * dY;
+            //find closest point on the line to the circle center: P(mid) = start + mid * direction
+            const nX = x0 + mid * dX;
+            const nY = y0 + mid * dY;
 
             //compute distance to center
             const ndX = cX - nX;

package/src/core/graph/metis/native/refine/compute_kway_params.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compute_kway_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/compute_kway_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAHW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM,QAyHhB"}
+{"version":3,"file":"compute_kway_params.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/graph/metis/native/refine/compute_kway_params.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,2CAHW,OAAO,kBAAkB,EAAE,UAAU,mBACrC,MAAM,QA0HhB"}

package/src/core/graph/metis/native/refine/compute_kway_params.js

@@ -1,138 +1,139 @@
-import { assert } from "../../../../assert.js";
-
-/**
- * From a freshly-assigned `vertex_partition[]`, populate the rest of the k-way
- * refinement state: per-partition weights, per-vertex internal/external degree,
- * the neighbour-partition list (via `neighbor_partition_pool`), the boundary
- * list, and the total edge cut.
- *
- * Mirrors `ComputeKWayPartitionParams` from libmetis/kwayrefine.c, cut-objective
- * branch only.
- *
- * Boundary insertion rule (refinement-type boundary): a vertex is added to the
- * boundary when `external_degree >= internal_degree`. That captures "worth
- * considering for a move" — vertices with no external pull aren't candidates.
- *
- * @param {import('../MetisGraph.js').MetisGraph} graph
- * @param {number} partition_count
- */
-export function compute_kway_params(graph, partition_count) {
-    const vertex_count = graph.vertex_count;
-    const edge_addresses = graph.edge_addresses;
-    const adjacency = graph.adjacency;
-    const edge_weights = graph.edge_weights;
-    const vertex_weights = graph.vertex_weights;
-    const vertex_partition = graph.vertex_partition;
-    const partition_weights = graph.partition_weights;
-    const internal_degree = graph.internal_degree;
-    const external_degree = graph.external_degree;
-    const neighbor_partition_count = graph.neighbor_partition_count;
-    const neighbor_partition_offset = graph.neighbor_partition_offset;
-    const boundary_vertices = graph.boundary_vertices;
-    const boundary_position_of_vertex = graph.boundary_position_of_vertex;
-    const neighbor_partition_pool = graph.neighbor_partition_pool;
-
-    assert.equal(vertex_partition !== null, true, 'graph.vertex_partition must be allocated');
-    assert.equal(neighbor_partition_pool !== null, true, 'graph.neighbor_partition_pool must be allocated');
-
-    partition_weights.fill(0);
-    internal_degree.fill(0);
-    external_degree.fill(0);
-    neighbor_partition_count.fill(0);
-    neighbor_partition_offset.fill(-1);
-    boundary_position_of_vertex.fill(-1);
-    neighbor_partition_pool.clear();
-
-    // Recompute partition weights from `vertex_partition`. initial_kway_bfs
-    // already produces these, but refinement passes invalidate the count, so
-    // recompute unconditionally to keep this routine self-contained.
-    for (let v = 0; v < vertex_count; v++) {
-        partition_weights[vertex_partition[v]] += vertex_weights[v];
-    }
-
-    // Scratch arrays for per-vertex neighbour-partition deduplication:
-    //   `scratch_partition_position[p]` = where in `scratch_partition_id` /
-    //   `scratch_partition_edge_weight` we've stored partition p for the current
-    //   vertex, or -1 if p hasn't been seen yet for this vertex.
-    const scratch_partition_position = new Int32Array(partition_count);
-    scratch_partition_position.fill(-1);
-
-    // A vertex's distinct neighbour-partition count never exceeds its degree
-    // nor `partition_count`; `partition_count` is the safe upper bound on
-    // scratch size.
-    const scratch_partition_id = new Uint32Array(partition_count);
-    const scratch_partition_edge_weight = new Uint32Array(partition_count);
-
-    let boundary_count = 0;
-    let cut_doubled = 0;
-
-    const pool_data = neighbor_partition_pool.data_uint32;
-
-    for (let vertex = 0; vertex < vertex_count; vertex++) {
-        const my_partition = vertex_partition[vertex];
-
-        let v_internal_degree = 0;
-        let v_external_degree = 0;
-        let distinct_neighbor_partitions = 0;
-
-        const edge_start = edge_addresses[vertex];
-        const edge_end = edge_addresses[vertex + 1];
-        for (let edge_offset = edge_start; edge_offset < edge_end; edge_offset++) {
-            const neighbor_partition = vertex_partition[adjacency[edge_offset]];
-            const edge_weight = edge_weights[edge_offset];
-            if (neighbor_partition === my_partition) {
-                v_internal_degree += edge_weight;
-            } else {
-                v_external_degree += edge_weight;
-                const existing_position = scratch_partition_position[neighbor_partition];
-                if (existing_position === -1) {
-                    scratch_partition_position[neighbor_partition] = distinct_neighbor_partitions;
-                    scratch_partition_id[distinct_neighbor_partitions] = neighbor_partition;
-                    scratch_partition_edge_weight[distinct_neighbor_partitions] = edge_weight;
-                    distinct_neighbor_partitions++;
-                } else {
-                    scratch_partition_edge_weight[existing_position] += edge_weight;
-                }
-            }
-        }
-
-        internal_degree[vertex] = v_internal_degree;
-        external_degree[vertex] = v_external_degree;
-
-        if (v_external_degree > 0) {
-            cut_doubled += v_external_degree;
-
-            // Reserve pool slots sized to the vertex's degree (not just the
-            // current distinct-neighbour-partition count). fm_kway can grow
-            // a vertex's neighbour-partition list when its neighbours move
-            // and introduce a new partition; we need room.
-            const degree = edge_end - edge_start;
-            const pool_record_offset = neighbor_partition_pool.allocate_continuous(degree);
-            neighbor_partition_offset[vertex] = pool_record_offset;
-            neighbor_partition_count[vertex] = distinct_neighbor_partitions;
-
-            // Each pool record is 8 bytes = 2 uint32 words: (partition_id, edge_weight).
-            const word_base = neighbor_partition_pool.element_word(pool_record_offset);
-            for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
-                pool_data[word_base + nbr * 2] = scratch_partition_id[nbr];
-                pool_data[word_base + nbr * 2 + 1] = scratch_partition_edge_weight[nbr];
-            }
-
-            if (v_external_degree >= v_internal_degree) {
-                boundary_vertices[boundary_count] = vertex;
-                boundary_position_of_vertex[vertex] = boundary_count;
-                boundary_count++;
-            }
-        }
-
-        // Reset only the touched scratch entries.
-        for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
-            scratch_partition_position[scratch_partition_id[nbr]] = -1;
-        }
-    }
-
-    // Each crossing edge contributes to both endpoints' external_degree, so we
-    // counted it twice across the loop above.
-    graph.current_cut = cut_doubled >> 1;
-    graph.boundary_count = boundary_count;
-}
+import { assert } from "../../../../assert.js";
+
+/**
+ * From a freshly-assigned `vertex_partition[]`, populate the rest of the k-way
+ * refinement state: per-partition weights, per-vertex internal/external degree,
+ * the neighbour-partition list (via `neighbor_partition_pool`), the boundary
+ * list, and the total edge cut.
+ *
+ * Mirrors `ComputeKWayPartitionParams` from libmetis/kwayrefine.c, cut-objective
+ * branch only.
+ *
+ * Boundary insertion rule (refinement-type boundary): a vertex is added to the
+ * boundary when `external_degree >= internal_degree`. That captures "worth
+ * considering for a move" — vertices with no external pull aren't candidates.
+ *
+ * @param {import('../MetisGraph.js').MetisGraph} graph
+ * @param {number} partition_count
+ */
+export function compute_kway_params(graph, partition_count) {
+    const vertex_count = graph.vertex_count;
+    const edge_addresses = graph.edge_addresses;
+    const adjacency = graph.adjacency;
+    const edge_weights = graph.edge_weights;
+    const vertex_weights = graph.vertex_weights;
+    const vertex_partition = graph.vertex_partition;
+    const partition_weights = graph.partition_weights;
+    const internal_degree = graph.internal_degree;
+    const external_degree = graph.external_degree;
+    const neighbor_partition_count = graph.neighbor_partition_count;
+    const neighbor_partition_offset = graph.neighbor_partition_offset;
+    const boundary_vertices = graph.boundary_vertices;
+    const boundary_position_of_vertex = graph.boundary_position_of_vertex;
+    const neighbor_partition_pool = graph.neighbor_partition_pool;
+
+    assert.equal(vertex_partition !== null, true, 'graph.vertex_partition must be allocated');
+    assert.equal(neighbor_partition_pool !== null, true, 'graph.neighbor_partition_pool must be allocated');
+
+    partition_weights.fill(0);
+    internal_degree.fill(0);
+    external_degree.fill(0);
+    neighbor_partition_count.fill(0);
+    neighbor_partition_offset.fill(-1);
+    boundary_position_of_vertex.fill(-1);
+    neighbor_partition_pool.clear();
+
+    // Recompute partition weights from `vertex_partition`. initial_kway_bfs
+    // already produces these, but refinement passes invalidate the count, so
+    // recompute unconditionally to keep this routine self-contained.
+    for (let v = 0; v < vertex_count; v++) {
+        partition_weights[vertex_partition[v]] += vertex_weights[v];
+    }
+
+    // Scratch arrays for per-vertex neighbour-partition deduplication:
+    //   `scratch_partition_position[p]` = where in `scratch_partition_id` /
+    //   `scratch_partition_edge_weight` we've stored partition p for the current
+    //   vertex, or -1 if p hasn't been seen yet for this vertex.
+    const scratch_partition_position = new Int32Array(partition_count);
+    scratch_partition_position.fill(-1);
+
+    // A vertex's distinct neighbour-partition count never exceeds its degree
+    // nor `partition_count`; `partition_count` is the safe upper bound on
+    // scratch size.
+    const scratch_partition_id = new Uint32Array(partition_count);
+    const scratch_partition_edge_weight = new Uint32Array(partition_count);
+
+    let boundary_count = 0;
+    let cut_doubled = 0;
+
+    for (let vertex = 0; vertex < vertex_count; vertex++) {
+        const my_partition = vertex_partition[vertex];
+
+        let v_internal_degree = 0;
+        let v_external_degree = 0;
+        let distinct_neighbor_partitions = 0;
+
+        const edge_start = edge_addresses[vertex];
+        const edge_end = edge_addresses[vertex + 1];
+        for (let edge_offset = edge_start; edge_offset < edge_end; edge_offset++) {
+            const neighbor_partition = vertex_partition[adjacency[edge_offset]];
+            const edge_weight = edge_weights[edge_offset];
+            if (neighbor_partition === my_partition) {
+                v_internal_degree += edge_weight;
+            } else {
+                v_external_degree += edge_weight;
+                const existing_position = scratch_partition_position[neighbor_partition];
+                if (existing_position === -1) {
+                    scratch_partition_position[neighbor_partition] = distinct_neighbor_partitions;
+                    scratch_partition_id[distinct_neighbor_partitions] = neighbor_partition;
+                    scratch_partition_edge_weight[distinct_neighbor_partitions] = edge_weight;
+                    distinct_neighbor_partitions++;
+                } else {
+                    scratch_partition_edge_weight[existing_position] += edge_weight;
+                }
+            }
+        }
+
+        internal_degree[vertex] = v_internal_degree;
+        external_degree[vertex] = v_external_degree;
+
+        if (v_external_degree > 0) {
+            cut_doubled += v_external_degree;
+
+            // Reserve pool slots sized to the vertex's degree (not just the
+            // current distinct-neighbour-partition count). fm_kway can grow
+            // a vertex's neighbour-partition list when its neighbours move
+            // and introduce a new partition; we need room.
+            const degree = edge_end - edge_start;
+            const pool_record_offset = neighbor_partition_pool.allocate_continuous(degree);
+            // Re-read the backing view AFTER allocating: allocate_continuous may have grown the pool and
+            // replaced data_uint32, leaving any previously-captured view pointing at a detached (stale) buffer.
+            const pool_data = neighbor_partition_pool.data_uint32;
+            neighbor_partition_offset[vertex] = pool_record_offset;
+            neighbor_partition_count[vertex] = distinct_neighbor_partitions;
+
+            // Each pool record is 8 bytes = 2 uint32 words: (partition_id, edge_weight).
+            const word_base = neighbor_partition_pool.element_word(pool_record_offset);
+            for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
+                pool_data[word_base + nbr * 2] = scratch_partition_id[nbr];
+                pool_data[word_base + nbr * 2 + 1] = scratch_partition_edge_weight[nbr];
+            }
+
+            if (v_external_degree >= v_internal_degree) {
+                boundary_vertices[boundary_count] = vertex;
+                boundary_position_of_vertex[vertex] = boundary_count;
+                boundary_count++;
+            }
+        }
+
+        // Reset only the touched scratch entries.
+        for (let nbr = 0; nbr < distinct_neighbor_partitions; nbr++) {
+            scratch_partition_position[scratch_partition_id[nbr]] = -1;
+        }
+    }
+
+    // Each crossing edge contributes to both endpoints' external_degree, so we
+    // counted it twice across the loop above.
+    graph.current_cut = cut_doubled >> 1;
+    graph.boundary_count = boundary_count;
+}

package/src/core/graph/mn_graph_coarsen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mn_graph_coarsen.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_coarsen.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,gFAFW,MAAM,QA2BhB"}
+{"version":3,"file":"mn_graph_coarsen.d.ts","sourceRoot":"","sources":["../../../../src/core/graph/mn_graph_coarsen.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH,gFAFW,MAAM,QA6BhB"}

package/src/core/graph/mn_graph_coarsen.js

@@ -30,8 +30,10 @@ export function mn_graph_coarsen(graph, max_node_limit) {
         // attempt collapse of the heaviest edge
         const collapsed = mn_graph_collapse_weighted_edge(graph, edge, max_node_limit, open_set);
 
-        if(!collapsed){
-            throw new Error(`Failed to collapse edge ${edge}`);
+        if (!collapsed) {
+            // The edge legitimately can't be collapsed within max_node_limit (coarsening is done / this edge
+            // is rejected). Drop it from the heap and keep coarsening the rest rather than aborting.
+            continue;
         }
     }
 }

package/src/core/graph/v2/NodeContainer.js

@@ -195,17 +195,17 @@ export class NodeContainer {
      * @returns {number}
      */
     traverseEdges(visitor, thisArg) {
-        let i = 0;
-
-        const edges = this.__edges;
+        // Iterate over a snapshot: a visitor may mutate the live __edges array (e.g. Graph.removeNode visits
+        // with removeEdge, which splices the edge out of this container). Walking the live array by index would
+        // skip edges whenever one is removed mid-traversal.
+        const edges = this.__edges.slice();
         const n = edges.length;
 
-        for (; i < n; i++) {
-            const edge = edges[i];
-            visitor.call(thisArg, edge);
+        for (let i = 0; i < n; i++) {
+            visitor.call(thisArg, edges[i]);
         }
 
-        return i;
+        return n;
     }
 
     /**

package/src/core/localization/LocalizationEngine.js

@@ -77,7 +77,7 @@ export class LocalizationEngine {
 
                         const fallback = fallbacks[i];
 
-                        if (array_get_index_in_range(resolve_chain, fallback, 0, resolve_chain_end) !== -1) {
+                        if (array_get_index_in_range(resolve_chain, fallback, 0, resolve_chain_end - 1) !== -1) {
                             // circular dependency, that language was already attempted
                             continue;
                         }

package/src/core/math/bell_membership_function.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bell_membership_function.d.ts","sourceRoot":"","sources":["../../../../src/core/math/bell_membership_function.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB"}
+{"version":3,"file":"bell_membership_function.d.ts","sourceRoot":"","sources":["../../../../src/core/math/bell_membership_function.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,4CANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgBlB"}

package/src/core/math/bell_membership_function.js

@@ -18,7 +18,9 @@ export function bell_membership_function(v, a, b, c) {
     const vc = v - c;
     const N = vc / a;
 
-    const d = 1 + Math.pow(N, b * 2);
+    // |(v-c)/a|^(2b): use the magnitude so the function is symmetric about c and avoids NaN from
+    // Math.pow(negative, non-integer) when v is left of center and b is non-integer.
+    const d = 1 + Math.pow(Math.abs(N), b * 2);
 
     return 1 / d;
 }

package/src/core/math/complex/complex_add.d.ts

@@ -1,8 +1,8 @@
 /**
  * Add two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
-export function complex_add(result: number[], a: number[], b: number[]): void;
+export function complex_add(result: number[] | Float64Array | Float32Array, a: number[] | Float64Array | Float32Array, b: number[] | Float64Array | Float32Array): void;
 //# sourceMappingURL=complex_add.d.ts.map

package/src/core/math/complex/complex_add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_add.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_add.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,QAKlB"}
+{"version":3,"file":"complex_add.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_add.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAc5C"}

package/src/core/math/complex/complex_add.js

@@ -1,11 +1,20 @@
 /**
  * Add two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_add(result, a, b) {
-    result[0] = a[0] + b[0];
-    result[1] = a[1] + b[1];
+    // Snapshot inputs before writing, so the function is safe even when `result`
+    // overlaps `a` or `b` — including partial overlaps from differently-offset
+    // TypedArray .subarray() views, where writing result[0] could clobber the
+    // cell that a[1]/b[1] reads.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
+
+    result[0] = a0 + b0;
+    result[1] = a1 + b1;
 }
 

package/src/core/math/complex/complex_div.d.ts

@@ -1,8 +1,8 @@
 /**
  * Divide two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
-export function complex_div(result: number[], a: number[], b: number[]): void;
+export function complex_div(result: number[] | Float64Array | Float32Array, a: number[] | Float64Array | Float32Array, b: number[] | Float64Array | Float32Array): void;
 //# sourceMappingURL=complex_div.d.ts.map

package/src/core/math/complex/complex_div.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_div.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_div.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,QAOlB"}
+{"version":3,"file":"complex_div.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_div.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAc5C"}

package/src/core/math/complex/complex_div.js

@@ -1,12 +1,19 @@
 /**
  * Divide two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_div(result, a, b) {
-    const sqr_norm_b = b[0] * b[0] + b[1] * b[1];
+    // Snapshot inputs so the function is safe when `result` aliases `a` or `b`;
+    // otherwise writing result[0] would corrupt the read of a[0]/b[0] below.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
 
-    result[0] = (a[0] * b[0] + a[1] * b[1]) / sqr_norm_b;
-    result[1] = (a[1] * b[0] - a[0] * b[1]) / sqr_norm_b;
+    const sqr_norm_b = b0 * b0 + b1 * b1;
+
+    result[0] = (a0 * b0 + a1 * b1) / sqr_norm_b;
+    result[1] = (a1 * b0 - a0 * b1) / sqr_norm_b;
 }

package/src/core/math/complex/complex_mul.d.ts

@@ -1,8 +1,8 @@
 /**
  * Multiply two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
-export function complex_mul(result: number[], a: number[], b: number[]): void;
+export function complex_mul(result: number[] | Float64Array | Float32Array, a: number[] | Float64Array | Float32Array, b: number[] | Float64Array | Float32Array): void;
 //# sourceMappingURL=complex_mul.d.ts.map

package/src/core/math/complex/complex_mul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_mul.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_mul.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,QAKlB"}
+{"version":3,"file":"complex_mul.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_mul.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAY5C"}

package/src/core/math/complex/complex_mul.js

@@ -1,10 +1,17 @@
 /**
  * Multiply two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_mul(result, a, b) {
-    result[0] = a[0] * b[0] - a[1] * b[1];
-    result[1] = a[0] * b[1] + a[1] * b[0];
+    // Snapshot inputs so the function is safe when `result` aliases `a` or `b`;
+    // otherwise writing result[0] would corrupt the read of a[0]/b[0] below.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
+
+    result[0] = a0 * b0 - a1 * b1;
+    result[1] = a0 * b1 + a1 * b0;
 }

package/src/core/math/complex/complex_sub.d.ts

@@ -1,8 +1,8 @@
 /**
  * Subtract two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
-export function complex_sub(result: number[], a: number[], b: number[]): void;
+export function complex_sub(result: number[] | Float64Array | Float32Array, a: number[] | Float64Array | Float32Array, b: number[] | Float64Array | Float32Array): void;
 //# sourceMappingURL=complex_sub.d.ts.map

package/src/core/math/complex/complex_sub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"complex_sub.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_sub.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,KACR,MAAM,EAAE,KACR,MAAM,EAAE,QAKlB"}
+{"version":3,"file":"complex_sub.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/complex/complex_sub.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,oCAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAc5C"}

package/src/core/math/complex/complex_sub.js

@@ -1,10 +1,19 @@
 /**
  * Subtract two complex numbers
- * @param {number[]} result
- * @param {number[]} a
- * @param {number[]} b
+ * @param {number[]|Float64Array|Float32Array} result `result` may alias `a` and/or `b`.
+ * @param {number[]|Float64Array|Float32Array} a
+ * @param {number[]|Float64Array|Float32Array} b
  */
 export function complex_sub(result, a, b) {
-    result[0] = a[0] - b[0];
-    result[1] = a[1] - b[1];
+    // Snapshot inputs before writing, so the function is safe even when `result`
+    // overlaps `a` or `b` — including partial overlaps from differently-offset
+    // TypedArray .subarray() views, where writing result[0] could clobber the
+    // cell that a[1]/b[1] reads.
+    const a0 = a[0];
+    const a1 = a[1];
+    const b0 = b[0];
+    const b1 = b[1];
+
+    result[0] = a0 - b0;
+    result[1] = a1 - b1;
 }

package/src/core/math/idct_1d.d.ts

@@ -1,14 +1,14 @@
 /**
- *  Performs a 1D Inverse Discrete Cosine Transform on an 8-element block.
+ * Performs a 1D Inverse Discrete Cosine Transform on an 8-element block.
  *
  * This function implements a fast AAN (Arai-Agui-Nakajima) algorithm.
  * It performs the transformation in-place, modifying the input array directly.
  *
  * NOTE: ported from ffmpeg https://github.com/RPi-Distro/ffmpeg/blob/3a48fe739a020d939a4e752684ef1eed901fd189/libavcodec/exr.c#L916
  *
- * @param {Float64Array} block A pointer to an array of 8 double-precision floating-point values.
+ * @param {number[]|Float32Array|Float64Array} block A pointer to an array of 8 floating-point values.
  * @param {number} offset
- * @param {number} stride
+ * @param {number} stride for images, this will typically be number of channels.
  */
-export function idct_1d(block: Float64Array, offset: number, stride: number): void;
+export function idct_1d(block: number[] | Float32Array | Float64Array, offset: number, stride: number): void;
 //# sourceMappingURL=idct_1d.d.ts.map

package/src/core/math/idct_1d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"idct_1d.d.ts","sourceRoot":"","sources":["../../../../src/core/math/idct_1d.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH,+BAJW,YAAY,UACZ,MAAM,UACN,MAAM,QA6ChB"}
+{"version":3,"file":"idct_1d.d.ts","sourceRoot":"","sources":["../../../../src/core/math/idct_1d.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;GAWG;AACH,+BAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,UAClC,MAAM,UACN,MAAM,QA6ChB"}

package/src/core/math/idct_1d.js

@@ -12,16 +12,16 @@ const f = .5 * Math.cos(3 * Math.PI / 8);
 const g = .5 * Math.cos(7 * Math.PI / 16);
 
 /**
- *  Performs a 1D Inverse Discrete Cosine Transform on an 8-element block.
+ * Performs a 1D Inverse Discrete Cosine Transform on an 8-element block.
  *
  * This function implements a fast AAN (Arai-Agui-Nakajima) algorithm.
  * It performs the transformation in-place, modifying the input array directly.
  *
  * NOTE: ported from ffmpeg https://github.com/RPi-Distro/ffmpeg/blob/3a48fe739a020d939a4e752684ef1eed901fd189/libavcodec/exr.c#L916
  *
- * @param {Float64Array} block A pointer to an array of 8 double-precision floating-point values.
+ * @param {number[]|Float32Array|Float64Array} block A pointer to an array of 8 floating-point values.
  * @param {number} offset
- * @param {number} stride
+ * @param {number} stride for images, this will typically be number of channels.
  */
 export function idct_1d(block, offset, stride) {