@undp/data-viz 1.2.8 → 1.3.0

package/dist/delaunay-C1uAf38t.js

@@ -0,0 +1,684 @@
+const E = 11102230246251565e-32, D = 134217729, lt = (3 + 8 * E) * E;
+function V(_, t, n, e, i) {
+  let s, l, h, r, a = t[0], f = e[0], o = 0, c = 0;
+  f > a == f > -a ? (s = a, a = t[++o]) : (s = f, f = e[++c]);
+  let u = 0;
+  if (o < _ && c < n)
+    for (f > a == f > -a ? (l = a + s, h = s - (l - a), a = t[++o]) : (l = f + s, h = s - (l - f), f = e[++c]), s = l, h !== 0 && (i[u++] = h); o < _ && c < n; )
+      f > a == f > -a ? (l = s + a, r = l - s, h = s - (l - r) + (a - r), a = t[++o]) : (l = s + f, r = l - s, h = s - (l - r) + (f - r), f = e[++c]), s = l, h !== 0 && (i[u++] = h);
+  for (; o < _; )
+    l = s + a, r = l - s, h = s - (l - r) + (a - r), a = t[++o], s = l, h !== 0 && (i[u++] = h);
+  for (; c < n; )
+    l = s + f, r = l - s, h = s - (l - r) + (f - r), f = e[++c], s = l, h !== 0 && (i[u++] = h);
+  return (s !== 0 || u === 0) && (i[u++] = s), u;
+}
+function ht(_, t) {
+  let n = t[0];
+  for (let e = 1; e < _; e++) n += t[e];
+  return n;
+}
+function B(_) {
+  return new Float64Array(_);
+}
+const rt = (3 + 16 * E) * E, ot = (2 + 12 * E) * E, ct = (9 + 64 * E) * E * E, N = B(4), J = B(8), W = B(12), tt = B(16), K = B(4);
+function at(_, t, n, e, i, s, l) {
+  let h, r, a, f, o, c, u, d, g, b, y, p, A, I, k, S, j, M;
+  const m = _ - i, x = n - i, w = t - s, v = e - s;
+  I = m * v, c = D * m, u = c - (c - m), d = m - u, c = D * v, g = c - (c - v), b = v - g, k = d * b - (I - u * g - d * g - u * b), S = w * x, c = D * w, u = c - (c - w), d = w - u, c = D * x, g = c - (c - x), b = x - g, j = d * b - (S - u * g - d * g - u * b), y = k - j, o = k - y, N[0] = k - (y + o) + (o - j), p = I + y, o = p - I, A = I - (p - o) + (y - o), y = A - S, o = A - y, N[1] = A - (y + o) + (o - S), M = p + y, o = M - p, N[2] = p - (M - o) + (y - o), N[3] = M;
+  let $ = ht(4, N), z = ot * l;
+  if ($ >= z || -$ >= z || (o = _ - m, h = _ - (m + o) + (o - i), o = n - x, a = n - (x + o) + (o - i), o = t - w, r = t - (w + o) + (o - s), o = e - v, f = e - (v + o) + (o - s), h === 0 && r === 0 && a === 0 && f === 0) || (z = ct * l + lt * Math.abs($), $ += m * f + v * h - (w * a + x * r), $ >= z || -$ >= z)) return $;
+  I = h * v, c = D * h, u = c - (c - h), d = h - u, c = D * v, g = c - (c - v), b = v - g, k = d * b - (I - u * g - d * g - u * b), S = r * x, c = D * r, u = c - (c - r), d = r - u, c = D * x, g = c - (c - x), b = x - g, j = d * b - (S - u * g - d * g - u * b), y = k - j, o = k - y, K[0] = k - (y + o) + (o - j), p = I + y, o = p - I, A = I - (p - o) + (y - o), y = A - S, o = A - y, K[1] = A - (y + o) + (o - S), M = p + y, o = M - p, K[2] = p - (M - o) + (y - o), K[3] = M;
+  const U = V(4, N, 4, K, J);
+  I = m * f, c = D * m, u = c - (c - m), d = m - u, c = D * f, g = c - (c - f), b = f - g, k = d * b - (I - u * g - d * g - u * b), S = w * a, c = D * w, u = c - (c - w), d = w - u, c = D * a, g = c - (c - a), b = a - g, j = d * b - (S - u * g - d * g - u * b), y = k - j, o = k - y, K[0] = k - (y + o) + (o - j), p = I + y, o = p - I, A = I - (p - o) + (y - o), y = A - S, o = A - y, K[1] = A - (y + o) + (o - S), M = p + y, o = M - p, K[2] = p - (M - o) + (y - o), K[3] = M;
+  const T = V(U, J, 4, K, W);
+  I = h * f, c = D * h, u = c - (c - h), d = h - u, c = D * f, g = c - (c - f), b = f - g, k = d * b - (I - u * g - d * g - u * b), S = r * a, c = D * r, u = c - (c - r), d = r - u, c = D * a, g = c - (c - a), b = a - g, j = d * b - (S - u * g - d * g - u * b), y = k - j, o = k - y, K[0] = k - (y + o) + (o - j), p = I + y, o = p - I, A = I - (p - o) + (y - o), y = A - S, o = A - y, K[1] = A - (y + o) + (o - S), M = p + y, o = M - p, K[2] = p - (M - o) + (y - o), K[3] = M;
+  const F = V(T, W, 4, K, tt);
+  return tt[F - 1];
+}
+function G(_, t, n, e, i, s) {
+  const l = (t - s) * (n - i), h = (_ - i) * (e - s), r = l - h, a = Math.abs(l + h);
+  return Math.abs(r) >= rt * a ? r : -at(_, t, n, e, i, s, a);
+}
+const nt = Math.pow(2, -52), Q = new Uint32Array(512);
+class O {
+  static from(t, n = dt, e = mt) {
+    const i = t.length, s = new Float64Array(i * 2);
+    for (let l = 0; l < i; l++) {
+      const h = t[l];
+      s[2 * l] = n(h), s[2 * l + 1] = e(h);
+    }
+    return new O(s);
+  }
+  constructor(t) {
+    const n = t.length >> 1;
+    if (n > 0 && typeof t[0] != "number") throw new Error("Expected coords to contain numbers.");
+    this.coords = t;
+    const e = Math.max(2 * n - 5, 0);
+    this._triangles = new Uint32Array(e * 3), this._halfedges = new Int32Array(e * 3), this._hashSize = Math.ceil(Math.sqrt(n)), this._hullPrev = new Uint32Array(n), this._hullNext = new Uint32Array(n), this._hullTri = new Uint32Array(n), this._hullHash = new Int32Array(this._hashSize), this._ids = new Uint32Array(n), this._dists = new Float64Array(n), this.update();
+  }
+  update() {
+    const { coords: t, _hullPrev: n, _hullNext: e, _hullTri: i, _hullHash: s } = this, l = t.length >> 1;
+    let h = 1 / 0, r = 1 / 0, a = -1 / 0, f = -1 / 0;
+    for (let m = 0; m < l; m++) {
+      const x = t[2 * m], w = t[2 * m + 1];
+      x < h && (h = x), w < r && (r = w), x > a && (a = x), w > f && (f = w), this._ids[m] = m;
+    }
+    const o = (h + a) / 2, c = (r + f) / 2;
+    let u, d, g;
+    for (let m = 0, x = 1 / 0; m < l; m++) {
+      const w = Z(o, c, t[2 * m], t[2 * m + 1]);
+      w < x && (u = m, x = w);
+    }
+    const b = t[2 * u], y = t[2 * u + 1];
+    for (let m = 0, x = 1 / 0; m < l; m++) {
+      if (m === u) continue;
+      const w = Z(b, y, t[2 * m], t[2 * m + 1]);
+      w < x && w > 0 && (d = m, x = w);
+    }
+    let p = t[2 * d], A = t[2 * d + 1], I = 1 / 0;
+    for (let m = 0; m < l; m++) {
+      if (m === u || m === d) continue;
+      const x = _t(b, y, p, A, t[2 * m], t[2 * m + 1]);
+      x < I && (g = m, I = x);
+    }
+    let k = t[2 * g], S = t[2 * g + 1];
+    if (I === 1 / 0) {
+      for (let w = 0; w < l; w++)
+        this._dists[w] = t[2 * w] - t[0] || t[2 * w + 1] - t[1];
+      Y(this._ids, this._dists, 0, l - 1);
+      const m = new Uint32Array(l);
+      let x = 0;
+      for (let w = 0, v = -1 / 0; w < l; w++) {
+        const $ = this._ids[w], z = this._dists[$];
+        z > v && (m[x++] = $, v = z);
+      }
+      this.hull = m.subarray(0, x), this.triangles = new Uint32Array(0), this.halfedges = new Uint32Array(0);
+      return;
+    }
+    if (G(b, y, p, A, k, S) < 0) {
+      const m = d, x = p, w = A;
+      d = g, p = k, A = S, g = m, k = x, S = w;
+    }
+    const j = gt(b, y, p, A, k, S);
+    this._cx = j.x, this._cy = j.y;
+    for (let m = 0; m < l; m++)
+      this._dists[m] = Z(t[2 * m], t[2 * m + 1], j.x, j.y);
+    Y(this._ids, this._dists, 0, l - 1), this._hullStart = u;
+    let M = 3;
+    e[u] = n[g] = d, e[d] = n[u] = g, e[g] = n[d] = u, i[u] = 0, i[d] = 1, i[g] = 2, s.fill(-1), s[this._hashKey(b, y)] = u, s[this._hashKey(p, A)] = d, s[this._hashKey(k, S)] = g, this.trianglesLen = 0, this._addTriangle(u, d, g, -1, -1, -1);
+    for (let m = 0, x, w; m < this._ids.length; m++) {
+      const v = this._ids[m], $ = t[2 * v], z = t[2 * v + 1];
+      if (m > 0 && Math.abs($ - x) <= nt && Math.abs(z - w) <= nt || (x = $, w = z, v === u || v === d || v === g)) continue;
+      let U = 0;
+      for (let P = 0, st = this._hashKey($, z); P < this._hashSize && (U = s[(st + P) % this._hashSize], !(U !== -1 && U !== e[U])); P++)
+        ;
+      U = n[U];
+      let T = U, F;
+      for (; F = e[T], G($, z, t[2 * T], t[2 * T + 1], t[2 * F], t[2 * F + 1]) >= 0; )
+        if (T = F, T === U) {
+          T = -1;
+          break;
+        }
+      if (T === -1) continue;
+      let L = this._addTriangle(T, v, e[T], -1, -1, i[T]);
+      i[v] = this._legalize(L + 2), i[T] = L, M++;
+      let C = e[T];
+      for (; F = e[C], G($, z, t[2 * C], t[2 * C + 1], t[2 * F], t[2 * F + 1]) < 0; )
+        L = this._addTriangle(C, v, F, i[v], -1, i[C]), i[v] = this._legalize(L + 2), e[C] = C, M--, C = F;
+      if (T === U)
+        for (; F = n[T], G($, z, t[2 * F], t[2 * F + 1], t[2 * T], t[2 * T + 1]) < 0; )
+          L = this._addTriangle(F, v, T, -1, i[T], i[F]), this._legalize(L + 2), i[F] = L, e[T] = T, M--, T = F;
+      this._hullStart = n[v] = T, e[T] = n[C] = v, e[v] = C, s[this._hashKey($, z)] = v, s[this._hashKey(t[2 * T], t[2 * T + 1])] = T;
+    }
+    this.hull = new Uint32Array(M);
+    for (let m = 0, x = this._hullStart; m < M; m++)
+      this.hull[m] = x, x = e[x];
+    this.triangles = this._triangles.subarray(0, this.trianglesLen), this.halfedges = this._halfedges.subarray(0, this.trianglesLen);
+  }
+  _hashKey(t, n) {
+    return Math.floor(ut(t - this._cx, n - this._cy) * this._hashSize) % this._hashSize;
+  }
+  _legalize(t) {
+    const { _triangles: n, _halfedges: e, coords: i } = this;
+    let s = 0, l = 0;
+    for (; ; ) {
+      const h = e[t], r = t - t % 3;
+      if (l = r + (t + 2) % 3, h === -1) {
+        if (s === 0) break;
+        t = Q[--s];
+        continue;
+      }
+      const a = h - h % 3, f = r + (t + 1) % 3, o = a + (h + 2) % 3, c = n[l], u = n[t], d = n[f], g = n[o];
+      if (ft(
+        i[2 * c],
+        i[2 * c + 1],
+        i[2 * u],
+        i[2 * u + 1],
+        i[2 * d],
+        i[2 * d + 1],
+        i[2 * g],
+        i[2 * g + 1]
+      )) {
+        n[t] = g, n[h] = c;
+        const y = e[o];
+        if (y === -1) {
+          let A = this._hullStart;
+          do {
+            if (this._hullTri[A] === o) {
+              this._hullTri[A] = t;
+              break;
+            }
+            A = this._hullPrev[A];
+          } while (A !== this._hullStart);
+        }
+        this._link(t, y), this._link(h, e[l]), this._link(l, o);
+        const p = a + (h + 1) % 3;
+        s < Q.length && (Q[s++] = p);
+      } else {
+        if (s === 0) break;
+        t = Q[--s];
+      }
+    }
+    return l;
+  }
+  _link(t, n) {
+    this._halfedges[t] = n, n !== -1 && (this._halfedges[n] = t);
+  }
+  // add a new triangle given vertex indices and adjacent half-edge ids
+  _addTriangle(t, n, e, i, s, l) {
+    const h = this.trianglesLen;
+    return this._triangles[h] = t, this._triangles[h + 1] = n, this._triangles[h + 2] = e, this._link(h, i), this._link(h + 1, s), this._link(h + 2, l), this.trianglesLen += 3, h;
+  }
+}
+function ut(_, t) {
+  const n = _ / (Math.abs(_) + Math.abs(t));
+  return (t > 0 ? 3 - n : 1 + n) / 4;
+}
+function Z(_, t, n, e) {
+  const i = _ - n, s = t - e;
+  return i * i + s * s;
+}
+function ft(_, t, n, e, i, s, l, h) {
+  const r = _ - l, a = t - h, f = n - l, o = e - h, c = i - l, u = s - h, d = r * r + a * a, g = f * f + o * o, b = c * c + u * u;
+  return r * (o * b - g * u) - a * (f * b - g * c) + d * (f * u - o * c) < 0;
+}
+function _t(_, t, n, e, i, s) {
+  const l = n - _, h = e - t, r = i - _, a = s - t, f = l * l + h * h, o = r * r + a * a, c = 0.5 / (l * a - h * r), u = (a * f - h * o) * c, d = (l * o - r * f) * c;
+  return u * u + d * d;
+}
+function gt(_, t, n, e, i, s) {
+  const l = n - _, h = e - t, r = i - _, a = s - t, f = l * l + h * h, o = r * r + a * a, c = 0.5 / (l * a - h * r), u = _ + (a * f - h * o) * c, d = t + (l * o - r * f) * c;
+  return { x: u, y: d };
+}
+function Y(_, t, n, e) {
+  if (e - n <= 20)
+    for (let i = n + 1; i <= e; i++) {
+      const s = _[i], l = t[s];
+      let h = i - 1;
+      for (; h >= n && t[_[h]] > l; ) _[h + 1] = _[h--];
+      _[h + 1] = s;
+    }
+  else {
+    const i = n + e >> 1;
+    let s = n + 1, l = e;
+    q(_, i, s), t[_[n]] > t[_[e]] && q(_, n, e), t[_[s]] > t[_[e]] && q(_, s, e), t[_[n]] > t[_[s]] && q(_, n, s);
+    const h = _[s], r = t[h];
+    for (; ; ) {
+      do
+        s++;
+      while (t[_[s]] < r);
+      do
+        l--;
+      while (t[_[l]] > r);
+      if (l < s) break;
+      q(_, s, l);
+    }
+    _[n + 1] = _[l], _[l] = h, e - s + 1 >= l - n ? (Y(_, t, s, e), Y(_, t, n, l - 1)) : (Y(_, t, n, l - 1), Y(_, t, s, e));
+  }
+}
+function q(_, t, n) {
+  const e = _[t];
+  _[t] = _[n], _[n] = e;
+}
+function dt(_) {
+  return _[0];
+}
+function mt(_) {
+  return _[1];
+}
+const it = 1e-6;
+class H {
+  constructor() {
+    this._x0 = this._y0 = // start of current subpath
+    this._x1 = this._y1 = null, this._ = "";
+  }
+  moveTo(t, n) {
+    this._ += `M${this._x0 = this._x1 = +t},${this._y0 = this._y1 = +n}`;
+  }
+  closePath() {
+    this._x1 !== null && (this._x1 = this._x0, this._y1 = this._y0, this._ += "Z");
+  }
+  lineTo(t, n) {
+    this._ += `L${this._x1 = +t},${this._y1 = +n}`;
+  }
+  arc(t, n, e) {
+    t = +t, n = +n, e = +e;
+    const i = t + e, s = n;
+    if (e < 0) throw new Error("negative radius");
+    this._x1 === null ? this._ += `M${i},${s}` : (Math.abs(this._x1 - i) > it || Math.abs(this._y1 - s) > it) && (this._ += "L" + i + "," + s), e && (this._ += `A${e},${e},0,1,1,${t - e},${n}A${e},${e},0,1,1,${this._x1 = i},${this._y1 = s}`);
+  }
+  rect(t, n, e, i) {
+    this._ += `M${this._x0 = this._x1 = +t},${this._y0 = this._y1 = +n}h${+e}v${+i}h${-e}Z`;
+  }
+  value() {
+    return this._ || null;
+  }
+}
+class R {
+  constructor() {
+    this._ = [];
+  }
+  moveTo(t, n) {
+    this._.push([t, n]);
+  }
+  closePath() {
+    this._.push(this._[0].slice());
+  }
+  lineTo(t, n) {
+    this._.push([t, n]);
+  }
+  value() {
+    return this._.length ? this._ : null;
+  }
+}
+class yt {
+  constructor(t, [n, e, i, s] = [0, 0, 960, 500]) {
+    if (!((i = +i) >= (n = +n)) || !((s = +s) >= (e = +e))) throw new Error("invalid bounds");
+    this.delaunay = t, this._circumcenters = new Float64Array(t.points.length * 2), this.vectors = new Float64Array(t.points.length * 2), this.xmax = i, this.xmin = n, this.ymax = s, this.ymin = e, this._init();
+  }
+  update() {
+    return this.delaunay.update(), this._init(), this;
+  }
+  _init() {
+    const { delaunay: { points: t, hull: n, triangles: e }, vectors: i } = this;
+    let s, l;
+    const h = this.circumcenters = this._circumcenters.subarray(0, e.length / 3 * 2);
+    for (let g = 0, b = 0, y = e.length, p, A; g < y; g += 3, b += 2) {
+      const I = e[g] * 2, k = e[g + 1] * 2, S = e[g + 2] * 2, j = t[I], M = t[I + 1], m = t[k], x = t[k + 1], w = t[S], v = t[S + 1], $ = m - j, z = x - M, U = w - j, T = v - M, F = ($ * T - z * U) * 2;
+      if (Math.abs(F) < 1e-9) {
+        if (s === void 0) {
+          s = l = 0;
+          for (const C of n) s += t[C * 2], l += t[C * 2 + 1];
+          s /= n.length, l /= n.length;
+        }
+        const L = 1e9 * Math.sign((s - j) * T - (l - M) * U);
+        p = (j + w) / 2 - L * T, A = (M + v) / 2 + L * U;
+      } else {
+        const L = 1 / F, C = $ * $ + z * z, P = U * U + T * T;
+        p = j + (T * C - z * P) * L, A = M + ($ * P - U * C) * L;
+      }
+      h[b] = p, h[b + 1] = A;
+    }
+    let r = n[n.length - 1], a, f = r * 4, o, c = t[2 * r], u, d = t[2 * r + 1];
+    i.fill(0);
+    for (let g = 0; g < n.length; ++g)
+      r = n[g], a = f, o = c, u = d, f = r * 4, c = t[2 * r], d = t[2 * r + 1], i[a + 2] = i[f] = u - d, i[a + 3] = i[f + 1] = c - o;
+  }
+  render(t) {
+    const n = t == null ? t = new H() : void 0, { delaunay: { halfedges: e, inedges: i, hull: s }, circumcenters: l, vectors: h } = this;
+    if (s.length <= 1) return null;
+    for (let f = 0, o = e.length; f < o; ++f) {
+      const c = e[f];
+      if (c < f) continue;
+      const u = Math.floor(f / 3) * 2, d = Math.floor(c / 3) * 2, g = l[u], b = l[u + 1], y = l[d], p = l[d + 1];
+      this._renderSegment(g, b, y, p, t);
+    }
+    let r, a = s[s.length - 1];
+    for (let f = 0; f < s.length; ++f) {
+      r = a, a = s[f];
+      const o = Math.floor(i[a] / 3) * 2, c = l[o], u = l[o + 1], d = r * 4, g = this._project(c, u, h[d + 2], h[d + 3]);
+      g && this._renderSegment(c, u, g[0], g[1], t);
+    }
+    return n && n.value();
+  }
+  renderBounds(t) {
+    const n = t == null ? t = new H() : void 0;
+    return t.rect(this.xmin, this.ymin, this.xmax - this.xmin, this.ymax - this.ymin), n && n.value();
+  }
+  renderCell(t, n) {
+    const e = n == null ? n = new H() : void 0, i = this._clip(t);
+    if (i === null || !i.length) return;
+    n.moveTo(i[0], i[1]);
+    let s = i.length;
+    for (; i[0] === i[s - 2] && i[1] === i[s - 1] && s > 1; ) s -= 2;
+    for (let l = 2; l < s; l += 2)
+      (i[l] !== i[l - 2] || i[l + 1] !== i[l - 1]) && n.lineTo(i[l], i[l + 1]);
+    return n.closePath(), e && e.value();
+  }
+  *cellPolygons() {
+    const { delaunay: { points: t } } = this;
+    for (let n = 0, e = t.length / 2; n < e; ++n) {
+      const i = this.cellPolygon(n);
+      i && (i.index = n, yield i);
+    }
+  }
+  cellPolygon(t) {
+    const n = new R();
+    return this.renderCell(t, n), n.value();
+  }
+  _renderSegment(t, n, e, i, s) {
+    let l;
+    const h = this._regioncode(t, n), r = this._regioncode(e, i);
+    h === 0 && r === 0 ? (s.moveTo(t, n), s.lineTo(e, i)) : (l = this._clipSegment(t, n, e, i, h, r)) && (s.moveTo(l[0], l[1]), s.lineTo(l[2], l[3]));
+  }
+  contains(t, n, e) {
+    return n = +n, n !== n || (e = +e, e !== e) ? !1 : this.delaunay._step(t, n, e) === t;
+  }
+  *neighbors(t) {
+    const n = this._clip(t);
+    if (n) for (const e of this.delaunay.neighbors(t)) {
+      const i = this._clip(e);
+      if (i) {
+        t: for (let s = 0, l = n.length; s < l; s += 2)
+          for (let h = 0, r = i.length; h < r; h += 2)
+            if (n[s] === i[h] && n[s + 1] === i[h + 1] && n[(s + 2) % l] === i[(h + r - 2) % r] && n[(s + 3) % l] === i[(h + r - 1) % r]) {
+              yield e;
+              break t;
+            }
+      }
+    }
+  }
+  _cell(t) {
+    const { circumcenters: n, delaunay: { inedges: e, halfedges: i, triangles: s } } = this, l = e[t];
+    if (l === -1) return null;
+    const h = [];
+    let r = l;
+    do {
+      const a = Math.floor(r / 3);
+      if (h.push(n[a * 2], n[a * 2 + 1]), r = r % 3 === 2 ? r - 2 : r + 1, s[r] !== t) break;
+      r = i[r];
+    } while (r !== l && r !== -1);
+    return h;
+  }
+  _clip(t) {
+    if (t === 0 && this.delaunay.hull.length === 1)
+      return [this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax, this.xmin, this.ymin];
+    const n = this._cell(t);
+    if (n === null) return null;
+    const { vectors: e } = this, i = t * 4;
+    return this._simplify(e[i] || e[i + 1] ? this._clipInfinite(t, n, e[i], e[i + 1], e[i + 2], e[i + 3]) : this._clipFinite(t, n));
+  }
+  _clipFinite(t, n) {
+    const e = n.length;
+    let i = null, s, l, h = n[e - 2], r = n[e - 1], a, f = this._regioncode(h, r), o, c = 0;
+    for (let u = 0; u < e; u += 2)
+      if (s = h, l = r, h = n[u], r = n[u + 1], a = f, f = this._regioncode(h, r), a === 0 && f === 0)
+        o = c, c = 0, i ? i.push(h, r) : i = [h, r];
+      else {
+        let d, g, b, y, p;
+        if (a === 0) {
+          if ((d = this._clipSegment(s, l, h, r, a, f)) === null) continue;
+          [g, b, y, p] = d;
+        } else {
+          if ((d = this._clipSegment(h, r, s, l, f, a)) === null) continue;
+          [y, p, g, b] = d, o = c, c = this._edgecode(g, b), o && c && this._edge(t, o, c, i, i.length), i ? i.push(g, b) : i = [g, b];
+        }
+        o = c, c = this._edgecode(y, p), o && c && this._edge(t, o, c, i, i.length), i ? i.push(y, p) : i = [y, p];
+      }
+    if (i)
+      o = c, c = this._edgecode(i[0], i[1]), o && c && this._edge(t, o, c, i, i.length);
+    else if (this.contains(t, (this.xmin + this.xmax) / 2, (this.ymin + this.ymax) / 2))
+      return [this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax, this.xmin, this.ymin];
+    return i;
+  }
+  _clipSegment(t, n, e, i, s, l) {
+    const h = s < l;
+    for (h && ([t, n, e, i, s, l] = [e, i, t, n, l, s]); ; ) {
+      if (s === 0 && l === 0) return h ? [e, i, t, n] : [t, n, e, i];
+      if (s & l) return null;
+      let r, a, f = s || l;
+      f & 8 ? (r = t + (e - t) * (this.ymax - n) / (i - n), a = this.ymax) : f & 4 ? (r = t + (e - t) * (this.ymin - n) / (i - n), a = this.ymin) : f & 2 ? (a = n + (i - n) * (this.xmax - t) / (e - t), r = this.xmax) : (a = n + (i - n) * (this.xmin - t) / (e - t), r = this.xmin), s ? (t = r, n = a, s = this._regioncode(t, n)) : (e = r, i = a, l = this._regioncode(e, i));
+    }
+  }
+  _clipInfinite(t, n, e, i, s, l) {
+    let h = Array.from(n), r;
+    if ((r = this._project(h[0], h[1], e, i)) && h.unshift(r[0], r[1]), (r = this._project(h[h.length - 2], h[h.length - 1], s, l)) && h.push(r[0], r[1]), h = this._clipFinite(t, h))
+      for (let a = 0, f = h.length, o, c = this._edgecode(h[f - 2], h[f - 1]); a < f; a += 2)
+        o = c, c = this._edgecode(h[a], h[a + 1]), o && c && (a = this._edge(t, o, c, h, a), f = h.length);
+    else this.contains(t, (this.xmin + this.xmax) / 2, (this.ymin + this.ymax) / 2) && (h = [this.xmin, this.ymin, this.xmax, this.ymin, this.xmax, this.ymax, this.xmin, this.ymax]);
+    return h;
+  }
+  _edge(t, n, e, i, s) {
+    for (; n !== e; ) {
+      let l, h;
+      switch (n) {
+        case 5:
+          n = 4;
+          continue;
+        // top-left
+        case 4:
+          n = 6, l = this.xmax, h = this.ymin;
+          break;
+        // top
+        case 6:
+          n = 2;
+          continue;
+        // top-right
+        case 2:
+          n = 10, l = this.xmax, h = this.ymax;
+          break;
+        // right
+        case 10:
+          n = 8;
+          continue;
+        // bottom-right
+        case 8:
+          n = 9, l = this.xmin, h = this.ymax;
+          break;
+        // bottom
+        case 9:
+          n = 1;
+          continue;
+        // bottom-left
+        case 1:
+          n = 5, l = this.xmin, h = this.ymin;
+          break;
+      }
+      (i[s] !== l || i[s + 1] !== h) && this.contains(t, l, h) && (i.splice(s, 0, l, h), s += 2);
+    }
+    return s;
+  }
+  _project(t, n, e, i) {
+    let s = 1 / 0, l, h, r;
+    if (i < 0) {
+      if (n <= this.ymin) return null;
+      (l = (this.ymin - n) / i) < s && (r = this.ymin, h = t + (s = l) * e);
+    } else if (i > 0) {
+      if (n >= this.ymax) return null;
+      (l = (this.ymax - n) / i) < s && (r = this.ymax, h = t + (s = l) * e);
+    }
+    if (e > 0) {
+      if (t >= this.xmax) return null;
+      (l = (this.xmax - t) / e) < s && (h = this.xmax, r = n + (s = l) * i);
+    } else if (e < 0) {
+      if (t <= this.xmin) return null;
+      (l = (this.xmin - t) / e) < s && (h = this.xmin, r = n + (s = l) * i);
+    }
+    return [h, r];
+  }
+  _edgecode(t, n) {
+    return (t === this.xmin ? 1 : t === this.xmax ? 2 : 0) | (n === this.ymin ? 4 : n === this.ymax ? 8 : 0);
+  }
+  _regioncode(t, n) {
+    return (t < this.xmin ? 1 : t > this.xmax ? 2 : 0) | (n < this.ymin ? 4 : n > this.ymax ? 8 : 0);
+  }
+  _simplify(t) {
+    if (t && t.length > 4) {
+      for (let n = 0; n < t.length; n += 2) {
+        const e = (n + 2) % t.length, i = (n + 4) % t.length;
+        (t[n] === t[e] && t[e] === t[i] || t[n + 1] === t[e + 1] && t[e + 1] === t[i + 1]) && (t.splice(e, 2), n -= 2);
+      }
+      t.length || (t = null);
+    }
+    return t;
+  }
+}
+const bt = 2 * Math.PI, X = Math.pow;
+function pt(_) {
+  return _[0];
+}
+function wt(_) {
+  return _[1];
+}
+function xt(_) {
+  const { triangles: t, coords: n } = _;
+  for (let e = 0; e < t.length; e += 3) {
+    const i = 2 * t[e], s = 2 * t[e + 1], l = 2 * t[e + 2];
+    if ((n[l] - n[i]) * (n[s + 1] - n[i + 1]) - (n[s] - n[i]) * (n[l + 1] - n[i + 1]) > 1e-10) return !1;
+  }
+  return !0;
+}
+function Tt(_, t, n) {
+  return [_ + Math.sin(_ + t) * n, t + Math.cos(_ - t) * n];
+}
+class et {
+  static from(t, n = pt, e = wt, i) {
+    return new et("length" in t ? At(t, n, e, i) : Float64Array.from(vt(t, n, e, i)));
+  }
+  constructor(t) {
+    this._delaunator = new O(t), this.inedges = new Int32Array(t.length / 2), this._hullIndex = new Int32Array(t.length / 2), this.points = this._delaunator.coords, this._init();
+  }
+  update() {
+    return this._delaunator.update(), this._init(), this;
+  }
+  _init() {
+    const t = this._delaunator, n = this.points;
+    if (t.hull && t.hull.length > 2 && xt(t)) {
+      this.collinear = Int32Array.from({ length: n.length / 2 }, (c, u) => u).sort((c, u) => n[2 * c] - n[2 * u] || n[2 * c + 1] - n[2 * u + 1]);
+      const r = this.collinear[0], a = this.collinear[this.collinear.length - 1], f = [n[2 * r], n[2 * r + 1], n[2 * a], n[2 * a + 1]], o = 1e-8 * Math.hypot(f[3] - f[1], f[2] - f[0]);
+      for (let c = 0, u = n.length / 2; c < u; ++c) {
+        const d = Tt(n[2 * c], n[2 * c + 1], o);
+        n[2 * c] = d[0], n[2 * c + 1] = d[1];
+      }
+      this._delaunator = new O(n);
+    } else
+      delete this.collinear;
+    const e = this.halfedges = this._delaunator.halfedges, i = this.hull = this._delaunator.hull, s = this.triangles = this._delaunator.triangles, l = this.inedges.fill(-1), h = this._hullIndex.fill(-1);
+    for (let r = 0, a = e.length; r < a; ++r) {
+      const f = s[r % 3 === 2 ? r - 2 : r + 1];
+      (e[r] === -1 || l[f] === -1) && (l[f] = r);
+    }
+    for (let r = 0, a = i.length; r < a; ++r)
+      h[i[r]] = r;
+    i.length <= 2 && i.length > 0 && (this.triangles = new Int32Array(3).fill(-1), this.halfedges = new Int32Array(3).fill(-1), this.triangles[0] = i[0], l[i[0]] = 1, i.length === 2 && (l[i[1]] = 0, this.triangles[1] = i[1], this.triangles[2] = i[1]));
+  }
+  voronoi(t) {
+    return new yt(this, t);
+  }
+  *neighbors(t) {
+    const { inedges: n, hull: e, _hullIndex: i, halfedges: s, triangles: l, collinear: h } = this;
+    if (h) {
+      const o = h.indexOf(t);
+      o > 0 && (yield h[o - 1]), o < h.length - 1 && (yield h[o + 1]);
+      return;
+    }
+    const r = n[t];
+    if (r === -1) return;
+    let a = r, f = -1;
+    do {
+      if (yield f = l[a], a = a % 3 === 2 ? a - 2 : a + 1, l[a] !== t) return;
+      if (a = s[a], a === -1) {
+        const o = e[(i[t] + 1) % e.length];
+        o !== f && (yield o);
+        return;
+      }
+    } while (a !== r);
+  }
+  find(t, n, e = 0) {
+    if (t = +t, t !== t || (n = +n, n !== n)) return -1;
+    const i = e;
+    let s;
+    for (; (s = this._step(e, t, n)) >= 0 && s !== e && s !== i; ) e = s;
+    return s;
+  }
+  _step(t, n, e) {
+    const { inedges: i, hull: s, _hullIndex: l, halfedges: h, triangles: r, points: a } = this;
+    if (i[t] === -1 || !a.length) return (t + 1) % (a.length >> 1);
+    let f = t, o = X(n - a[t * 2], 2) + X(e - a[t * 2 + 1], 2);
+    const c = i[t];
+    let u = c;
+    do {
+      let d = r[u];
+      const g = X(n - a[d * 2], 2) + X(e - a[d * 2 + 1], 2);
+      if (g < o && (o = g, f = d), u = u % 3 === 2 ? u - 2 : u + 1, r[u] !== t) break;
+      if (u = h[u], u === -1) {
+        if (u = s[(l[t] + 1) % s.length], u !== d && X(n - a[u * 2], 2) + X(e - a[u * 2 + 1], 2) < o)
+          return u;
+        break;
+      }
+    } while (u !== c);
+    return f;
+  }
+  render(t) {
+    const n = t == null ? t = new H() : void 0, { points: e, halfedges: i, triangles: s } = this;
+    for (let l = 0, h = i.length; l < h; ++l) {
+      const r = i[l];
+      if (r < l) continue;
+      const a = s[l] * 2, f = s[r] * 2;
+      t.moveTo(e[a], e[a + 1]), t.lineTo(e[f], e[f + 1]);
+    }
+    return this.renderHull(t), n && n.value();
+  }
+  renderPoints(t, n) {
+    n === void 0 && (!t || typeof t.moveTo != "function") && (n = t, t = null), n = n == null ? 2 : +n;
+    const e = t == null ? t = new H() : void 0, { points: i } = this;
+    for (let s = 0, l = i.length; s < l; s += 2) {
+      const h = i[s], r = i[s + 1];
+      t.moveTo(h + n, r), t.arc(h, r, n, 0, bt);
+    }
+    return e && e.value();
+  }
+  renderHull(t) {
+    const n = t == null ? t = new H() : void 0, { hull: e, points: i } = this, s = e[0] * 2, l = e.length;
+    t.moveTo(i[s], i[s + 1]);
+    for (let h = 1; h < l; ++h) {
+      const r = 2 * e[h];
+      t.lineTo(i[r], i[r + 1]);
+    }
+    return t.closePath(), n && n.value();
+  }
+  hullPolygon() {
+    const t = new R();
+    return this.renderHull(t), t.value();
+  }
+  renderTriangle(t, n) {
+    const e = n == null ? n = new H() : void 0, { points: i, triangles: s } = this, l = s[t *= 3] * 2, h = s[t + 1] * 2, r = s[t + 2] * 2;
+    return n.moveTo(i[l], i[l + 1]), n.lineTo(i[h], i[h + 1]), n.lineTo(i[r], i[r + 1]), n.closePath(), e && e.value();
+  }
+  *trianglePolygons() {
+    const { triangles: t } = this;
+    for (let n = 0, e = t.length / 3; n < e; ++n)
+      yield this.trianglePolygon(n);
+  }
+  trianglePolygon(t) {
+    const n = new R();
+    return this.renderTriangle(t, n), n.value();
+  }
+}
+function At(_, t, n, e) {
+  const i = _.length, s = new Float64Array(i * 2);
+  for (let l = 0; l < i; ++l) {
+    const h = _[l];
+    s[l * 2] = t.call(e, h, l, _), s[l * 2 + 1] = n.call(e, h, l, _);
+  }
+  return s;
+}
+function* vt(_, t, n, e) {
+  let i = 0;
+  for (const s of _)
+    yield t.call(e, s, i, _), yield n.call(e, s, i, _), ++i;
+}
+export {
+  et as D
+};
+//# sourceMappingURL=delaunay-C1uAf38t.js.map