@performant-software/geospatial 3.1.25-beta.1 → 3.1.25-beta.2

package/dist/index.es358.js

@@ -0,0 +1,261 @@
+import { orient2d as j } from "./index.es271.js";
+const Y = Math.pow(2, -52), q = new Uint32Array(512);
+class C {
+  /**
+   * Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).
+   * `getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.
+   *
+   * @template P
+   * @param {P[]} points
+   * @param {(p: P) => number} [getX]
+   * @param {(p: P) => number} [getY]
+   */
+  // @ts-expect-error TS2322
+  static from(t, i = Q, h = V) {
+    const r = t.length, l = new Float64Array(r * 2);
+    for (let n = 0; n < r; n++) {
+      const o = t[n];
+      l[2 * n] = i(o), l[2 * n + 1] = h(o);
+    }
+    return new C(l);
+  }
+  /**
+   * Constructs a delaunay triangulation object given an array of point coordinates of the form:
+   * `[x0, y0, x1, y1, ...]` (use a typed array for best performance). Duplicate points are skipped.
+   *
+   * @param {T} coords
+   */
+  constructor(t) {
+    const i = t.length >> 1;
+    if (i > 0 && typeof t[0] != "number") throw new Error("Expected coords to contain numbers.");
+    this.coords = t;
+    const h = Math.max(2 * i - 5, 0);
+    this._triangles = new Uint32Array(h * 3), this._halfedges = new Int32Array(h * 3), this._hashSize = Math.ceil(Math.sqrt(i)), this._hullPrev = new Uint32Array(i), this._hullNext = new Uint32Array(i), this._hullTri = new Uint32Array(i), this._hullHash = new Int32Array(this._hashSize), this._ids = new Uint32Array(i), this._dists = new Float64Array(i), this.trianglesLen = 0, this._cx = 0, this._cy = 0, this._hullStart = 0, this.hull = this._triangles, this.triangles = this._triangles, this.halfedges = this._halfedges, this.update();
+  }
+  /**
+   * Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.
+   * Useful for iterative relaxation algorithms such as Lloyd's.
+   */
+  update() {
+    const { coords: t, _hullPrev: i, _hullNext: h, _hullTri: r, _hullHash: l } = this, n = t.length >> 1;
+    let o = 1 / 0, f = 1 / 0, g = -1 / 0, m = -1 / 0;
+    for (let e = 0; e < n; e++) {
+      const u = t[2 * e], a = t[2 * e + 1];
+      u < o && (o = u), a < f && (f = a), u > g && (g = u), a > m && (m = a), this._ids[e] = e;
+    }
+    const d = (o + g) / 2, b = (f + m) / 2;
+    let c = 0, y = 0, w = 0;
+    for (let e = 0, u = 1 / 0; e < n; e++) {
+      const a = X(d, b, t[2 * e], t[2 * e + 1]);
+      a < u && (c = e, u = a);
+    }
+    const T = t[2 * c], M = t[2 * c + 1];
+    for (let e = 0, u = 1 / 0; e < n; e++) {
+      if (e === c) continue;
+      const a = X(T, M, t[2 * e], t[2 * e + 1]);
+      a < u && a > 0 && (y = e, u = a);
+    }
+    let U = t[2 * y], k = t[2 * y + 1], G = 1 / 0;
+    for (let e = 0; e < n; e++) {
+      if (e === c || e === y) continue;
+      const u = B(T, M, U, k, t[2 * e], t[2 * e + 1]);
+      u < G && (w = e, G = u);
+    }
+    let D = t[2 * w], E = t[2 * w + 1];
+    if (G === 1 / 0) {
+      for (let a = 0; a < n; a++)
+        this._dists[a] = t[2 * a] - t[0] || t[2 * a + 1] - t[1];
+      L(this._ids, this._dists, 0, n - 1);
+      const e = new Uint32Array(n);
+      let u = 0;
+      for (let a = 0, x = -1 / 0; a < n; a++) {
+        const A = this._ids[a], S = this._dists[A];
+        S > x && (e[u++] = A, x = S);
+      }
+      this.hull = e.subarray(0, u), this.triangles = new Uint32Array(0), this.halfedges = new Int32Array(0);
+      return;
+    }
+    if (j(T, M, U, k, D, E) < 0) {
+      const e = y, u = U, a = k;
+      y = w, U = D, k = E, w = e, D = u, E = a;
+    }
+    const N = J(T, M, U, k, D, E);
+    this._cx = N.x, this._cy = N.y;
+    for (let e = 0; e < n; e++)
+      this._dists[e] = X(t[2 * e], t[2 * e + 1], N.x, N.y);
+    L(this._ids, this._dists, 0, n - 1), this._hullStart = c;
+    let P = 3;
+    h[c] = i[w] = y, h[y] = i[c] = w, h[w] = i[y] = c, r[c] = 0, r[y] = 1, r[w] = 2, l.fill(-1), l[this._hashKey(T, M)] = c, l[this._hashKey(U, k)] = y, l[this._hashKey(D, E)] = w, this.trianglesLen = 0, this._addTriangle(c, y, w, -1, -1, -1);
+    for (let e = 0, u = 0, a = 0; e < this._ids.length; e++) {
+      const x = this._ids[e], A = t[2 * x], S = t[2 * x + 1];
+      if (e > 0 && Math.abs(A - u) <= Y && Math.abs(S - a) <= Y || (u = A, a = S, x === c || x === y || x === w)) continue;
+      let z = 0;
+      for (let H = 0, F = this._hashKey(A, S); H < this._hashSize && (z = l[(F + H) % this._hashSize], !(z !== -1 && z !== h[z])); H++)
+        ;
+      z = i[z];
+      let _ = z, p;
+      for (; p = h[_], j(A, S, t[2 * _], t[2 * _ + 1], t[2 * p], t[2 * p + 1]) >= 0; )
+        if (_ = p, _ === z) {
+          _ = -1;
+          break;
+        }
+      if (_ === -1) continue;
+      let K = this._addTriangle(_, x, h[_], -1, -1, r[_]);
+      r[x] = this._legalize(K + 2), r[_] = K, P++;
+      let I = h[_];
+      for (; p = h[I], j(A, S, t[2 * I], t[2 * I + 1], t[2 * p], t[2 * p + 1]) < 0; )
+        K = this._addTriangle(I, x, p, r[x], -1, r[I]), r[x] = this._legalize(K + 2), h[I] = I, P--, I = p;
+      if (_ === z)
+        for (; p = i[_], j(A, S, t[2 * p], t[2 * p + 1], t[2 * _], t[2 * _ + 1]) < 0; )
+          K = this._addTriangle(p, x, _, -1, r[_], r[p]), this._legalize(K + 2), r[p] = K, h[_] = _, P--, _ = p;
+      this._hullStart = i[x] = _, h[_] = i[I] = x, h[x] = I, l[this._hashKey(A, S)] = x, l[this._hashKey(t[2 * _], t[2 * _ + 1])] = _;
+    }
+    this.hull = new Uint32Array(P);
+    for (let e = 0, u = this._hullStart; e < P; e++)
+      this.hull[e] = u, u = h[u];
+    this.triangles = this._triangles.subarray(0, this.trianglesLen), this.halfedges = this._halfedges.subarray(0, this.trianglesLen);
+  }
+  /**
+   * Calculate an angle-based key for the edge hash used for advancing convex hull.
+   *
+   * @param {number} x
+   * @param {number} y
+   * @private
+   */
+  _hashKey(t, i) {
+    return Math.floor(O(t - this._cx, i - this._cy) * this._hashSize) % this._hashSize;
+  }
+  /**
+   * Flip an edge in a pair of triangles if it doesn't satisfy the Delaunay condition.
+   *
+   * @param {number} a
+   * @private
+   */
+  _legalize(t) {
+    const { _triangles: i, _halfedges: h, coords: r } = this;
+    let l = 0, n = 0;
+    for (; ; ) {
+      const o = h[t], f = t - t % 3;
+      if (n = f + (t + 2) % 3, o === -1) {
+        if (l === 0) break;
+        t = q[--l];
+        continue;
+      }
+      const g = o - o % 3, m = f + (t + 1) % 3, d = g + (o + 2) % 3, b = i[n], c = i[t], y = i[m], w = i[d];
+      if (R(
+        r[2 * b],
+        r[2 * b + 1],
+        r[2 * c],
+        r[2 * c + 1],
+        r[2 * y],
+        r[2 * y + 1],
+        r[2 * w],
+        r[2 * w + 1]
+      )) {
+        i[t] = w, i[o] = b;
+        const M = h[d];
+        if (M === -1) {
+          let k = this._hullStart;
+          do {
+            if (this._hullTri[k] === d) {
+              this._hullTri[k] = t;
+              break;
+            }
+            k = this._hullPrev[k];
+          } while (k !== this._hullStart);
+        }
+        this._link(t, M), this._link(o, h[n]), this._link(n, d);
+        const U = g + (o + 1) % 3;
+        l < q.length && (q[l++] = U);
+      } else {
+        if (l === 0) break;
+        t = q[--l];
+      }
+    }
+    return n;
+  }
+  /**
+   * Link two half-edges to each other.
+   * @param {number} a
+   * @param {number} b
+   * @private
+   */
+  _link(t, i) {
+    this._halfedges[t] = i, i !== -1 && (this._halfedges[i] = t);
+  }
+  /**
+   * Add a new triangle given vertex indices and adjacent half-edge ids.
+   *
+   * @param {number} i0
+   * @param {number} i1
+   * @param {number} i2
+   * @param {number} a
+   * @param {number} b
+   * @param {number} c
+   * @private
+   */
+  _addTriangle(t, i, h, r, l, n) {
+    const o = this.trianglesLen;
+    return this._triangles[o] = t, this._triangles[o + 1] = i, this._triangles[o + 2] = h, this._link(o, r), this._link(o + 1, l), this._link(o + 2, n), this.trianglesLen += 3, o;
+  }
+}
+function O(s, t) {
+  const i = s / (Math.abs(s) + Math.abs(t));
+  return (t > 0 ? 3 - i : 1 + i) / 4;
+}
+function X(s, t, i, h) {
+  const r = s - i, l = t - h;
+  return r * r + l * l;
+}
+function R(s, t, i, h, r, l, n, o) {
+  const f = s - n, g = t - o, m = i - n, d = h - o, b = r - n, c = l - o, y = f * f + g * g, w = m * m + d * d, T = b * b + c * c;
+  return f * (d * T - w * c) - g * (m * T - w * b) + y * (m * c - d * b) < 0;
+}
+function B(s, t, i, h, r, l) {
+  const n = i - s, o = h - t, f = r - s, g = l - t, m = n * n + o * o, d = f * f + g * g, b = 0.5 / (n * g - o * f), c = (g * m - o * d) * b, y = (n * d - f * m) * b;
+  return c * c + y * y;
+}
+function J(s, t, i, h, r, l) {
+  const n = i - s, o = h - t, f = r - s, g = l - t, m = n * n + o * o, d = f * f + g * g, b = 0.5 / (n * g - o * f), c = s + (g * m - o * d) * b, y = t + (n * d - f * m) * b;
+  return { x: c, y };
+}
+function L(s, t, i, h) {
+  if (h - i <= 20)
+    for (let r = i + 1; r <= h; r++) {
+      const l = s[r], n = t[l];
+      let o = r - 1;
+      for (; o >= i && t[s[o]] > n; ) s[o + 1] = s[o--];
+      s[o + 1] = l;
+    }
+  else {
+    const r = i + h >> 1;
+    let l = i + 1, n = h;
+    v(s, r, l), t[s[i]] > t[s[h]] && v(s, i, h), t[s[l]] > t[s[h]] && v(s, l, h), t[s[i]] > t[s[l]] && v(s, i, l);
+    const o = s[l], f = t[o];
+    for (; ; ) {
+      do
+        l++;
+      while (t[s[l]] < f);
+      do
+        n--;
+      while (t[s[n]] > f);
+      if (n < l) break;
+      v(s, l, n);
+    }
+    s[i + 1] = s[n], s[n] = o, h - l + 1 >= n - i ? (L(s, t, l, h), L(s, t, i, n - 1)) : (L(s, t, i, n - 1), L(s, t, l, h));
+  }
+}
+function v(s, t, i) {
+  const h = s[t];
+  s[t] = s[i], s[i] = h;
+}
+function Q(s) {
+  return s[0];
+}
+function V(s) {
+  return s[1];
+}
+export {
+  C as default
+};
+//# sourceMappingURL=index.es358.js.map

package/dist/index.es358.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es358.js","sources":["../../../node_modules/delaunator/index.js"],"sourcesContent":["\nconst EPSILON = Math.pow(2, -52);\nconst EDGE_STACK = new Uint32Array(512);\n\nimport {orient2d} from 'robust-predicates';\n\n/** @template {ArrayLike<number>} T */\nexport default class Delaunator {\n\n    /**\n     * Constructs a delaunay triangulation object given an array of points (`[x, y]` by default).\n     * `getX` and `getY` are optional functions of the form `(point) => value` for custom point formats.\n     *\n     * @template P\n     * @param {P[]} points\n     * @param {(p: P) => number} [getX]\n     * @param {(p: P) => number} [getY]\n     */\n    // @ts-expect-error TS2322\n    static from(points, getX = defaultGetX, getY = defaultGetY) {\n        const n = points.length;\n        const coords = new Float64Array(n * 2);\n\n        for (let i = 0; i < n; i++) {\n            const p = points[i];\n            coords[2 * i] = getX(p);\n            coords[2 * i + 1] = getY(p);\n        }\n\n        return new Delaunator(coords);\n    }\n\n    /**\n     * Constructs a delaunay triangulation object given an array of point coordinates of the form:\n     * `[x0, y0, x1, y1, ...]` (use a typed array for best performance). Duplicate points are skipped.\n     *\n     * @param {T} coords\n     */\n    constructor(coords) {\n        const n = coords.length >> 1;\n        if (n > 0 && typeof coords[0] !== 'number') throw new Error('Expected coords to contain numbers.');\n\n        this.coords = coords;\n\n        // arrays that will store the triangulation graph\n        const maxTriangles = Math.max(2 * n - 5, 0);\n        /** @private */ this._triangles = new Uint32Array(maxTriangles * 3);\n        /** @private */ this._halfedges = new Int32Array(maxTriangles * 3);\n\n        // temporary arrays for tracking the edges of the advancing convex hull\n        /** @private */ this._hashSize = Math.ceil(Math.sqrt(n));\n        /** @private */ this._hullPrev = new Uint32Array(n); // edge to prev edge\n        /** @private */ this._hullNext = new Uint32Array(n); // edge to next edge\n        /** @private */ this._hullTri = new Uint32Array(n); // edge to adjacent triangle\n        /** @private */ this._hullHash = new Int32Array(this._hashSize); // angular edge hash\n\n        // temporary arrays for sorting points\n        /** @private */ this._ids = new Uint32Array(n);\n        /** @private */ this._dists = new Float64Array(n);\n\n        /** @private */ this.trianglesLen = 0;\n        /** @private */ this._cx = 0;\n        /** @private */ this._cy = 0;\n        /** @private */ this._hullStart = 0;\n\n\n        /** A `Uint32Array` array of indices that reference points on the convex hull of the input data, counter-clockwise. */\n        this.hull = this._triangles;\n        /** A `Uint32Array` array of triangle vertex indices (each group of three numbers forms a triangle). All triangles are directed counterclockwise. */\n        this.triangles = this._triangles;\n        /**\n         * A `Int32Array` array of triangle half-edge indices that allows you to traverse the triangulation.\n         * `i`-th half-edge in the array corresponds to vertex `triangles[i]` the half-edge is coming from.\n         * `halfedges[i]` is the index of a twin half-edge in an adjacent triangle (or `-1` for outer half-edges on the convex hull).\n         */\n        this.halfedges = this._halfedges;\n\n        this.update();\n    }\n\n    /**\n     * Updates the triangulation if you modified `delaunay.coords` values in place, avoiding expensive memory allocations.\n     * Useful for iterative relaxation algorithms such as Lloyd's.\n     */\n    update() {\n        const {coords, _hullPrev: hullPrev, _hullNext: hullNext, _hullTri: hullTri, _hullHash: hullHash} =  this;\n        const n = coords.length >> 1;\n\n        // populate an array of point indices; calculate input data bbox\n        let minX = Infinity;\n        let minY = Infinity;\n        let maxX = -Infinity;\n        let maxY = -Infinity;\n\n        for (let i = 0; i < n; i++) {\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n            if (x < minX) minX = x;\n            if (y < minY) minY = y;\n            if (x > maxX) maxX = x;\n            if (y > maxY) maxY = y;\n            this._ids[i] = i;\n        }\n        const cx = (minX + maxX) / 2;\n        const cy = (minY + maxY) / 2;\n\n        let i0 = 0, i1 = 0, i2 = 0;\n\n        // pick a seed point close to the center\n        for (let i = 0, minDist = Infinity; i < n; i++) {\n            const d = dist(cx, cy, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist) {\n                i0 = i;\n                minDist = d;\n            }\n        }\n        const i0x = coords[2 * i0];\n        const i0y = coords[2 * i0 + 1];\n\n        // find the point closest to the seed\n        for (let i = 0, minDist = Infinity; i < n; i++) {\n            if (i === i0) continue;\n            const d = dist(i0x, i0y, coords[2 * i], coords[2 * i + 1]);\n            if (d < minDist && d > 0) {\n                i1 = i;\n                minDist = d;\n            }\n        }\n        let i1x = coords[2 * i1];\n        let i1y = coords[2 * i1 + 1];\n\n        let minRadius = Infinity;\n\n        // find the third point which forms the smallest circumcircle with the first two\n        for (let i = 0; i < n; i++) {\n            if (i === i0 || i === i1) continue;\n            const r = circumradius(i0x, i0y, i1x, i1y, coords[2 * i], coords[2 * i + 1]);\n            if (r < minRadius) {\n                i2 = i;\n                minRadius = r;\n            }\n        }\n        let i2x = coords[2 * i2];\n        let i2y = coords[2 * i2 + 1];\n\n        if (minRadius === Infinity) {\n            // order collinear points by dx (or dy if all x are identical)\n            // and return the list as a hull\n            for (let i = 0; i < n; i++) {\n                this._dists[i] = (coords[2 * i] - coords[0]) || (coords[2 * i + 1] - coords[1]);\n            }\n            quicksort(this._ids, this._dists, 0, n - 1);\n            const hull = new Uint32Array(n);\n            let j = 0;\n            for (let i = 0, d0 = -Infinity; i < n; i++) {\n                const id = this._ids[i];\n                const d = this._dists[id];\n                if (d > d0) {\n                    hull[j++] = id;\n                    d0 = d;\n                }\n            }\n            this.hull = hull.subarray(0, j);\n            this.triangles = new Uint32Array(0);\n            this.halfedges = new Int32Array(0);\n            return;\n        }\n\n        // swap the order of the seed points for counter-clockwise orientation\n        if (orient2d(i0x, i0y, i1x, i1y, i2x, i2y) < 0) {\n            const i = i1;\n            const x = i1x;\n            const y = i1y;\n            i1 = i2;\n            i1x = i2x;\n            i1y = i2y;\n            i2 = i;\n            i2x = x;\n            i2y = y;\n        }\n\n        const center = circumcenter(i0x, i0y, i1x, i1y, i2x, i2y);\n        this._cx = center.x;\n        this._cy = center.y;\n\n        for (let i = 0; i < n; i++) {\n            this._dists[i] = dist(coords[2 * i], coords[2 * i + 1], center.x, center.y);\n        }\n\n        // sort the points by distance from the seed triangle circumcenter\n        quicksort(this._ids, this._dists, 0, n - 1);\n\n        // set up the seed triangle as the starting hull\n        this._hullStart = i0;\n        let hullSize = 3;\n\n        hullNext[i0] = hullPrev[i2] = i1;\n        hullNext[i1] = hullPrev[i0] = i2;\n        hullNext[i2] = hullPrev[i1] = i0;\n\n        hullTri[i0] = 0;\n        hullTri[i1] = 1;\n        hullTri[i2] = 2;\n\n        hullHash.fill(-1);\n        hullHash[this._hashKey(i0x, i0y)] = i0;\n        hullHash[this._hashKey(i1x, i1y)] = i1;\n        hullHash[this._hashKey(i2x, i2y)] = i2;\n\n        this.trianglesLen = 0;\n        this._addTriangle(i0, i1, i2, -1, -1, -1);\n\n        for (let k = 0, xp = 0, yp = 0; k < this._ids.length; k++) {\n            const i = this._ids[k];\n            const x = coords[2 * i];\n            const y = coords[2 * i + 1];\n\n            // skip near-duplicate points\n            if (k > 0 && Math.abs(x - xp) <= EPSILON && Math.abs(y - yp) <= EPSILON) continue;\n            xp = x;\n            yp = y;\n\n            // skip seed triangle points\n            if (i === i0 || i === i1 || i === i2) continue;\n\n            // find a visible edge on the convex hull using edge hash\n            let start = 0;\n            for (let j = 0, key = this._hashKey(x, y); j < this._hashSize; j++) {\n                start = hullHash[(key + j) % this._hashSize];\n                if (start !== -1 && start !== hullNext[start]) break;\n            }\n\n            start = hullPrev[start];\n            let e = start, q;\n            while (q = hullNext[e], orient2d(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1]) >= 0) {\n                e = q;\n                if (e === start) {\n                    e = -1;\n                    break;\n                }\n            }\n            if (e === -1) continue; // likely a near-duplicate point; skip it\n\n            // add the first triangle from the point\n            let t = this._addTriangle(e, i, hullNext[e], -1, -1, hullTri[e]);\n\n            // recursively flip triangles from the point until they satisfy the Delaunay condition\n            hullTri[i] = this._legalize(t + 2);\n            hullTri[e] = t; // keep track of boundary triangles on the hull\n            hullSize++;\n\n            // walk forward through the hull, adding more triangles and flipping recursively\n            let n = hullNext[e];\n            while (q = hullNext[n], orient2d(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1]) < 0) {\n                t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]);\n                hullTri[i] = this._legalize(t + 2);\n                hullNext[n] = n; // mark as removed\n                hullSize--;\n                n = q;\n            }\n\n            // walk backward from the other side, adding more triangles and flipping\n            if (e === start) {\n                while (q = hullPrev[e], orient2d(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]) < 0) {\n                    t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]);\n                    this._legalize(t + 2);\n                    hullTri[q] = t;\n                    hullNext[e] = e; // mark as removed\n                    hullSize--;\n                    e = q;\n                }\n            }\n\n            // update the hull indices\n            this._hullStart = hullPrev[i] = e;\n            hullNext[e] = hullPrev[n] = i;\n            hullNext[i] = n;\n\n            // save the two new edges in the hash table\n            hullHash[this._hashKey(x, y)] = i;\n            hullHash[this._hashKey(coords[2 * e], coords[2 * e + 1])] = e;\n        }\n\n        this.hull = new Uint32Array(hullSize);\n        for (let i = 0, e = this._hullStart; i < hullSize; i++) {\n            this.hull[i] = e;\n            e = hullNext[e];\n        }\n\n        // trim typed triangle mesh arrays\n        this.triangles = this._triangles.subarray(0, this.trianglesLen);\n        this.halfedges = this._halfedges.subarray(0, this.trianglesLen);\n    }\n\n    /**\n     * Calculate an angle-based key for the edge hash used for advancing convex hull.\n     *\n     * @param {number} x\n     * @param {number} y\n     * @private\n     */\n    _hashKey(x, y) {\n        return Math.floor(pseudoAngle(x - this._cx, y - this._cy) * this._hashSize) % this._hashSize;\n    }\n\n    /**\n     * Flip an edge in a pair of triangles if it doesn't satisfy the Delaunay condition.\n     *\n     * @param {number} a\n     * @private\n     */\n    _legalize(a) {\n        const {_triangles: triangles, _halfedges: halfedges, coords} = this;\n\n        let i = 0;\n        let ar = 0;\n\n        // recursion eliminated with a fixed-size stack\n        while (true) {\n            const b = halfedges[a];\n\n            /* if the pair of triangles doesn't satisfy the Delaunay condition\n             * (p1 is inside the circumcircle of [p0, pl, pr]), flip them,\n             * then do the same check/flip recursively for the new pair of triangles\n             *\n             *           pl                    pl\n             *          /||\\                  /  \\\n             *       al/ || \\bl            al/    \\a\n             *        /  ||  \\              /      \\\n             *       /  a||b  \\    flip    /___ar___\\\n             *     p0\\   ||   /p1   =>   p0\\---bl---/p1\n             *        \\  ||  /              \\      /\n             *       ar\\ || /br             b\\    /br\n             *          \\||/                  \\  /\n             *           pr                    pr\n             */\n            const a0 = a - a % 3;\n            ar = a0 + (a + 2) % 3;\n\n            if (b === -1) { // convex hull edge\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n                continue;\n            }\n\n            const b0 = b - b % 3;\n            const al = a0 + (a + 1) % 3;\n            const bl = b0 + (b + 2) % 3;\n\n            const p0 = triangles[ar];\n            const pr = triangles[a];\n            const pl = triangles[al];\n            const p1 = triangles[bl];\n\n            const illegal = inCircle(\n                coords[2 * p0], coords[2 * p0 + 1],\n                coords[2 * pr], coords[2 * pr + 1],\n                coords[2 * pl], coords[2 * pl + 1],\n                coords[2 * p1], coords[2 * p1 + 1]);\n\n            if (illegal) {\n                triangles[a] = p1;\n                triangles[b] = p0;\n\n                const hbl = halfedges[bl];\n\n                // edge swapped on the other side of the hull (rare); fix the half-edge reference\n                if (hbl === -1) {\n                    let e = this._hullStart;\n                    do {\n                        if (this._hullTri[e] === bl) {\n                            this._hullTri[e] = a;\n                            break;\n                        }\n                        e = this._hullPrev[e];\n                    } while (e !== this._hullStart);\n                }\n                this._link(a, hbl);\n                this._link(b, halfedges[ar]);\n                this._link(ar, bl);\n\n                const br = b0 + (b + 1) % 3;\n\n                // don't worry about hitting the cap: it can only happen on extremely degenerate input\n                if (i < EDGE_STACK.length) {\n                    EDGE_STACK[i++] = br;\n                }\n            } else {\n                if (i === 0) break;\n                a = EDGE_STACK[--i];\n            }\n        }\n\n        return ar;\n    }\n\n    /**\n     * Link two half-edges to each other.\n     * @param {number} a\n     * @param {number} b\n     * @private\n     */\n    _link(a, b) {\n        this._halfedges[a] = b;\n        if (b !== -1) this._halfedges[b] = a;\n    }\n\n    /**\n     * Add a new triangle given vertex indices and adjacent half-edge ids.\n     *\n     * @param {number} i0\n     * @param {number} i1\n     * @param {number} i2\n     * @param {number} a\n     * @param {number} b\n     * @param {number} c\n     * @private\n     */\n    _addTriangle(i0, i1, i2, a, b, c) {\n        const t = this.trianglesLen;\n\n        this._triangles[t] = i0;\n        this._triangles[t + 1] = i1;\n        this._triangles[t + 2] = i2;\n\n        this._link(t, a);\n        this._link(t + 1, b);\n        this._link(t + 2, c);\n\n        this.trianglesLen += 3;\n\n        return t;\n    }\n}\n\n/**\n * Monotonically increases with real angle, but doesn't need expensive trigonometry.\n *\n * @param {number} dx\n * @param {number} dy\n */\nfunction pseudoAngle(dx, dy) {\n    const p = dx / (Math.abs(dx) + Math.abs(dy));\n    return (dy > 0 ? 3 - p : 1 + p) / 4; // [0..1]\n}\n\n/**\n * Squared distance between two points.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n */\nfunction dist(ax, ay, bx, by) {\n    const dx = ax - bx;\n    const dy = ay - by;\n    return dx * dx + dy * dy;\n}\n\n/**\n * Check whether point P is inside a circle formed by points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n * @param {number} px\n * @param {number} py\n */\nfunction inCircle(ax, ay, bx, by, cx, cy, px, py) {\n    const dx = ax - px;\n    const dy = ay - py;\n    const ex = bx - px;\n    const ey = by - py;\n    const fx = cx - px;\n    const fy = cy - py;\n\n    const ap = dx * dx + dy * dy;\n    const bp = ex * ex + ey * ey;\n    const cp = fx * fx + fy * fy;\n\n    return dx * (ey * cp - bp * fy) -\n           dy * (ex * cp - bp * fx) +\n           ap * (ex * fy - ey * fx) < 0;\n}\n\n/**\n * Squared radius of the circle formed by points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n */\nfunction circumradius(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = (ey * bl - dy * cl) * d;\n    const y = (dx * cl - ex * bl) * d;\n\n    return x * x + y * y;\n}\n\n/**\n * Get coordinates of a circumcenter for points A, B, C.\n *\n * @param {number} ax\n * @param {number} ay\n * @param {number} bx\n * @param {number} by\n * @param {number} cx\n * @param {number} cy\n */\nfunction circumcenter(ax, ay, bx, by, cx, cy) {\n    const dx = bx - ax;\n    const dy = by - ay;\n    const ex = cx - ax;\n    const ey = cy - ay;\n\n    const bl = dx * dx + dy * dy;\n    const cl = ex * ex + ey * ey;\n    const d = 0.5 / (dx * ey - dy * ex);\n\n    const x = ax + (ey * bl - dy * cl) * d;\n    const y = ay + (dx * cl - ex * bl) * d;\n\n    return {x, y};\n}\n\n/**\n * Sort points by distance via an array of point indices and an array of calculated distances.\n *\n * @param {Uint32Array} ids\n * @param {Float64Array} dists\n * @param {number} left\n * @param {number} right\n */\nfunction quicksort(ids, dists, left, right) {\n    if (right - left <= 20) {\n        for (let i = left + 1; i <= right; i++) {\n            const temp = ids[i];\n            const tempDist = dists[temp];\n            let j = i - 1;\n            while (j >= left && dists[ids[j]] > tempDist) ids[j + 1] = ids[j--];\n            ids[j + 1] = temp;\n        }\n    } else {\n        const median = (left + right) >> 1;\n        let i = left + 1;\n        let j = right;\n        swap(ids, median, i);\n        if (dists[ids[left]] > dists[ids[right]]) swap(ids, left, right);\n        if (dists[ids[i]] > dists[ids[right]]) swap(ids, i, right);\n        if (dists[ids[left]] > dists[ids[i]]) swap(ids, left, i);\n\n        const temp = ids[i];\n        const tempDist = dists[temp];\n        while (true) {\n            do i++; while (dists[ids[i]] < tempDist);\n            do j--; while (dists[ids[j]] > tempDist);\n            if (j < i) break;\n            swap(ids, i, j);\n        }\n        ids[left + 1] = ids[j];\n        ids[j] = temp;\n\n        if (right - i + 1 >= j - left) {\n            quicksort(ids, dists, i, right);\n            quicksort(ids, dists, left, j - 1);\n        } else {\n            quicksort(ids, dists, left, j - 1);\n            quicksort(ids, dists, i, right);\n        }\n    }\n}\n\n/**\n * @param {Uint32Array} arr\n * @param {number} i\n * @param {number} j\n */\nfunction swap(arr, i, j) {\n    const tmp = arr[i];\n    arr[i] = arr[j];\n    arr[j] = tmp;\n}\n\n/** @param {[number, number]} p */\nfunction defaultGetX(p) {\n    return p[0];\n}\n/** @param {[number, number]} p */\nfunction defaultGetY(p) {\n    return p[1];\n}\n"],"names":["EPSILON","EDGE_STACK","Delaunator","points","getX","defaultGetX","getY","defaultGetY","n","coords","i","p","maxTriangles","hullPrev","hullNext","hullTri","hullHash","minX","minY","maxX","maxY","x","y","cx","cy","i0","i1","i2","minDist","d","dist","i0x","i0y","i1x","i1y","minRadius","r","circumradius","i2x","i2y","quicksort","hull","j","d0","id","orient2d","center","circumcenter","hullSize","k","xp","yp","start","key","e","q","t","pseudoAngle","a","triangles","halfedges","ar","b","a0","b0","al","bl","p0","pr","pl","p1","inCircle","hbl","br","c","dx","dy","ax","ay","bx","by","px","py","ex","ey","fx","fy","ap","bp","cp","cl","ids","dists","left","right","temp","tempDist","median","swap","arr","tmp"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/index.es359.js

@@ -0,0 +1,108 @@
+import { orient2d as d } from "./index.es469.js";
+import P from "./index.es470.js";
+import { computeBbox as R } from "./index.es215.js";
+import { closeRing as x, distance as y, lineAngle as L, stepDistanceAngle as M } from "./index.es275.js";
+function D(t, e, o = !0) {
+  const [n, s] = t, [[r, c], [i, l]] = e;
+  return o && (n === r && s === c || n === i && s === l) || (n - r) * (n - i) > 0 || (s - c) * (s - l) > 0 ? !1 : d(r, c, i, l, n, s) === 0;
+}
+function A(t) {
+  const e = new P(t.length);
+  for (const [o, n] of t)
+    e.add(o, n);
+  return e.finish(), { tree: e, points: t };
+}
+function B(t, { tree: e, points: o }) {
+  const n = [];
+  for (let s = 0; s < t.length; s++) {
+    const r = t[s], c = t[(s + 1) % t.length], [i, l] = r, [h, p] = c;
+    n.push(r);
+    const g = e.range(Math.min(i, h), Math.min(l, p), Math.max(i, h), Math.max(l, p));
+    if (g.length === 0)
+      continue;
+    const u = [];
+    for (const f of g) {
+      const [a, m] = o[f];
+      D([a, m], [r, c]) && u.push(o[f]);
+    }
+    u.length === 1 ? n.push(u[0]) : u.length > 1 && (u.sort(([f, a], [m, b]) => (f - i) ** 2 + (a - l) ** 2 - ((m - i) ** 2 + (b - l) ** 2)), n.push(...u));
+  }
+  return n;
+}
+function T(t, e, o = A(e)) {
+  return t.map((n) => B(n, o));
+}
+function v(t, e) {
+  const o = y(...t), n = Math.ceil(o / e) - 1, s = L(t);
+  let r = t[0];
+  const c = [r];
+  for (let i = 1; i <= n; i++)
+    r = M(r, e, s), c.push(r);
+  return c;
+}
+function w(t, e) {
+  t = x(t);
+  let o = [];
+  for (let n = 0; n < t.length - 1; n++)
+    o = o.concat(v([t[n], t[n + 1]], e));
+  return o;
+}
+function k(t, e) {
+  return t.map((o) => w(o, e));
+}
+function q(t, e) {
+  const o = [];
+  for (let n = t[0] + e, s = 0; n <= t[2]; s++, n += e)
+    for (let r = t[1] + e, c = 0; r <= t[3]; c++, r += e)
+      o.push([n, r]);
+  return o;
+}
+function E(t) {
+  const e = t.map((n) => {
+    const s = x(n), r = s.length - 1, c = new Float64Array(s.length * 2);
+    for (let i = 0; i < s.length; i++)
+      c[i * 2] = s[i][0], c[i * 2 + 1] = s[i][1];
+    return { coords: c, length: r };
+  }), o = R(t);
+  return { closedRings: e, bbox: o };
+}
+function I(t, e, o) {
+  if (t < o.bbox[0] || e < o.bbox[1] || t > o.bbox[2] || e > o.bbox[3])
+    return !1;
+  let n = 0;
+  const s = o.closedRings;
+  for (let r = 0; r < s.length; r++) {
+    const c = s[r].coords, i = s[r].length;
+    let l = c[0] - t, h = c[1] - e;
+    for (let p = 0; p < i; p++) {
+      const g = (p + 1) * 2, u = c[g] - t, f = c[g + 1] - e;
+      if (h === 0 && f === 0) {
+        if (u <= 0 && l >= 0 || l <= 0 && u >= 0)
+          return 0;
+      } else if (f >= 0 && h <= 0 || f <= 0 && h >= 0) {
+        const a = d(l, u, h, f, 0, 0);
+        if (a === 0)
+          return 0;
+        (a > 0 && f > 0 && h <= 0 || a < 0 && f <= 0 && h > 0) && n++;
+      }
+      l = u, h = f;
+    }
+  }
+  return n % 2 !== 0;
+}
+function F(t, e, o) {
+  return o.some((n) => I(t, e, n));
+}
+export {
+  q as bboxToGridPoints,
+  A as buildKDBushPointIndex,
+  I as coordsInPolygonForInsidenessCheck,
+  F as coordsInPolygonsForInsidenessCheck,
+  k as interpolatePolygon,
+  w as interpolateRing,
+  D as pointOnLine,
+  E as preprocessPolygonForInsideCheck,
+  T as splitPolygonLines,
+  B as splitRingLines
+};
+//# sourceMappingURL=index.es359.js.map

package/dist/index.es359.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.es359.js","sources":["../../../node_modules/@allmaps/triangulate/dist/shared.js"],"sourcesContent":["import { orient2d } from 'robust-predicates';\nimport KDBush from 'kdbush';\nimport { distance, stepDistanceAngle, lineAngle, closeRing, computeBbox } from '@allmaps/stdlib';\n// Split lines using points\nexport function pointOnLine(point, line, exclude = true) {\n    const [x, y] = point;\n    const [[x0, y0], [x1, y1]] = line;\n    if (exclude) {\n        if (x === x0 && y === y0)\n            return false;\n        if (x === x1 && y === y1)\n            return false;\n    }\n    if ((x - x0) * (x - x1) > 0)\n        return false;\n    if ((y - y0) * (y - y1) > 0)\n        return false;\n    return orient2d(x0, y0, x1, y1, x, y) === 0;\n}\nexport function buildKDBushPointIndex(points) {\n    const tree = new KDBush(points.length);\n    for (const [x, y] of points)\n        tree.add(x, y);\n    tree.finish();\n    return { tree, points };\n}\nexport function splitRingLines(ring, { tree, points }) {\n    const result = [];\n    for (let i = 0; i < ring.length; i++) {\n        const p0 = ring[i];\n        const p1 = ring[(i + 1) % ring.length];\n        const [x0, y0] = p0;\n        const [x1, y1] = p1;\n        result.push(p0);\n        const ids = tree.range(Math.min(x0, x1), Math.min(y0, y1), Math.max(x0, x1), Math.max(y0, y1));\n        if (ids.length === 0)\n            continue;\n        const hits = [];\n        for (const id of ids) {\n            const [x, y] = points[id];\n            if (pointOnLine([x, y], [p0, p1]))\n                hits.push(points[id]);\n        }\n        if (hits.length === 1) {\n            result.push(hits[0]);\n        }\n        else if (hits.length > 1) {\n            hits.sort(([ax, ay], [bx, by]) => (ax - x0) ** 2 + (ay - y0) ** 2 - ((bx - x0) ** 2 + (by - y0) ** 2));\n            result.push(...hits);\n        }\n    }\n    return result;\n}\nexport function splitPolygonLines(polygon, points, index = buildKDBushPointIndex(points)) {\n    return polygon.map((ring) => splitRingLines(ring, index));\n}\n// Interpolate line using distance\n// Return an array of points containing the first line point,\n// and betwen the first and last line point other points every `dist`\nfunction interpolateLine(line, dist) {\n    const lineDistance = distance(...line);\n    // Note: ciel - 1 instead of floor, such that for round numbers we don't include the last step\n    const steps = Math.ceil(lineDistance / dist) - 1;\n    const angle = lineAngle(line);\n    let currentPoint = line[0];\n    const result = [currentPoint];\n    for (let step = 1; step <= steps; step++) {\n        currentPoint = stepDistanceAngle(currentPoint, dist, angle);\n        result.push(currentPoint);\n    }\n    // Note: the last nextpoint, which is also line[1], is not pushed\n    return result;\n}\n// Return an array of points containing the ring points,\n// and between every pair of ring points other points every `dist`\nexport function interpolateRing(ring, dist) {\n    ring = closeRing(ring);\n    let result = [];\n    for (let i = 0; i < ring.length - 1; i++) {\n        result = result.concat(interpolateLine([ring[i], ring[i + 1]], dist));\n    }\n    return result;\n}\nexport function interpolatePolygon(polygon, dist) {\n    return polygon.map((ring) => interpolateRing(ring, dist));\n}\n// Grid\nexport function bboxToGridPoints(bbox, gridSize) {\n    const grid = [];\n    for (let x = bbox[0] + gridSize, i = 0; x <= bbox[2]; i++, x += gridSize) {\n        for (let y = bbox[1] + gridSize, j = 0; y <= bbox[3]; j++, y += gridSize) {\n            grid.push([x, y]);\n        }\n    }\n    return grid;\n}\n// Point inside triangle\nexport function preprocessPolygonForInsideCheck(polygon) {\n    const closedRings = polygon.map((ring) => {\n        const closedRing = closeRing(ring);\n        const ringLength = closedRing.length - 1;\n        // Flat typed array: [x0, y0, x1, y1, ...] — avoids nested array pointer chasing\n        const coords = new Float64Array(closedRing.length * 2);\n        for (let i = 0; i < closedRing.length; i++) {\n            coords[i * 2] = closedRing[i][0];\n            coords[i * 2 + 1] = closedRing[i][1];\n        }\n        return { coords, length: ringLength };\n    });\n    const bbox = computeBbox(polygon);\n    return { closedRings, bbox };\n}\n// Improved from point-in-polygon-hao package\n// https://github.com/rowanwins/point-in-polygon-hao/blob/938b2be31d326c52c8f6cffbbb1c59bae4d609bc/src/index.js\n// Returns true if point is inside of polygon with holes\n//\n// Speedups:\n// - Reuse preprocessed polygon\n// - Avoid point allocation (and it's garbage collection) and use coordinates\nexport function coordsInPolygonForInsidenessCheck(x, y, polygonForInsidenessCheck) {\n    if (x < polygonForInsidenessCheck.bbox[0] ||\n        y < polygonForInsidenessCheck.bbox[1] ||\n        x > polygonForInsidenessCheck.bbox[2] ||\n        y > polygonForInsidenessCheck.bbox[3])\n        return false;\n    let k = 0;\n    const closedRings = polygonForInsidenessCheck.closedRings;\n    for (let i = 0; i < closedRings.length; i++) {\n        const coords = closedRings[i].coords;\n        const length = closedRings[i].length;\n        let u1 = coords[0] - x;\n        let v1 = coords[1] - y;\n        for (let ii = 0; ii < length; ii++) {\n            const base = (ii + 1) * 2;\n            const u2 = coords[base] - x;\n            const v2 = coords[base + 1] - y;\n            if (v1 === 0 && v2 === 0) {\n                if ((u2 <= 0 && u1 >= 0) || (u1 <= 0 && u2 >= 0))\n                    return 0;\n            }\n            else if ((v2 >= 0 && v1 <= 0) || (v2 <= 0 && v1 >= 0)) {\n                const f = orient2d(u1, u2, v1, v2, 0, 0);\n                if (f === 0)\n                    return 0;\n                if ((f > 0 && v2 > 0 && v1 <= 0) || (f < 0 && v2 <= 0 && v1 > 0))\n                    k++;\n            }\n            u1 = u2;\n            v1 = v2;\n        }\n    }\n    return k % 2 !== 0;\n}\nexport function coordsInPolygonsForInsidenessCheck(x, y, polygonsForInsidenessChecks) {\n    return polygonsForInsidenessChecks.some((polygonForInsidenessChecks) => coordsInPolygonForInsidenessCheck(x, y, polygonForInsidenessChecks));\n}\n"],"names":["pointOnLine","point","line","exclude","x","y","x0","y0","x1","y1","orient2d","buildKDBushPointIndex","points","tree","KDBush","splitRingLines","ring","result","i","p0","p1","ids","hits","id","ax","ay","bx","by","splitPolygonLines","polygon","index","interpolateLine","dist","lineDistance","distance","steps","angle","lineAngle","currentPoint","step","stepDistanceAngle","interpolateRing","closeRing","interpolatePolygon","bboxToGridPoints","bbox","gridSize","grid","j","preprocessPolygonForInsideCheck","closedRings","closedRing","ringLength","coords","computeBbox","coordsInPolygonForInsidenessCheck","polygonForInsidenessCheck","k","length","u1","v1","ii","base","u2","v2","f","coordsInPolygonsForInsidenessCheck","polygonsForInsidenessChecks","polygonForInsidenessChecks"],"mappings":"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","x_google_ignoreList":[0]}