@pacem/pacem-numerical 1.0.0-abel

package/dist/bundle/pacem-numerical.mjs

@@ -0,0 +1,2459 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// packages/numerical/dist/esm/index-geometry.js
+var index_geometry_exports = {};
+__export(index_geometry_exports, {
+  LinearAlgebra: () => index_geometry_linearalgebra_exports,
+  Polygon: () => Polygon,
+  Utils: () => Utils,
+  Utils3D: () => Utils3D
+});
+
+// packages/numerical/dist/esm/geom/geom.js
+import { Point as Point2, Rect, NullChecker } from "@pacem/pacem-foundation";
+
+// packages/numerical/dist/esm/geom/linear-algebra.js
+import { Point } from "@pacem/pacem-foundation";
+var Vector = class _Vector {
+  /**
+   * Returns the unit (normalized) vector having the same direction and sense of the provided one.
+   * @param v
+   */
+  static unit(v) {
+    const clone = { x: v.x, y: v.y };
+    this.normalize(clone);
+    return clone;
+  }
+  static magSqr(v) {
+    return v.x * v.x + v.y * v.y;
+  }
+  static mag(v) {
+    return Math.sqrt(_Vector.magSqr(v));
+  }
+  /**
+   * Normalizes the provided vector in place.
+   * @param v
+   */
+  static normalize(v) {
+    const l = _Vector.mag(v);
+    if (l <= 0) {
+      throw "Cannot normalize a vector of length 0.";
+    }
+    const inv = 1 / l;
+    v.x *= inv;
+    v.y *= inv;
+  }
+  /**
+   * Returns the vector joining two points.
+   * @param p1 Start point
+   * @param p2 End point
+   */
+  static from(p1, p2) {
+    return Point.subtract(p1, p2);
+  }
+  /**
+   * Returns the dot product between two vectors/points.
+   * @param v1
+   * @param v2
+   */
+  static dot(v1, v2) {
+    return v1.x * v2.x + v1.y * v2.y;
+  }
+  /**
+   * Returns the cross product between two vectors/points (magnitude along the z axis).
+   * @param v1
+   * @param v2
+   */
+  static cross(v1, v2) {
+    return v1.x * v2.y - v1.y * v2.x;
+  }
+  /**
+   * Checks if the two points are effectively the same location.
+   * @param v1 The first point.
+   * @param v2 The second point.
+   * @returns True if the points are considered coincident within tolerance; otherwise, false.
+   */
+  static areClose(v1, v2) {
+    return (v2.x - v1.x).isCloseTo(0) && (v2.y - v1.y).isCloseTo(0);
+  }
+};
+
+// packages/numerical/dist/esm/geom/algorithms/delaunay.js
+var Vertex = class {
+  constructor(x, y, index = -1) {
+    this.x = x;
+    this.y = y;
+    this.index = index;
+  }
+  equals(other) {
+    return this.x === other.x && this.y === other.y;
+  }
+};
+function calcCircumCirc(v0, v1, v2) {
+  const ax = v0.x, ay = v0.y;
+  const bx = v1.x, by = v1.y;
+  const cx = v2.x, cy = v2.y;
+  const d = 2 * (ax * (by - cy) + bx * (cy - ay) + cx * (ay - by));
+  if (Math.abs(d) < 1e-12) {
+    return { c: { x: 0, y: 0 }, r: Infinity };
+  }
+  const ux = ((ax * ax + ay * ay) * (by - cy) + (bx * bx + by * by) * (cy - ay) + (cx * cx + cy * cy) * (ay - by)) / d;
+  const uy = ((ax * ax + ay * ay) * (cx - bx) + (bx * bx + by * by) * (ax - cx) + (cx * cx + cy * cy) * (bx - ax)) / d;
+  const r = Math.hypot(ux - ax, uy - ay);
+  return { c: { x: ux, y: uy }, r };
+}
+var Triangle = class {
+  constructor(v0, v1, v2) {
+    this.v0 = v0;
+    this.v1 = v1;
+    this.v2 = v2;
+    this.circumCirc = calcCircumCirc(v0, v1, v2);
+  }
+  inCircumcircle(v) {
+    const dx = this.circumCirc.c.x - v.x;
+    const dy = this.circumCirc.c.y - v.y;
+    return Math.hypot(dx, dy) <= this.circumCirc.r + 1e-9;
+  }
+};
+function superTriangle(vertices) {
+  let minX = Infinity, minY = Infinity;
+  let maxX = -Infinity, maxY = -Infinity;
+  for (const v of vertices) {
+    minX = Math.min(minX, v.x);
+    minY = Math.min(minY, v.y);
+    maxX = Math.max(maxX, v.x);
+    maxY = Math.max(maxY, v.y);
+  }
+  const dx = (maxX - minX) * 10;
+  const dy = (maxY - minY) * 10;
+  const v0 = new Vertex(minX - dx, minY - dy * 3);
+  const v1 = new Vertex(minX - dx, maxY + dy);
+  const v2 = new Vertex(maxX + dx * 3, maxY + dy);
+  return new Triangle(v0, v1, v2);
+}
+function uniqueEdges(edges) {
+  const unique = [];
+  for (let i = 0; i < edges.length; ++i) {
+    let isUnique = true;
+    for (let j = 0; j < edges.length; ++j) {
+      if (i !== j) {
+        const e1 = edges[i];
+        const e2 = edges[j];
+        if (e1.v0.equals(e2.v0) && e1.v1.equals(e2.v1) || e1.v0.equals(e2.v1) && e1.v1.equals(e2.v0)) {
+          isUnique = false;
+          break;
+        }
+      }
+    }
+    if (isUnique)
+      unique.push(edges[i]);
+  }
+  return unique;
+}
+function addVertex(vertex, triangles) {
+  const edges = [];
+  triangles = triangles.filter((triangle) => {
+    if (triangle.inCircumcircle(vertex)) {
+      edges.push({ v0: triangle.v0, v1: triangle.v1 });
+      edges.push({ v0: triangle.v1, v1: triangle.v2 });
+      edges.push({ v0: triangle.v2, v1: triangle.v0 });
+      return false;
+    }
+    return true;
+  });
+  const unique = uniqueEdges(edges);
+  for (const edge of unique) {
+    triangles.push(new Triangle(edge.v0, edge.v1, vertex));
+  }
+  return triangles;
+}
+function triangulate(vertices) {
+  if (vertices.length < 3)
+    return [];
+  const st = superTriangle(vertices);
+  let triangles = [st];
+  for (const vertex of vertices) {
+    triangles = addVertex(vertex, triangles);
+  }
+  triangles = triangles.filter((t) => !(t.v0 === st.v0 || t.v0 === st.v1 || t.v0 === st.v2 || t.v1 === st.v0 || t.v1 === st.v1 || t.v1 === st.v2 || t.v2 === st.v0 || t.v2 === st.v1 || t.v2 === st.v2));
+  return triangles;
+}
+function delaunayTriangulation(vertices) {
+  if (vertices.length < 3)
+    return [];
+  const vertList = vertices.map((p, idx) => new Vertex(p.x, p.y, idx));
+  const triangles = triangulate(vertList);
+  const indices = [];
+  for (const t of triangles) {
+    indices.push(t.v0.index, t.v1.index, t.v2.index);
+  }
+  return indices;
+}
+var Delaunay = class {
+  static triangulate(vertices) {
+    return delaunayTriangulation(vertices);
+  }
+};
+
+// packages/numerical/dist/esm/geom/geom.js
+var RAD2DEG = 180 / Math.PI;
+var RAD_ROUND = 2 * Math.PI;
+var PRECISION = 12;
+function isPoint(p) {
+  return Point2.isPoint(p);
+}
+function isSegment(s) {
+  return s != null && Array.isArray(s) && s.length === 2 && isPoint(s[0]) && isPoint(s[1]);
+}
+var Utils = class _Utils {
+  /**
+   * Computes the slope (in radians) of the segment joining two points.
+   * @param p1 Point 1
+   * @param p2 Point 2
+   */
+  static slopeRad(p1, p2) {
+    return Math.atan2(p2.y - p1.y, p2.x - p1.x);
+  }
+  /**
+   * Computes the slope (in radians) of the segment joining two points and returns a strictly positive value (0 to 2*pi).
+   * @param p1 Point 1
+   * @param p2 Point 2
+   */
+  static slopeRad2(p1, p2) {
+    return (RAD_ROUND + _Utils.slopeRad(p1, p2)) % RAD_ROUND;
+  }
+  /**
+   * Computes the slope (in degrees) of the segment joining two points.
+   * @param p1 Point 1
+   * @param p2 Point 2
+   */
+  static slopeDeg(p1, p2) {
+    return _Utils.slopeRad(p1, p2) * RAD2DEG;
+  }
+  /**
+   * Computes the slope (in degrees) of the segment joining two points and returns a strictly positive value (0 to 360).
+   * @param p1 Point 1
+   * @param p2 Point 2
+   */
+  static slopeDeg2(p1, p2) {
+    return (360 + _Utils.slopeDeg(p1, p2)) % 360;
+  }
+  static intersect(arg1, arg2, ...args) {
+    if (Array.isArray(arg1) && Array.isArray(arg2)) {
+      return _Utils._intersectSegments(arg1, arg2, true);
+    } else if (Rect.isRect(arg1)) {
+      return _Utils._intersectRects(...arguments);
+    } else if ("vertices" in arg1) {
+      return _Utils._mergePolygons(arg1, arg2, "intersect")?.polygons ?? null;
+    } else {
+      return null;
+    }
+  }
+  static boundingBox(vertices) {
+    let xmin = Number.MAX_VALUE, ymin = Number.MAX_VALUE, xmax = -Number.MAX_VALUE, ymax = -Number.MAX_VALUE;
+    const l = vertices.length;
+    for (let v of vertices) {
+      xmin = Math.min(xmin, v.x);
+      ymin = Math.min(ymin, v.y);
+      xmax = Math.max(xmax, v.x);
+      ymax = Math.max(ymax, v.y);
+    }
+    return { x: xmin, y: ymin, width: xmax - xmin, height: ymax - ymin };
+  }
+  static combinePolygons(polygon1, polygon2, operator) {
+    return _Utils._mergePolygons(polygon1, polygon2, operator);
+  }
+  static _mergePolygons(polygon1, polygon2, operator) {
+    if (NullChecker.isNullOrEmpty(polygon1?.vertices) || NullChecker.isNullOrEmpty(polygon2?.vertices)) {
+      return null;
+    }
+    const contained1 = polygon1.vertices.filter((v) => _Utils.inPolygon(v, polygon2.vertices));
+    if (polygon1.vertices.length == contained1.length) {
+      return {
+        polygons: operator === "intersect" ? [polygon1] : (
+          /* hole in difference */
+          [polygon2]
+        )
+      };
+    }
+    const contained2 = polygon2.vertices.filter((v) => _Utils.inPolygon(v, polygon1.vertices));
+    if (polygon2.vertices.length === contained2.length) {
+      return {
+        polygons: operator === "intersect" ? [polygon2] : (
+          /* hole in difference */
+          [polygon1]
+        )
+      };
+    }
+    const bbox1 = _Utils.boundingBox(polygon1.vertices), bbox2 = _Utils.boundingBox(polygon2.vertices);
+    const rect = _Utils.intersect(bbox1, bbox2);
+    if (operator !== "union" && (!Rect.isRect(rect) || !(rect.width > 0) || !(rect.height > 0))) {
+      return null;
+    }
+    const { vertices: vertices1 } = polygon1, { vertices: vertices2 } = polygon2;
+    if (vertices1.length < 3 || vertices2.length < 3) {
+      return null;
+    }
+    const sideBuilderCallback = (v, j, arr) => [v, arr[(j + 1) % arr.length]];
+    const verticesSortCallback = (a, b) => a.x === b.x ? a.y - b.y : a.x - b.x;
+    const edges1 = vertices1.map(sideBuilderCallback), edges2 = vertices2.map(sideBuilderCallback);
+    const outputVertices = vertices1.concat(vertices2);
+    const memoizer = /* @__PURE__ */ new Map();
+    const ensureMemoizer = (e) => {
+      if (!memoizer.has(e)) {
+        const retval = [];
+        memoizer.set(e, retval);
+      }
+      return memoizer.get(e);
+    };
+    let thereAreIntersections = false;
+    for (let edge1 of edges1) {
+      const additionalVertices1 = ensureMemoizer(edge1);
+      for (let edge2 of edges2) {
+        const additionalVertices2 = ensureMemoizer(edge2);
+        const intersection = _Utils.intersect(edge1, edge2);
+        if (!NullChecker.isNull(intersection)) {
+          thereAreIntersections = true;
+          outputVertices.push(intersection);
+          additionalVertices1.push(intersection);
+          additionalVertices2.push(intersection);
+        }
+      }
+    }
+    if (contained1.length === 0 && contained2.length === 0 && !thereAreIntersections) {
+      switch (operator) {
+        case "union":
+          return { polygons: [polygon1, polygon2] };
+        default:
+          return null;
+      }
+    }
+    const constraints = [];
+    for (let edge of edges1.concat(edges2)) {
+      const additionalVertices = ensureMemoizer(edge);
+      if (NullChecker.isNullOrEmpty(additionalVertices)) {
+        constraints.push(edge);
+      } else {
+        const totalVertices = edge.concat(additionalVertices).sort(verticesSortCallback);
+        for (let j = 0; j < totalVertices.length - 1; j++) {
+          constraints.push([totalVertices[j], totalVertices[j + 1]]);
+        }
+      }
+    }
+    var dirty = false;
+    var mesh;
+    do {
+      outputVertices.sort(verticesSortCallback);
+      outputVertices.filter((v, i, arr) => {
+        return i === 0 || !_Utils.areClose(v, arr[i - 1]);
+      });
+      mesh = _Utils.mesh(outputVertices);
+      const { vertices: vertices3, triangleIndices: triangleIndices2 } = mesh;
+      dirty = false;
+      for (let j = 0; j < triangleIndices2.length; j += 3) {
+        const indexA = triangleIndices2[j], indexB = triangleIndices2[j + 1], indexC = triangleIndices2[j + 2];
+        const A = vertices3[indexA], B = vertices3[indexB], C = vertices3[indexC];
+        const sides = [[A, B], [B, C], [C, A]];
+        for (let constraint of constraints) {
+          for (let side of sides) {
+            const consecutive = _Utils.areClose(side[0], constraint[0]) || _Utils.areClose(side[1], constraint[1]) || _Utils.areClose(side[0], constraint[1]) || _Utils.areClose(side[1], constraint[0]);
+            const intersection = consecutive ? null : _Utils.intersect(side, constraint);
+            if (!NullChecker.isNull(intersection) && outputVertices.findIndex((p) => _Utils.areClose(p, intersection, 4)) === -1) {
+              dirty = true;
+              outputVertices.push(intersection);
+            }
+          }
+        }
+      }
+    } while (dirty);
+    const { vertices, triangleIndices } = mesh;
+    const triangles = [];
+    for (let j = 0; j < triangleIndices.length; j += 3) {
+      const jA = j, jB = j + 1, jC = j + 2;
+      const A = vertices[triangleIndices[jA]], B = vertices[triangleIndices[jB]], C = vertices[triangleIndices[jC]];
+      const O = { x: (A.x + B.x + C.x) / 3, y: (A.y + B.y + C.y) / 3 };
+      const in1 = _Utils.inPolygon(O, vertices1), in2 = _Utils.inPolygon(O, vertices2);
+      if (in1 && in2 && operator === "intersect" || (in1 || in2) && operator === "union" || (in1 && !in2 || !in1 && in2) && operator === "difference") {
+        triangles.push([A, B, C]);
+      }
+    }
+    const edges = triangles.flatMap(([A, B, C]) => [[A, B], [B, C], [C, A]]);
+    const uniqueEdges2 = [];
+    for (let j = 0; j < edges.length; j++) {
+      const edge = edges[j];
+      if (j == 0) {
+        uniqueEdges2.push(edge);
+        continue;
+      }
+      const alreadyIn = uniqueEdges2.findIndex((e) => _Utils.areClose(e[0], edge[0]) && _Utils.areClose(e[1], edge[1]) || _Utils.areClose(e[0], edge[1]) && _Utils.areClose(e[1], edge[0]));
+      if (alreadyIn === -1) {
+        uniqueEdges2.push(edge);
+      } else {
+        uniqueEdges2.splice(alreadyIn, 1);
+      }
+    }
+    if (uniqueEdges2.length < 3) {
+      return null;
+    }
+    const polygons = [];
+    const cleanupPolygon = (vertices3) => {
+      const { length } = vertices3;
+      const repeated = _Utils.areClose(vertices3[0], vertices3[length - 1]);
+      const retval = vertices3.slice(0, repeated ? length - 1 : length);
+      if (retval.length > 3 && _Utils.inSegment(retval[0], [retval[1], retval[retval.length - 1]])) {
+        retval.shift();
+      }
+      return retval;
+    };
+    const [P0, P1] = uniqueEdges2.shift();
+    const boundaryVertices = [P0, P1];
+    while (uniqueEdges2.length > 1) {
+      const lastVertex = boundaryVertices[boundaryVertices.length - 1];
+      const nextEdgeIndex = uniqueEdges2.findIndex((e) => _Utils.areClose(e[0], lastVertex) || _Utils.areClose(e[1], lastVertex));
+      if (nextEdgeIndex === -1) {
+        polygons.push({ vertices: cleanupPolygon(boundaryVertices.splice(0)) });
+        const [P2, P3] = uniqueEdges2.shift();
+        boundaryVertices.push(P2, P3);
+      } else {
+        const [nextEdge] = uniqueEdges2.splice(nextEdgeIndex, 1);
+        const nextVertex = _Utils.areClose(nextEdge[0], lastVertex) ? nextEdge[1] : _Utils.areClose(nextEdge[1], lastVertex) ? nextEdge[0] : null;
+        if (boundaryVertices.length > 1 && _Utils.inSegment(boundaryVertices[boundaryVertices.length - 1], [boundaryVertices[boundaryVertices.length - 2], nextVertex])) {
+          boundaryVertices.splice(boundaryVertices.length - 1, 1, nextVertex);
+        } else {
+          boundaryVertices.push(nextVertex);
+        }
+      }
+    }
+    polygons.push({ vertices: cleanupPolygon(boundaryVertices) });
+    return {
+      polygons,
+      mesh,
+      triangles: triangles.map((vertices3) => {
+        return { vertices: vertices3 };
+      })
+    };
+  }
+  static mesh(point, ...points) {
+    const vertices = [].concat(point).concat(points), triangleIndices = Delaunay.triangulate(vertices);
+    return { vertices, triangleIndices };
+  }
+  static intersectLines(segment1, segment2, m2, q2) {
+    let s1, s2;
+    if (Array.isArray(segment1) && Array.isArray(segment2) && segment1.length === 2 && segment2.length === 2 && typeof segment1[0] === "number" && typeof segment2[0] === "number" && typeof segment1[1] === "number" && typeof segment2[1] === "number") {
+      m2 = segment2[0];
+      q2 = segment2[1];
+      segment2 = segment1[1];
+      segment1 = segment1[0];
+    }
+    if (typeof segment1 === "number" && typeof segment2 === "number") {
+      const m1 = segment1, q1 = segment2;
+      s1 = [
+        { x: 0, y: q1 },
+        { x: 1, y: m1 + q1 }
+      ];
+      s2 = [
+        { x: 0, y: q2 },
+        { x: 1, y: m2 + q2 }
+      ];
+    } else {
+      s1 = segment1;
+      s2 = segment2;
+    }
+    return _Utils._intersectSegments(s1, s2, false);
+  }
+  static cramer(l1, l2) {
+    if (Array.isArray(l1)) {
+      l1 = { a: l1[0], b: l1[1], c: l1[2] };
+    }
+    if (Array.isArray(l2)) {
+      l2 = { a: l2[0], b: l2[1], c: l2[2] };
+    }
+    let xP = (l1.b * l2.c - l1.c * l2.b) / (l1.b * l2.a - l1.a * l2.b), yP = (l1.c * l2.a - l1.a * l2.c) / (l1.b * l2.a - l1.a * l2.b);
+    return { x: -xP.roundoff(), y: -yP.roundoff() };
+  }
+  static mq(arg0, p2) {
+    let p1;
+    if (isPoint(arg0)) {
+      p1 = arg0;
+    } else {
+      p1 = arg0[0];
+      p2 = arg0[1];
+    }
+    if (p1.x === p2.x) {
+      return [Number.NaN, Number.NaN];
+    }
+    const m = (p2.y - p1.y) / (p2.x - p1.x);
+    const q = p1.y - m * p1.x;
+    return [m, q];
+  }
+  static _intersectSegments(segment1, segment2, excludeProjection) {
+    const A = segment1[0], B = segment1[1], C = segment2[0], D = segment2[1], xAB = Math.min(A.x, B.x), yAB = Math.min(A.y, B.y), XAB = Math.max(A.x, B.x), wAB = XAB - xAB, YAB = Math.max(A.y, B.y), hAB = YAB - yAB, xCD = Math.min(C.x, D.x), yCD = Math.min(C.y, D.y), XCD = Math.max(C.x, D.x), wCD = XCD - xCD, YCD = Math.max(C.y, D.y), hCD = YCD - yCD;
+    if (wAB === 0 && wCD === 0) {
+      return null;
+    }
+    if (hAB === 0 && hCD === 0) {
+      return null;
+    }
+    const outOfXBounds = (p) => {
+      return p.x < xCD || p.x > XCD || p.x < xAB || p.x > XAB;
+    };
+    const outOfYBounds = (p) => {
+      return p.y < yCD || p.y > YCD || p.y < yAB || p.y > YAB;
+    };
+    var retval = null;
+    if (wAB === 0) {
+      if (excludeProjection && (xCD > xAB || XCD < XAB)) {
+        return null;
+      }
+      const mqCD = _Utils.mq(C, D);
+      retval = _Utils.cramer([1, 0, -xAB], [mqCD[0], -1, mqCD[1]]);
+      if (excludeProjection && outOfYBounds(retval)) {
+        retval = null;
+      }
+    } else if (wCD === 0) {
+      if (excludeProjection && (xAB > xCD || XAB < XCD)) {
+        return null;
+      }
+      const mqAB = _Utils.mq(A, B);
+      retval = _Utils.cramer([mqAB[0], -1, mqAB[1]], [1, 0, -xCD]);
+      if (excludeProjection && outOfYBounds(retval)) {
+        retval = null;
+      }
+    } else if (hAB === 0) {
+      if (excludeProjection && (yCD > yAB || YCD < YAB)) {
+        return null;
+      }
+      const mqCD = _Utils.mq(C, D);
+      retval = _Utils.cramer([0, 1, -yAB], [mqCD[0], -1, mqCD[1]]);
+      if (excludeProjection && outOfXBounds(retval)) {
+        retval = null;
+      }
+    } else if (hCD === 0) {
+      if (excludeProjection && (yAB > yCD || YAB < YCD)) {
+        return null;
+      }
+      const mqAB = _Utils.mq(A, B);
+      retval = _Utils.cramer([mqAB[0], -1, mqAB[1]], [0, 1, -yCD]);
+      if (excludeProjection && outOfXBounds(retval)) {
+        retval = null;
+      }
+    } else {
+      let intersection;
+      if (!excludeProjection || (intersection = _Utils._intersectRects({ x: xAB, y: yAB, width: wAB, height: hAB }, { x: xCD, y: yCD, width: wCD, height: hCD })) && intersection.width > 0 && intersection.height > 0) {
+        const mqAB = _Utils.mq(A, B), mqCD = _Utils.mq(C, D);
+        const mAB = mqAB[0], mCD = mqCD[0], qAB = mqAB[1], qCD = mqCD[1];
+        if (mAB !== mCD) {
+          retval = _Utils.cramer([mAB, -1, qAB], [mCD, -1, qCD]);
+          let xR = retval.x, yR = retval.y;
+          if (excludeProjection && (xR < intersection.x || xR > intersection.x + intersection.width || yR < intersection.y || yR > intersection.y + intersection.height)) {
+            retval = null;
+          }
+        }
+      }
+    }
+    if (retval === null) {
+      return null;
+    }
+    return { x: retval.x, y: retval.y };
+  }
+  static _intersectRects(...args) {
+    return Rect.intersect(...args);
+  }
+  static _areClose(p1, p2, precision = PRECISION) {
+    return Math.abs(p1.x - p2.x).isCloseTo(0, precision) && Math.abs(p1.y - p2.y).isCloseTo(0, precision);
+  }
+  static areClose(p1, p2, precision = PRECISION) {
+    return _Utils._areClose(p1, p2, precision);
+  }
+  /**
+   * Returns the dot product between two vectors/points.
+   * @param v1
+   * @param v2
+   */
+  static dot(v1, v2) {
+    return Vector.dot(v1, v2);
+  }
+  /**
+   * Returns the cross product between two vectors/points (magnitude along the z axis).
+   * @param v1
+   * @param v2
+   */
+  static cross(v1, v2) {
+    return Vector.cross(v1, v2);
+  }
+  static distance(p1, arg2) {
+    if (isSegment(p1)) {
+      return Point2.distance(p1[0], p1[1]);
+    } else if (isPoint(arg2)) {
+      return Point2.distance(p1, arg2);
+    } else {
+      const m = arg2[0], q = arg2[1];
+      return Math.abs(m * p1.x - p1.y + q) / Math.sqrt(Math.pow(m, 2) + 1);
+    }
+  }
+  static _pointSegmentDistance(p, segment) {
+    const v1 = Vector.from(segment[0], segment[1]), v2 = Vector.from(segment[0], p);
+    return _Utils.cross(v1, v2);
+  }
+  static isWithin(p, segment, clockwise, precision = PRECISION) {
+    const cross = _Utils._pointSegmentDistance(p, segment);
+    if (cross.isCloseTo(0, precision)) {
+      return false;
+    }
+    return clockwise ? cross < 0 : cross > 0;
+  }
+  static isBeyond(p, segment, clockwise, precision = PRECISION) {
+    return _Utils.isWithin(p, segment, !clockwise, precision);
+  }
+  static inLine(p, segment, precision = PRECISION) {
+    const cross = _Utils._pointSegmentDistance(p, segment);
+    return cross.isCloseTo(0, precision);
+  }
+  static inSegment(p, segment, precision = PRECISION) {
+    const minx = Math.min(segment[0].x, segment[1].x), maxx = Math.max(segment[0].x, segment[1].x), miny = Math.min(segment[0].y, segment[1].y), maxy = Math.max(segment[0].y, segment[1].y);
+    return p.x >= minx && p.x <= maxx && p.y >= miny && p.y <= maxy && _Utils.inLine(p, segment, precision);
+  }
+  static inTriangle(p, triangle) {
+    let last;
+    for (let j = 0; j < 3; j++) {
+      const p1 = triangle[j], p2 = triangle[(j + 1) % 3], v1 = Point2.subtract(p2, p), v2 = Point2.subtract(p1, p), current = _Utils.cross(v1, v2);
+      if (j > 0 && current * last <= 0) {
+        return false;
+      }
+      last = current;
+    }
+    return true;
+  }
+  static inPolygon(p, vertices, precision = PRECISION) {
+    if (!(vertices?.length >= 3)) {
+      throw `Not enough vertices`;
+    }
+    const length = vertices.length;
+    if (length === 3) {
+      return _Utils.inTriangle(p, [vertices[0], vertices[1], vertices[2]]);
+    }
+    if (precision > 0) {
+      vertices = vertices.map((v) => {
+        return { x: v.x.roundoff(precision), y: v.y.roundoff(precision) };
+      });
+      p = { x: p.x.roundoff(precision), y: p.y.roundoff(precision) };
+    }
+    let minx = Number.MAX_VALUE, miny = Number.MAX_VALUE, maxx = Number.MIN_VALUE, maxy = Number.MIN_VALUE;
+    for (let j = 0; j < length; j++) {
+      const v = vertices[j];
+      minx = Math.min(minx, v.x);
+      miny = Math.min(miny, v.y);
+      maxx = Math.max(maxx, v.x);
+      maxy = Math.max(maxy, v.y);
+    }
+    if (p.x < minx || p.x > maxx || p.y < miny || p.y > maxy) {
+      return false;
+    }
+    const outerPoint = { x: minx - 1, y: p.y }, test = [outerPoint, p];
+    let intersections = 0;
+    for (let j = 0; j < length; j++) {
+      const p1 = vertices[j], p2 = vertices[(j + 1) % length], side = [p1, p2];
+      if (p1.y === p.y) {
+        const p0 = vertices[(j - 1 + length) % length];
+        if (p.x > p1.x && (p0.y - p.y) * (p2.y - p.y) < 0) {
+          intersections++;
+        }
+      } else if (p2.y === p.y) {
+        continue;
+      } else {
+        if (_Utils.intersect(side, test) != null) {
+          intersections++;
+        }
+      }
+    }
+    return intersections % 2 === 1;
+  }
+  static area(point, ...points) {
+    const pts = [].concat(point).concat(points);
+    let retval = 0;
+    const length = pts.length;
+    if (length >= 3) {
+      for (let j = 0; j < pts.length; j++) {
+        const { x: xj, y: yj } = pts[j], next = j === length - 1 ? 0 : j + 1, { x: xnext, y: ynext } = pts[next];
+        retval += xj * ynext - yj * xnext;
+      }
+      retval *= 0.5;
+    }
+    return Math.abs(retval.roundoff());
+  }
+  static convexHull(point, ...points) {
+    const pts = [].concat(point).concat(points);
+    if (!(pts?.length > 1)) {
+      return pts?.slice() ?? [];
+    }
+    const sorted = pts.map((p) => ({ x: p.x, y: p.y })).sort((a, b) => a.x === b.x ? a.y - b.y : a.x - b.x);
+    const unique = [];
+    for (const p of sorted) {
+      const last = unique[unique.length - 1];
+      if (!last || last.x !== p.x || last.y !== p.y) {
+        unique.push(p);
+      }
+    }
+    if (unique.length <= 2) {
+      return unique;
+    }
+    const cross = (o, a, b) => {
+      return (a.x - o.x) * (b.y - o.y) - (a.y - o.y) * (b.x - o.x);
+    };
+    const lower = [];
+    for (const p of unique) {
+      while (lower.length >= 2 && cross(lower[lower.length - 2], lower[lower.length - 1], p) <= 0) {
+        lower.pop();
+      }
+      lower.push(p);
+    }
+    const upper = [];
+    for (let j = unique.length - 1; j >= 0; j--) {
+      const p = unique[j];
+      while (upper.length >= 2 && cross(upper[upper.length - 2], upper[upper.length - 1], p) <= 0) {
+        upper.pop();
+      }
+      upper.push(p);
+    }
+    lower.pop();
+    upper.pop();
+    return lower.concat(upper);
+  }
+};
+
+// packages/numerical/dist/esm/geom/polygon.js
+import { Point as Point3, Matrix2D, Angle, NullChecker as NullChecker2 } from "@pacem/pacem-foundation";
+function isPolygon(obj) {
+  let vertices;
+  return "vertices" in obj && Array.isArray(obj.vertices) && (vertices = obj.vertices).length >= 3 && vertices.every((i) => Point3.isPoint(i));
+}
+var Polygon = class _Polygon {
+  static {
+    this._eps = 1e-12;
+  }
+  static isPolygon(obj) {
+    return isPolygon(obj);
+  }
+  static from(...points) {
+    return { vertices: Array.from(points) };
+  }
+  static contains(polygon, p) {
+    return Utils.inPolygon(p, polygon.vertices, 12);
+  }
+  static centroid(polygon) {
+    const bbox = _Polygon.boundingBox(polygon);
+    return { x: bbox.x + bbox.width / 2, y: bbox.y + bbox.height / 2 };
+  }
+  static boundingBox(polygon) {
+    return Utils.boundingBox(polygon.vertices);
+  }
+  static sides(polygon) {
+    const { vertices } = polygon;
+    const retval = [];
+    for (let j = 1; j <= vertices.length; j++) {
+      const v = vertices[j % vertices.length], v0 = vertices[j - 1];
+      retval.push([v0, v]);
+    }
+    return retval;
+  }
+  static isConvex(polygon) {
+    const { vertices } = polygon, l = vertices.length;
+    if (l <= 3) {
+      return true;
+    }
+    let sign = 0;
+    for (let j = 0; j < vertices.length; j++) {
+      const p0 = vertices[(j - 1 + l) % l], p = vertices[j], p1 = vertices[(j + 1) % l];
+      const theta = Angle.angleBetween(p, p0, p1);
+      if (sign === 0) {
+        sign = Math.sign(theta);
+        continue;
+      }
+      if (sign != Math.sign(theta)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Check whether a polygon is a self-intersecting one.
+   * @param polygon
+   * @returns
+   */
+  static isSelfIntersecting(polygon) {
+    const { vertices } = polygon;
+    if (vertices.length <= 3) {
+      return false;
+    }
+    const sides = _Polygon.sides(polygon);
+    for (let side of sides) {
+      for (let check of sides) {
+        if (
+          /* same */
+          check === side || /* contiguous */
+          check[0] === side[1] || side[0] === check[1]
+        ) {
+          continue;
+        }
+        const intersection = Utils.intersect(check, side);
+        if (!NullChecker2.isNull(intersection)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  /**
+   * Returns whether the vertices of the spcified polygon have been provided in counter-clockwise order.
+   * Meaningless in case of self-intersecting polygons.
+   * @param polygon
+   * @returns
+   */
+  static isCounterClockwise(polygon) {
+    const { vertices: [p0, p1, p2] } = polygon;
+    return Angle.angleBetween(p1, p0, p2) > 0;
+  }
+  /**
+   * Expands (or contracts) a polygon by a provided offset.
+   * @param polygon
+   * @param offset
+   *
+   */
+  static expand(polygon, offset) {
+    const { vertices } = polygon, l = vertices.length, retval = [];
+    for (let j = 0; j < vertices.length; j++) {
+      const p0 = vertices[(j - 1 + l) % l], p = vertices[j], p1 = vertices[(j + 1) % l];
+      const theta = Angle.angleBetween(p, p0, p1), scale = -offset / Math.sin(Math.abs(theta) / 2);
+      const matrix = Matrix2D.scale(Matrix2D.identity, scale);
+      const v0 = Point3.subtract(p, p0);
+      Vector.normalize(v0);
+      const v1 = Point3.subtract(p, p1);
+      Vector.normalize(v1);
+      const vector = Point3.add(v0, v1);
+      Vector.normalize(vector);
+      const pOffset = Matrix2D.multiply(vector, matrix);
+      retval.push(Point3.add(p, { x: pOffset.x.roundoff(), y: pOffset.y.roundoff() }));
+    }
+    return { vertices: retval };
+  }
+  /**
+   * Returns the area of a polygon using the shoelace algorithm. It's meaningless in case of self-intersecting polygons.
+   * @param polygon
+   * @returns
+   */
+  static area(polygon) {
+    return Utils.area(polygon.vertices);
+  }
+  static intersect(polygon1, polygon2) {
+    return Utils.intersect(polygon1, polygon2);
+  }
+  /**
+   * Returns the convex hull of a polygon.
+   * @param polygon
+   * @returns
+   */
+  static convexHull(polygon) {
+    const vertices = Utils.convexHull(polygon.vertices);
+    return { vertices };
+  }
+};
+
+// packages/numerical/dist/esm/geom/geom3d.js
+import { parseAsNumericalArray } from "@pacem/pacem-foundation";
+var RAD2DEG2 = 180 / Math.PI;
+var DEG2RAD = 1 / RAD2DEG2;
+var Vector3D = class _Vector3D {
+  static from(...args) {
+    const l = 3;
+    if (args.length !== l) {
+      throw new RangeError(`Must provide exactly ${l} numbers`);
+    }
+    return { x: args[0], y: args[1], z: args[2] };
+  }
+  static parse(input) {
+    const arr = parseAsNumericalArray(input);
+    if (arr && arr.length === 3) {
+      return _Vector3D.from.apply(null, arr);
+    }
+    throw new Error(`Cannot parse "${input}" as a valid Vector3D.`);
+  }
+  // notable vectors
+  static i() {
+    return { x: 1, y: 0, z: 0 };
+  }
+  static j() {
+    return { x: 0, y: 1, z: 0 };
+  }
+  static k() {
+    return { x: 0, y: 0, z: 1 };
+  }
+  static zero() {
+    return { x: 0, y: 0, z: 0 };
+  }
+  /**
+   * Subtracts a point p from another and returns the resulting vector.
+   * @param p Point to subtract
+   * @param from Point to be subtracted from
+   */
+  static subtract(p, from) {
+    return { x: from.x - p.x, y: from.y - p.y, z: from.z - p.z };
+  }
+  /**
+   * Adds a set of points together and returns the resulting vector.
+   * @param points Points to add
+   */
+  static add(...points) {
+    var point = { x: 0, y: 0, z: 0 };
+    for (var p of points) {
+      point.x += p.x;
+      point.y += p.y;
+      point.z += p.z;
+    }
+    return point;
+  }
+  /**
+  * Returns the dot product between two vectors/points.
+  * @param v1
+  * @param v2
+  */
+  static dot(v1, v2) {
+    return v1.x * v2.x + v1.y * v2.y + v1.z * v2.z;
+  }
+  /**
+   * Returns the cross product between two vectors/points (as a vector itself).
+   * @param v1
+   * @param v2
+   */
+  static cross(v1, v2) {
+    return {
+      x: v1.y * v2.z - v1.z * v2.y,
+      y: v1.z * v2.x - v1.x * v2.z,
+      z: v1.x * v2.y - v1.y * v2.x
+    };
+  }
+  static scale(v, fx, fy = fx, fz = fx) {
+    return { x: v.x * fx, y: v.y * fy, z: v.z * fz };
+  }
+  static magSqr(v) {
+    return v.x * v.x + v.y * v.y + v.z * v.z;
+  }
+  /**
+   * Checks if the two points are effectively the same location.
+   * @param v1 The first point.
+   * @param v2 The second point.
+   * @returns True if the points are considered coincident within tolerance; otherwise, false.
+   */
+  static areClose(v1, v2) {
+    return (v2.x - v1.x).isCloseTo(0) && (v2.y - v1.y).isCloseTo(0) && (v2.z - v1.z).isCloseTo(0);
+  }
+  static mag(v) {
+    return Math.sqrt(_Vector3D.magSqr(v));
+  }
+  static negate(v) {
+    return { x: -v.x, y: -v.y, z: -v.z };
+  }
+  /**
+   * Returns the unit (normalized) vector having the same direction and sense of the provided one.
+   * @param v
+   */
+  static unit(v) {
+    const clone = { x: v.x, y: v.y, z: v.z };
+    this.normalize(clone);
+    return clone;
+  }
+  /**
+   * Normalizes the provided vector in place.
+   * @param v
+   */
+  static normalize(v) {
+    const l = _Vector3D.mag(v);
+    if (l <= 0) {
+      throw "Cannot normalize a vector of length 0.";
+    }
+    const inv = 1 / l;
+    v.x *= inv;
+    v.y *= inv;
+    v.z *= inv;
+  }
+  /**
+   * Returns the angle (in degrees) between two vectors.
+   * @param vector1
+   * @param vector2
+   */
+  static angleBetween(vector1, vector2) {
+    let num;
+    const v1 = _Vector3D.unit(vector1);
+    const v2 = _Vector3D.unit(vector2);
+    const dot = _Vector3D.dot(v1, v2);
+    if (dot < 0) {
+      const vectord = { x: -v1.x - v2.x, y: -v1.y - v2.y, z: -v1.z - v2.z };
+      const length = _Vector3D.mag(vectord);
+      num = Math.PI - 2 * Math.asin(length / 2);
+    } else {
+      const vectord = { x: v1.x - v2.x, y: v1.y - v2.y, z: v1.z - v2.z };
+      const length = _Vector3D.mag(vectord);
+      num = 2 * Math.asin(length / 2);
+    }
+    return RAD2DEG2 * num;
+  }
+};
+var Spherical = class _Spherical {
+  /**
+   * Creates a new {@link Spherical} object.
+   * @param rho radius.
+   * @param theta Azimuth angle in degrees.
+   * @param phi Polar angle in degrees.
+   * @returns
+   */
+  static from(rho, theta, phi) {
+    return { rho: rho.clamp(0, Infinity), theta: theta.clamp(-180, 180), phi: phi.clamp(0, 360) };
+  }
+  static fromVector(v, y, z) {
+    if (typeof v === "number") {
+      v = Vector3D.from(v, y, z);
+    }
+    const rho = Vector3D.mag(v);
+    if (rho.isCloseTo(0)) {
+      return _Spherical.from(0, 0, 0);
+    }
+    const theta = Math.atan2(v.x, v.z), phi = Math.acos((v.y / rho).clamp(-1, 1));
+    return _Spherical.from(rho, theta * RAD2DEG2, phi * RAD2DEG2);
+  }
+  static toVector(coords) {
+    const { rho, theta: thetaDeg, phi: phiDeg } = coords;
+    const phi = phiDeg * DEG2RAD;
+    const theta = thetaDeg * DEG2RAD;
+    const sinPhiRho = Math.sin(phi) * rho;
+    return {
+      x: sinPhiRho * Math.sin(theta),
+      y: Math.cos(phi) * rho,
+      z: sinPhiRho * Math.cos(theta)
+    };
+  }
+  static toRotationMatrix(coords) {
+    const { theta, phi } = coords;
+    const t = DEG2RAD * theta, sinTheta = Math.sin(t), cosTheta = Math.cos(t), p = DEG2RAD * phi, sinPhi = Math.sin(p), cosPhi = Math.cos(p);
+    return Matrix3D.from(sinTheta * cosPhi, sinTheta * sinPhi, cosTheta, 0, cosTheta * cosPhi, cosTheta * sinPhi, -sinTheta, 0, -sinPhi, cosPhi, 0, 0, 0, 0, 0, 1);
+  }
+};
+var Matrix3DUtils = class _Matrix3DUtils {
+  /**
+   * Modifies the content of a provided matrix and returns it as a new matrix instance.
+   * @param m Input matrix
+   * @param action Content change callback
+   * @returns New matrix instance.
+   */
+  static modify(m, action) {
+    const { m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, offsetX, offsetY, offsetZ, m44 } = m;
+    const retval = {
+      m11,
+      m12,
+      m13,
+      m14,
+      m21,
+      m22,
+      m23,
+      m24,
+      m31,
+      m32,
+      m33,
+      m34,
+      offsetX,
+      offsetY,
+      offsetZ,
+      m44
+    };
+    action(retval);
+    return retval;
+  }
+  static clone(m) {
+    return _Matrix3DUtils.modify(m, (_) => {
+    });
+  }
+  static multiply(m1, m2) {
+    if (Matrix3D.isIdentity(m1))
+      return m2;
+    if (Matrix3D.isIdentity(m2))
+      return m1;
+    return Matrix3D.from(m1.m11 * m2.m11 + m1.m12 * m2.m21 + m1.m13 * m2.m31 + m1.m14 * m2.offsetX, m1.m11 * m2.m12 + m1.m12 * m2.m22 + m1.m13 * m2.m32 + m1.m14 * m2.offsetY, m1.m11 * m2.m13 + m1.m12 * m2.m23 + m1.m13 * m2.m33 + m1.m14 * m2.offsetZ, m1.m11 * m2.m14 + m1.m12 * m2.m24 + m1.m13 * m2.m34 + m1.m14 * m2.m44, m1.m21 * m2.m11 + m1.m22 * m2.m21 + m1.m23 * m2.m31 + m1.m24 * m2.offsetX, m1.m21 * m2.m12 + m1.m22 * m2.m22 + m1.m23 * m2.m32 + m1.m24 * m2.offsetY, m1.m21 * m2.m13 + m1.m22 * m2.m23 + m1.m23 * m2.m33 + m1.m24 * m2.offsetZ, m1.m21 * m2.m14 + m1.m22 * m2.m24 + m1.m23 * m2.m34 + m1.m24 * m2.m44, m1.m31 * m2.m11 + m1.m32 * m2.m21 + m1.m33 * m2.m31 + m1.m34 * m2.offsetX, m1.m31 * m2.m12 + m1.m32 * m2.m22 + m1.m33 * m2.m32 + m1.m34 * m2.offsetY, m1.m31 * m2.m13 + m1.m32 * m2.m23 + m1.m33 * m2.m33 + m1.m34 * m2.offsetZ, m1.m31 * m2.m14 + m1.m32 * m2.m24 + m1.m33 * m2.m34 + m1.m34 * m2.m44, m1.offsetX * m2.m11 + m1.offsetY * m2.m21 + m1.offsetZ * m2.m31 + m1.m44 * m2.offsetX, m1.offsetX * m2.m12 + m1.offsetY * m2.m22 + m1.offsetZ * m2.m32 + m1.m44 * m2.offsetY, m1.offsetX * m2.m13 + m1.offsetY * m2.m23 + m1.offsetZ * m2.m33 + m1.m44 * m2.offsetZ, m1.offsetX * m2.m14 + m1.offsetY * m2.m24 + m1.offsetZ * m2.m34 + m1.m44 * m2.m44);
+  }
+};
+var Matrix3D = class _Matrix3D {
+  //#region notable matrices
+  /**
+   * Identity 4x4 matrix.
+   * @returns
+   */
+  static identity() {
+    return {
+      m11: 1,
+      m12: 0,
+      m13: 0,
+      m14: 0,
+      m21: 0,
+      m22: 1,
+      m23: 0,
+      m24: 0,
+      m31: 0,
+      m32: 0,
+      m33: 1,
+      m34: 0,
+      offsetX: 0,
+      offsetY: 0,
+      offsetZ: 0,
+      m44: 1
+    };
+  }
+  //#endregion
+  static from(...args) {
+    const l = 16;
+    if (args.length !== l) {
+      throw new RangeError(`Must provide exactly ${l} numbers`);
+    }
+    return {
+      m11: args[0],
+      m12: args[1],
+      m13: args[2],
+      m14: args[3],
+      m21: args[4],
+      m22: args[5],
+      m23: args[6],
+      m24: args[7],
+      m31: args[8],
+      m32: args[9],
+      m33: args[10],
+      m34: args[11],
+      offsetX: args[12],
+      offsetY: args[13],
+      offsetZ: args[14],
+      m44: args[15]
+    };
+  }
+  static transpose(m) {
+    return _Matrix3D.from(m.m11, m.m21, m.m31, m.offsetX, m.m12, m.m22, m.m32, m.offsetY, m.m13, m.m23, m.m33, m.offsetZ, m.m14, m.m24, m.m34, m.m44);
+  }
+  static toArray(m) {
+    return [
+      m.m11,
+      m.m12,
+      m.m13,
+      m.m14,
+      m.m21,
+      m.m22,
+      m.m23,
+      m.m24,
+      m.m31,
+      m.m32,
+      m.m33,
+      m.m34,
+      m.offsetX,
+      m.offsetY,
+      m.offsetZ,
+      m.m44
+    ];
+  }
+  static clone(m, modifier) {
+    return typeof modifier === "function" ? Matrix3DUtils.modify(m, modifier) : Matrix3DUtils.clone(m);
+  }
+  static scale(m, x, y, z) {
+    if (typeof x === "number") {
+      y ??= x;
+      z ??= x;
+    } else {
+      z = x.z;
+      y = x.y;
+      x = x.x;
+    }
+    return Matrix3DUtils.modify(m, (s) => {
+      s.m11 *= x;
+      s.m22 *= y;
+      s.m33 *= z;
+    });
+  }
+  static translate(m, offset) {
+    return Matrix3DUtils.modify(m, (s) => {
+      s.offsetX += offset.x;
+      s.offsetY += offset.y;
+      s.offsetZ += offset.z;
+    });
+  }
+  static parse(input) {
+    const arr = parseAsNumericalArray(input);
+    if (arr && arr.length === 16) {
+      return _Matrix3D.from.apply(null, arr);
+    }
+    throw new Error(`Cannot parse "${input}" as a valid Matrix3D.`);
+  }
+  static isIdentity(m) {
+    return m.m11 == 1 && m.m12 == 0 && m.m13 == 0 && m.m14 == 0 && m.m21 == 0 && m.m22 == 1 && m.m23 == 0 && m.m24 == 0 && m.m31 == 0 && m.m32 == 0 && m.m33 == 1 && m.m34 == 0 && m.offsetX == 0 && m.offsetY == 0 && m.offsetZ == 0 && m.m44 == 1;
+  }
+  static isAffine(m) {
+    return m.m14 == 0 && m.m24 == 0 && m.m34 == 0 && m.m44 == 1;
+  }
+  static determinant(m) {
+    if (_Matrix3D.isIdentity(m)) {
+      return 1;
+    } else if (_Matrix3D.isAffine(m)) {
+      return m.m11 * (m.m22 * m.m33 - m.m32 * m.m23) - m.m12 * (m.m21 * m.m33 - m.m31 * m.m23) + m.m13 * (m.m21 * m.m32 - m.m31 * m.m22);
+    } else {
+      const num6 = m.m13 * m.m24 - m.m23 * m.m14;
+      const num5 = m.m13 * m.m34 - m.m33 * m.m14;
+      const num4 = m.m13 * m.m44 - m.offsetZ * m.m14;
+      const num3 = m.m23 * m.m34 - m.m33 * m.m24;
+      const num2 = m.m23 * m.m44 - m.offsetZ * m.m24;
+      const num = m.m33 * m.m44 - m.offsetZ * m.m34;
+      const num10 = m.m22 * num5 - m.m32 * num6 - m.m12 * num3;
+      const num9 = m.m12 * num2 - m.m22 * num4 + m.offsetY * num6;
+      const num8 = m.m32 * num4 - m.offsetY * num5 - m.m12 * num;
+      const num7 = m.m22 * num - m.m32 * num2 + m.offsetY * num3;
+      const det = m.offsetX * num10 + m.m31 * num9 + m.m21 * num8 + m.m11 * num7;
+      return det;
+    }
+  }
+  /**
+   * Multiplies two matrices in the provided order (i.e.: applies {@link m2} to {@link m1}).
+   * @param matrices Matrices to apply one to the other, sequentially.
+   * @returns Combination matrix.
+   */
+  static multiply(...matrices) {
+    if (matrices.length === 0) {
+      throw new ReferenceError("Matrix not provided.");
+    }
+    const arr = Array.from(matrices);
+    let m = arr[0];
+    for (let i = 1; i < arr.length; i++) {
+      m = Matrix3DUtils.multiply(m, arr[i]);
+    }
+    return m;
+  }
+  static invert(m) {
+    if (_Matrix3D.isAffine(m)) {
+      const determinant = _Matrix3D.determinant(m);
+      if (determinant == 0) {
+        return null;
+      }
+      const cofactor31 = m.m12 * m.m23 - m.m22 * m.m13;
+      const cofactor21 = m.m32 * m.m13 - m.m12 * m.m33;
+      const cofactor11 = m.m22 * m.m33 - m.m32 * m.m23;
+      const num20 = m.m21 * m.m13 - m.m11 * m.m23;
+      const num19 = m.m11 * m.m33 - m.m31 * m.m13;
+      const num18 = m.m31 * m.m23 - m.m21 * m.m33;
+      const num7 = m.m11 * m.m22 - m.m21 * m.m12;
+      const num6 = m.m11 * m.m32 - m.m31 * m.m12;
+      const num5 = m.m11 * m.offsetY - m.offsetX * m.m12;
+      const num4 = m.m21 * m.m32 - m.m31 * m.m22;
+      const num3 = m.m21 * m.offsetY - m.offsetX * m.m22;
+      const num2 = m.m31 * m.offsetY - m.offsetX * m.m32;
+      const num17 = m.m23 * num5 - m.offsetZ * num7 - m.m13 * num3;
+      const num16 = m.m13 * num2 - m.m33 * num5 + m.offsetZ * num6;
+      const num15 = m.m33 * num3 - m.offsetZ * num4 - m.m23 * num2;
+      const num14 = num7;
+      const num13 = -num6;
+      const num12 = num4;
+      const invdet = 1 / determinant;
+      return _Matrix3D.from(cofactor11 * invdet, cofactor21 * invdet, cofactor31 * invdet, 0, num18 * invdet, num19 * invdet, num20 * invdet, 0, num12 * invdet, num13 * invdet, num14 * invdet, 0, num15 * invdet, num16 * invdet, num17 * invdet, 1);
+    } else {
+      const determinant = _Matrix3D.determinant(m);
+      if (determinant == 0) {
+        return null;
+      }
+      const num1 = m.m33 * m.m44 - m.m34 * m.offsetZ;
+      const num2 = m.m32 * m.m44 - m.m34 * m.offsetY;
+      const num3 = m.m31 * m.m44 - m.m34 * m.offsetX;
+      const num4 = m.m32 * m.offsetZ - m.m33 * m.offsetY;
+      const num5 = m.m31 * m.offsetZ - m.m33 * m.offsetX;
+      const num6 = m.m31 * m.offsetY - m.m32 * m.offsetX;
+      const num7 = m.m33 * m.m44 - m.m34 * m.offsetZ;
+      const num8 = m.m32 * m.m44 - m.m34 * m.offsetY;
+      const num9 = m.m31 * m.m44 - m.m34 * m.offsetX;
+      const num10 = m.m32 * m.offsetZ - m.m33 * m.offsetY;
+      const num11 = m.m31 * m.offsetZ - m.m33 * m.offsetX;
+      const num12 = m.m31 * m.offsetY - m.m32 * m.offsetX;
+      const num13 = m.m23 * m.m44 - m.m24 * m.offsetZ;
+      const num14 = m.m22 * m.m44 - m.m24 * m.offsetY;
+      const num15 = m.m21 * m.m44 - m.m24 * m.offsetX;
+      const num16 = m.m22 * m.offsetZ - m.m23 * m.offsetY;
+      const num17 = m.m21 * m.offsetZ - m.m23 * m.offsetX;
+      const num18 = m.m21 * m.offsetY - m.m22 * m.offsetX;
+      const num19 = m.m23 * m.m34 - m.m24 * m.m33;
+      const num20 = m.m22 * m.m34 - m.m24 * m.m32;
+      const num21 = m.m21 * m.m34 - m.m24 * m.m31;
+      const num22 = m.m22 * m.m33 - m.m23 * m.m32;
+      const num23 = m.m21 * m.m33 - m.m23 * m.m31;
+      const num24 = m.m21 * m.m32 - m.m22 * m.m31;
+      const cofactor11 = m.m22 * num1 - m.m23 * num2 + m.m24 * num4;
+      const cofactor12 = -(m.m21 * num1 - m.m23 * num3 + m.m24 * num5);
+      const cofactor13 = m.m21 * num2 - m.m22 * num3 + m.m24 * num6;
+      const cofactor14 = -(m.m21 * num4 - m.m22 * num5 + m.m23 * num6);
+      const cofactor21 = -(m.m12 * num7 - m.m13 * num8 + m.m14 * num10);
+      const cofactor22 = m.m11 * num7 - m.m13 * num9 + m.m14 * num11;
+      const cofactor23 = -(m.m11 * num8 - m.m12 * num9 + m.m14 * num12);
+      const cofactor24 = m.m11 * num10 - m.m12 * num11 + m.m13 * num12;
+      const cofactor31 = m.m12 * num13 - m.m13 * num14 + m.m14 * num16;
+      const cofactor32 = -(m.m11 * num13 - m.m13 * num15 + m.m14 * num17);
+      const cofactor33 = m.m11 * num14 - m.m12 * num15 + m.m14 * num18;
+      const cofactor34 = -(m.m11 * num16 - m.m12 * num17 + m.m13 * num18);
+      const cofactor41 = -(m.m12 * num19 - m.m13 * num20 + m.m14 * num22);
+      const cofactor42 = m.m11 * num19 - m.m13 * num21 + m.m14 * num23;
+      const cofactor43 = -(m.m11 * num20 - m.m12 * num21 + m.m14 * num24);
+      const cofactor44 = m.m11 * num22 - m.m12 * num23 + m.m13 * num24;
+      const inverseDet = 1 / determinant;
+      return _Matrix3D.from(cofactor11 * inverseDet, cofactor21 * inverseDet, cofactor31 * inverseDet, cofactor41 * inverseDet, cofactor12 * inverseDet, cofactor22 * inverseDet, cofactor32 * inverseDet, cofactor42 * inverseDet, cofactor13 * inverseDet, cofactor23 * inverseDet, cofactor33 * inverseDet, cofactor43 * inverseDet, cofactor14 * inverseDet, cofactor24 * inverseDet, cofactor34 * inverseDet, cofactor44 * inverseDet);
+    }
+  }
+  /**
+   * Moves a given point in 3D space given the transformation matrix.
+   * @param point
+   * @param matrix
+   */
+  static transform(point, matrix) {
+    var pt = { x: point.x, y: point.y, z: point.z };
+    if (!_Matrix3D.isIdentity(matrix)) {
+      var x = pt.x;
+      var y = pt.y;
+      var z = pt.z;
+      pt.x = x * matrix.m11 + y * matrix.m21 + z * matrix.m31 + matrix.offsetX;
+      pt.y = x * matrix.m12 + y * matrix.m22 + z * matrix.m32 + matrix.offsetY;
+      pt.z = x * matrix.m13 + y * matrix.m23 + z * matrix.m33 + matrix.offsetZ;
+      if (!_Matrix3D.isAffine(matrix)) {
+        var num4 = x * matrix.m14 + y * matrix.m24 + z * matrix.m34 + matrix.m44;
+        if (num4 != 0) {
+          pt.x /= num4;
+          pt.y /= num4;
+          pt.z /= num4;
+        }
+      }
+    }
+    return pt;
+  }
+};
+var Quaternion = class _Quaternion {
+  static identity() {
+    return _Quaternion.from(0, 0, 0, 1);
+  }
+  static from(...args) {
+    const l = 4;
+    if (args.length !== l) {
+      throw new RangeError(`Must provide exactly ${l} numbers`);
+    }
+    return {
+      x: args[0],
+      y: args[1],
+      z: args[2],
+      w: args[3]
+    };
+  }
+  static parse(input) {
+    const arr = parseAsNumericalArray(input);
+    if (arr && arr.length === 4) {
+      return _Quaternion.from.apply(null, arr);
+    }
+    throw new Error(`Cannot parse "${input}" as a valid Quaternion.`);
+  }
+  static fromVectors(from, to) {
+    Vector3D.normalize(from);
+    Vector3D.normalize(to);
+    const yieldQ = (x, y, z, w) => {
+      const retval = _Quaternion.from(x, y, z, w);
+      _Quaternion.normalize(retval);
+      return retval;
+    };
+    let r = Vector3D.dot(from, to) + 1;
+    if (r.isCloseTo(0)) {
+      if (Math.abs(from.x) > Math.abs(from.z)) {
+        return yieldQ(
+          -from.y,
+          from.x,
+          0,
+          /* r */
+          0
+        );
+      }
+      return yieldQ(
+        0,
+        -from.z,
+        from.y,
+        /* r */
+        0
+      );
+    } else {
+      return yieldQ(from.y * to.z - from.z * to.y, from.z * to.x - from.x * to.z, from.x * to.y - from.y * to.x, r);
+    }
+  }
+  /**
+   * In-place normalizarion of the provided quaternion
+   * @param q {Quaternion}
+   */
+  static normalize(q) {
+    const l = _Quaternion.mag(q);
+    if (l.isCloseTo(0)) {
+      q.x = q.y = q.z = 0;
+      q.w = 1;
+    } else {
+      const f = 1 / l;
+      q.x *= f;
+      q.y *= f;
+      q.z *= f;
+      q.w *= f;
+    }
+  }
+  /**
+   * Returns a normalized copy of the source quaternion.
+   * @param q {Quaternion}
+   */
+  static unit(q) {
+    const clone = _Quaternion.from(q.x, q.y, q.z, q.w);
+    _Quaternion.normalize(clone);
+    return clone;
+  }
+  /**
+   * Creates a quaternion instance given the rotation axis and an angle (in degrees).
+   * @param axis
+   * @param angleDeg
+   */
+  static fromAxisAngle(axis, angleDeg) {
+    angleDeg %= 360;
+    var angleInRadians = DEG2RAD * angleDeg;
+    var length = Vector3D.mag(axis);
+    if (length == 0) {
+      throw new RangeError("Invalid argument");
+    }
+    var factor = Math.sin(0.5 * angleInRadians) / length;
+    var x = axis.x * factor;
+    var y = axis.y * factor;
+    var z = axis.z * factor;
+    return _Quaternion.from(x, y, z, Math.cos(0.5 * angleInRadians));
+  }
+  /**
+   * Creates a quaternion instance given the rotation matrix.
+   * @param rotationMatrix
+   */
+  static fromRotationMatrix(rotationMatrix) {
+    const trace = rotationMatrix.m11 + rotationMatrix.m22 + rotationMatrix.m33 + rotationMatrix.m44;
+    if (trace > 0) {
+      const sq = 0.5 / Math.sqrt(trace);
+      const w = 0.25 / sq;
+      const x = (rotationMatrix.m23 - rotationMatrix.m32) * sq;
+      const y = (rotationMatrix.m31 - rotationMatrix.m13) * sq;
+      const z = (rotationMatrix.m12 - rotationMatrix.m21) * sq;
+      return _Quaternion.from(x, y, z, w);
+    } else {
+      if (rotationMatrix.m11 > rotationMatrix.m22 && rotationMatrix.m11 > rotationMatrix.m22) {
+        const sq = 0.5 / Math.sqrt(rotationMatrix.m44 + rotationMatrix.m11 - rotationMatrix.m22 - rotationMatrix.m33);
+        const w = (rotationMatrix.m23 - rotationMatrix.m32) * sq;
+        const x = 0.25 / sq;
+        const y = (rotationMatrix.m12 + rotationMatrix.m21) * sq;
+        const z = (rotationMatrix.m31 + rotationMatrix.m13) * sq;
+        return _Quaternion.from(x, y, z, w);
+      } else if (rotationMatrix.m22 > rotationMatrix.m33) {
+        const sq = 0.5 / Math.sqrt(rotationMatrix.m44 + rotationMatrix.m22 - rotationMatrix.m11 - rotationMatrix.m33);
+        const z = (rotationMatrix.m23 + rotationMatrix.m32) * sq;
+        const y = 0.25 / sq;
+        const x = (rotationMatrix.m12 + rotationMatrix.m21) * sq;
+        const w = (rotationMatrix.m31 - rotationMatrix.m13) * sq;
+        return _Quaternion.from(x, y, z, w);
+      } else {
+        const sq = 0.5 / Math.sqrt(rotationMatrix.m44 + rotationMatrix.m33 - rotationMatrix.m11 - rotationMatrix.m22);
+        const y = (rotationMatrix.m23 + rotationMatrix.m32) * sq;
+        const z = 0.25 / sq;
+        const w = (rotationMatrix.m12 - rotationMatrix.m21) * sq;
+        const x = (rotationMatrix.m31 - rotationMatrix.m13) * sq;
+        return _Quaternion.from(x, y, z, w);
+      }
+    }
+  }
+  static conjugate(q) {
+    return _Quaternion.from(-q.x, -q.y, -q.z, q.w);
+  }
+  /**
+   * Returns the magnitude/length of the provided quaternion.
+   * @param q {Quaternion}
+   */
+  static mag(q) {
+    return Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z + q.w * q.w);
+  }
+  static norm(q) {
+    return q.x * q.x + q.y * q.y + q.z * q.z;
+  }
+  static axis(q) {
+    if (q.x == 0 && q.y == 0 && q.z == 0) {
+      return Vector3D.j();
+    }
+    return Vector3D.unit(q);
+  }
+  static transform(v, q) {
+    _Quaternion.normalize(q);
+    const cross = Vector3D.cross(q, v);
+    const t = Vector3D.scale(cross, 2);
+    const tCross = Vector3D.cross(q, t);
+    return {
+      x: v.x + q.w * t.x + tCross.x,
+      y: v.y + q.w * t.y + tCross.y,
+      z: v.z + q.w * t.z + tCross.z
+    };
+  }
+  /**
+   * Returns the rotation angle (in degrees) of the provided quaternion.
+   * @param q
+   */
+  static angle(q) {
+    let y = Math.sqrt(q.x * q.x + q.y * q.y + q.z * q.z);
+    let x = q.w;
+    if (y > Number.MAX_VALUE) {
+      const num = Math.max(Math.abs(q.x), Math.max(Math.abs(q.y), Math.abs(q.z)));
+      const num5 = q.x / num;
+      const num4 = q.y / num;
+      const num3 = q.z / num;
+      y = Math.sqrt(num5 * num5 + num4 * num4 + num3 * num3);
+      x /= num;
+    }
+    return Math.atan2(y, x) * 114.59155902616465;
+  }
+  static toRotationMatrix(q) {
+    var m = Matrix3D.identity();
+    var X = q.x;
+    var Y = q.y;
+    var Z = q.z;
+    var W = q.w;
+    m.m11 = 1 - 2 * Y * Y - 2 * Z * Z;
+    m.m12 = 2 * X * Y + 2 * W * Z;
+    m.m13 = 2 * X * Z - 2 * W * Y;
+    m.m21 = 2 * X * Y - 2 * W * Z;
+    m.m22 = 1 - 2 * X * X - 2 * Z * Z;
+    m.m23 = 2 * Y * Z + 2 * W * X;
+    m.m31 = 2 * W * Y + 2 * X * Z;
+    m.m32 = 2 * Y * Z - 2 * W * X;
+    m.m33 = 1 - 2 * X * X - 2 * Y * Y;
+    return m;
+  }
+  static invert(q) {
+    const n = _Quaternion.unit(q);
+    return _Quaternion.conjugate(n);
+  }
+  /**
+   * Combines two quaternions.
+   * @param q1
+   * @param q2
+   */
+  static multiply(q1, q2) {
+    return _Quaternion.from(q1.w * q2.x + q1.x + q2.w + q1.y * q2.z - q1.z * q2.y, q1.w * q2.y - q1.x * q2.z + q1.y * q2.w + q1.z * q2.x, q1.w * q2.z + q1.x * q2.y - q1.y * q2.x + q1.z * q2.w, q1.w * q2.w - q1.x * q2.x - q1.y * q2.y - q1.z * q2.z);
+  }
+  /**
+   * Returns the dot product of two quaternions.
+   * @param q1
+   * @param q2
+   */
+  static dot(q1, q2) {
+    var q = _Quaternion.multiply(q1, _Quaternion.conjugate(q2));
+    return q.w;
+  }
+};
+
+// packages/numerical/dist/esm/geom/util3d.js
+var Utils3D = class {
+  /**
+   * Computes the intersection between a ray and a triangle in the 3D space - if any - using the Möller–Trumbore algorithm.
+   * @param ray Array of two points identifying a ray.
+   * @param triangle Array of three points identifying a triangle.
+   * @returns Intersection point if any, otherwise null.
+   */
+  static intersect(ray, triangle) {
+    const [start, end] = ray;
+    const vector = Vector3D.subtract(start, end);
+    const [a, b, c] = triangle;
+    const ab = Vector3D.subtract(a, b);
+    const ac = Vector3D.subtract(a, c);
+    const cross = Vector3D.cross(vector, ac);
+    const det = Vector3D.dot(ab, cross);
+    if (det.isCloseTo(0)) {
+      return null;
+    }
+    const invDet = 1 / det;
+    const s = Vector3D.subtract(start, a);
+    const u = invDet * Vector3D.dot(s, cross);
+    if (u < 0 || u > 1) {
+      return null;
+    }
+    const scross = Vector3D.cross(s, ab);
+    const v = invDet * Vector3D.dot(vector, scross);
+    if (v < 0 || u + v > 1) {
+      return null;
+    }
+    const t = invDet * Vector3D.dot(ac, scross);
+    if (t < 0 || t.isCloseTo(0)) {
+      return null;
+    }
+    return Vector3D.add(start, Vector3D.scale(vector, t));
+  }
+};
+
+// packages/numerical/dist/esm/index-geometry-linearalgebra.js
+var index_geometry_linearalgebra_exports = {};
+__export(index_geometry_linearalgebra_exports, {
+  Matrix3D: () => Matrix3D,
+  Quaternion: () => Quaternion,
+  Spherical: () => Spherical,
+  Vector: () => Vector,
+  Vector3D: () => Vector3D
+});
+
+// packages/numerical/dist/esm/index-mathematics.js
+var index_mathematics_exports = {};
+__export(index_mathematics_exports, {
+  Complex: () => Complex,
+  DataAnalysis: () => index_mathematics_dataanalysis_exports,
+  NumberTheory: () => math_exports
+});
+
+// packages/numerical/dist/esm/math/complex.js
+function complex(c) {
+  if (typeof c === "number") {
+    c = { real: c, img: 0 };
+  }
+  return c;
+}
+var NOT_A_COMPLEX;
+function buildComplex(real, img) {
+  const c = {};
+  Object.defineProperty(c, "real", { value: real, writable: false });
+  Object.defineProperty(c, "img", { value: img, writable: false });
+  return c;
+}
+function nac() {
+  return NOT_A_COMPLEX || (NOT_A_COMPLEX = buildComplex(Number.NaN, Number.NaN));
+}
+var Complex = class {
+  static build(real, img) {
+    if (this.isComplex(real)) {
+      return real;
+    }
+    img ??= 0;
+    if (typeof real != "number" || typeof img != "number") {
+      return nac();
+    }
+    return buildComplex(real, img || 0);
+  }
+  static add(a, b) {
+    const ac = complex(a), bc = complex(b);
+    return buildComplex(ac.real + bc.real, ac.img + bc.img);
+  }
+  static subtract(from, what) {
+    const ac = complex(from), bc = complex(what);
+    return buildComplex(ac.real - bc.real, ac.img - bc.img);
+  }
+  static multiply(a, b) {
+    const ac = complex(a), bc = complex(b);
+    return buildComplex(
+      /* real*/
+      ac.real * bc.real - ac.img * bc.img,
+      /* img */
+      ac.real * bc.img + ac.img * bc.real
+    );
+  }
+  static divide(a, b) {
+    const ac = complex(a), bc = complex(b);
+    const div = this.absSquare(bc).roundoff();
+    if (div === 0) {
+      return nac();
+    }
+    const inv_div = 1 / div;
+    return buildComplex(
+      /* real*/
+      inv_div * (ac.real * bc.real + ac.img * bc.img),
+      /* img */
+      inv_div * (ac.img * bc.real - ac.real * bc.img)
+    );
+  }
+  static absSquare(c) {
+    const ac = complex(c);
+    return Math.pow(ac.real, 2) + Math.pow(ac.img, 2);
+  }
+  static modulus(c) {
+    return Math.sqrt(this.absSquare(c));
+  }
+  static isComplex(c) {
+    return c != null && typeof c === "object" && "real" in c && "img" in c && typeof c.real === "number" && typeof c.img === "number";
+  }
+  static conjugate(a) {
+    a = complex(a);
+    return buildComplex(a.real, Math.abs(a.img) == 0 ? 0 : -a.img);
+  }
+  static equals(c1, c2) {
+    const c_1 = this.build(c1), c_2 = this.build(c2);
+    if (!this.isComplex(c1) || !this.isComplex(c2)) {
+      return false;
+    }
+    return c_1.real === c_2.real && c_1.img === c_2.img;
+  }
+  //static isNaN(c: Complex | number): boolean {
+  //    switch (c) {
+  //        case undefined:
+  //            // doh!
+  //            return true;
+  //        case null:
+  //            // doh!
+  //            return false;
+  //        default:
+  //            if (!this.isComplex(  c)
+  //    }
+  //}
+  static get NaC() {
+    return nac();
+  }
+};
+
+// packages/numerical/dist/esm/index-mathematics-dataanalysis.js
+var index_mathematics_dataanalysis_exports = {};
+__export(index_mathematics_dataanalysis_exports, {
+  Fourier: () => Fourier,
+  Gaussian: () => Gaussian,
+  Lagrange: () => Lagrange,
+  Lagrangian: () => Lagrangian,
+  Newton: () => Newton,
+  Pchip: () => Pchip,
+  SearchFunctions: () => SearchFunctions,
+  Utils: () => Utils2
+});
+
+// packages/numerical/dist/esm/math/fourier.js
+function euler(k, N) {
+  const x = 2 * Math.PI * k / N;
+  return Complex.build(Math.cos(x), Math.sin(x));
+}
+var unitCircle = {};
+function exp(k, N) {
+  const memN = unitCircle[N] = unitCircle[N] || {};
+  return memN[k] = memN[k] || euler(k, N);
+}
+function isPowerOfTwo(length) {
+  return length > 0 && (length & length - 1) === 0;
+}
+function fftRec(data) {
+  const retval = [], N = data.length;
+  if (N === 1) {
+    return [Complex.build(data[0])];
+  }
+  const retval_2n = fftRec(data.filter((_, i) => i % 2 === 0)), retval_2n1 = fftRec(data.filter((_, i) => i % 2 === 1));
+  for (var k = 0; k < N / 2; k++) {
+    const t = retval_2n[k], e = Complex.multiply(exp(k, N), retval_2n1[k]);
+    retval[k] = Complex.add(t, e);
+    retval[k + N / 2] = Complex.subtract(t, e);
+  }
+  return retval;
+}
+var Fourier = class {
+  /**
+   * Checks the input vector and outputs a frequency vector using the best performing algo.
+   * @param data Input vector of any size
+   * @param normalize Whether to normalize the signal or not (default true)
+   */
+  static transform(data, normalize = true) {
+    data = data || [];
+    if (isPowerOfTwo(data.length)) {
+      return this.fft(data, normalize);
+    }
+    return this.dft(data, normalize);
+  }
+  /**
+   * Checks the input vector and applies inverted fourier transform's best performing algo.
+   * @param data Input frequency vector
+   */
+  static invert(data, normalize = true) {
+    return this.idft(data || [], normalize);
+  }
+  /**
+   * Naive Discrete Fourier Transform implementation (O(n^2) algo).
+   * @param data Input vector of any size
+   * @param normalize Whether to normalize the signal or not (default true)
+   */
+  static dft(data, normalize = true) {
+    const N = (data || [])?.length, DEN = normalize ? 1 / Math.sqrt(N) : 1, retval = [];
+    for (let k = 0; k < N; k++) {
+      retval.push({ real: 0, img: 0 });
+      for (let j = 0; j < N; j++) {
+        const e = exp(k * j, N), item = Complex.multiply(data[j], e), itemN = Complex.multiply(item, DEN);
+        retval[k] = Complex.add(retval[k], itemN);
+      }
+    }
+    return retval;
+  }
+  /**
+   * Inverse Discrete Fourier Transform.
+   * @param data Input vector data of any size
+   */
+  static idft(data, normalize = true) {
+    const reversed = data.map((i) => Complex.build(i.img, i.real)), temp = this.transform(reversed, normalize);
+    return temp.map((c) => Complex.build(c.img, c.real));
+  }
+  /**
+   * FFT processing using Cooley-Tukey.
+   * @param data Input vector (size MUST be power of 2)
+   */
+  static fft(data, normalize = true) {
+    const retval = fftRec(data);
+    if (!normalize) {
+      return retval;
+    }
+    const DEN = 1 / Math.sqrt(data.length);
+    return retval.map((i) => Complex.multiply(i, DEN));
+  }
+};
+
+// packages/numerical/dist/esm/math/gaussian.js
+var SQRT_PI = Math.sqrt(Math.PI);
+function erfc(x) {
+  const z = Math.abs(x);
+  const t = 1 / (1 + 0.5 * z);
+  const ans = t * Math.exp(-z * z - 1.26551223 + t * (1.00002368 + t * (0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * (0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * (-0.82215223 + t * 0.17087277)))))))));
+  return x >= 0 ? ans : 2 - ans;
+}
+var Gaussian = class {
+  constructor(mean2, stdev2) {
+    this.mean = mean2;
+    this.stdev = Math.abs(stdev2);
+    this.variance = Math.pow(stdev2, 2);
+  }
+  static get normal() {
+    return _normal;
+  }
+  /**
+   * Un-normalized probability density function.
+   * Can be useful as a weight function without requiring the integral w(x)dx to be 1.
+   * @param x Input value
+   */
+  weight(x) {
+    return Math.exp(-0.5 * Math.pow(this._z(x), 2));
+  }
+  /**
+   * Probability density function (PDF).
+   * @param x Input value
+   */
+  probabilityDensity(x) {
+    const inv_coeff = this.stdev * Math.SQRT2 * SQRT_PI, exp_part = this.weight(x);
+    return exp_part / inv_coeff;
+  }
+  _z(x) {
+    return (x - this.mean) / this.stdev;
+  }
+  /**
+   * Returns the area under the PDF from -∞ to x
+   * @param x Input value
+   */
+  probability(x) {
+    return 0.5 * erfc(-this._z(x) / Math.SQRT2);
+  }
+};
+var _normal = new Gaussian(0, 1);
+
+// packages/numerical/dist/esm/math/interpolation.js
+var Lagrange = class _Lagrange {
+  constructor(points) {
+    this.#set = points;
+  }
+  #set;
+  #weights = null;
+  _prepareBarycentric() {
+    if (this.#weights) {
+      return;
+    }
+    const points = this.#set || [];
+    const n = points.length;
+    if (n === 0) {
+      this.#weights = [];
+      return;
+    }
+    const logs = new Array(n);
+    const signs = new Array(n);
+    for (let j = 0; j < n; j++) {
+      let sumLog = 0;
+      let sign = 1;
+      const xj = points[j].x;
+      for (let m = 0; m < n; m++) {
+        if (m === j)
+          continue;
+        const diff = xj - points[m].x;
+        if (diff === 0) {
+          throw new Error("Invalid function provided.");
+        }
+        if (diff < 0)
+          sign = -sign;
+        sumLog += Math.log(Math.abs(diff));
+      }
+      logs[j] = -sumLog;
+      signs[j] = sign;
+    }
+    let maxLog = logs[0];
+    for (let j = 1; j < n; j++) {
+      if (logs[j] > maxLog)
+        maxLog = logs[j];
+    }
+    const w = new Array(n);
+    for (let j = 0; j < n; j++) {
+      const scaled = Math.exp(logs[j] - maxLog);
+      w[j] = signs[j] * scaled;
+    }
+    this.#weights = w;
+  }
+  _computeBarycentric(x) {
+    const points = this.#set || [];
+    if (!this.#weights) {
+      this._prepareBarycentric();
+    }
+    const w = this.#weights || [];
+    let numerator = 0;
+    let denominator = 0;
+    for (let j = 0; j < points.length; j++) {
+      const xj = points[j].x;
+      if (x === xj) {
+        return points[j].y;
+      }
+      const temp = w[j] / (x - xj);
+      numerator += temp * points[j].y;
+      denominator += temp;
+    }
+    return numerator / denominator;
+  }
+  // Iterative/global Lagrange computation removed — barycentric is used
+  // exclusively for interpolation.
+  interpolate(x) {
+    return this._computeBarycentric(x);
+  }
+  static create(...values) {
+    var array = [];
+    if (arguments.length > 0 && Array.isArray(arguments[0])) {
+      array = arguments[0];
+    } else {
+      array = Array.from(values);
+    }
+    const points = array.map((y, x) => {
+      return typeof y === "number" ? { x, y } : y;
+    });
+    return new _Lagrange(points);
+  }
+};
+var Lagrangian = {
+  create: Lagrange.create
+};
+var Pchip = class _Pchip {
+  constructor(points) {
+    if (!points || points.length < 2)
+      throw new Error("Need at least 2 points");
+    const pts = points.slice().sort((a, b) => a.x - b.x);
+    this.xs = pts.map((p) => p.x);
+    this.ys = pts.map((p) => p.y);
+    this.ms = this.computeDerivatives();
+  }
+  computeDerivatives() {
+    const n = this.xs.length;
+    const h = new Array(n - 1);
+    const delta = new Array(n - 1);
+    for (let i = 0; i < n - 1; i++) {
+      h[i] = this.xs[i + 1] - this.xs[i];
+      delta[i] = (this.ys[i + 1] - this.ys[i]) / h[i];
+    }
+    const m = new Array(n).fill(0);
+    m[0] = delta[0];
+    m[n - 1] = delta[n - 2];
+    for (let i = 1; i < n - 1; i++) {
+      const d1 = delta[i - 1], d2 = delta[i];
+      if (d1 === 0 || d2 === 0 || d1 * d2 <= 0) {
+        m[i] = 0;
+      } else {
+        const w1 = 2 * h[i] + h[i - 1];
+        const w2 = h[i] + 2 * h[i - 1];
+        m[i] = (w1 + w2) / (w1 / d1 + w2 / d2);
+      }
+    }
+    for (let i = 0; i < n - 1; i++) {
+      if (delta[i] === 0) {
+        m[i] = 0;
+        m[i + 1] = 0;
+      } else {
+        const a = m[i] / delta[i];
+        const b = m[i + 1] / delta[i];
+        const s = a * a + b * b;
+        if (s > 9) {
+          const tau = 3 / Math.sqrt(s);
+          m[i] = tau * a * delta[i];
+          m[i + 1] = tau * b * delta[i];
+        }
+      }
+    }
+    return m;
+  }
+  interpolate(x) {
+    const xs = this.xs, ys = this.ys, ms = this.ms;
+    const n = xs.length;
+    if (x <= xs[0]) {
+      const slope = ms[0];
+      return ys[0] + slope * (x - xs[0]);
+    }
+    if (x >= xs[n - 1]) {
+      const slope = ms[n - 1];
+      return ys[n - 1] + slope * (x - xs[n - 1]);
+    }
+    let i = 0, j = n - 1;
+    while (j - i > 1) {
+      const mid = i + j >> 1;
+      if (xs[mid] <= x)
+        i = mid;
+      else
+        j = mid;
+    }
+    const h = xs[i + 1] - xs[i];
+    const t = (x - xs[i]) / h;
+    const t2 = t * t, t3 = t2 * t;
+    const h00 = 2 * t3 - 3 * t2 + 1;
+    const h10 = t3 - 2 * t2 + t;
+    const h01 = -2 * t3 + 3 * t2;
+    const h11 = t3 - t2;
+    return h00 * ys[i] + h10 * (ms[i] * h) + h01 * ys[i + 1] + h11 * (ms[i + 1] * h);
+  }
+  static create(...values) {
+    var array = [];
+    if (arguments.length > 0 && Array.isArray(arguments[0])) {
+      array = arguments[0];
+    } else {
+      array = Array.from(values);
+    }
+    const points = array.map((y, x) => {
+      return typeof y === "number" ? { x, y } : y;
+    });
+    return new _Pchip(points);
+  }
+};
+var Newton = class _Newton {
+  constructor(points) {
+    if (!points || points.length === 0)
+      throw new Error("Need at least 1 point");
+    const pts = points.slice().sort((a2, b) => a2.x - b.x);
+    this.xs = pts.map((p) => p.x);
+    const n = pts.length;
+    const a = pts.map((p) => p.y);
+    for (let j = 1; j < n; j++) {
+      for (let i = n - 1; i >= j; i--) {
+        const denom = this.xs[i] - this.xs[i - j];
+        if (denom === 0)
+          throw new Error("Invalid function provided.");
+        a[i] = (a[i] - a[i - 1]) / denom;
+      }
+    }
+    this.coeffs = a;
+  }
+  interpolate(x) {
+    const xs = this.xs, a = this.coeffs;
+    const n = a.length;
+    if (n === 0)
+      return NaN;
+    let result = a[n - 1];
+    for (let i = n - 2; i >= 0; i--) {
+      result = result * (x - xs[i]) + a[i];
+    }
+    return result;
+  }
+  static create(...values) {
+    var array = [];
+    if (arguments.length > 0 && Array.isArray(arguments[0])) {
+      array = arguments[0];
+    } else {
+      array = Array.from(values);
+    }
+    const points = array.map((y, x) => {
+      return typeof y === "number" ? { x, y } : y;
+    });
+    return new _Newton(points);
+  }
+};
+
+// packages/numerical/dist/esm/math/statistics.js
+var selfSelector = (i, _) => i;
+function mode(set, selector = selfSelector) {
+  const groups = Object.groupBy(set, selector);
+  let key, max = 0;
+  for (let group in groups) {
+    const l = groups[group].length;
+    if (l > max) {
+      key = parseInt(group);
+      max = l;
+    }
+  }
+  return key;
+}
+function median(set, selector = selfSelector) {
+  const setCopy = set.slice(0), length = setCopy.length;
+  setCopy.sort((a, b) => {
+    const i = selector(a), j = selector(b);
+    return i - j;
+  });
+  const index = Math.ceil(setCopy.length / 2) - 1;
+  if (length % 2 == 1) {
+    return setCopy[index];
+  }
+  return 0.5 * (setCopy[index + 1] + setCopy[index]);
+}
+function sum(set, selector = selfSelector) {
+  return set.reduce((p, c, i) => p + selector(c, i), 0);
+}
+function mean(set, selector = selfSelector) {
+  return sum(set, selector) / set.length;
+}
+function variance(set, selector = selfSelector, bessel = false) {
+  const avg = mean(set, selector);
+  return set.reduce((p, c) => Math.pow(c - avg, 2) + p, 0) / (set.length - (bessel ? 1 : 0));
+}
+function stdev(set, selector = selfSelector, bessel = false) {
+  const v = variance(set, selector, bessel);
+  return Math.sqrt(v);
+}
+function correlation(set, arg2, selector1 = selfSelector, selector2 = selfSelector) {
+  const twoArrays = Array.isArray(arg2);
+  if (twoArrays && arg2.length !== set.length) {
+    throw new Error("Sets must be of the same length.");
+  }
+  const length = set.length;
+  const setX = set, setY = twoArrays ? arg2 : set;
+  const selectorX = twoArrays ? selector1 : arg2;
+  const selectorY = twoArrays ? selector2 : selector1;
+  const meanX = mean(setX, selectorX);
+  const meanY = mean(setY, selectorY);
+  let accNum = 0;
+  let accDenXSq = 0;
+  let accDenYSq = 0;
+  for (let i = 0; i < length; i++) {
+    const itemX = setX[i], itemY = setY[i];
+    const a = selectorX(itemX, i) - meanX;
+    const b = selectorY(itemY, i) - meanY;
+    accNum += a * b;
+    accDenXSq += a * a;
+    accDenYSq += b * b;
+  }
+  return accNum / Math.sqrt(accDenXSq * accDenYSq);
+}
+function linearRegression(set, arg2, selector1 = selfSelector, selector2 = selfSelector) {
+  const twoArrays = Array.isArray(arg2);
+  if (twoArrays && arg2.length !== set.length) {
+    throw new Error("Sets must be of the same length.");
+  }
+  const setX = set, setY = twoArrays ? arg2 : set;
+  const selectorX0 = twoArrays ? selector1 : arg2;
+  const selectorY0 = twoArrays ? selector2 : selectorX0;
+  const selectorX = selectorX0 ?? ((p) => p.x);
+  const selectorY = selectorY0 ?? ((p) => p.y);
+  const length = set.length;
+  let xyAcc = 0, xAcc = 0, yAcc = 0, x2Acc = 0, y2Acc = 0;
+  for (let i = 0; i < length; i++) {
+    const itemX = setX[i], itemY = setY[i];
+    const x = selectorX(itemX, i);
+    const y = selectorY(itemY, i);
+    xyAcc += x * y;
+    xAcc += x;
+    yAcc += y;
+    x2Acc += x * x;
+    y2Acc += y * y;
+  }
+  const m = (length * xyAcc - xAcc * yAcc) / (length * x2Acc - Math.pow(xAcc, 2));
+  const q = (yAcc - m * xAcc) / length;
+  return [m, q];
+}
+var Utils2 = class {
+  static sum(set, selector) {
+    return sum(set, selector);
+  }
+  static mean(set, selector) {
+    return mean(set, selector);
+  }
+  static median(set, selector) {
+    return median(set, selector);
+  }
+  static mode(set, selector) {
+    return mode(set, selector);
+  }
+  static var(set, selector) {
+    return variance(set, selector, true);
+  }
+  static varp(set, selector) {
+    return variance(set, selector, false);
+  }
+  static stdevp(set, selector) {
+    return stdev(set, selector, false);
+  }
+  static stdev(set, selector) {
+    return stdev(set, selector, true);
+  }
+  static correlation(set, arg2, selector1, selector2) {
+    return correlation(set, arg2, selector1, selector2);
+  }
+  static linearRegression(set, arg2, selector1, selector2) {
+    return linearRegression(set, arg2, selector1, selector2);
+  }
+  // restart from here: https://en.wikipedia.org/wiki/Multivariate_statistics#Multivariate_analysis
+  /**
+   * Returns a set of utilities for gaussian distribution computations.
+   * @param mean
+   * @param stdev
+   */
+  static gaussian(mean2, stdev2) {
+    return new Gaussian(mean2, stdev2);
+  }
+};
+function searchFnFactory(minAssigner, maxAssigner) {
+  const fn = (left, right, f, tolerance) => {
+    let min = left;
+    let max = right;
+    let x1 = minAssigner(min, max);
+    let x2 = maxAssigner(min, max);
+    let f1 = f(x1);
+    let f2 = f(x2);
+    while (max - min > tolerance) {
+      if (f1 < f2) {
+        max = x2;
+        x2 = x1;
+        f2 = f1;
+        x1 = minAssigner(min, max);
+        f1 = f(x1);
+      } else {
+        min = x1;
+        x1 = x2;
+        f1 = f2;
+        x2 = maxAssigner(min, max);
+        f2 = f(x2);
+      }
+    }
+    return 0.5 * (x1 + x2);
+  };
+  return fn;
+}
+var DEFAULT_TOLERANCE = 1e-3;
+var goldenRatioSearch = (left, right, weight, tolerance = DEFAULT_TOLERANCE) => {
+  const phi = 1.618;
+  const minAssigner = (min, max) => max - (max - min) / phi;
+  const maxAssigner = (min, max) => min + (max - min) / phi;
+  const fn = searchFnFactory(minAssigner, maxAssigner);
+  return fn(left, right, weight, tolerance);
+};
+function linearSearch(segments) {
+  if (segments <= 1) {
+    throw new RangeError("segments must be a number grater than 1.");
+  }
+  return (left, right, weight, tolerance = DEFAULT_TOLERANCE) => {
+    const minAssigner = (min, max) => min + (max - min) / segments;
+    const maxAssigner = (min, max) => max - (max - min) / segments;
+    const fn = searchFnFactory(minAssigner, maxAssigner);
+    return fn(left, right, weight, tolerance);
+  };
+}
+var gaussianSearch = (left, right, weight, tolerance = DEFAULT_TOLERANCE) => {
+  var sigma0 = null;
+  var length0 = null;
+  const computeSigma = (min, max) => {
+    length0 ??= max - min;
+    sigma0 ??= length0 / Math.sqrt(12);
+    return sigma0 * (max - min) / length0;
+  };
+  const minAssigner = (min, max) => Math.max(min, (max + min) / 2 - computeSigma(min, max));
+  const maxAssigner = (min, max) => Math.min(max, (max + min) / 2 + computeSigma(min, max));
+  const fn = searchFnFactory(minAssigner, maxAssigner);
+  return fn(left, right, weight, tolerance);
+};
+var SearchFunctions = {
+  /**
+   * Creates a linear search function.
+   * @param segments How many segments to split the range into.
+   */
+  linear: (segments = 2) => linearSearch(segments),
+  /** Golden section search function. */
+  goldenRatio: goldenRatioSearch,
+  /** Gaussian search function. */
+  gaussian: gaussianSearch
+};
+
+// packages/numerical/dist/esm/math/math.js
+var math_exports = {};
+__export(math_exports, {
+  Utils: () => Utils3
+});
+import { Numbers, NullChecker as NullChecker3 } from "@pacem/pacem-foundation";
+var ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
+var OUT_OF_RANGE = `Radix out of range: possible values go between positive 1 exclusive and ${ALPHABET.length} inclusive`;
+var Utils3 = class _Utils {
+  static lcd(...args) {
+    if (NullChecker3.isNullOrEmpty(args) || args.length <= 1) {
+      throw "Insufficient set of numbers.";
+    }
+    function ex9(x, y) {
+      if (!y)
+        return y === 0 ? x : NaN;
+      return ex9(y, x % y);
+    }
+    function ex10(x, y) {
+      return x * y / ex9(x, y);
+    }
+    let result = Math.round(args[0]);
+    for (let j = 1; j < args.length; j++) {
+      result = ex10(result, Math.round(args[j]));
+    }
+    return result;
+  }
+  static gcd(a, b) {
+    a = Math.round(a), b = Math.round(b);
+    if (a === 0) {
+      return b;
+    }
+    return _Utils.gcd(b % a, a);
+  }
+  static rebaseInt(v, from, to) {
+    return Numbers.rebase(v, from, to);
+  }
+  static rebaseFloat(v, fromRadix, toRadix, precision = 12) {
+    const from10 = _Utils.rebaseFloat10ToN, to10 = _Utils.rebaseFloatNTo10;
+    if (fromRadix === 10) {
+      const vFloat = parseFloat(v.toString());
+      if (toRadix % 1 === 0) {
+        return _Utils.rebaseFloat10ToNIntBase(vFloat, toRadix, precision);
+      }
+      return from10(vFloat, toRadix, precision);
+    }
+    if (toRadix === 10) {
+      return to10(v.toString(), fromRadix, precision);
+    }
+    const _10 = to10(v.toString(), fromRadix, precision + 1);
+    return from10(_10, toRadix, precision);
+  }
+  static rebaseFloatNTo10(v, radix, precision = 12) {
+    const alphabet = ALPHABET;
+    if (radix <= 1 || radix > alphabet.length) {
+      throw new Error(OUT_OF_RANGE);
+    }
+    const vs = (v ?? "0").toString().toLowerCase(), nan = Number.NaN;
+    if (vs === "0") {
+      return 0;
+    }
+    const arr = /^([-+]?) *([\da-z]+)?(.[\da-z]+)?$/.exec(vs);
+    if (arr.length < 2) {
+      return nan;
+    }
+    const sign = arr[1] === "-" ? -1 : 1, int = arr[2] || "0", frac = arr[3] || ".0";
+    let retval = 0, cursor = 0;
+    for (let digit of int + frac.substr(1)) {
+      const num = alphabet.indexOf(digit);
+      if (num === -1 || num >= radix) {
+        return nan;
+      }
+      retval += num * Math.pow(radix, int.length - cursor - 1);
+      cursor++;
+    }
+    return sign * retval;
+  }
+  static rebaseFloat10ToNIntBase(v, radix, precision = 12) {
+    const alphabet = ALPHABET;
+    if (radix <= 1 || radix > alphabet.length) {
+      throw new Error(OUT_OF_RANGE);
+    }
+    const to = radix;
+    let value = Math.abs(v ?? 0);
+    if (value === 0 || Number.isNaN(value)) {
+      return v.toString();
+    }
+    let decimals = (value % 1).roundoff();
+    let output = "";
+    do {
+      let div = value / to;
+      let divFloor = Math.floor(div);
+      let mod = (value - divFloor * to).roundoff();
+      let intPart = Math.floor(mod);
+      if (intPart >= alphabet.length) {
+        output = `[${intPart}]` + output;
+      } else {
+        output = alphabet[intPart] + output;
+      }
+      if (divFloor <= 0) {
+        break;
+      }
+      value = divFloor;
+    } while (true);
+    output = output.replace(/^0+/, "");
+    output ||= "0";
+    if (decimals === 0) {
+      return output;
+    }
+    let rebasedFrac = "";
+    do {
+      value = (decimals * to).roundoff();
+      const intPart = Math.floor(value), remainder = (value - intPart).roundoff();
+      if (intPart >= alphabet.length) {
+        rebasedFrac = `[${intPart}]`;
+      } else {
+        rebasedFrac += alphabet[intPart];
+      }
+      decimals = remainder;
+    } while (!decimals.isCloseTo(0) && rebasedFrac.length < precision);
+    if (/^0*$/.test(rebasedFrac)) {
+      return output;
+    }
+    return (Math.sign(v) < 0 ? "-" : "") + output + "." + rebasedFrac.replace(/0+$/, "");
+  }
+  static rebaseFloat10ToN(v, radix, precision = 12) {
+    const alphabet = ALPHABET;
+    if (radix <= 1 || radix > alphabet.length) {
+      throw new Error(OUT_OF_RANGE);
+    }
+    const to = radix;
+    let value = Math.abs(v ?? 0);
+    if (value === 0 || Number.isNaN(value)) {
+      return v.toString();
+    }
+    let sign = Math.sign(v) < 0 ? "-" : "";
+    let int = [];
+    let dec = [];
+    for (let j = 0; j < 20; j++) {
+      int.push("0");
+      dec.push("0");
+    }
+    const maxIndex = to % 1 === 0 ? to : Math.ceil(to);
+    function add(integers, j, digitIndex) {
+      const output = integers ? int : dec;
+      const current = output[j] = output[j] || "0";
+      const index = alphabet.indexOf(current) + digitIndex, tgetIndex = index % maxIndex, carryIndex = Math.floor(index / maxIndex);
+      output[j] = alphabet[tgetIndex];
+      if (carryIndex > 0) {
+        if (integers) {
+          add(integers, j + 1, carryIndex);
+        } else {
+          if (j === 0) {
+            add(true, 0, carryIndex);
+          } else {
+            add(false, j - 1, carryIndex);
+          }
+        }
+      }
+      return carryIndex;
+    }
+    let step = 0;
+    do {
+      const magnitude = Math.floor(Numbers.log(value, to));
+      const isInteger = magnitude >= 0;
+      const absMagnitude = isInteger ? magnitude : Math.abs(1 + magnitude);
+      add(isInteger, absMagnitude, 1);
+      value = (value - Math.pow(to, magnitude).roundoff()).roundoff();
+      if (!isInteger) {
+        step++;
+      }
+      if (value === 0 || step >= 100) {
+        const integer = sign + (int.reverse().map((i) => i || "0").join("").replace(/^0+/, "") || "0"), fractional = dec.map((i) => i || "0").join("").substr(0, precision).replace(/0+$/, "");
+        if (/^0*$/.test(fractional)) {
+          return integer;
+        }
+        return integer + "." + fractional;
+      }
+    } while (true);
+  }
+};
+export {
+  index_geometry_exports as Geometry,
+  index_mathematics_exports as Mathematics
+};
+//# sourceMappingURL=pacem-numerical.mjs.map