@woosh/meep-engine 3.1.0 → 3.2.0

package/src/core/geom/3d/quadric/quadric3_add.js

@@ -1,33 +1,33 @@
-/**
- * `out = a + b`, element-wise, weight included.
- *
- * Folding one quadric into another is the whole of quadric accumulation: the sum of two fundamental
- * error quadrics is the quadric of the squared distance to *both* planes, and the summed weight
- * keeps {@link quadric3_distance} reading as a mean over everything folded in.
- *
- * `out` may be the same array as `a` and/or `b` when the ranges coincide exactly; partially
- * overlapping ranges are not supported.
- *
- * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
- * @param {number} out_offset
- * @param {ArrayLike<number>} a
- * @param {number} a_offset
- * @param {ArrayLike<number>} b
- * @param {number} b_offset
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_add(out, out_offset, a, a_offset, b, b_offset) {
-    out[out_offset] = a[a_offset] + b[b_offset];
-    out[out_offset + 1] = a[a_offset + 1] + b[b_offset + 1];
-    out[out_offset + 2] = a[a_offset + 2] + b[b_offset + 2];
-    out[out_offset + 3] = a[a_offset + 3] + b[b_offset + 3];
-    out[out_offset + 4] = a[a_offset + 4] + b[b_offset + 4];
-    out[out_offset + 5] = a[a_offset + 5] + b[b_offset + 5];
-    out[out_offset + 6] = a[a_offset + 6] + b[b_offset + 6];
-    out[out_offset + 7] = a[a_offset + 7] + b[b_offset + 7];
-    out[out_offset + 8] = a[a_offset + 8] + b[b_offset + 8];
-    out[out_offset + 9] = a[a_offset + 9] + b[b_offset + 9];
-    out[out_offset + 10] = a[a_offset + 10] + b[b_offset + 10];
-}
+/**
+ * `out = a + b`, element-wise, weight included.
+ *
+ * Folding one quadric into another is the whole of quadric accumulation: the sum of two fundamental
+ * error quadrics is the quadric of the squared distance to *both* planes, and the summed weight
+ * keeps {@link quadric3_distance} reading as a mean over everything folded in.
+ *
+ * `out` may be the same array as `a` and/or `b` when the ranges coincide exactly; partially
+ * overlapping ranges are not supported.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} a
+ * @param {number} a_offset
+ * @param {ArrayLike<number>} b
+ * @param {number} b_offset
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_add(out, out_offset, a, a_offset, b, b_offset) {
+    out[out_offset] = a[a_offset] + b[b_offset];
+    out[out_offset + 1] = a[a_offset + 1] + b[b_offset + 1];
+    out[out_offset + 2] = a[a_offset + 2] + b[b_offset + 2];
+    out[out_offset + 3] = a[a_offset + 3] + b[b_offset + 3];
+    out[out_offset + 4] = a[a_offset + 4] + b[b_offset + 4];
+    out[out_offset + 5] = a[a_offset + 5] + b[b_offset + 5];
+    out[out_offset + 6] = a[a_offset + 6] + b[b_offset + 6];
+    out[out_offset + 7] = a[a_offset + 7] + b[b_offset + 7];
+    out[out_offset + 8] = a[a_offset + 8] + b[b_offset + 8];
+    out[out_offset + 9] = a[a_offset + 9] + b[b_offset + 9];
+    out[out_offset + 10] = a[a_offset + 10] + b[b_offset + 10];
+}

package/src/core/geom/3d/quadric/quadric3_clear.js

@@ -1,25 +1,25 @@
-/**
- * Zero every element of the quadric, weight included.
- *
- * A zero quadric is the identity of {@link quadric3_add} and reports a distance of zero everywhere,
- * which is what a vertex that has accumulated nothing yet should say.
- *
- * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
- * @param {number} out_offset
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_clear(out, out_offset) {
-    out[out_offset] = 0;
-    out[out_offset + 1] = 0;
-    out[out_offset + 2] = 0;
-    out[out_offset + 3] = 0;
-    out[out_offset + 4] = 0;
-    out[out_offset + 5] = 0;
-    out[out_offset + 6] = 0;
-    out[out_offset + 7] = 0;
-    out[out_offset + 8] = 0;
-    out[out_offset + 9] = 0;
-    out[out_offset + 10] = 0;
-}
+/**
+ * Zero every element of the quadric, weight included.
+ *
+ * A zero quadric is the identity of {@link quadric3_add} and reports a distance of zero everywhere,
+ * which is what a vertex that has accumulated nothing yet should say.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
+ * @param {number} out_offset
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_clear(out, out_offset) {
+    out[out_offset] = 0;
+    out[out_offset + 1] = 0;
+    out[out_offset + 2] = 0;
+    out[out_offset + 3] = 0;
+    out[out_offset + 4] = 0;
+    out[out_offset + 5] = 0;
+    out[out_offset + 6] = 0;
+    out[out_offset + 7] = 0;
+    out[out_offset + 8] = 0;
+    out[out_offset + 9] = 0;
+    out[out_offset + 10] = 0;
+}

package/src/core/geom/3d/quadric/quadric3_copy.js

@@ -1,27 +1,27 @@
-/**
- * `out = source`, all 11 elements.
- *
- * `out` may be the same array as `source` when the ranges coincide exactly; partially overlapping
- * ranges are not supported.
- *
- * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
- * @param {number} out_offset
- * @param {ArrayLike<number>} source
- * @param {number} source_offset
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_copy(out, out_offset, source, source_offset) {
-    out[out_offset] = source[source_offset];
-    out[out_offset + 1] = source[source_offset + 1];
-    out[out_offset + 2] = source[source_offset + 2];
-    out[out_offset + 3] = source[source_offset + 3];
-    out[out_offset + 4] = source[source_offset + 4];
-    out[out_offset + 5] = source[source_offset + 5];
-    out[out_offset + 6] = source[source_offset + 6];
-    out[out_offset + 7] = source[source_offset + 7];
-    out[out_offset + 8] = source[source_offset + 8];
-    out[out_offset + 9] = source[source_offset + 9];
-    out[out_offset + 10] = source[source_offset + 10];
-}
+/**
+ * `out = source`, all 11 elements.
+ *
+ * `out` may be the same array as `source` when the ranges coincide exactly; partially overlapping
+ * ranges are not supported.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} source
+ * @param {number} source_offset
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_copy(out, out_offset, source, source_offset) {
+    out[out_offset] = source[source_offset];
+    out[out_offset + 1] = source[source_offset + 1];
+    out[out_offset + 2] = source[source_offset + 2];
+    out[out_offset + 3] = source[source_offset + 3];
+    out[out_offset + 4] = source[source_offset + 4];
+    out[out_offset + 5] = source[source_offset + 5];
+    out[out_offset + 6] = source[source_offset + 6];
+    out[out_offset + 7] = source[source_offset + 7];
+    out[out_offset + 8] = source[source_offset + 8];
+    out[out_offset + 9] = source[source_offset + 9];
+    out[out_offset + 10] = source[source_offset + 10];
+}

package/src/core/geom/3d/quadric/quadric3_distance.js

@@ -1,36 +1,36 @@
-import { quadric3_evaluate } from "./quadric3_evaluate.js";
-
-/**
- * Object-space distance from the point to the surface this quadric accumulated.
- *
- * The root of the mean squared distance to every plane folded in — {@link quadric3_evaluate}
- * normalized by the weight. This is the form to compare against a tolerance, to report, or to
- * project to screen space; the raw evaluation grows with the number of planes, so a vertex sitting
- * exactly on twenty coincident planes and one sitting a millimetre off a single plane are not
- * comparable without this.
- *
- * A quadric with no weight has accumulated nothing and is zero everywhere, so it reports zero. So
- * does one whose weight came out negative, which only a {@link quadric3_sub} can produce: there is
- * no mean to take over a negative count, and the root of a negative is not a length.
- *
- * @param {ArrayLike<number>} q 11 elements from `q_offset`
- * @param {number} q_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @returns {number}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_distance(q, q_offset, x, y, z) {
-    const weight = q[q_offset + 10];
-
-    if (weight <= 0) {
-        return 0;
-    }
-
-    // Clamped: the quadric is positive semi-definite in exact arithmetic, and a point on the
-    // surface evaluates to a small negative in floating point rather than to zero.
-    return Math.sqrt(Math.max(0, quadric3_evaluate(q, q_offset, x, y, z) / weight));
-}
+import { quadric3_evaluate } from "./quadric3_evaluate.js";
+
+/**
+ * Object-space distance from the point to the surface this quadric accumulated.
+ *
+ * The root of the mean squared distance to every plane folded in — {@link quadric3_evaluate}
+ * normalized by the weight. This is the form to compare against a tolerance, to report, or to
+ * project to screen space; the raw evaluation grows with the number of planes, so a vertex sitting
+ * exactly on twenty coincident planes and one sitting a millimetre off a single plane are not
+ * comparable without this.
+ *
+ * A quadric with no weight has accumulated nothing and is zero everywhere, so it reports zero. So
+ * does one whose weight came out negative, which only a {@link quadric3_sub} can produce: there is
+ * no mean to take over a negative count, and the root of a negative is not a length.
+ *
+ * @param {ArrayLike<number>} q 11 elements from `q_offset`
+ * @param {number} q_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_distance(q, q_offset, x, y, z) {
+    const weight = q[q_offset + 10];
+
+    if (weight <= 0) {
+        return 0;
+    }
+
+    // Clamped: the quadric is positive semi-definite in exact arithmetic, and a point on the
+    // surface evaluates to a small negative in floating point rather than to zero.
+    return Math.sqrt(Math.max(0, quadric3_evaluate(q, q_offset, x, y, z) / weight));
+}

package/src/core/geom/3d/quadric/quadric3_evaluate.js

@@ -1,25 +1,25 @@
-/**
- * Sum of squared distances from the point to every plane accumulated into the quadric.
- *
- * A cost to rank collapses by and nothing more: its scale depends on how many planes happen to be in
- * the quadric, so a value from one quadric is not comparable with a value from another. Use
- * {@link quadric3_distance} for anything that has to mean a length.
- *
- * @param {ArrayLike<number>} q 11 elements from `q_offset`
- * @param {number} q_offset
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @returns {number}
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_evaluate(q, q_offset, x, y, z) {
-    // Evaluate vAv + 2bv + c
-
-    return (x * x * q[q_offset]) + (2 * x * y * q[q_offset + 1]) + (2 * x * z * q[q_offset + 2]) + (2 * x * q[q_offset + 3])    // A
-        + (y * y * q[q_offset + 4]) + (2 * y * z * q[q_offset + 5]) + (2 * y * q[q_offset + 6])                                 // B
-        + (z * z * q[q_offset + 7]) + (2 * z * q[q_offset + 8])                                                                 // C
-        + q[q_offset + 9];                                                                                                      // D
-}
+/**
+ * Sum of squared distances from the point to every plane accumulated into the quadric.
+ *
+ * A cost to rank collapses by and nothing more: its scale depends on how many planes happen to be in
+ * the quadric, so a value from one quadric is not comparable with a value from another. Use
+ * {@link quadric3_distance} for anything that has to mean a length.
+ *
+ * @param {ArrayLike<number>} q 11 elements from `q_offset`
+ * @param {number} q_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_evaluate(q, q_offset, x, y, z) {
+    // Evaluate vAv + 2bv + c
+
+    return (x * x * q[q_offset]) + (2 * x * y * q[q_offset + 1]) + (2 * x * z * q[q_offset + 2]) + (2 * x * q[q_offset + 3])    // A
+        + (y * y * q[q_offset + 4]) + (2 * y * z * q[q_offset + 5]) + (2 * y * q[q_offset + 6])                                 // B
+        + (z * z * q[q_offset + 7]) + (2 * z * q[q_offset + 8])                                                                 // C
+        + q[q_offset + 9];                                                                                                      // D
+}

package/src/core/geom/3d/quadric/quadric3_optimize.js

@@ -1,45 +1,45 @@
-import { EPSILON } from "../../../math/EPSILON.js";
-import { v3_matrix3_multiply } from "../../vec3/v3_matrix3_multiply.js";
-import { v3_negate_array } from "../../vec3/v3_negate_array.js";
-import { quadric3_to_tensor_m3_inverse } from "./quadric3_to_tensor_m3_inverse.js";
-import { quadric3_to_vector3 } from "./quadric3_to_vector3.js";
-
-const scratch_m3 = new Float64Array(9);
-
-/**
- * Find the position that minimizes the quadric — the solution of `A x = -b`.
- *
- * Nothing is written when the quadric's tensor is singular, which happens whenever the accumulated
- * planes fail to pin the position in all three directions (a flat patch, a straight crease). A
- * caller that gets `false` has to choose a position by some other rule; there is no minimum to find.
- *
- * The inverted tensor is held at single precision, so the position comes back to roughly seven
- * significant figures however wide the quadric's own numbers are. That is well inside what a
- * collapse candidate is judged on and has been so since this was written, but a caller wanting the
- * full double-precision solve has to invert with {@link quadric3_to_tensor_m3_inverse} itself.
- *
- * Based on Blender's implementation:
- * https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
- *
- * @param {number[]|Float32Array|Float64Array} result destination vector3, 3 elements from
- *     `result_offset`, written only when this returns `true`
- * @param {number} result_offset
- * @param {ArrayLike<number>} q 11 elements from `q_offset`
- * @param {number} q_offset
- * @returns {boolean} whether a minimum was found
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_optimize(result, result_offset, q, q_offset) {
-    if (!quadric3_to_tensor_m3_inverse(scratch_m3, 0, q, q_offset, EPSILON)) {
-        return false;
-    }
-
-    quadric3_to_vector3(result, result_offset, q, q_offset);
-
-    v3_matrix3_multiply(result, result_offset, result, result_offset, scratch_m3);
-    v3_negate_array(result, result_offset, result, result_offset);
-
-    return true;
-}
+import { EPSILON } from "../../../math/EPSILON.js";
+import { v3_matrix3_multiply } from "../../vec3/v3_matrix3_multiply.js";
+import { v3_negate_array } from "../../vec3/v3_negate_array.js";
+import { quadric3_to_tensor_m3_inverse } from "./quadric3_to_tensor_m3_inverse.js";
+import { quadric3_to_vector3 } from "./quadric3_to_vector3.js";
+
+const scratch_m3 = new Float64Array(9);
+
+/**
+ * Find the position that minimizes the quadric — the solution of `A x = -b`.
+ *
+ * Nothing is written when the quadric's tensor is singular, which happens whenever the accumulated
+ * planes fail to pin the position in all three directions (a flat patch, a straight crease). A
+ * caller that gets `false` has to choose a position by some other rule; there is no minimum to find.
+ *
+ * The inverted tensor is held at single precision, so the position comes back to roughly seven
+ * significant figures however wide the quadric's own numbers are. That is well inside what a
+ * collapse candidate is judged on and has been so since this was written, but a caller wanting the
+ * full double-precision solve has to invert with {@link quadric3_to_tensor_m3_inverse} itself.
+ *
+ * Based on Blender's implementation:
+ * https://github.com/blender/blender/blob/594f47ecd2d5367ca936cf6fc6ec8168c2b360d0/source/blender/blenlib/intern/quadric.c
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination vector3, 3 elements from
+ *     `result_offset`, written only when this returns `true`
+ * @param {number} result_offset
+ * @param {ArrayLike<number>} q 11 elements from `q_offset`
+ * @param {number} q_offset
+ * @returns {boolean} whether a minimum was found
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_optimize(result, result_offset, q, q_offset) {
+    if (!quadric3_to_tensor_m3_inverse(scratch_m3, 0, q, q_offset, EPSILON)) {
+        return false;
+    }
+
+    quadric3_to_vector3(result, result_offset, q, q_offset);
+
+    v3_matrix3_multiply(result, result_offset, result, result_offset, scratch_m3);
+    v3_negate_array(result, result_offset, result, result_offset);
+
+    return true;
+}

package/src/core/geom/3d/quadric/quadric3_scale.js

@@ -1,32 +1,32 @@
-/**
- * `out = a * scalar`, element-wise, weight included.
- *
- * The weight scales with the rest, which is what makes this the classic area weighting: a face
- * quadric scaled by the triangle's area both counts more in the sum and declares that it does, so
- * {@link quadric3_distance} still reports a length.
- *
- * `out` may be the same array as `a` when the ranges coincide exactly; partially overlapping ranges
- * are not supported.
- *
- * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
- * @param {number} out_offset
- * @param {ArrayLike<number>} a
- * @param {number} a_offset
- * @param {number} scalar
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_scale(out, out_offset, a, a_offset, scalar) {
-    out[out_offset] = a[a_offset] * scalar;
-    out[out_offset + 1] = a[a_offset + 1] * scalar;
-    out[out_offset + 2] = a[a_offset + 2] * scalar;
-    out[out_offset + 3] = a[a_offset + 3] * scalar;
-    out[out_offset + 4] = a[a_offset + 4] * scalar;
-    out[out_offset + 5] = a[a_offset + 5] * scalar;
-    out[out_offset + 6] = a[a_offset + 6] * scalar;
-    out[out_offset + 7] = a[a_offset + 7] * scalar;
-    out[out_offset + 8] = a[a_offset + 8] * scalar;
-    out[out_offset + 9] = a[a_offset + 9] * scalar;
-    out[out_offset + 10] = a[a_offset + 10] * scalar;
-}
+/**
+ * `out = a * scalar`, element-wise, weight included.
+ *
+ * The weight scales with the rest, which is what makes this the classic area weighting: a face
+ * quadric scaled by the triangle's area both counts more in the sum and declares that it does, so
+ * {@link quadric3_distance} still reports a length.
+ *
+ * `out` may be the same array as `a` when the ranges coincide exactly; partially overlapping ranges
+ * are not supported.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} a
+ * @param {number} a_offset
+ * @param {number} scalar
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_scale(out, out_offset, a, a_offset, scalar) {
+    out[out_offset] = a[a_offset] * scalar;
+    out[out_offset + 1] = a[a_offset + 1] * scalar;
+    out[out_offset + 2] = a[a_offset + 2] * scalar;
+    out[out_offset + 3] = a[a_offset + 3] * scalar;
+    out[out_offset + 4] = a[a_offset + 4] * scalar;
+    out[out_offset + 5] = a[a_offset + 5] * scalar;
+    out[out_offset + 6] = a[a_offset + 6] * scalar;
+    out[out_offset + 7] = a[a_offset + 7] * scalar;
+    out[out_offset + 8] = a[a_offset + 8] * scalar;
+    out[out_offset + 9] = a[a_offset + 9] * scalar;
+    out[out_offset + 10] = a[a_offset + 10] * scalar;
+}

package/src/core/geom/3d/quadric/quadric3_set_from_plane_through_point.js

@@ -1,30 +1,30 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-import { quadric3_set_from_vector4 } from "./quadric3_set_from_vector4.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 {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`,
- *     overwritten
- * @param {number} out_offset
- * @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(out, out_offset, nx, ny, nz, px, py, pz) {
-    const plane_constant = -v3_dot(nx, ny, nz, px, py, pz);
-
-    quadric3_set_from_vector4(out, out_offset, nx, ny, nz, plane_constant);
-}
+import { v3_dot } from "../../vec3/v3_dot.js";
+import { quadric3_set_from_vector4 } from "./quadric3_set_from_vector4.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 {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`,
+ *     overwritten
+ * @param {number} out_offset
+ * @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(out, out_offset, nx, ny, nz, px, py, pz) {
+    const plane_constant = -v3_dot(nx, ny, nz, px, py, pz);
+
+    quadric3_set_from_vector4(out, out_offset, nx, ny, nz, plane_constant);
+}

package/src/core/geom/3d/quadric/quadric3_set_from_vector4.js

@@ -1,35 +1,35 @@
-/**
- * Set a quadric to the fundamental error quadric of the plane `(x, y, z, w)` — that is, `p p^T` for
- * the plane vector `p`, whose evaluation at a point is the squared distance to that plane when the
- * normal is unit.
- *
- * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`,
- *     overwritten
- * @param {number} out_offset
- * @param {number} x plane normal
- * @param {number} y plane normal
- * @param {number} z plane normal
- * @param {number} w plane offset
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function quadric3_set_from_vector4(out, out_offset, x, y, z, w) {
-    out[out_offset] = x * x;
-    out[out_offset + 1] = x * y;
-    out[out_offset + 2] = x * z;
-    out[out_offset + 3] = x * w;
-
-    out[out_offset + 4] = y * y;
-    out[out_offset + 5] = y * z;
-    out[out_offset + 6] = y * w;
-
-    out[out_offset + 7] = z * z;
-    out[out_offset + 8] = z * w;
-
-    out[out_offset + 9] = w * w;
-
-    // One plane, and callers pass unit normals, so it weighs one. A caller wanting the classic
-    // area weighting scales the whole quadric afterwards, which scales this with it.
-    out[out_offset + 10] = 1;
-}
+/**
+ * Set a quadric to the fundamental error quadric of the plane `(x, y, z, w)` — that is, `p p^T` for
+ * the plane vector `p`, whose evaluation at a point is the squared distance to that plane when the
+ * normal is unit.
+ *
+ * @param {number[]|Float32Array|Float64Array} out destination, 11 elements from `out_offset`,
+ *     overwritten
+ * @param {number} out_offset
+ * @param {number} x plane normal
+ * @param {number} y plane normal
+ * @param {number} z plane normal
+ * @param {number} w plane offset
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quadric3_set_from_vector4(out, out_offset, x, y, z, w) {
+    out[out_offset] = x * x;
+    out[out_offset + 1] = x * y;
+    out[out_offset + 2] = x * z;
+    out[out_offset + 3] = x * w;
+
+    out[out_offset + 4] = y * y;
+    out[out_offset + 5] = y * z;
+    out[out_offset + 6] = y * w;
+
+    out[out_offset + 7] = z * z;
+    out[out_offset + 8] = z * w;
+
+    out[out_offset + 9] = w * w;
+
+    // One plane, and callers pass unit normals, so it weighs one. A caller wanting the classic
+    // area weighting scales the whole quadric afterwards, which scales this with it.
+    out[out_offset + 10] = 1;
+}