@iqworksai/common-components 0.1.21 → 0.1.23

package/dist/node_modules/d3-geo/src/path/centroid.mjs

@@ -0,0 +1,48 @@
+import { sqrt as N } from "../math.mjs";
+var g = 0, E = 0, f = 0, l = 0, S = 0, d = 0, s = 0, v = 0, p = 0, R, m, o, r, e = {
+  point: c,
+  lineStart: P,
+  lineEnd: L,
+  polygonStart: function() {
+    e.lineStart = z, e.lineEnd = F;
+  },
+  polygonEnd: function() {
+    e.point = c, e.lineStart = P, e.lineEnd = L;
+  },
+  result: function() {
+    var n = p ? [s / p, v / p] : d ? [l / d, S / d] : f ? [g / f, E / f] : [NaN, NaN];
+    return g = E = f = l = S = d = s = v = p = 0, n;
+  }
+};
+function c(n, t) {
+  g += n, E += t, ++f;
+}
+function P() {
+  e.point = Y;
+}
+function Y(n, t) {
+  e.point = Z, c(o = n, r = t);
+}
+function Z(n, t) {
+  var a = n - o, u = t - r, i = N(a * a + u * u);
+  l += i * (o + n) / 2, S += i * (r + t) / 2, d += i, c(o = n, r = t);
+}
+function L() {
+  e.point = c;
+}
+function z() {
+  e.point = q;
+}
+function F() {
+  X(R, m);
+}
+function q(n, t) {
+  e.point = X, c(R = o = n, m = r = t);
+}
+function X(n, t) {
+  var a = n - o, u = t - r, i = N(a * a + u * u);
+  l += i * (o + n) / 2, S += i * (r + t) / 2, d += i, i = r * n - o * t, s += i * (o + n), v += i * (r + t), p += i * 3, c(o = n, r = t);
+}
+export {
+  e as default
+};

package/dist/node_modules/d3-geo/src/path/context.mjs

@@ -0,0 +1,43 @@
+import { tau as n } from "../math.mjs";
+import o from "../noop.mjs";
+function s(t) {
+  this._context = t;
+}
+s.prototype = {
+  _radius: 4.5,
+  pointRadius: function(t) {
+    return this._radius = t, this;
+  },
+  polygonStart: function() {
+    this._line = 0;
+  },
+  polygonEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._point = 0;
+  },
+  lineEnd: function() {
+    this._line === 0 && this._context.closePath(), this._point = NaN;
+  },
+  point: function(t, i) {
+    switch (this._point) {
+      case 0: {
+        this._context.moveTo(t, i), this._point = 1;
+        break;
+      }
+      case 1: {
+        this._context.lineTo(t, i);
+        break;
+      }
+      default: {
+        this._context.moveTo(t + this._radius, i), this._context.arc(t, i, this._radius, 0, n);
+        break;
+      }
+    }
+  },
+  result: o
+};
+export {
+  s as default
+};

package/dist/node_modules/d3-geo/src/path/index.mjs

@@ -0,0 +1,41 @@
+import c from "../identity.mjs";
+import f from "../stream.mjs";
+import m from "./area.mjs";
+import s from "./bounds.mjs";
+import p from "./centroid.mjs";
+import h from "./context.mjs";
+import g from "./measure.mjs";
+import d from "./string.mjs";
+function C(a, o) {
+  let e = 3, i = 4.5, u, r;
+  function n(t) {
+    return t && (typeof i == "function" && r.pointRadius(+i.apply(this, arguments)), f(t, u(r))), r.result();
+  }
+  return n.area = function(t) {
+    return f(t, u(m)), m.result();
+  }, n.measure = function(t) {
+    return f(t, u(g)), g.result();
+  }, n.bounds = function(t) {
+    return f(t, u(s)), s.result();
+  }, n.centroid = function(t) {
+    return f(t, u(p)), p.result();
+  }, n.projection = function(t) {
+    return arguments.length ? (u = t == null ? (a = null, c) : (a = t).stream, n) : a;
+  }, n.context = function(t) {
+    return arguments.length ? (r = t == null ? (o = null, new d(e)) : new h(o = t), typeof i != "function" && r.pointRadius(i), n) : o;
+  }, n.pointRadius = function(t) {
+    return arguments.length ? (i = typeof t == "function" ? t : (r.pointRadius(+t), +t), n) : i;
+  }, n.digits = function(t) {
+    if (!arguments.length) return e;
+    if (t == null) e = null;
+    else {
+      const l = Math.floor(t);
+      if (!(l >= 0)) throw new RangeError(`invalid digits: ${t}`);
+      e = l;
+    }
+    return o === null && (r = new d(e)), n;
+  }, n.projection(a).digits(e).context(o);
+}
+export {
+  C as default
+};

package/dist/node_modules/d3-geo/src/path/measure.mjs

@@ -0,0 +1,31 @@
+import { sqrt as m } from "../math.mjs";
+import u from "../noop.mjs";
+import { Adder as f } from "../../../d3-array/src/fsum.mjs";
+var e = new f(), r, p, a, t, o, l = {
+  point: u,
+  lineStart: function() {
+    l.point = c;
+  },
+  lineEnd: function() {
+    r && g(p, a), l.point = u;
+  },
+  polygonStart: function() {
+    r = !0;
+  },
+  polygonEnd: function() {
+    r = null;
+  },
+  result: function() {
+    var n = +e;
+    return e = new f(), n;
+  }
+};
+function c(n, i) {
+  l.point = g, p = t = n, a = o = i;
+}
+function g(n, i) {
+  t -= n, o -= i, e.add(m(t * t + o * o)), t = n, o = i;
+}
+export {
+  l as default
+};

package/dist/node_modules/d3-geo/src/path/string.mjs

@@ -0,0 +1,69 @@
+let o, a, p, r;
+class d {
+  constructor(t) {
+    this._append = t == null ? _ : l(t), this._radius = 4.5, this._ = "";
+  }
+  pointRadius(t) {
+    return this._radius = +t, this;
+  }
+  polygonStart() {
+    this._line = 0;
+  }
+  polygonEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {
+    this._line === 0 && (this._ += "Z"), this._point = NaN;
+  }
+  point(t, n) {
+    switch (this._point) {
+      case 0: {
+        this._append`M${t},${n}`, this._point = 1;
+        break;
+      }
+      case 1: {
+        this._append`L${t},${n}`;
+        break;
+      }
+      default: {
+        if (this._append`M${t},${n}`, this._radius !== p || this._append !== a) {
+          const i = this._radius, e = this._;
+          this._ = "", this._append`m0,${i}a${i},${i} 0 1,1 0,${-2 * i}a${i},${i} 0 1,1 0,${2 * i}z`, p = i, a = this._append, r = this._, this._ = e;
+        }
+        this._ += r;
+        break;
+      }
+    }
+  }
+  result() {
+    const t = this._;
+    return this._ = "", t.length ? t : null;
+  }
+}
+function _(s) {
+  let t = 1;
+  this._ += s[0];
+  for (const n = s.length; t < n; ++t)
+    this._ += arguments[t] + s[t];
+}
+function l(s) {
+  const t = Math.floor(s);
+  if (!(t >= 0)) throw new RangeError(`invalid digits: ${s}`);
+  if (t > 15) return _;
+  if (t !== o) {
+    const n = 10 ** t;
+    o = t, a = function(e) {
+      let h = 1;
+      this._ += e[0];
+      for (const c = e.length; h < c; ++h)
+        this._ += Math.round(arguments[h] * n) / n + e[h];
+    };
+  }
+  return a;
+}
+export {
+  d as default
+};

package/dist/node_modules/d3-geo/src/pointEqual.mjs

@@ -0,0 +1,7 @@
+import { abs as n, epsilon as r } from "./math.mjs";
+function i(o, t) {
+  return n(o[0] - t[0]) < r && n(o[1] - t[1]) < r;
+}
+export {
+  i as default
+};

package/dist/node_modules/d3-geo/src/polygonContains.mjs

@@ -0,0 +1,27 @@
+import { cartesianCross as S, cartesian as T, cartesianNormalizeInPlace as U } from "./cartesian.mjs";
+import { quarterPi as V, atan2 as $, sin as e, cos as g, asin as k, epsilon as l, halfPi as W, pi as w, tau as Y, epsilon2 as h, abs as X, sign as j } from "./math.mjs";
+import { Adder as t } from "../../d3-array/src/fsum.mjs";
+function A(r) {
+  return X(r[0]) <= w ? r[0] : j(r[0]) * ((X(r[0]) + w) % Y - w);
+}
+function p(r, B) {
+  var v = A(B), u = B[1], E = e(u), Z = [e(v), -g(v), 0], C = 0, F = 0, G = new t();
+  E === 1 ? u = W + l : E === -1 && (u = -W - l);
+  for (var c = 0, _ = r.length; c < _; ++c)
+    if (q = (m = r[c]).length)
+      for (var m, q, s = m[q - 1], x = A(s), H = s[1] / 2 + V, J = e(H), K = g(H), z = 0; z < q; ++z, x = I, J = M, K = O, s = o) {
+        var o = m[z], I = A(o), L = o[1] / 2 + V, M = e(L), O = g(L), f = I - x, N = f >= 0 ? 1 : -1, y = N * f, a = y > w, P = J * M;
+        if (G.add($(P * N * e(y), K * O + P * g(y))), C += a ? f + N * Y : f, a ^ x >= v ^ I >= v) {
+          var n = S(T(s), T(o));
+          U(n);
+          var Q = S(Z, n);
+          U(Q);
+          var R = (a ^ f >= 0 ? -1 : 1) * k(Q[2]);
+          (u > R || u === R && (n[0] || n[1])) && (F += a ^ f >= 0 ? 1 : -1);
+        }
+      }
+  return (C < -l || C < l && G < -h) ^ F & 1;
+}
+export {
+  p as default
+};

package/dist/node_modules/d3-geo/src/projection/albers.mjs

@@ -0,0 +1,7 @@
+import e from "./conicEqualArea.mjs";
+function a() {
+  return e().parallels([29.5, 45.5]).scale(1070).translate([480, 250]).rotate([96, 0]).center([-0.6, 38.7]);
+}
+export {
+  a as default
+};

package/dist/node_modules/d3-geo/src/projection/albersUsa.mjs

@@ -0,0 +1,65 @@
+import { epsilon as c } from "../math.mjs";
+import E from "./albers.mjs";
+import x from "./conicEqualArea.mjs";
+import { fitExtent as S, fitSize as y, fitWidth as d, fitHeight as k } from "./fit.mjs";
+function b(l) {
+  var o = l.length;
+  return {
+    point: function(e, s) {
+      for (var u = -1; ++u < o; ) l[u].point(e, s);
+    },
+    sphere: function() {
+      for (var e = -1; ++e < o; ) l[e].sphere();
+    },
+    lineStart: function() {
+      for (var e = -1; ++e < o; ) l[e].lineStart();
+    },
+    lineEnd: function() {
+      for (var e = -1; ++e < o; ) l[e].lineEnd();
+    },
+    polygonStart: function() {
+      for (var e = -1; ++e < o; ) l[e].polygonStart();
+    },
+    polygonEnd: function() {
+      for (var e = -1; ++e < o; ) l[e].polygonEnd();
+    }
+  };
+}
+function U() {
+  var l, o, e = E(), s, u = x().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]), v, f = x().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]), m, p, g = { point: function(t, n) {
+    p = [t, n];
+  } };
+  function i(t) {
+    var n = t[0], r = t[1];
+    return p = null, s.point(n, r), p || (v.point(n, r), p) || (m.point(n, r), p);
+  }
+  i.invert = function(t) {
+    var n = e.scale(), r = e.translate(), a = (t[0] - r[0]) / n, h = (t[1] - r[1]) / n;
+    return (h >= 0.12 && h < 0.234 && a >= -0.425 && a < -0.214 ? u : h >= 0.166 && h < 0.234 && a >= -0.214 && a < -0.115 ? f : e).invert(t);
+  }, i.stream = function(t) {
+    return l && o === t ? l : l = b([e.stream(o = t), u.stream(t), f.stream(t)]);
+  }, i.precision = function(t) {
+    return arguments.length ? (e.precision(t), u.precision(t), f.precision(t), w()) : e.precision();
+  }, i.scale = function(t) {
+    return arguments.length ? (e.scale(t), u.scale(t * 0.35), f.scale(t), i.translate(e.translate())) : e.scale();
+  }, i.translate = function(t) {
+    if (!arguments.length) return e.translate();
+    var n = e.scale(), r = +t[0], a = +t[1];
+    return s = e.translate(t).clipExtent([[r - 0.455 * n, a - 0.238 * n], [r + 0.455 * n, a + 0.238 * n]]).stream(g), v = u.translate([r - 0.307 * n, a + 0.201 * n]).clipExtent([[r - 0.425 * n + c, a + 0.12 * n + c], [r - 0.214 * n - c, a + 0.234 * n - c]]).stream(g), m = f.translate([r - 0.205 * n, a + 0.212 * n]).clipExtent([[r - 0.214 * n + c, a + 0.166 * n + c], [r - 0.115 * n - c, a + 0.234 * n - c]]).stream(g), w();
+  }, i.fitExtent = function(t, n) {
+    return S(i, t, n);
+  }, i.fitSize = function(t, n) {
+    return y(i, t, n);
+  }, i.fitWidth = function(t, n) {
+    return d(i, t, n);
+  }, i.fitHeight = function(t, n) {
+    return k(i, t, n);
+  };
+  function w() {
+    return l = o = null, i;
+  }
+  return i.scale(1070);
+}
+export {
+  U as default
+};

package/dist/node_modules/d3-geo/src/projection/azimuthal.mjs

@@ -0,0 +1,23 @@
+import { atan2 as f, asin as s, sqrt as m, sin as a, cos as o } from "../math.mjs";
+function z(u) {
+  return function(n, r) {
+    var t = o(n), c = o(r), i = u(t * c);
+    return i === 1 / 0 ? [2, 0] : [
+      i * c * a(n),
+      i * a(r)
+    ];
+  };
+}
+function h(u) {
+  return function(n, r) {
+    var t = m(n * n + r * r), c = u(t), i = a(c), e = o(c);
+    return [
+      f(n * i, t * e),
+      s(t && r * i / t)
+    ];
+  };
+}
+export {
+  h as azimuthalInvert,
+  z as azimuthalRaw
+};

package/dist/node_modules/d3-geo/src/projection/azimuthalEqualArea.mjs

@@ -0,0 +1,16 @@
+import { sqrt as a, asin as e } from "../math.mjs";
+import { azimuthalInvert as i, azimuthalRaw as n } from "./azimuthal.mjs";
+import o from "./index.mjs";
+var t = n(function(r) {
+  return a(2 / (1 + r));
+});
+t.invert = i(function(r) {
+  return 2 * e(r / 2);
+});
+function f() {
+  return o(t).scale(124.75).clipAngle(180 - 1e-3);
+}
+export {
+  t as azimuthalEqualAreaRaw,
+  f as default
+};

package/dist/node_modules/d3-geo/src/projection/azimuthalEquidistant.mjs

@@ -0,0 +1,16 @@
+import { acos as r, sin as a } from "../math.mjs";
+import { azimuthalInvert as n, azimuthalRaw as o } from "./azimuthal.mjs";
+import u from "./index.mjs";
+var i = o(function(t) {
+  return (t = r(t)) && t / a(t);
+});
+i.invert = n(function(t) {
+  return t;
+});
+function f() {
+  return u(i).scale(79.4188).clipAngle(180 - 1e-3);
+}
+export {
+  i as azimuthalEquidistantRaw,
+  f as default
+};

package/dist/node_modules/d3-geo/src/projection/conic.mjs

@@ -0,0 +1,11 @@
+import { radians as i, degrees as p, pi as c } from "../math.mjs";
+import { projectionMutator as m } from "./index.mjs";
+function l(a) {
+  var r = 0, o = c / 3, t = m(a), n = t(r, o);
+  return n.parallels = function(e) {
+    return arguments.length ? t(r = e[0] * i, o = e[1] * i) : [r * p, o * p];
+  }, n;
+}
+export {
+  l as conicProjection
+};

package/dist/node_modules/d3-geo/src/projection/conicConformal.mjs

@@ -0,0 +1,26 @@
+import { atan as P, pow as s, halfPi as a, sin as w, log as C, cos as m, atan2 as R, abs as b, sign as e, sqrt as d, tan as h, epsilon as c, pi as q } from "../math.mjs";
+import { conicProjection as k } from "./conic.mjs";
+import { mercatorRaw as z } from "./mercator.mjs";
+function l(o) {
+  return h((a + o) / 2);
+}
+function A(o, u) {
+  var p = m(o), r = o === u ? w(o) : C(p / m(u)) / C(l(u) / l(o)), f = p * s(l(o), r) / r;
+  if (!r) return z;
+  function v(t, i) {
+    f > 0 ? i < -a + c && (i = -a + c) : i > a - c && (i = a - c);
+    var n = f / s(l(i), r);
+    return [n * w(r * t), f - n * m(r * t)];
+  }
+  return v.invert = function(t, i) {
+    var n = f - i, j = e(r) * d(t * t + n * n), g = R(t, b(n)) * e(n);
+    return n * r < 0 && (g -= q * e(t) * e(n)), [g / r, 2 * P(s(f / j, 1 / r)) - a];
+  }, v;
+}
+function F() {
+  return k(A).scale(109.5).parallels([30, 30]);
+}
+export {
+  A as conicConformalRaw,
+  F as default
+};

package/dist/node_modules/d3-geo/src/projection/conicEqualArea.mjs

@@ -0,0 +1,23 @@
+import { abs as p, epsilon as q, asin as A, sin as a, cos as E, atan2 as d, sign as c, sqrt as m, pi as g } from "../math.mjs";
+import { conicProjection as j } from "./conic.mjs";
+import { cylindricalEqualAreaRaw as w } from "./cylindricalEqualArea.mjs";
+function y(u, v) {
+  var o = a(u), r = (o + a(v)) / 2;
+  if (p(r) < q) return w(u);
+  var t = 1 + o * (2 * r - o), f = m(t) / r;
+  function s(i, e) {
+    var n = m(t - 2 * r * a(e)) / r;
+    return [n * a(i *= r), f - n * E(i)];
+  }
+  return s.invert = function(i, e) {
+    var n = f - e, l = d(i, p(n)) * c(n);
+    return n * r < 0 && (l -= g * c(i) * c(n)), [l / r, A((t - (i * i + n * n) * r * r) / (2 * r))];
+  }, s;
+}
+function P() {
+  return j(y).scale(155.424).center([0, 33.6442]);
+}
+export {
+  y as conicEqualAreaRaw,
+  P as default
+};

package/dist/node_modules/d3-geo/src/projection/conicEquidistant.mjs

@@ -0,0 +1,22 @@
+import { abs as g, sin as m, epsilon as l, sign as c, sqrt as q, cos as f, atan2 as v, pi as d } from "../math.mjs";
+import { conicProjection as j } from "./conic.mjs";
+import { equirectangularRaw as w } from "./equirectangular.mjs";
+function E(i, a) {
+  var s = f(i), r = i === a ? m(i) : (s - f(a)) / (a - i), e = s / r + i;
+  if (g(r) < l) return w;
+  function p(t, u) {
+    var n = e - u, o = r * t;
+    return [n * m(o), e - n * f(o)];
+  }
+  return p.invert = function(t, u) {
+    var n = e - u, o = v(t, g(n)) * c(n);
+    return n * r < 0 && (o -= d * c(t) * c(n)), [o / r, e - c(r) * q(t * t + n * n)];
+  }, p;
+}
+function P() {
+  return j(E).scale(131.154).center([0, 13.9389]);
+}
+export {
+  E as conicEquidistantRaw,
+  P as default
+};

package/dist/node_modules/d3-geo/src/projection/cylindricalEqualArea.mjs

@@ -0,0 +1,13 @@
+import { asin as a, sin as c, cos as u } from "../math.mjs";
+function f(t) {
+  var r = u(t);
+  function o(n, i) {
+    return [n * r, c(i) / r];
+  }
+  return o.invert = function(n, i) {
+    return [n / r, a(i * r)];
+  }, o;
+}
+export {
+  f as cylindricalEqualAreaRaw
+};

package/dist/node_modules/d3-geo/src/projection/equalEarth.mjs

@@ -0,0 +1,25 @@
+import b from "./index.mjs";
+import { asin as p, cos as A, sin as q, sqrt as h, abs as g, epsilon2 as j } from "../math.mjs";
+var n = 1.340264, o = -0.081106, e = 893e-6, i = 3796e-6, s = h(3) / 2, k = 12;
+function E(u, l) {
+  var t = p(s * q(l)), r = t * t, a = r * r * r;
+  return [
+    u * A(t) / (s * (n + 3 * o * r + a * (7 * e + 9 * i * r))),
+    t * (n + o * r + a * (e + i * r))
+  ];
+}
+E.invert = function(u, l) {
+  for (var t = l, r = t * t, a = r * r * r, c = 0, f, v, m; c < k && (v = t * (n + o * r + a * (e + i * r)) - l, m = n + 3 * o * r + a * (7 * e + 9 * i * r), t -= f = v / m, r = t * t, a = r * r * r, !(g(f) < j)); ++c)
+    ;
+  return [
+    s * u * (n + 3 * o * r + a * (7 * e + 9 * i * r)) / A(t),
+    p(q(t) / s)
+  ];
+};
+function M() {
+  return b(E).scale(177.158);
+}
+export {
+  M as default,
+  E as equalEarthRaw
+};

package/dist/node_modules/d3-geo/src/projection/equirectangular.mjs

@@ -0,0 +1,12 @@
+import n from "./index.mjs";
+function r(e, t) {
+  return [e, t];
+}
+r.invert = r;
+function a() {
+  return n(r).scale(152.63);
+}
+export {
+  a as default,
+  r as equirectangularRaw
+};

package/dist/node_modules/d3-geo/src/projection/fit.mjs

@@ -0,0 +1,33 @@
+import e from "../stream.mjs";
+import c from "../path/bounds.mjs";
+function s(n, a, r) {
+  var t = n.clipExtent && n.clipExtent();
+  return n.scale(150).translate([0, 0]), t != null && n.clipExtent(null), e(r, n.stream(c)), a(c.result()), t != null && n.clipExtent(t), n;
+}
+function h(n, a, r) {
+  return s(n, function(t) {
+    var u = a[1][0] - a[0][0], l = a[1][1] - a[0][1], f = Math.min(u / (t[1][0] - t[0][0]), l / (t[1][1] - t[0][1])), i = +a[0][0] + (u - f * (t[1][0] + t[0][0])) / 2, m = +a[0][1] + (l - f * (t[1][1] + t[0][1])) / 2;
+    n.scale(150 * f).translate([i, m]);
+  }, r);
+}
+function x(n, a, r) {
+  return h(n, [[0, 0], a], r);
+}
+function k(n, a, r) {
+  return s(n, function(t) {
+    var u = +a, l = u / (t[1][0] - t[0][0]), f = (u - l * (t[1][0] + t[0][0])) / 2, i = -l * t[0][1];
+    n.scale(150 * l).translate([f, i]);
+  }, r);
+}
+function y(n, a, r) {
+  return s(n, function(t) {
+    var u = +a, l = u / (t[1][1] - t[0][1]), f = -l * t[0][0], i = (u - l * (t[1][1] + t[0][1])) / 2;
+    n.scale(150 * l).translate([f, i]);
+  }, r);
+}
+export {
+  h as fitExtent,
+  y as fitHeight,
+  x as fitSize,
+  k as fitWidth
+};

package/dist/node_modules/d3-geo/src/projection/gnomonic.mjs

@@ -0,0 +1,15 @@
+import { atan as c, sin as i, cos as e } from "../math.mjs";
+import { azimuthalInvert as m } from "./azimuthal.mjs";
+import f from "./index.mjs";
+function a(o, n) {
+  var r = e(n), t = e(o) * r;
+  return [r * i(o) / t, i(n) / t];
+}
+a.invert = m(c);
+function s() {
+  return f(a).scale(144.049).clipAngle(60);
+}
+export {
+  s as default,
+  a as gnomonicRaw
+};