@woosh/meep-engine 3.40.0 → 3.42.0

package/src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Eigendecomposition of a symmetric 4x4 matrix via cyclic Jacobi rotations.
+ *
+ * Only the upper triangle of `m` is read (the matrix is assumed symmetric, so
+ * row- and column-major are the same); the input is not modified. Eigenpairs
+ * are emitted sorted by **ascending eigenvalue** (signed, not by magnitude),
+ * so index 3 is the largest. Equal eigenvalues keep their column order, so a
+ * multiple of the identity comes back as the identity basis, in order.
+ *
+ * Unlike power iteration, this converges whatever the gaps between eigenvalues:
+ * a ±λ pair or a near-tie at the top costs nothing extra, and only the
+ * eigenvectors of a genuinely repeated eigenvalue are arbitrary (any orthonormal
+ * basis of that eigenspace is returned).
+ *
+ * Eigenvector sign is arbitrary (an eigenvector and its negation are both
+ * valid); callers that need a consistent orientation must fix the sign
+ * themselves.
+ *
+ * @param {Float64Array|Float32Array|number[]} out_values length >= 4, eigenvalues ascending
+ * @param {Float64Array|Float32Array|number[]} out_vectors length >= 16, eigenvector k
+ *   in out_vectors[k*4 .. k*4 + 3] (contiguous per eigenvector)
+ * @param {Float64Array|Float32Array|number[]} m symmetric 4x4 (index = row*4 + col)
+ */
+export function matrix_symmetric_4x4_eigen(out_values: Float64Array | Float32Array | number[], out_vectors: Float64Array | Float32Array | number[], m: Float64Array | Float32Array | number[]): void;
+//# sourceMappingURL=matrix_symmetric_4x4_eigen.d.ts.map

package/src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix_symmetric_4x4_eigen.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uDALW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,eAClC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,KAElC,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,QA0D5C"}

package/src/core/math/linalg/eigen/matrix_symmetric_4x4_eigen.js

@@ -0,0 +1,166 @@
+/**
+ * Maximum number of cyclic Jacobi sweeps. A symmetric 4x4 reaches full double
+ * precision in 3-6 sweeps (Jacobi converges quadratically, whatever the gaps
+ * between eigenvalues): never more than 6 over 200,000 measured matrices,
+ * among them ±λ pairs, near and exact ties, rank 1, Horn's N, and scales from
+ * 1e-310 to 1e300. 50 only bounds the loop.
+ * @type {number}
+ */
+const MAX_SWEEPS = 50;
+
+/**
+ * Working copy of the input, row-major (index = row*4 + col).
+ * @type {Float64Array}
+ */
+const scratch_a = new Float64Array(16);
+
+/**
+ * Rotation accumulator, row-major; its columns become the eigenvectors.
+ * @type {Float64Array}
+ */
+const scratch_v = new Float64Array(16);
+
+/**
+ * Column index of each eigenpair, sorted by ascending eigenvalue.
+ * @type {Uint8Array}
+ */
+const scratch_order = new Uint8Array(4);
+
+/**
+ * One Jacobi rotation in the (p, q) plane that zeroes the off-diagonal entry
+ * a[p][q]. `a` and `v` are 4x4 matrices stored row-major (index = row*4 + col).
+ * `a` is the symmetric working matrix; `v` accumulates the rotations so its
+ * columns become the eigenvectors.
+ *
+ * @param {Float64Array} a symmetric 4x4, mutated in place
+ * @param {Float64Array} v 4x4 rotation accumulator, mutated in place
+ * @param {number} p
+ * @param {number} q
+ */
+function jacobi_rotate(a, v, p, q) {
+    const apq = a[p * 4 + q];
+
+    if (apq === 0) {
+        return;
+    }
+
+    const app = a[p * 4 + p];
+    const aqq = a[q * 4 + q];
+
+    // tan of the rotation angle (Numerical Recipes form, |angle| <= pi/4).
+    const theta = (aqq - app) / (2 * apq);
+    const t = (theta >= 0)
+        ? 1 / (theta + Math.sqrt(theta * theta + 1))
+        : -1 / (-theta + Math.sqrt(theta * theta + 1));
+    const c = 1 / Math.sqrt(t * t + 1);
+    const s = t * c;
+
+    a[p * 4 + p] = app - t * apq;
+    a[q * 4 + q] = aqq + t * apq;
+    a[p * 4 + q] = 0;
+    a[q * 4 + p] = 0;
+
+    for (let r = 0; r < 4; r++) {
+        if (r === p || r === q) {
+            continue;
+        }
+
+        const arp = a[r * 4 + p];
+        const arq = a[r * 4 + q];
+
+        const new_rp = c * arp - s * arq;
+        const new_rq = s * arp + c * arq;
+        a[r * 4 + p] = new_rp;
+        a[p * 4 + r] = new_rp;
+        a[r * 4 + q] = new_rq;
+        a[q * 4 + r] = new_rq;
+    }
+
+    for (let row = 0; row < 4; row++) {
+        const vrp = v[row * 4 + p];
+        const vrq = v[row * 4 + q];
+        v[row * 4 + p] = c * vrp - s * vrq;
+        v[row * 4 + q] = s * vrp + c * vrq;
+    }
+}
+
+/**
+ * Eigendecomposition of a symmetric 4x4 matrix via cyclic Jacobi rotations.
+ *
+ * Only the upper triangle of `m` is read (the matrix is assumed symmetric, so
+ * row- and column-major are the same); the input is not modified. Eigenpairs
+ * are emitted sorted by **ascending eigenvalue** (signed, not by magnitude),
+ * so index 3 is the largest. Equal eigenvalues keep their column order, so a
+ * multiple of the identity comes back as the identity basis, in order.
+ *
+ * Unlike power iteration, this converges whatever the gaps between eigenvalues:
+ * a ±λ pair or a near-tie at the top costs nothing extra, and only the
+ * eigenvectors of a genuinely repeated eigenvalue are arbitrary (any orthonormal
+ * basis of that eigenspace is returned).
+ *
+ * Eigenvector sign is arbitrary (an eigenvector and its negation are both
+ * valid); callers that need a consistent orientation must fix the sign
+ * themselves.
+ *
+ * @param {Float64Array|Float32Array|number[]} out_values length >= 4, eigenvalues ascending
+ * @param {Float64Array|Float32Array|number[]} out_vectors length >= 16, eigenvector k
+ *   in out_vectors[k*4 .. k*4 + 3] (contiguous per eigenvector)
+ * @param {Float64Array|Float32Array|number[]} m symmetric 4x4 (index = row*4 + col)
+ */
+export function matrix_symmetric_4x4_eigen(out_values, out_vectors, m) {
+    const a = scratch_a;
+    const v = scratch_v;
+
+    for (let row = 0; row < 4; row++) {
+        for (let col = row; col < 4; col++) {
+            const value = m[row * 4 + col];
+            a[row * 4 + col] = value;
+            a[col * 4 + row] = value;
+
+            v[row * 4 + col] = row === col ? 1 : 0;
+            v[col * 4 + row] = row === col ? 1 : 0;
+        }
+    }
+
+    for (let sweep = 0; sweep < MAX_SWEEPS; sweep++) {
+        const scale = Math.abs(a[0]) + Math.abs(a[5]) + Math.abs(a[10]) + Math.abs(a[15]);
+        const off = Math.abs(a[1]) + Math.abs(a[2]) + Math.abs(a[3])
+            + Math.abs(a[6]) + Math.abs(a[7]) + Math.abs(a[11]);
+
+        if (off <= 1e-18 * scale) {
+            break;
+        }
+
+        jacobi_rotate(a, v, 0, 1);
+        jacobi_rotate(a, v, 0, 2);
+        jacobi_rotate(a, v, 0, 3);
+        jacobi_rotate(a, v, 1, 2);
+        jacobi_rotate(a, v, 1, 3);
+        jacobi_rotate(a, v, 2, 3);
+    }
+
+    // Eigenvalues live on the diagonal; eigenvector k is column k of V.
+    // Stable insertion sort of the four column indices by eigenvalue.
+    const order = scratch_order;
+
+    for (let k = 0; k < 4; k++) {
+        const value = a[k * 5];
+        let slot = k;
+
+        while (slot > 0 && a[order[slot - 1] * 5] > value) {
+            order[slot] = order[slot - 1];
+            slot--;
+        }
+
+        order[slot] = k;
+    }
+
+    for (let k = 0; k < 4; k++) {
+        const col = order[k];
+        out_values[k] = a[col * 5];
+        out_vectors[k * 4] = v[col];
+        out_vectors[k * 4 + 1] = v[4 + col];
+        out_vectors[k * 4 + 2] = v[8 + col];
+        out_vectors[k * 4 + 3] = v[12 + col];
+    }
+}

package/src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.d.ts

@@ -3,9 +3,11 @@
  * symmetric square matrix using power iteration.
  *
  * Designed for small symmetric matrices where the dominant eigenvalue is
- * well-separated from the rest (Horn's quaternion method on a 4x4, PCA on a
- * 3x3 covariance, etc.). Unsuitable when the top two eigenvalues have nearly
- * equal magnitude — convergence stalls in that regime.
+ * well-separated from the rest (PCA on a 3x3 covariance, etc.). Unsuitable
+ * when the top two eigenvalues have nearly equal magnitude — convergence
+ * stalls in that regime. That rules out Horn's quaternion matrix: a coplanar
+ * input makes its spectrum symmetric about zero (+λ and −λ); use
+ * `matrix_symmetric_4x4_eigen` there.
  *
  * @param {SquareMatrix} matrix Symmetric, column-major as per SquareMatrix
  * @param {number[]|Float32Array|Float64Array} out Eigenvector is written here, length >= matrix.size

package/src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"matrix_top_eigenvector_power_iteration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;GAcG;AACH,kFALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,cACN,MAAM,GACJ,MAAM,CAoFlB"}
+{"version":3,"file":"matrix_top_eigenvector_power_iteration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;GAgBG;AACH,kFALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,cACN,MAAM,GACJ,MAAM,CAoFlB"}

package/src/core/math/linalg/eigen/matrix_top_eigenvector_power_iteration.js

@@ -12,9 +12,11 @@ function ensure_scratch(n) {
  * symmetric square matrix using power iteration.
  *
  * Designed for small symmetric matrices where the dominant eigenvalue is
- * well-separated from the rest (Horn's quaternion method on a 4x4, PCA on a
- * 3x3 covariance, etc.). Unsuitable when the top two eigenvalues have nearly
- * equal magnitude — convergence stalls in that regime.
+ * well-separated from the rest (PCA on a 3x3 covariance, etc.). Unsuitable
+ * when the top two eigenvalues have nearly equal magnitude — convergence
+ * stalls in that regime. That rules out Horn's quaternion matrix: a coplanar
+ * input makes its spectrum symmetric about zero (+λ and −λ); use
+ * `matrix_symmetric_4x4_eigen` there.
  *
  * @param {SquareMatrix} matrix Symmetric, column-major as per SquareMatrix
  * @param {number[]|Float32Array|Float64Array} out Eigenvector is written here, length >= matrix.size

package/src/core/math/noise/curl_noise_3dt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curl_noise_3dt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3dt.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAehB"}
+{"version":3,"file":"curl_noise_3dt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3dt.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAwBhB"}

package/src/core/math/noise/curl_noise_3dt.js

@@ -1,8 +1,9 @@
-import { sdnoise3 } from "./sdnoise.js";
+import { sdnoise3_array } from "./sdnoise.js";
 
-const p_x0 = [];
-const p_y0 = [];
-const p_z0 = [];
+const p_x0 = new Float64Array(4);
+const p_y0 = new Float64Array(4);
+const p_z0 = new Float64Array(4);
+const sample_position = new Float64Array(3);
 
 /**
  *
@@ -14,13 +15,22 @@ const p_z0 = [];
  */
 export function curl_noise_3dt(result, x, y, z, w) {
 
-    sdnoise3(p_x0, x + w, y, z);
-    sdnoise3(p_y0, x + 31.341, y - 43.23 + w, z + 12.34);
-    sdnoise3(p_z0, x - 231.141, y + 124.123, z - 54.4341 + w);
+    sample_position[0] = x + w;
+    sample_position[1] = y;
+    sample_position[2] = z;
+    sdnoise3_array(p_x0, 0, sample_position, 0);
+    sample_position[0] = x + 31.341;
+    sample_position[1] = y - 43.23 + w;
+    sample_position[2] = z + 12.34;
+    sdnoise3_array(p_y0, 0, sample_position, 0);
+    sample_position[0] = x - 231.141;
+    sample_position[1] = y + 124.123;
+    sample_position[2] = z - 54.4341 + w;
+    sdnoise3_array(p_z0, 0, sample_position, 0);
 
-    const _x = p_z0[1] - p_y0[2];
-    const _y = p_x0[2] - p_z0[0];
-    const _z = p_y0[0] - p_x0[1];
+    const _x = p_z0[2] - p_y0[3];
+    const _y = p_x0[3] - p_z0[1];
+    const _z = p_y0[1] - p_x0[2];
 
     result[0] = _x;
     result[1] = _y;

package/src/core/math/noise/sdnoise.d.ts

@@ -17,17 +17,28 @@ export function sdnoise1(derivatives: number[], x: number): number;
  * @returns {number}
  */
 export function sdnoise2(derivatives: number[], x: number, y: number): number;
-/** 3D simplex noise with derivatives.
- * If the last tthree arguments are not null, the analytic derivative
- * (the 3D gradient of the scalar noise field) is also calculated.
+/** 3D simplex noise with its analytic gradient, written into derivatives[0..2].
+ * Scalar facade over {@link sdnoise3_array}; returns the noise value.
  *
+ * @param {number[]|Float32Array|Float64Array} derivatives
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} derivatives
  * @returns {number}
  */
-export function sdnoise3(derivatives: number[], x: number, y: number, z: number): number;
+export function sdnoise3(derivatives: number[] | Float32Array | Float64Array, x: number, y: number, z: number): number;
+/**
+ * 3D simplex noise and its analytic gradient, with packed coordinates.
+ * Writes [noise, dx, dy, dz] at out_offset and returns nothing. Coordinates
+ * are read before output stores, so input and output may overlap.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} position
+ * @param {number} position_offset
+ * @returns {void}
+ */
+export function sdnoise3_array(out: number[] | Float32Array | Float64Array, out_offset: number, position: ArrayLike<number>, position_offset: number): void;
 /**
  * 4D simplex noise with derivatives.
  * If the last four arguments are not null, the analytic derivative

package/src/core/math/noise/sdnoise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CAgPlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}
+{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAaD;;;;;;;;GAQG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;;;;;GAUG;AACH,oCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,YACN,UAAU,MAAM,CAAC,mBACjB,MAAM,GACJ,IAAI,CAkPhB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}

package/src/core/math/noise/sdnoise.js

@@ -404,18 +404,53 @@ export function sdnoise2(derivatives, x, y) {
 const F3 = 0.3333333333333333;
 const G3 = 0.16666666666666666;
 
+const scalar_position = new Float64Array(3);
+const scalar_noise_gradient = new Float64Array(4);
 
-/** 3D simplex noise with derivatives.
- * If the last tthree arguments are not null, the analytic derivative
- * (the 3D gradient of the scalar noise field) is also calculated.
+
+/** 3D simplex noise with its analytic gradient, written into derivatives[0..2].
+ * Scalar facade over {@link sdnoise3_array}; returns the noise value.
  *
+ * @param {number[]|Float32Array|Float64Array} derivatives
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} derivatives
  * @returns {number}
  */
 export function sdnoise3(derivatives, x, y, z) {
+    scalar_position[0] = x;
+    scalar_position[1] = y;
+    scalar_position[2] = z;
+    sdnoise3_array(scalar_noise_gradient, 0, scalar_position, 0);
+
+    // A destination setter may start another sample and overwrite our scratch.
+    // Capture every lane before the first externally observable store.
+    const noise = scalar_noise_gradient[0];
+    const dx = scalar_noise_gradient[1];
+    const dy = scalar_noise_gradient[2];
+    const dz = scalar_noise_gradient[3];
+
+    derivatives[0] = dx;
+    derivatives[1] = dy;
+    derivatives[2] = dz;
+    return noise;
+}
+
+/**
+ * 3D simplex noise and its analytic gradient, with packed coordinates.
+ * Writes [noise, dx, dy, dz] at out_offset and returns nothing. Coordinates
+ * are read before output stores, so input and output may overlap.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} position
+ * @param {number} position_offset
+ * @returns {void}
+ */
+export function sdnoise3_array(out, out_offset, position, position_offset) {
+    const x = position[position_offset];
+    const y = position[position_offset + 1];
+    const z = position[position_offset + 2];
     let n0, n1, n2, n3; /* Noise contributions from the four simplex corners */
     let gx0, gy0, gz0, gx1, gy1, gz1; /* Gradients at simplex corners */
     let gx2, gy2, gz2, gx3, gy3, gz3;
@@ -648,11 +683,10 @@ export function sdnoise3(derivatives, x, y, z) {
     dnoise_dy *= 28.0;
     dnoise_dz *= 28.0;
 
-    derivatives[0] = dnoise_dx;
-    derivatives[1] = dnoise_dy;
-    derivatives[2] = dnoise_dz;
-
-    return noise;
+    out[out_offset] = noise;
+    out[out_offset + 1] = dnoise_dx;
+    out[out_offset + 2] = dnoise_dy;
+    out[out_offset + 3] = dnoise_dz;
 }
 
 // The skewing and unskewing factors are hairy again for the 4D case

package/src/core/math/spline/spline3_hermite_nearest_point.d.ts

@@ -1,7 +1,7 @@
 /**
  * Finds the parameter 't' of the nearest point on a 1D Hermite spline
  * function graph to a reference point. The curve is defined by (t, p(t)).
- * This version is optimized to avoid allocations.
+ * Scalar facade over {@link spline3_hermite_nearest_point_array}.
  *
  * @param {number} ref_t - The 't' coordinate of the reference point.
  * @param {number} ref_p - The 'p' coordinate of the reference point.
@@ -12,4 +12,19 @@
  * @returns {number} The parameter 't' of the nearest point. This value is always in [0..1] range
  */
 export function spline3_hermite_nearest_point(ref_t: number, ref_p: number, p0: number, p1: number, m0: number, m1: number): number;
+/**
+ * Finds the nearest parameter on a 1D Hermite spline using packed inputs and
+ * writes it into `out[out_offset]`. The reference is `[ref_t, ref_p]` and the
+ * spline is `[p0, p1, m0, m1]`. All inputs are read before the output store,
+ * so the destination may overlap either input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} reference
+ * @param {number} reference_offset
+ * @param {ArrayLike<number>} spline
+ * @param {number} spline_offset
+ * @returns {void}
+ */
+export function spline3_hermite_nearest_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, reference: ArrayLike<number>, reference_offset: number, spline: ArrayLike<number>, spline_offset: number): void;
 //# sourceMappingURL=spline3_hermite_nearest_point.d.ts.map

package/src/core/math/spline/spline3_hermite_nearest_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_nearest_point.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_nearest_point.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;GAYG;AACH,qDARW,MAAM,SACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyFlB"}
+{"version":3,"file":"spline3_hermite_nearest_point.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_nearest_point.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;GAYG;AACH,qDARW,MAAM,SACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;;;;;;;GAaG;AACH,yDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,aACN,UAAU,MAAM,CAAC,oBACjB,MAAM,UACN,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,IAAI,CAgGhB"}

package/src/core/math/spline/spline3_hermite_nearest_point.js

@@ -20,13 +20,17 @@ function polyval(p, t, size) {
 const quintic_coeffs = new Float32Array(6);
 const quartic_coeffs = new Float32Array(5);
 
+const scalar_reference = new Float64Array(2);
+const scalar_spline = new Float64Array(4);
+const scalar_result = new Float64Array(1);
+
 const NEWTON_STEPS = 3;
 const START_ROOT_COUNT = 5;
 
 /**
  * Finds the parameter 't' of the nearest point on a 1D Hermite spline
  * function graph to a reference point. The curve is defined by (t, p(t)).
- * This version is optimized to avoid allocations.
+ * Scalar facade over {@link spline3_hermite_nearest_point_array}.
  *
  * @param {number} ref_t - The 't' coordinate of the reference point.
  * @param {number} ref_p - The 'p' coordinate of the reference point.
@@ -40,6 +44,43 @@ export function spline3_hermite_nearest_point(
     ref_t, ref_p,
     p0, p1, m0, m1
 ) {
+    scalar_reference[0] = ref_t;
+    scalar_reference[1] = ref_p;
+    scalar_spline[0] = p0;
+    scalar_spline[1] = p1;
+    scalar_spline[2] = m0;
+    scalar_spline[3] = m1;
+
+    spline3_hermite_nearest_point_array(scalar_result, 0, scalar_reference, 0, scalar_spline, 0);
+
+    return scalar_result[0];
+}
+
+/**
+ * Finds the nearest parameter on a 1D Hermite spline using packed inputs and
+ * writes it into `out[out_offset]`. The reference is `[ref_t, ref_p]` and the
+ * spline is `[p0, p1, m0, m1]`. All inputs are read before the output store,
+ * so the destination may overlap either input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} reference
+ * @param {number} reference_offset
+ * @param {ArrayLike<number>} spline
+ * @param {number} spline_offset
+ * @returns {void}
+ */
+export function spline3_hermite_nearest_point_array(
+    out, out_offset,
+    reference, reference_offset,
+    spline, spline_offset
+) {
+    const ref_t = reference[reference_offset];
+    const ref_p = reference[reference_offset + 1];
+    const p0 = spline[spline_offset];
+    const p1 = spline[spline_offset + 1];
+    const m0 = spline[spline_offset + 2];
+    const m1 = spline[spline_offset + 3];
 
     // 1. Calculate polynomial coefficients A, B, C for p(t)
     const A = 2 * p0 - 2 * p1 + m0 + m1;
@@ -122,5 +163,5 @@ export function spline3_hermite_nearest_point(
         }
     }
 
-    return best_t;
-}
+    out[out_offset] = best_t;
+}

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBAuGC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAl5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBA2GC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAt5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -770,12 +770,14 @@ class Engine {
             ? knowledge.load(this.assetManager, this.executor)
             : Promise.resolve();
 
-        return Promise.all([
+        const startupPromises = [
             soundStarted.then(promiseEntityManager),
             knowledgeLoaded,
             this.gui.startup(this),
             this.plugins.startup()
-        ]).then(async () => {
+        ];
+
+        return Promise.all(startupPromises).then(async () => {
 
             this.#last_frame_timestamp = performance.now();
 
@@ -804,6 +806,8 @@ class Engine {
             logger.info('engine started');
         }, async (e) => {
             logger.error(`Engine Failed to start: ${e}`);
+            // Each branch must settle before its resources can safely be released.
+            await Promise.allSettled(startupPromises);
 
             // Unwind what did come up. Before the Promise.all this method has already acquired the
             // GPU device, started the asset manager, subscribed the sound engine to pointer and

package/src/engine/animation/curve/AnimationCurve.d.ts

@@ -119,12 +119,15 @@ export class AnimationCurve implements Iterable<Keyframe> {
      * Returns index of a key that is just before or at the time specified.
      * Useful for insertion and evaluation logic.
      * Note: if time is past the end of last key - index of the last key will be returned instead
+     * With assertions stripped, a NaN time is at or after no key, so like a time before the first key it returns 0.
      * @param {number} time
      * @returns {number} index of the key
      */
     getKeyIndexLow(time: number): number;
     /**
      * Evaluate interpolated value across the curve at a given time.
+     * On a curve of two or more keys, a NaN time fails an assertion during development; with assertions stripped it
+     * evaluates to NaN, or to the first key's value if the first two keys share a time.
      * @param {number} time time in seconds
      * @return {number} value at the specified time
      */

package/src/engine/animation/curve/AnimationCurve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gDANwB,QAAQ;IAuZ5B;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAQ1B;IAED;;;;;;;;;OASG;IACH,6BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAUzB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,MAAM,UACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAezB;IApdD;;;;;OAKG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;;OAKG;IACH,SAHW,QAAQ,GACN,MAAM,CAuClB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAUpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAGD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,yBAUC;IAED;;;;OAIG;IACH,uBAUC;IAED;;;;OAIG;IACH,uBAcC;IAED;;;;;;OAMG;IACH,qBAHW,MAAM,GACJ,MAAM,CAmDlB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACL,MAAM,CAoCjB;IAED;;;;OAIG;IACH,qBAFW,MAAM,QAqChB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;OAEG;IACH,yBAQC;IAGD;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;MAIC;IAED;;aAkBC;IAoFL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;IAGzC;;;OAGG;IACH,mBAA+B;IA9F3B,wDAQC;CAuEJ;yBAjfwB,eAAe"}
+{"version":3,"file":"AnimationCurve.d.ts","sourceRoot":"","sources":["../../../../../src/engine/animation/curve/AnimationCurve.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gDANwB,QAAQ;IA4Z5B;;;;OAIG;IACH,kBAHW,QAAQ,EAAE,GACR,cAAc,CAQ1B;IAED;;;;;;;;;OASG;IACH,6BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAUzB;IAED;;;;;;OAMG;IACH,4BALW,MAAM,YACN,MAAM,UACN,MAAM,GACL,cAAc,CAOzB;IAED;;;;;;;OAOG;IACH,0BANW,MAAM,eACN,MAAM,YACN,MAAM,aACN,MAAM,GACL,cAAc,CAezB;IAzdD;;;;;OAKG;IACH,eAFU,QAAQ,EAAE,CAEV;IAEV;;;;;OAKG;IACH,SAHW,QAAQ,GACN,MAAM,CAuClB;IAED;;;OAGG;IACH,cAFW,QAAQ,EAAE,QAUpB;IAED;;;;OAIG;IACH,YAHW,QAAQ,GACN,OAAO,CAYnB;IAED;;OAEG;IACH,cAEC;IAGD;;;OAGG;IACH,WAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAEC;IAED;;;;OAIG;IACH,yBAUC;IAED;;;;OAIG;IACH,uBAUC;IAED;;;;OAIG;IACH,uBAcC;IAED;;;;;;;OAOG;IACH,qBAHW,MAAM,GACJ,MAAM,CAqDlB;IAED;;;;;;OAMG;IACH,eAHW,MAAM,GACL,MAAM,CAoCjB;IAED;;;;OAIG;IACH,qBAFW,MAAM,QAqChB;IAED;;;;OAIG;IACH,sBAHW,MAAM,UACN,MAAM,QAIhB;IAED;;OAEG;IACH,yBAQC;IAGD;;;OAGG;IACH,YAFW,cAAc,QAIxB;IAED;;;OAGG;IACH,SAFY,cAAc,CAQzB;IAED;;;;OAIG;IACH,cAHW,cAAc,GACb,OAAO,CAIlB;IAED;;;OAGG;IACH,QAFY,MAAM,CAIjB;IAED;;MAIC;IAED;;aAkBC;IAoFL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;IAGzC;;;OAGG;IACH,mBAA+B;IA9F3B,wDAQC;CAuEJ;yBAtfwB,eAAe"}

package/src/engine/animation/curve/AnimationCurve.js

@@ -200,6 +200,7 @@ export class AnimationCurve {
      * Returns index of a key that is just before or at the time specified.
      * Useful for insertion and evaluation logic.
      * Note: if time is past the end of last key - index of the last key will be returned instead
+     * With assertions stripped, a NaN time is at or after no key, so like a time before the first key it returns 0.
      * @param {number} time
      * @returns {number} index of the key
      */
@@ -239,7 +240,9 @@ export class AnimationCurve {
             if (key_time <= time) {
                 found_index = pivot;
                 i0 = pivot + 1;
-            } else if (key_time > time) {
+            } else {
+                // also where a NaN on either side lands, as it compares false both ways:
+                // every iteration has to narrow the range, or the search never ends
                 i1 = pivot - 1;
             }
         }
@@ -256,6 +259,8 @@ export class AnimationCurve {
 
     /**
      * Evaluate interpolated value across the curve at a given time.
+     * On a curve of two or more keys, a NaN time fails an assertion during development; with assertions stripped it
+     * evaluates to NaN, or to the first key's value if the first two keys share a time.
      * @param {number} time time in seconds
      * @return {number} value at the specified time
      */

package/src/engine/control/first-person/FirstPersonPlayerController.d.ts

@@ -134,6 +134,15 @@ export class FirstPersonPlayerController {
                 upFactor: number;
                 nearWallMaxDistance: number;
             };
+            scrambleUp: {
+                baseJumpForce: number;
+                momentumForcePerSpeed: number;
+                maxJumpForce: number;
+                decel: number;
+                hugSpeed: number;
+                maxDuration: number;
+                kickOutwardImpulse: number;
+            };
             slide: {
                 minEntrySpeed: number;
                 endSpeed: number;

package/src/engine/control/first-person/FirstPersonPlayerController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAEhD,0CAAiD;IACjD,0BAAiC;IACjC,wBAA+B;IAC/B,sBAA6B;IAC7B,4BAAmC;IAEnC;;;;;;OAMG;IACH,SAFU,UAAU,CAEO;IAE3B;;;;;OAKG;IACH,WAFU,UAAU,CAES;IAE7B;;;;;;OAMG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;qCA7FA,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F9E;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDAzMiD,wCAAwC;AAK1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,yEAAyE;IACzE,uBAAgD;IAEhD,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB;;;;;;;OAOG;IACH,SAFU,MAAM,CAEmB;IAEnC,oBAAgB;CACnB;gCAzFkF,2BAA2B;AA2F9G;;;GAGG;AACH;IACI,uDAAuD;IACvD,mBAA0B;IAC1B,yEAAyE;IACzE,oBAA2B;IAC3B,kBAAkB;IAClB,mBAA0B;IAC1B,6BAA6B;IAC7B,sBAA6B;IAC7B,iDAAiD;IACjD,eAAsB;IACtB,sBAA6B;IAC7B,qBAA4B;IAC5B,sBAA6B;IAC7B,qBAA4B;IAC5B,2EAA2E;IAC3E,mBAA0B;IAC1B,2EAA2E;IAC3E,oBAA2B;IAC3B,6DAA6D;IAC7D,oBAA2B;IAC3B,+DAA+D;IAC/D,uBAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}
+{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAEhD,0CAAiD;IACjD,0BAAiC;IACjC,wBAA+B;IAC/B,sBAA6B;IAC7B,4BAAmC;IAEnC;;;;;;OAMG;IACH,SAFU,UAAU,CAEO;IAE3B;;;;;OAKG;IACH,WAFU,UAAU,CAES;IAE7B;;;;;;OAMG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;qCA7FA,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F9E;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDAzMiD,wCAAwC;AAK1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,yEAAyE;IACzE,uBAAgD;IAEhD,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB;;;;;;;OAOG;IACH,SAFU,MAAM,CAEmB;IAEnC,oBAAgB;CACnB;gCAzFkF,2BAA2B;AA2F9G;;;GAGG;AACH;IACI,uDAAuD;IACvD,mBAA0B;IAC1B,yEAAyE;IACzE,oBAA2B;IAC3B,kBAAkB;IAClB,mBAA0B;IAC1B,6BAA6B;IAC7B,sBAA6B;IAC7B,iDAAiD;IACjD,eAAsB;IACtB,sBAA6B;IAC7B,qBAA4B;IAC5B,sBAA6B;IAC7B,qBAA4B;IAC5B,2EAA2E;IAC3E,mBAA0B;IAC1B,2EAA2E;IAC3E,oBAA2B;IAC3B,6DAA6D;IAC7D,oBAA2B;IAC3B,+DAA+D;IAC/D,uBAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}