@woosh/meep-engine 2.168.1 → 2.169.1

package/src/core/geom/3d/polygon/polygon3_triangulate.js

@@ -0,0 +1,94 @@
+import { assert } from "../../../assert.js";
+import { polygon2_triangulate } from "../../2d/polygon/polygon2_triangulate.js";
+
+/**
+ * Projected (u, v) per vertex for the current call. Module-static and grown on
+ * demand, matching {@link polygon2_triangulate}'s own storage -- and, like it,
+ * this function is therefore not re-entrant.
+ * @type {Float64Array}
+ */
+let _projected = new Float64Array(0);
+
+/**
+ * Triangulate a planar 3D polygon with holes, viewed along `-normal`.
+ *
+ * The polygon is projected to 2D by **dropping the axis the normal points most
+ * strongly along** and keeping the other two verbatim, swapped when that
+ * component is negative so the projection stays counter-clockwise as seen from
+ * `+normal`. Nothing is rotated and no coordinate is recomputed, which is the
+ * whole point: {@link polygon2_triangulate} decides exactly, and it can only do
+ * that on coordinates that are exactly the input's. A rotation into a fitted
+ * plane basis would round every vertex first and hand the exact predicate
+ * approximate data.
+ *
+ * `normal` need not be normalised, but it must not be zero. Derive it with
+ * {@link polygon3_compute_normal} when the caller has no authoritative one.
+ *
+ * Output indices address `points3` -- the same vertices the caller passed in --
+ * and each triangle is counter-clockwise when viewed from `+normal`.
+ *
+ * @param {Uint32Array} result receives 3 point indices per triangle
+ * @param {number} result_offset first index written in `result`
+ * @param {ArrayLike<number>} points3 flat (x, y, z) triples, stride 3
+ * @param {ArrayLike<number>} contour_ends exclusive end vertex index per contour
+ * @param {number} contour_count number of contours; contour 0 is the outer boundary
+ * @param {number} nx
+ * @param {number} ny
+ * @param {number} nz polygon normal, need not be unit length
+ * @returns {number} number of triangles written; see {@link polygon2_triangulate}
+ *     for what a short count means
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function polygon3_triangulate(
+    result, result_offset,
+    points3, contour_ends, contour_count,
+    nx, ny, nz
+) {
+    assert.isArrayLike(points3, "points3");
+    assert.isPositiveInteger(contour_count, "contour_count");
+    assert.ok(nx !== 0 || ny !== 0 || nz !== 0, "polygon normal must not be zero");
+
+    const vertex_count = contour_ends[contour_count - 1];
+
+    if (vertex_count < 3) {
+        return 0;
+    }
+
+    if (_projected.length < vertex_count * 2) {
+        _projected = new Float64Array(vertex_count * 2);
+    }
+
+    const ax = Math.abs(nx);
+    const ay = Math.abs(ny);
+    const az = Math.abs(nz);
+
+    // Component offsets of the two axes kept, in the order that preserves
+    // counter-clockwise winding seen from +normal:
+    //   +x -> (y, z)    -x -> (z, y)
+    //   +y -> (z, x)    -y -> (x, z)
+    //   +z -> (x, y)    -z -> (y, x)
+    let u_axis;
+    let v_axis;
+
+    if (ax >= ay && ax >= az) {
+        u_axis = nx > 0 ? 1 : 2;
+        v_axis = nx > 0 ? 2 : 1;
+    } else if (ay >= az) {
+        u_axis = ny > 0 ? 2 : 0;
+        v_axis = ny > 0 ? 0 : 2;
+    } else {
+        u_axis = nz > 0 ? 0 : 1;
+        v_axis = nz > 0 ? 1 : 0;
+    }
+
+    for (let i = 0; i < vertex_count; i++) {
+        const i3 = i * 3;
+
+        _projected[i * 2] = points3[i3 + u_axis];
+        _projected[i * 2 + 1] = points3[i3 + v_axis];
+    }
+
+    return polygon2_triangulate(result, result_offset, _projected, contour_ends, contour_count);
+}

package/src/core/geom/3d/quaternion/quat3_multiply.d.ts

@@ -14,8 +14,14 @@
  *
  * @param {number[]|Float32Array|Float64Array} out
  * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
- * @param {number} ax @param {number} ay @param {number} az @param {number} aw
- * @param {number} bx @param {number} by @param {number} bz @param {number} bw
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} aw
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} bw
  */
 export function quat3_multiply(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, aw: number, bx: number, by: number, bz: number, bw: number): void;
 //# sourceMappingURL=quat3_multiply.d.ts.map

package/src/core/geom/3d/quaternion/quat3_multiply.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quat3_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,oCALW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MAAa,MAAM,MAAa,MAAM,MAAa,MAAM,MAC/D,MAAM,MAAa,MAAM,MAAa,MAAM,MAAa,MAAM,QAOzE"}
+{"version":3,"file":"quat3_multiply.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_multiply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,oCAXW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAOhB"}

package/src/core/geom/3d/quaternion/quat3_multiply.js

@@ -14,8 +14,14 @@
  *
  * @param {number[]|Float32Array|Float64Array} out
  * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
- * @param {number} ax @param {number} ay @param {number} az @param {number} aw
- * @param {number} bx @param {number} by @param {number} bz @param {number} bw
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} aw
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} bw
  */
 export function quat3_multiply(out, out_offset, ax, ay, az, aw, bx, by, bz, bw) {
     out[out_offset]     = aw * bx + ax * bw + ay * bz - az * by;

package/src/core/geom/3d/shape/ConvexHullShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA+CI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IAxDG;;;;OAIG;IACH,UAFU,YAAY,CAEa;IAEnC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;OAMG;IACH,cAFU,WAAW,CAEiB;IACtC,0BAA0B;IAC1B,YADW,WAAW,CACc;IAEpC;;;;;;OAMG;IACH,iBAAmC;IAEnC,oCAAoC;IACpC,eAAiC;IACjC,8BAA8B;IAC9B,iBAAiB;IACjB,8BAA8B;IAC9B,uBAAuB;IAmB3B;;;OAGG;IACH,kBAmDC;IAKD,wCAIC;IAED;;;;;OAKG;IACH,qGAgBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAwBC;IAED,mEAEC;IAED,4DAwBC;IAED,kFAmBC;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCAxT+B,sBAAsB"}
+{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IA+CI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IAxDG;;;;OAIG;IACH,UAFU,YAAY,CAEa;IAEnC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;OAMG;IACH,cAFU,WAAW,CAEiB;IACtC,0BAA0B;IAC1B,YADW,WAAW,CACc;IAEpC;;;;;;OAMG;IACH,iBAAmC;IAEnC,oCAAoC;IACpC,eAAiC;IACjC,8BAA8B;IAC9B,iBAAiB;IACjB,8BAA8B;IAC9B,uBAAuB;IAmB3B;;;OAGG;IACH,kBAiFC;IAKD,wCAIC;IAED;;;;;OAKG;IACH,qGAgBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAwBC;IAED,mEAEC;IAED,4DAwBC;IAED,kFAmBC;IAED;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCAtV+B,sBAAsB"}

package/src/core/geom/3d/shape/ConvexHullShape3D.js

@@ -113,10 +113,34 @@ export class ConvexHullShape3D extends AbstractShape3D {
         const b = this.__bbox;
         b[0] = mnx; b[1] = mny; b[2] = mnz; b[3] = mxx; b[4] = mxy; b[5] = mxz;
 
+        // Volume is accumulated about the hull's own bbox centre, not the
+        // origin. Σ a·(b×c) is translation invariant over a closed surface --
+        // shifting `a` by a constant r changes the sum by r·Σn, and the face
+        // area vectors of a closed surface sum to zero -- so the apex may be
+        // moved freely, and moving it onto the hull is what keeps the terms on
+        // the scale of the hull instead of on the scale of its distance from
+        // the origin. Anchored at the origin, a hull sitting 1e6 away produced
+        // terms around 1e18 that had to cancel down to its volume, and the
+        // reported volume drifted by ~7e-4 relative for a hull whose vertices
+        // were stored exactly.
+        //
+        // Σn = 0 needs the surface to be closed and consistently wound, which
+        // `from` does not check. For a surface that is not -- an open cap, a
+        // flipped or duplicated face -- this reports a different number than
+        // anchoring at the origin did. Both are meaningless for such input, but
+        // note the old one was meaningless in a more flattering way: a face
+        // touching the origin contributed nothing, so a broken hull could still
+        // read a plausible 1.0 at the origin and something else entirely once
+        // translated. This number is at least a property of the surface rather
+        // than of where it sits.
+        const ox = (mnx + mxx) * 0.5;
+        const oy = (mny + mxy) * 0.5;
+        const oz = (mnz + mxz) * 0.5;
+
         const tri = idx.length / 3;
         const planes = new Float64Array(tri * 4);
         let area = 0;
-        let vol6 = 0; // 6× the signed volume (Σ a·(b×c) over outward faces)
+        let vol6 = 0; // 6× the signed volume (Σ (a − o)·n over outward faces)
         for (let f = 0; f < tri; f++) {
             const ia = idx[f * 3] * 3, ib = idx[f * 3 + 1] * 3, ic = idx[f * 3 + 2] * 3;
             const ax = v[ia], ay = v[ia + 1], az = v[ia + 2];
@@ -130,7 +154,13 @@ export class ConvexHullShape3D extends AbstractShape3D {
             let nz = e1x * e2y - e1y * e2x;
             const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
             area += 0.5 * len;
-            vol6 += ax * (by * cz - bz * cy) + ay * (bz * cx - bx * cz) + az * (bx * cy - by * cx);
+            // Two rewrites, both exact, and together they remove every product
+            // of absolute coordinates:
+            //   a·(b × c) === a·((b − a) × (c − a)), since a·(b × a) and
+            //   a·(a × c) are both zero -- so the normal already computed above
+            //   can be reused in place of the b × c cross product;
+            //   Σ a·n === Σ (a − o)·n over a closed surface, since Σ n = 0.
+            vol6 += (ax - ox) * nx + (ay - oy) * ny + (az - oz) * nz;
 
             nx /= len; ny /= len; nz /= len;
             const o = f * 4;

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

@@ -102,10 +102,10 @@ export class TetrahedralMesh {
     get isCompacted(): boolean;
     /**
      * Traverse live tetrahedrons
-     * @param { function( tet_id:number, mesh:TetrahedralMesh ):* } visitor
+     * @param { (tet_id: number, mesh: TetrahedralMesh) => *} visitor
      * @param {*} [thisArg]
      */
-    forEach(visitor: any, thisArg?: any): void;
+    forEach(visitor: (tet_id: number, mesh: TetrahedralMesh) => any, thisArg?: any): void;
     /**
      * Produces a list of live tetrahedrons
      * Allocates.

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

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAI3B;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,2CAUC;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAkElB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAYjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAUhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA7xB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IACI;;;OAGG;IACH,2BAFW,MAAM,EAqDhB;IAhDG;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAE9B;;;;OAIG;IACH,mBAAmB;IAEnB;;;;OAIG;IACH,eAAgB;IAEhB;;;;OAIG;IACH,uBAAuB;IAI3B;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,0BAHqB,MAAM,QAAQ,eAAe,+BAajD;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAkElB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAYjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAUhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA7xB4B,iCAAiC"}

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

@@ -157,7 +157,7 @@ export class TetrahedralMesh {
 
     /**
      * Traverse live tetrahedrons
-     * @param { function( tet_id:number, mesh:TetrahedralMesh ):* } visitor
+     * @param { (tet_id: number, mesh: TetrahedralMesh) => *} visitor
      * @param {*} [thisArg]
      */
     forEach(visitor, thisArg) {

package/src/core/geom/3d/tetrahedra/delaunay/debug/push_boundary_with_validation.d.ts

@@ -7,10 +7,7 @@
  * @param {number} d
  * @param {number} neighbour
  * @param {number[]} points
- * @param {function(problem:string):*} consumer
+ * @param {(problem: string) => *} consumer
  */
-export function push_boundary_with_validation(points: number[], cavity: Cavity, a: number, b: number, c: number, d: number, neighbour: number, consumer?: {
-    (...data: any[]): void;
-    (message?: any, ...optionalParams: any[]): void;
-}): boolean;
+export function push_boundary_with_validation(points: number[], cavity: Cavity, a: number, b: number, c: number, d: number, neighbour: number, consumer?: (problem: string) => any): boolean;
 //# sourceMappingURL=push_boundary_with_validation.d.ts.map

package/src/core/geom/3d/tetrahedra/delaunay/debug/push_boundary_with_validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"push_boundary_with_validation.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/tetrahedra/delaunay/debug/push_boundary_with_validation.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,sDAHW,MAAM,EAAE,qBALR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM;;;YAiBhB"}
+{"version":3,"file":"push_boundary_with_validation.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/tetrahedra/delaunay/debug/push_boundary_with_validation.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,sDAHW,MAAM,EAAE,qBALR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,uBAEI,MAAM,mBAe1B"}

package/src/core/geom/3d/tetrahedra/delaunay/debug/push_boundary_with_validation.js

@@ -9,7 +9,7 @@ import { tetrahedron_compute_signed_volume } from "../../tetrahedron_compute_sig
  * @param {number} d
  * @param {number} neighbour
  * @param {number[]} points
- * @param {function(problem:string):*} consumer
+ * @param {(problem: string) => *} consumer
  */
 export function push_boundary_with_validation(points, cavity, a, b, c, d, neighbour, consumer = console.warn) {
     let valid = true;

package/src/core/geom/3d/tetrahedra/delaunay/debug/validate_cavity_boundary.d.ts

@@ -2,8 +2,8 @@ export function debug_validate_cavity_boundary(mesh: any, cavity: any): boolean;
 /**
  *
  * @param {Cavity} cavity
- * @param {function(problem:string):*} consumer
+ * @param {(problem: string) => *} consumer
  * @returns {boolean}
  */
-export function validate_cavity_boundary(cavity: Cavity, consumer: any): boolean;
+export function validate_cavity_boundary(cavity: Cavity, consumer: (problem: string) => any): boolean;
 //# sourceMappingURL=validate_cavity_boundary.d.ts.map

package/src/core/geom/3d/tetrahedra/delaunay/debug/validate_cavity_boundary.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate_cavity_boundary.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/tetrahedra/delaunay/debug/validate_cavity_boundary.js"],"names":[],"mappings":"AAGA,gFAaC;AAED;;;;;GAKG;AACH,yEAFa,OAAO,CAqCnB"}
+{"version":3,"file":"validate_cavity_boundary.d.ts","sourceRoot":"","sources":["../../../../../../../../src/core/geom/3d/tetrahedra/delaunay/debug/validate_cavity_boundary.js"],"names":[],"mappings":"AAGA,gFAaC;AAED;;;;;GAKG;AACH,6EAHqB,MAAM,WACd,OAAO,CAqCnB"}

package/src/core/geom/3d/tetrahedra/delaunay/debug/validate_cavity_boundary.js

@@ -19,7 +19,7 @@ export function debug_validate_cavity_boundary(mesh, cavity) {
 /**
  *
  * @param {Cavity} cavity
- * @param {function(problem:string):*} consumer
+ * @param {(problem: string) => *} consumer
  * @returns {boolean}
  */
 export function validate_cavity_boundary(cavity, consumer) {

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

@@ -2,9 +2,8 @@
  *
  * @param {TetrahedralMesh} mesh
  * @param {ArrayLike<number>|number[]|Float32Array} points
- * @param {function(problem:string):*} [consumer]
+ * @param {(problem: string) => *} [consumer]
  * @returns {boolean}
  */
-export function validate_tetrahedral_mesh(mesh: TetrahedralMesh, points: ArrayLike<number> | number[] | Float32Array, consumer?: typeof noop): boolean;
-import { noop } from "../../../function/noop.js";
+export function validate_tetrahedral_mesh(mesh: TetrahedralMesh, points: ArrayLike<number> | number[] | Float32Array, consumer?: (problem: string) => any): boolean;
 //# sourceMappingURL=validate_tetrahedral_mesh.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate_tetrahedral_mesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/validate_tetrahedral_mesh.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,yEAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,2BAErC,OAAO,CAkCnB;qBApEoB,2BAA2B"}
+{"version":3,"file":"validate_tetrahedral_mesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/validate_tetrahedral_mesh.js"],"names":[],"mappings":"AA6BA;;;;;;GAMG;AACH,yEAJW,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,uBAC7B,MAAM,WACd,OAAO,CAkCnB"}

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

@@ -1,69 +1,69 @@
-import { noop } from "../../../function/noop.js";
-import { tetrahedral_mesh_compute_tet_volume } from "./tetrahedral_mesh_compute_tet_volume.js";
-import { is_tetrahedron_degenerate } from "./is_tetrahedron_degenerate.js";
-import { validate_tetrahedron_neighbourhood } from "./validate_tetrahedron_neighbourhood.js";
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {number} tet
- * @param {number} max_index
- * @param {function(problem:string):*} consumer
- */
-function validate_tetrahedron_point_index_range(mesh, tet, max_index, consumer) {
-    let valid = true;
-
-    for (let i = 0; i < 4; i++) {
-
-        const vertex_index = mesh.getVertexIndex(tet, i);
-
-        if (vertex_index > max_index) {
-            consumer(`Tetrahedron ${tet} points to non-existing vertex ${vertex_index} as it's ordinal vertex ${i}. Maximum allowed vertex index is ${max_index}`);
-            valid = false;
-        }
-
-    }
-
-    return valid;
-}
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {ArrayLike<number>|number[]|Float32Array} points
- * @param {function(problem:string):*} [consumer]
- * @returns {boolean}
- */
-export function validate_tetrahedral_mesh(mesh, points, consumer = noop) {
-    let is_valid = true;
-
-    const max_point_index = (points.length / 3) - 1;
-
-    mesh.forEach((tet, mesh) => {
-
-        if (!validate_tetrahedron_point_index_range(mesh, tet, max_point_index, consumer)) {
-            is_valid = false;
-        }
-
-        const volume = tetrahedral_mesh_compute_tet_volume(mesh, points, tet);
-        if (volume < 0) {
-            is_valid = false;
-
-            consumer(`Tetrahedron ${tet} has negative volume ${volume}`);
-        }
-
-        // check for degeneracy
-        if (is_tetrahedron_degenerate(mesh, tet)) {
-            is_valid = false;
-            consumer(`Tetrahedron ${tet} is degenerate (multiple vertices have the same index)`);
-        }
-
-        if (!validate_tetrahedron_neighbourhood(mesh, tet, consumer)) {
-            is_valid = false;
-        }
-
-    });
-
-
-    return is_valid;
-}
+import { noop } from "../../../function/noop.js";
+import { tetrahedral_mesh_compute_tet_volume } from "./tetrahedral_mesh_compute_tet_volume.js";
+import { is_tetrahedron_degenerate } from "./is_tetrahedron_degenerate.js";
+import { validate_tetrahedron_neighbourhood } from "./validate_tetrahedron_neighbourhood.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {number} tet
+ * @param {number} max_index
+ * @param {(problem: string) => *} consumer
+ */
+function validate_tetrahedron_point_index_range(mesh, tet, max_index, consumer) {
+    let valid = true;
+
+    for (let i = 0; i < 4; i++) {
+
+        const vertex_index = mesh.getVertexIndex(tet, i);
+
+        if (vertex_index > max_index) {
+            consumer(`Tetrahedron ${tet} points to non-existing vertex ${vertex_index} as it's ordinal vertex ${i}. Maximum allowed vertex index is ${max_index}`);
+            valid = false;
+        }
+
+    }
+
+    return valid;
+}
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {ArrayLike<number>|number[]|Float32Array} points
+ * @param {(problem: string) => *} [consumer]
+ * @returns {boolean}
+ */
+export function validate_tetrahedral_mesh(mesh, points, consumer = noop) {
+    let is_valid = true;
+
+    const max_point_index = (points.length / 3) - 1;
+
+    mesh.forEach((tet, mesh) => {
+
+        if (!validate_tetrahedron_point_index_range(mesh, tet, max_point_index, consumer)) {
+            is_valid = false;
+        }
+
+        const volume = tetrahedral_mesh_compute_tet_volume(mesh, points, tet);
+        if (volume < 0) {
+            is_valid = false;
+
+            consumer(`Tetrahedron ${tet} has negative volume ${volume}`);
+        }
+
+        // check for degeneracy
+        if (is_tetrahedron_degenerate(mesh, tet)) {
+            is_valid = false;
+            consumer(`Tetrahedron ${tet} is degenerate (multiple vertices have the same index)`);
+        }
+
+        if (!validate_tetrahedron_neighbourhood(mesh, tet, consumer)) {
+            is_valid = false;
+        }
+
+    });
+
+
+    return is_valid;
+}

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

@@ -2,8 +2,7 @@
  *
  * @param {TetrahedralMesh} mesh
  * @param {number} tet
- * @param {function(problem:string):*} consumer
+ * @param {(problem: string) => *} consumer
  */
-export function validate_tetrahedron_neighbourhood(mesh: TetrahedralMesh, tet: number, consumer?: typeof noop): boolean;
-import { noop } from "../../../function/noop.js";
+export function validate_tetrahedron_neighbourhood(mesh: TetrahedralMesh, tet: number, consumer?: (problem: string) => any): boolean;
 //# sourceMappingURL=validate_tetrahedron_neighbourhood.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"validate_tetrahedron_neighbourhood.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/validate_tetrahedron_neighbourhood.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,+EAHW,MAAM,mCA0ChB;qBAjDoB,2BAA2B"}
+{"version":3,"file":"validate_tetrahedron_neighbourhood.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/validate_tetrahedron_neighbourhood.js"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,+EAHW,MAAM,uBACI,MAAM,mBAyC1B"}

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

@@ -1,50 +1,50 @@
-import { noop } from "../../../function/noop.js";
-import { validate_neighbour } from "./validate_neighbour.js";
-import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
-
-/**
- *
- * @param {TetrahedralMesh} mesh
- * @param {number} tet
- * @param {function(problem:string):*} consumer
- */
-export function validate_tetrahedron_neighbourhood(mesh, tet, consumer = noop) {
-    let valid = true;
-
-    for (let i = 0; i < 4; i++) {
-
-        if (!validate_neighbour(mesh, tet, i, consumer)) {
-            valid = false;
-        }
-
-    }
-
-    // validate all neighbours together
-    for (let i = 0; i < 3; i++) {
-        const neighbour_a = mesh.getNeighbour(tet, i);
-
-        if (neighbour_a === INVALID_NEIGHBOUR) {
-            continue;
-        }
-
-        const tet_a = neighbour_a >>> 2;
-
-        for (let j = i+1; j < 4; j++) {
-            const neighbour_b = mesh.getNeighbour(tet, j);
-
-            if (neighbour_b === INVALID_NEIGHBOUR) {
-                continue;
-            }
-
-            const tet_b = neighbour_b >>> 2;
-
-            if (tet_a === tet_b) {
-                consumer(`Tetrahedron ${tet} points to the same neighbour tetrahedron ${tet_a} for neighbour index ${i} and ${j}. Each neighbour tet must be unique`)
-
-                valid = false;
-            }
-        }
-    }
-
-    return valid;
-}
+import { noop } from "../../../function/noop.js";
+import { validate_neighbour } from "./validate_neighbour.js";
+import { INVALID_NEIGHBOUR } from "./TetrahedralMesh.js";
+
+/**
+ *
+ * @param {TetrahedralMesh} mesh
+ * @param {number} tet
+ * @param {(problem: string) => *} consumer
+ */
+export function validate_tetrahedron_neighbourhood(mesh, tet, consumer = noop) {
+    let valid = true;
+
+    for (let i = 0; i < 4; i++) {
+
+        if (!validate_neighbour(mesh, tet, i, consumer)) {
+            valid = false;
+        }
+
+    }
+
+    // validate all neighbours together
+    for (let i = 0; i < 3; i++) {
+        const neighbour_a = mesh.getNeighbour(tet, i);
+
+        if (neighbour_a === INVALID_NEIGHBOUR) {
+            continue;
+        }
+
+        const tet_a = neighbour_a >>> 2;
+
+        for (let j = i+1; j < 4; j++) {
+            const neighbour_b = mesh.getNeighbour(tet, j);
+
+            if (neighbour_b === INVALID_NEIGHBOUR) {
+                continue;
+            }
+
+            const tet_b = neighbour_b >>> 2;
+
+            if (tet_a === tet_b) {
+                consumer(`Tetrahedron ${tet} points to the same neighbour tetrahedron ${tet_a} for neighbour index ${i} and ${j}. Each neighbour tet must be unique`)
+
+                valid = false;
+            }
+        }
+    }
+
+    return valid;
+}

package/src/core/geom/3d/topology/struct/TopoEdge.d.ts

@@ -39,10 +39,10 @@ export class TopoEdge {
     clone(): TopoEdge;
     /**
      *
-     * @param {function(reason:string)} error_consumer
+     * @param {(reason: string) => void} error_consumer
      * @return {boolean}
      */
-    validate(error_consumer: any): boolean;
+    validate(error_consumer: (reason: string) => void): boolean;
     /**
      * Returns false if edge is not licked back to by it's vertices (v0 is used for the check)
      * @return {boolean}

package/src/core/geom/3d/topology/struct/TopoEdge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopoEdge.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoEdge.js"],"names":[],"mappings":"AAUA;IACI;;;OAGG;IACH,OAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,eAAU;IACV;;;OAGG;IACH,eAAU;IAGV;;;OAGG;IACH,OAFU,cAAc,CAEb;IAEX;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf,uBAEC;IAED;;;;OAIG;IACH,oBAHW,MAAM,cAWhB;IAED;;;OAGG;IACH,YAFW,QAAQ,QASlB;IAED,kBAMC;IAED;;;;OAIG;IACH,+BAFY,OAAO,CAiClB;IAED;;;OAGG;IACH,YAFY,OAAO,CAIlB;IAED;;OAEG;IACH,eAkBC;IAED;;;OAGG;IACH,oBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAMC;IAED,6BAiBC;IAED;;;;OAIG;IACH,mEASC;IAED;;;;OAIG;IACH,aAFW,QAAQ,QA0ClB;IAED;;;;OAIG;IACH,kCAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,kCAKC;IAED;;;OAGG;IACH,wCAIC;IAED;;;OAGG;IACH,kCAIC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;OAIG;IACH,+BAFY,OAAO,CAIlB;IAED;;;;;OAKG;IACH,oDAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,8BAHW,QAAQ,GACN,OAAO,CAInB;IAGL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B"}
+{"version":3,"file":"TopoEdge.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoEdge.js"],"names":[],"mappings":"AAUA;IACI;;;OAGG;IACH,OAFU,MAAM,CAEQ;IAExB;;;OAGG;IACH,eAAU;IACV;;;OAGG;IACH,eAAU;IAGV;;;OAGG;IACH,OAFU,cAAc,CAEb;IAEX;;;OAGG;IACH,WAFU,MAAM,CAED;IAEf,uBAEC;IAED;;;;OAIG;IACH,oBAHW,MAAM,cAWhB;IAED;;;OAGG;IACH,YAFW,QAAQ,QASlB;IAED,kBAMC;IAED;;;;OAIG;IACH,kCAHoB,MAAM,KAAK,IAAI,GACvB,OAAO,CAiClB;IAED;;;OAGG;IACH,YAFY,OAAO,CAIlB;IAED;;OAEG;IACH,eAkBC;IAED;;;OAGG;IACH,oBAFa,OAAO,CAInB;IAED;;;;OAIG;IACH,oBAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,qBAMC;IAED,6BAiBC;IAED;;;;OAIG;IACH,mEASC;IAED;;;;OAIG;IACH,aAFW,QAAQ,QA0ClB;IAED;;;;OAIG;IACH,kCAFY,OAAO,CAIlB;IAED;;;OAGG;IACH,kCAKC;IAED;;;OAGG;IACH,wCAIC;IAED;;;OAGG;IACH,kCAIC;IAED;;;;OAIG;IACH,0CAEC;IAED;;;;OAIG;IACH,+BAFY,OAAO,CAIlB;IAED;;;;;OAKG;IACH,oDAFY,OAAO,CAIlB;IAED;;;;OAIG;IACH,8BAHW,QAAQ,GACN,OAAO,CAInB;IAGL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAN5B"}

package/src/core/geom/3d/topology/struct/TopoEdge.js

@@ -81,7 +81,7 @@ export class TopoEdge {
 
     /**
      *
-     * @param {function(reason:string)} error_consumer
+     * @param {(reason: string) => void} error_consumer
      * @return {boolean}
      */
     validate(error_consumer) {

package/src/core/geom/3d/topology/struct/TopoMesh.d.ts

@@ -44,10 +44,10 @@ export class TopoMesh {
     getFaceByIndex(index: number): undefined | TopoTriangle;
     /**
      *
-     * @param {function(reason:string)} [error_consumer]
+     * @param {(reason: string) => void} [error_consumer]
      * @returns {boolean}
      */
-    validate(error_consumer?: typeof noop): boolean;
+    validate(error_consumer?: (reason: string) => void): boolean;
     clone(): TopoMesh;
     /**
      *
@@ -191,5 +191,4 @@ export class TopoMesh {
 import { TopoVertex } from "./TopoVertex.js";
 import { TopoEdge } from "./TopoEdge.js";
 import { TopoTriangle } from "./TopoTriangle.js";
-import { noop } from "../../../../function/noop.js";
 //# sourceMappingURL=TopoMesh.d.ts.map

package/src/core/geom/3d/topology/struct/TopoMesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoMesh.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAEI;;;OAGG;IACH,UAFU,UAAU,EAAE,CAER;IAEd;;;;OAIG;IACH,gBAAoB;IAGpB;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,uBAkBC;IAED;;;OAGG;IACH,YAFa,IAAI,QAAQ,CAAC,CAIzB;IAED;;;OAGG;IACH,YAFa,IAAI,YAAY,CAAC,CAI7B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,YAAY,CAYjC;IAED;;;;OAIG;IACH,wCAFa,OAAO,CA0GnB;IAED,kBAMC;IAED;;;OAGG;IACH,sBAFa,IAAI,MAAM,EAAE,UAAU,CAAC,CAoBnC;IAED;;;;OAIG;IACH,yBAHW,QAAQ,cACR,IAAI,MAAM,EAAE,UAAU,CAAC,QAYjC;IAED;;;;OAIG;IACH,kBAHW,YAAY,cACZ,IAAI,MAAM,EAAC,UAAU,CAAC,QAqChC;IAED;;;;OAIG;IACH,qBAFW,YAAY,QAsBtB;IAED;;;OAGG;IACH,WAFW,QAAQ,QAclB;IAED;;;OAGG;IACH,aAFW,UAAU,QAKpB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAMpB;IAED;;;OAGG;IACH,gBAFW,UAAU,QAIpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAKnB;IAGD;;;OAGG;IACH,WAFW,QAAQ,QAKlB;IAED;;;OAGG;IACH,iBAFW,QAAQ,QAMlB;IAED;;;OAGG;IACH,cAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,gBAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,uBAFW,SAAS,YAAY,CAAC,QAMhC;IAED;;;OAGG;IACH,cAFW,YAAY,QAwBtB;IAED;;;OAGG;IACH,cAFW,YAAY,QAItB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,OAAO,CAKnB;IAED;;;;;;OAMG;IACH,cALW,UAAU,KACV,UAAU,GAER,QAAQ,CAoCpB;IAED,mBAsCC;IAED,kCAQC;IAED;;;OAGG;IACH,+BAFW,YAAY,QA6BtB;IAED;;;OAGG;IACH,8BAFW,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,QA4B1C;IAED,0BAiBC;IAED;;;;OAIG;IACH,gBAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,UAClC,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,MAAM,EAAE,QAYrD;IAED;;;;;;;OAOG;IACH,sBANW,MAAM,MACN,UAAU,MACV,UAAU,MACV,UAAU,GACR,YAAY,CA0BxB;IAED,mBAEC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B;2BAtsB0B,iBAAiB;yBAFnB,eAAe;6BACX,mBAAmB;qBAR3B,8BAA8B"}
+{"version":3,"file":"TopoMesh.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/struct/TopoMesh.js"],"names":[],"mappings":"AAcA;;;GAGG;AACH;IAEI;;;OAGG;IACH,UAFU,UAAU,EAAE,CAER;IAEd;;;;OAIG;IACH,gBAAoB;IAGpB;;;;OAIG;IACH,gBAAoB;IAEpB;;;;OAIG;IACH,uBAkBC;IAED;;;OAGG;IACH,YAFa,IAAI,QAAQ,CAAC,CAIzB;IAED;;;OAGG;IACH,YAFa,IAAI,YAAY,CAAC,CAI7B;IAED;;;;OAIG;IACH,sBAHW,MAAM,GACL,SAAS,GAAC,YAAY,CAYjC;IAED;;;;OAIG;IACH,mCAHoB,MAAM,KAAK,IAAI,GACtB,OAAO,CA0GnB;IAED,kBAMC;IAED;;;OAGG;IACH,sBAFa,IAAI,MAAM,EAAE,UAAU,CAAC,CAoBnC;IAED;;;;OAIG;IACH,yBAHW,QAAQ,cACR,IAAI,MAAM,EAAE,UAAU,CAAC,QAYjC;IAED;;;;OAIG;IACH,kBAHW,YAAY,cACZ,IAAI,MAAM,EAAC,UAAU,CAAC,QAqChC;IAED;;;;OAIG;IACH,qBAFW,YAAY,QAsBtB;IAED;;;OAGG;IACH,WAFW,QAAQ,QAclB;IAED;;;OAGG;IACH,aAFW,UAAU,QAKpB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAMpB;IAED;;;OAGG;IACH,gBAFW,UAAU,QAIpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,GACR,OAAO,CAKnB;IAGD;;;OAGG;IACH,WAFW,QAAQ,QAKlB;IAED;;;OAGG;IACH,iBAFW,QAAQ,QAMlB;IAED;;;OAGG;IACH,cAFW,QAAQ,QAIlB;IAED;;;;OAIG;IACH,gBAHW,QAAQ,GACN,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,uBAFW,SAAS,YAAY,CAAC,QAMhC;IAED;;;OAGG;IACH,cAFW,YAAY,QAwBtB;IAED;;;OAGG;IACH,cAFW,YAAY,QAItB;IAED;;;;OAIG;IACH,gBAHW,YAAY,GACV,OAAO,CAKnB;IAED;;;;;;OAMG;IACH,cALW,UAAU,KACV,UAAU,GAER,QAAQ,CAoCpB;IAED,mBAsCC;IAED,kCAQC;IAED;;;OAGG;IACH,+BAFW,YAAY,QA6BtB;IAED;;;OAGG;IACH,8BAFW,WAAW,GAAC,WAAW,GAAC,MAAM,EAAE,QA4B1C;IAED,0BAiBC;IAED;;;;OAIG;IACH,gBAHW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,UAClC,WAAW,GAAC,WAAW,GAAC,UAAU,GAAC,MAAM,EAAE,QAYrD;IAED;;;;;;;OAOG;IACH,sBANW,MAAM,MACN,UAAU,MACV,UAAU,MACV,UAAU,GACR,YAAY,CA0BxB;IAED,mBAEC;IAIL;;;OAGG;IACH,qBAFU,OAAO,CAEY;CAP5B;2BAtsB0B,iBAAiB;yBAFnB,eAAe;6BACX,mBAAmB"}

package/src/core/geom/3d/topology/struct/TopoMesh.js

@@ -99,7 +99,7 @@ export class TopoMesh {
 
     /**
      *
-     * @param {function(reason:string)} [error_consumer]
+     * @param {(reason: string) => void} [error_consumer]
      * @returns {boolean}
      */
     validate(error_consumer = noop) {