@mui/x-charts-vendor 7.12.0

package/lib-vendor/delaunator/delaunator.min.js

@@ -0,0 +1,316 @@
+"use strict";
+
+!function (t, i) {
+  "object" == typeof exports && "undefined" != typeof module ? module.exports = i() : "function" == typeof define && define.amd ? define(i) : (t = "undefined" != typeof globalThis ? globalThis : t || self).Delaunator = i();
+}(this, function () {
+  "use strict";
+
+  const t = 11102230246251565e-32,
+    i = 134217729,
+    s = (3 + 8 * t) * t;
+  function e(t, i, s, e, n) {
+    let h,
+      r,
+      l,
+      o,
+      a = i[0],
+      f = e[0],
+      c = 0,
+      u = 0;
+    f > a == f > -a ? (h = a, a = i[++c]) : (h = f, f = e[++u]);
+    let _ = 0;
+    if (c < t && u < s) for (f > a == f > -a ? (r = a + h, l = h - (r - a), a = i[++c]) : (r = f + h, l = h - (r - f), f = e[++u]), h = r, 0 !== l && (n[_++] = l); c < t && u < s;) f > a == f > -a ? (r = h + a, o = r - h, l = h - (r - o) + (a - o), a = i[++c]) : (r = h + f, o = r - h, l = h - (r - o) + (f - o), f = e[++u]), h = r, 0 !== l && (n[_++] = l);
+    for (; c < t;) r = h + a, o = r - h, l = h - (r - o) + (a - o), a = i[++c], h = r, 0 !== l && (n[_++] = l);
+    for (; u < s;) r = h + f, o = r - h, l = h - (r - o) + (f - o), f = e[++u], h = r, 0 !== l && (n[_++] = l);
+    return 0 === h && 0 !== _ || (n[_++] = h), _;
+  }
+  function n(t) {
+    return new Float64Array(t);
+  }
+  const h = 22204460492503146e-32,
+    r = 11093356479670487e-47,
+    l = n(4),
+    o = n(8),
+    a = n(12),
+    f = n(16),
+    c = n(4);
+  function u(t, n, u, _, d, g) {
+    const y = (n - g) * (u - d),
+      w = (t - d) * (_ - g),
+      b = y - w,
+      A = Math.abs(y + w);
+    return Math.abs(b) >= 33306690738754716e-32 * A ? b : -function (t, n, u, _, d, g, y) {
+      let w, b, A, k, M, p, x, S, T, z, U, m, K, L, v, F, P, E;
+      const H = t - d,
+        I = u - d,
+        N = n - g,
+        j = _ - g;
+      L = H * j, p = i * H, x = p - (p - H), S = H - x, p = i * j, T = p - (p - j), z = j - T, v = S * z - (L - x * T - S * T - x * z), F = N * I, p = i * N, x = p - (p - N), S = N - x, p = i * I, T = p - (p - I), z = I - T, P = S * z - (F - x * T - S * T - x * z), U = v - P, M = v - U, l[0] = v - (U + M) + (M - P), m = L + U, M = m - L, K = L - (m - M) + (U - M), U = K - F, M = K - U, l[1] = K - (U + M) + (M - F), E = m + U, M = E - m, l[2] = m - (E - M) + (U - M), l[3] = E;
+      let q = function (t, i) {
+          let s = i[0];
+          for (let e = 1; e < t; e++) s += i[e];
+          return s;
+        }(4, l),
+        D = h * y;
+      if (q >= D || -q >= D) return q;
+      if (M = t - H, w = t - (H + M) + (M - d), M = u - I, A = u - (I + M) + (M - d), M = n - N, b = n - (N + M) + (M - g), M = _ - j, k = _ - (j + M) + (M - g), 0 === w && 0 === b && 0 === A && 0 === k) return q;
+      if (D = r * y + s * Math.abs(q), q += H * k + j * w - (N * A + I * b), q >= D || -q >= D) return q;
+      L = w * j, p = i * w, x = p - (p - w), S = w - x, p = i * j, T = p - (p - j), z = j - T, v = S * z - (L - x * T - S * T - x * z), F = b * I, p = i * b, x = p - (p - b), S = b - x, p = i * I, T = p - (p - I), z = I - T, P = S * z - (F - x * T - S * T - x * z), U = v - P, M = v - U, c[0] = v - (U + M) + (M - P), m = L + U, M = m - L, K = L - (m - M) + (U - M), U = K - F, M = K - U, c[1] = K - (U + M) + (M - F), E = m + U, M = E - m, c[2] = m - (E - M) + (U - M), c[3] = E;
+      const B = e(4, l, 4, c, o);
+      L = H * k, p = i * H, x = p - (p - H), S = H - x, p = i * k, T = p - (p - k), z = k - T, v = S * z - (L - x * T - S * T - x * z), F = N * A, p = i * N, x = p - (p - N), S = N - x, p = i * A, T = p - (p - A), z = A - T, P = S * z - (F - x * T - S * T - x * z), U = v - P, M = v - U, c[0] = v - (U + M) + (M - P), m = L + U, M = m - L, K = L - (m - M) + (U - M), U = K - F, M = K - U, c[1] = K - (U + M) + (M - F), E = m + U, M = E - m, c[2] = m - (E - M) + (U - M), c[3] = E;
+      const C = e(B, o, 4, c, a);
+      L = w * k, p = i * w, x = p - (p - w), S = w - x, p = i * k, T = p - (p - k), z = k - T, v = S * z - (L - x * T - S * T - x * z), F = b * A, p = i * b, x = p - (p - b), S = b - x, p = i * A, T = p - (p - A), z = A - T, P = S * z - (F - x * T - S * T - x * z), U = v - P, M = v - U, c[0] = v - (U + M) + (M - P), m = L + U, M = m - L, K = L - (m - M) + (U - M), U = K - F, M = K - U, c[1] = K - (U + M) + (M - F), E = m + U, M = E - m, c[2] = m - (E - M) + (U - M), c[3] = E;
+      const G = e(C, a, 4, c, f);
+      return f[G - 1];
+    }(t, n, u, _, d, g, A);
+  }
+  const _ = Math.pow(2, -52),
+    d = new Uint32Array(512);
+  class g {
+    static from(t, i = M, s = p) {
+      const e = t.length,
+        n = new Float64Array(2 * e);
+      for (let h = 0; h < e; h++) {
+        const e = t[h];
+        n[2 * h] = i(e), n[2 * h + 1] = s(e);
+      }
+      return new g(n);
+    }
+    constructor(t) {
+      const i = t.length >> 1;
+      if (i > 0 && "number" != typeof t[0]) throw new Error("Expected coords to contain numbers.");
+      this.coords = t;
+      const s = Math.max(2 * i - 5, 0);
+      this._triangles = new Uint32Array(3 * s), this._halfedges = new Int32Array(3 * s), 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.update();
+    }
+    update() {
+      const {
+          coords: t,
+          _hullPrev: i,
+          _hullNext: s,
+          _hullTri: e,
+          _hullHash: n
+        } = this,
+        h = t.length >> 1;
+      let r = 1 / 0,
+        l = 1 / 0,
+        o = -1 / 0,
+        a = -1 / 0;
+      for (let i = 0; i < h; i++) {
+        const s = t[2 * i],
+          e = t[2 * i + 1];
+        s < r && (r = s), e < l && (l = e), s > o && (o = s), e > a && (a = e), this._ids[i] = i;
+      }
+      const f = (r + o) / 2,
+        c = (l + a) / 2;
+      let d, g, w;
+      for (let i = 0, s = 1 / 0; i < h; i++) {
+        const e = y(f, c, t[2 * i], t[2 * i + 1]);
+        e < s && (d = i, s = e);
+      }
+      const k = t[2 * d],
+        M = t[2 * d + 1];
+      for (let i = 0, s = 1 / 0; i < h; i++) {
+        if (i === d) continue;
+        const e = y(k, M, t[2 * i], t[2 * i + 1]);
+        e < s && e > 0 && (g = i, s = e);
+      }
+      let p = t[2 * g],
+        x = t[2 * g + 1],
+        S = 1 / 0;
+      for (let i = 0; i < h; i++) {
+        if (i === d || i === g) continue;
+        const s = b(k, M, p, x, t[2 * i], t[2 * i + 1]);
+        s < S && (w = i, S = s);
+      }
+      let T = t[2 * w],
+        z = t[2 * w + 1];
+      if (S === 1 / 0) {
+        for (let i = 0; i < h; i++) this._dists[i] = t[2 * i] - t[0] || t[2 * i + 1] - t[1];
+        A(this._ids, this._dists, 0, h - 1);
+        const i = new Uint32Array(h);
+        let s = 0;
+        for (let t = 0, e = -1 / 0; t < h; t++) {
+          const n = this._ids[t],
+            h = this._dists[n];
+          h > e && (i[s++] = n, e = h);
+        }
+        return this.hull = i.subarray(0, s), this.triangles = new Uint32Array(0), void (this.halfedges = new Uint32Array(0));
+      }
+      if (u(k, M, p, x, T, z) < 0) {
+        const t = g,
+          i = p,
+          s = x;
+        g = w, p = T, x = z, w = t, T = i, z = s;
+      }
+      const U = function (t, i, s, e, n, h) {
+        const r = s - t,
+          l = e - i,
+          o = n - t,
+          a = h - i,
+          f = r * r + l * l,
+          c = o * o + a * a,
+          u = .5 / (r * a - l * o);
+        return {
+          x: t + (a * f - l * c) * u,
+          y: i + (r * c - o * f) * u
+        };
+      }(k, M, p, x, T, z);
+      this._cx = U.x, this._cy = U.y;
+      for (let i = 0; i < h; i++) this._dists[i] = y(t[2 * i], t[2 * i + 1], U.x, U.y);
+      A(this._ids, this._dists, 0, h - 1), this._hullStart = d;
+      let m = 3;
+      s[d] = i[w] = g, s[g] = i[d] = w, s[w] = i[g] = d, e[d] = 0, e[g] = 1, e[w] = 2, n.fill(-1), n[this._hashKey(k, M)] = d, n[this._hashKey(p, x)] = g, n[this._hashKey(T, z)] = w, this.trianglesLen = 0, this._addTriangle(d, g, w, -1, -1, -1);
+      for (let h, r, l = 0; l < this._ids.length; l++) {
+        const o = this._ids[l],
+          a = t[2 * o],
+          f = t[2 * o + 1];
+        if (l > 0 && Math.abs(a - h) <= _ && Math.abs(f - r) <= _) continue;
+        if (h = a, r = f, o === d || o === g || o === w) continue;
+        let c = 0;
+        for (let t = 0, i = this._hashKey(a, f); t < this._hashSize && (c = n[(i + t) % this._hashSize], -1 === c || c === s[c]); t++);
+        c = i[c];
+        let y,
+          b = c;
+        for (; y = s[b], u(a, f, t[2 * b], t[2 * b + 1], t[2 * y], t[2 * y + 1]) >= 0;) if (b = y, b === c) {
+          b = -1;
+          break;
+        }
+        if (-1 === b) continue;
+        let A = this._addTriangle(b, o, s[b], -1, -1, e[b]);
+        e[o] = this._legalize(A + 2), e[b] = A, m++;
+        let k = s[b];
+        for (; y = s[k], u(a, f, t[2 * k], t[2 * k + 1], t[2 * y], t[2 * y + 1]) < 0;) A = this._addTriangle(k, o, y, e[o], -1, e[k]), e[o] = this._legalize(A + 2), s[k] = k, m--, k = y;
+        if (b === c) for (; y = i[b], u(a, f, t[2 * y], t[2 * y + 1], t[2 * b], t[2 * b + 1]) < 0;) A = this._addTriangle(y, o, b, -1, e[b], e[y]), this._legalize(A + 2), e[y] = A, s[b] = b, m--, b = y;
+        this._hullStart = i[o] = b, s[b] = i[k] = o, s[o] = k, n[this._hashKey(a, f)] = o, n[this._hashKey(t[2 * b], t[2 * b + 1])] = b;
+      }
+      this.hull = new Uint32Array(m);
+      for (let t = 0, i = this._hullStart; t < m; t++) this.hull[t] = i, i = s[i];
+      this.triangles = this._triangles.subarray(0, this.trianglesLen), this.halfedges = this._halfedges.subarray(0, this.trianglesLen);
+    }
+    _hashKey(t, i) {
+      return Math.floor(function (t, i) {
+        const s = t / (Math.abs(t) + Math.abs(i));
+        return (i > 0 ? 3 - s : 1 + s) / 4;
+      }(t - this._cx, i - this._cy) * this._hashSize) % this._hashSize;
+    }
+    _legalize(t) {
+      const {
+        _triangles: i,
+        _halfedges: s,
+        coords: e
+      } = this;
+      let n = 0,
+        h = 0;
+      for (;;) {
+        const r = s[t],
+          l = t - t % 3;
+        if (h = l + (t + 2) % 3, -1 === r) {
+          if (0 === n) break;
+          t = d[--n];
+          continue;
+        }
+        const o = r - r % 3,
+          a = l + (t + 1) % 3,
+          f = o + (r + 2) % 3,
+          c = i[h],
+          u = i[t],
+          _ = i[a],
+          g = i[f];
+        if (w(e[2 * c], e[2 * c + 1], e[2 * u], e[2 * u + 1], e[2 * _], e[2 * _ + 1], e[2 * g], e[2 * g + 1])) {
+          i[t] = g, i[r] = c;
+          const e = s[f];
+          if (-1 === e) {
+            let i = this._hullStart;
+            do {
+              if (this._hullTri[i] === f) {
+                this._hullTri[i] = t;
+                break;
+              }
+              i = this._hullPrev[i];
+            } while (i !== this._hullStart);
+          }
+          this._link(t, e), this._link(r, s[h]), this._link(h, f);
+          const l = o + (r + 1) % 3;
+          n < d.length && (d[n++] = l);
+        } else {
+          if (0 === n) break;
+          t = d[--n];
+        }
+      }
+      return h;
+    }
+    _link(t, i) {
+      this._halfedges[t] = i, -1 !== i && (this._halfedges[i] = t);
+    }
+    _addTriangle(t, i, s, e, n, h) {
+      const r = this.trianglesLen;
+      return this._triangles[r] = t, this._triangles[r + 1] = i, this._triangles[r + 2] = s, this._link(r, e), this._link(r + 1, n), this._link(r + 2, h), this.trianglesLen += 3, r;
+    }
+  }
+  function y(t, i, s, e) {
+    const n = t - s,
+      h = i - e;
+    return n * n + h * h;
+  }
+  function w(t, i, s, e, n, h, r, l) {
+    const o = t - r,
+      a = i - l,
+      f = s - r,
+      c = e - l,
+      u = n - r,
+      _ = h - l,
+      d = f * f + c * c,
+      g = u * u + _ * _;
+    return o * (c * g - d * _) - a * (f * g - d * u) + (o * o + a * a) * (f * _ - c * u) < 0;
+  }
+  function b(t, i, s, e, n, h) {
+    const r = s - t,
+      l = e - i,
+      o = n - t,
+      a = h - i,
+      f = r * r + l * l,
+      c = o * o + a * a,
+      u = .5 / (r * a - l * o),
+      _ = (a * f - l * c) * u,
+      d = (r * c - o * f) * u;
+    return _ * _ + d * d;
+  }
+  function A(t, i, s, e) {
+    if (e - s <= 20) for (let n = s + 1; n <= e; n++) {
+      const e = t[n],
+        h = i[e];
+      let r = n - 1;
+      for (; r >= s && i[t[r]] > h;) t[r + 1] = t[r--];
+      t[r + 1] = e;
+    } else {
+      let n = s + 1,
+        h = e;
+      k(t, s + e >> 1, n), i[t[s]] > i[t[e]] && k(t, s, e), i[t[n]] > i[t[e]] && k(t, n, e), i[t[s]] > i[t[n]] && k(t, s, n);
+      const r = t[n],
+        l = i[r];
+      for (;;) {
+        do {
+          n++;
+        } while (i[t[n]] < l);
+        do {
+          h--;
+        } while (i[t[h]] > l);
+        if (h < n) break;
+        k(t, n, h);
+      }
+      t[s + 1] = t[h], t[h] = r, e - n + 1 >= h - s ? (A(t, i, n, e), A(t, i, s, h - 1)) : (A(t, i, s, h - 1), A(t, i, n, e));
+    }
+  }
+  function k(t, i, s) {
+    const e = t[i];
+    t[i] = t[s], t[s] = e;
+  }
+  function M(t) {
+    return t[0];
+  }
+  function p(t) {
+    return t[1];
+  }
+  return g;
+});