@pibit.ai/cure-design-system 0.6.41 → 0.6.43

package/dist/node_modules/d3-scale/src/log.js

@@ -0,0 +1,86 @@
+import E from "./nice.js";
+import { transformer as v, copy as F } from "./continuous.js";
+import { initRange as L } from "./init.js";
+import d from "../../d3-array/src/ticks.js";
+import j from "../../d3-format/src/formatSpecifier.js";
+import { format as z } from "../../d3-format/src/defaultLocale.js";
+function y(t) {
+  return Math.log(t);
+}
+function w(t) {
+  return Math.exp(t);
+}
+function I(t) {
+  return -Math.log(-t);
+}
+function R(t) {
+  return -Math.exp(-t);
+}
+function S(t) {
+  return isFinite(t) ? +("1e" + t) : t < 0 ? 0 : t;
+}
+function q(t) {
+  return t === 10 ? S : t === Math.E ? Math.exp : (n) => Math.pow(t, n);
+}
+function A(t) {
+  return t === Math.E ? Math.log : t === 10 && Math.log10 || t === 2 && Math.log2 || (t = Math.log(t), (n) => Math.log(n) / t);
+}
+function x(t) {
+  return (n, m) => -t(-n, m);
+}
+function B(t) {
+  const n = t(y, w), m = n.domain;
+  let l = 10, h, i;
+  function k() {
+    return h = A(l), i = q(l), m()[0] < 0 ? (h = x(h), i = x(i), t(I, R)) : t(y, w), n;
+  }
+  return n.base = function(o) {
+    return arguments.length ? (l = +o, k()) : l;
+  }, n.domain = function(o) {
+    return arguments.length ? (m(o), k()) : m();
+  }, n.ticks = (o) => {
+    const e = m();
+    let u = e[0], f = e[e.length - 1];
+    const M = f < u;
+    M && ([u, f] = [f, u]);
+    let r = h(u), g = h(f), a, c;
+    const p = o == null ? 10 : +o;
+    let s = [];
+    if (!(l % 1) && g - r < p) {
+      if (r = Math.floor(r), g = Math.ceil(g), u > 0) {
+        for (; r <= g; ++r)
+          for (a = 1; a < l; ++a)
+            if (c = r < 0 ? a / i(-r) : a * i(r), !(c < u)) {
+              if (c > f) break;
+              s.push(c);
+            }
+      } else for (; r <= g; ++r)
+        for (a = l - 1; a >= 1; --a)
+          if (c = r > 0 ? a / i(-r) : a * i(r), !(c < u)) {
+            if (c > f) break;
+            s.push(c);
+          }
+      s.length * 2 < p && (s = d(u, f, p));
+    } else
+      s = d(r, g, Math.min(g - r, p)).map(i);
+    return M ? s.reverse() : s;
+  }, n.tickFormat = (o, e) => {
+    if (o == null && (o = 10), e == null && (e = l === 10 ? "s" : ","), typeof e != "function" && (!(l % 1) && (e = j(e)).precision == null && (e.trim = !0), e = z(e)), o === 1 / 0) return e;
+    const u = Math.max(1, l * o / n.ticks().length);
+    return (f) => {
+      let M = f / i(Math.round(h(f)));
+      return M * l < l - 0.5 && (M *= l), M <= u ? e(f) : "";
+    };
+  }, n.nice = () => m(E(m(), {
+    floor: (o) => i(Math.floor(h(o))),
+    ceil: (o) => i(Math.ceil(h(o)))
+  })), n;
+}
+function C() {
+  const t = B(v()).domain([1, 10]);
+  return t.copy = () => F(t, C()).base(t.base()), L.apply(t, arguments), t;
+}
+export {
+  C as default,
+  B as loggish
+};

package/dist/node_modules/d3-scale/src/nice.js

@@ -0,0 +1,8 @@
+function x(e, u) {
+  e = e.slice();
+  var t = 0, c = e.length - 1, f = e[t], l = e[c], r;
+  return l < f && (r = t, t = c, c = r, r = f, f = l, l = r), e[t] = u.floor(f), e[c] = u.ceil(l), e;
+}
+export {
+  x as default
+};

package/dist/node_modules/d3-scale/src/number.js

@@ -0,0 +1,6 @@
+function n(e) {
+  return +e;
+}
+export {
+  n as default
+};

package/dist/node_modules/d3-scale/src/ordinal.js

@@ -0,0 +1,31 @@
+import { initRange as c } from "./init.js";
+import { InternMap as a } from "../../internmap/src/index.js";
+const f = Symbol("implicit");
+function l() {
+  var r = new a(), i = [], u = [], o = f;
+  function n(t) {
+    let e = r.get(t);
+    if (e === void 0) {
+      if (o !== f) return o;
+      r.set(t, e = i.push(t) - 1);
+    }
+    return u[e % u.length];
+  }
+  return n.domain = function(t) {
+    if (!arguments.length) return i.slice();
+    i = [], r = new a();
+    for (const e of t)
+      r.has(e) || r.set(e, i.push(e) - 1);
+    return n;
+  }, n.range = function(t) {
+    return arguments.length ? (u = Array.from(t), n) : u.slice();
+  }, n.unknown = function(t) {
+    return arguments.length ? (o = t, n) : o;
+  }, n.copy = function() {
+    return l(i, u).unknown(o);
+  }, c.apply(n, arguments), n;
+}
+export {
+  l as default,
+  f as implicit
+};

package/dist/node_modules/d3-scale/src/pow.js

@@ -0,0 +1,37 @@
+import { linearish as p } from "./linear.js";
+import { transformer as c, copy as f, identity as e } from "./continuous.js";
+import { initRange as s } from "./init.js";
+function o(n) {
+  return function(t) {
+    return t < 0 ? -Math.pow(-t, n) : Math.pow(t, n);
+  };
+}
+function l(n) {
+  return n < 0 ? -Math.sqrt(-n) : Math.sqrt(n);
+}
+function m(n) {
+  return n < 0 ? -n * n : n * n;
+}
+function h(n) {
+  var t = n(e, e), r = 1;
+  function a() {
+    return r === 1 ? n(e, e) : r === 0.5 ? n(l, m) : n(o(r), o(1 / r));
+  }
+  return t.exponent = function(i) {
+    return arguments.length ? (r = +i, a()) : r;
+  }, p(t);
+}
+function u() {
+  var n = h(c());
+  return n.copy = function() {
+    return f(n, u()).exponent(n.exponent());
+  }, s.apply(n, arguments), n;
+}
+function y() {
+  return u.apply(null, arguments).exponent(0.5);
+}
+export {
+  u as default,
+  h as powish,
+  y as sqrt
+};

package/dist/node_modules/d3-scale/src/quantile.js

@@ -0,0 +1,38 @@
+import { initRange as l } from "./init.js";
+import f from "../../d3-array/src/ascending.js";
+import { quantileSorted as s } from "../../d3-array/src/quantile.js";
+import { bisectRight as c } from "../../d3-array/src/bisect.js";
+function m() {
+  var t = [], u = [], i = [], a;
+  function o() {
+    var n = 0, r = Math.max(1, u.length);
+    for (i = new Array(r - 1); ++n < r; ) i[n - 1] = s(t, n / r);
+    return e;
+  }
+  function e(n) {
+    return n == null || isNaN(n = +n) ? a : u[c(i, n)];
+  }
+  return e.invertExtent = function(n) {
+    var r = u.indexOf(n);
+    return r < 0 ? [NaN, NaN] : [
+      r > 0 ? i[r - 1] : t[0],
+      r < i.length ? i[r] : t[t.length - 1]
+    ];
+  }, e.domain = function(n) {
+    if (!arguments.length) return t.slice();
+    t = [];
+    for (let r of n) r != null && !isNaN(r = +r) && t.push(r);
+    return t.sort(f), o();
+  }, e.range = function(n) {
+    return arguments.length ? (u = Array.from(n), o()) : u.slice();
+  }, e.unknown = function(n) {
+    return arguments.length ? (a = n, e) : a;
+  }, e.quantiles = function() {
+    return i.slice();
+  }, e.copy = function() {
+    return m().domain(t).range(u).unknown(a);
+  }, l.apply(e, arguments);
+}
+export {
+  m as default
+};

package/dist/node_modules/d3-scale/src/quantize.js

@@ -0,0 +1,31 @@
+import { linearish as l } from "./linear.js";
+import { initRange as m } from "./init.js";
+import { bisectRight as g } from "../../d3-array/src/bisect.js";
+function s() {
+  var i = 0, u = 1, t = 1, e = [0.5], a = [0, 1], c;
+  function r(n) {
+    return n != null && n <= n ? a[g(e, n, 0, t)] : c;
+  }
+  function f() {
+    var n = -1;
+    for (e = new Array(t); ++n < t; ) e[n] = ((n + 1) * u - (n - t) * i) / (t + 1);
+    return r;
+  }
+  return r.domain = function(n) {
+    return arguments.length ? ([i, u] = n, i = +i, u = +u, f()) : [i, u];
+  }, r.range = function(n) {
+    return arguments.length ? (t = (a = Array.from(n)).length - 1, f()) : a.slice();
+  }, r.invertExtent = function(n) {
+    var o = a.indexOf(n);
+    return o < 0 ? [NaN, NaN] : o < 1 ? [i, e[0]] : o >= t ? [e[t - 1], u] : [e[o - 1], e[o]];
+  }, r.unknown = function(n) {
+    return arguments.length && (c = n), r;
+  }, r.thresholds = function() {
+    return e.slice();
+  }, r.copy = function() {
+    return s().domain([i, u]).range(a).unknown(c);
+  }, m.apply(l(r), arguments);
+}
+export {
+  s as default
+};

package/dist/node_modules/d3-scale/src/radial.js

@@ -0,0 +1,37 @@
+import m from "./continuous.js";
+import { initRange as c } from "./init.js";
+import { linearish as s } from "./linear.js";
+import f from "./number.js";
+function i(n) {
+  return Math.sign(n) * n * n;
+}
+function g(n) {
+  return Math.sign(n) * Math.sqrt(Math.abs(n));
+}
+function l() {
+  var n = m(), e = [0, 1], u = !1, a;
+  function r(t) {
+    var o = g(n(t));
+    return isNaN(o) ? a : u ? Math.round(o) : o;
+  }
+  return r.invert = function(t) {
+    return n.invert(i(t));
+  }, r.domain = function(t) {
+    return arguments.length ? (n.domain(t), r) : n.domain();
+  }, r.range = function(t) {
+    return arguments.length ? (n.range((e = Array.from(t, f)).map(i)), r) : e.slice();
+  }, r.rangeRound = function(t) {
+    return r.range(t).round(!0);
+  }, r.round = function(t) {
+    return arguments.length ? (u = !!t, r) : u;
+  }, r.clamp = function(t) {
+    return arguments.length ? (n.clamp(t), r) : n.clamp();
+  }, r.unknown = function(t) {
+    return arguments.length ? (a = t, r) : a;
+  }, r.copy = function() {
+    return l(n.domain(), e).round(u).clamp(n.clamp()).unknown(a);
+  }, c.apply(r, arguments), s(r);
+}
+export {
+  l as default
+};

package/dist/node_modules/d3-scale/src/sequential.js

@@ -0,0 +1,70 @@
+import { identity as d } from "./continuous.js";
+import { initInterpolator as m } from "./init.js";
+import { linearish as w } from "./linear.js";
+import { loggish as k } from "./log.js";
+import { symlogish as b } from "./symlog.js";
+import { powish as M } from "./pow.js";
+import N from "../../d3-interpolate/src/value.js";
+import R from "../../d3-interpolate/src/round.js";
+function p() {
+  var n = 0, o = 1, e, a, i, l, u = d, f = !1, s;
+  function r(t) {
+    return t == null || isNaN(t = +t) ? s : u(i === 0 ? 0.5 : (t = (l(t) - e) * i, f ? Math.max(0, Math.min(1, t)) : t));
+  }
+  r.domain = function(t) {
+    return arguments.length ? ([n, o] = t, e = l(n = +n), a = l(o = +o), i = e === a ? 0 : 1 / (a - e), r) : [n, o];
+  }, r.clamp = function(t) {
+    return arguments.length ? (f = !!t, r) : f;
+  }, r.interpolator = function(t) {
+    return arguments.length ? (u = t, r) : u;
+  };
+  function g(t) {
+    return function(v) {
+      var y, h;
+      return arguments.length ? ([y, h] = v, u = t(y, h), r) : [u(0), u(1)];
+    };
+  }
+  return r.range = g(N), r.rangeRound = g(R), r.unknown = function(t) {
+    return arguments.length ? (s = t, r) : s;
+  }, function(t) {
+    return l = t, e = t(n), a = t(o), i = e === a ? 0 : 1 / (a - e), r;
+  };
+}
+function c(n, o) {
+  return o.domain(n.domain()).interpolator(n.interpolator()).clamp(n.clamp()).unknown(n.unknown());
+}
+function S() {
+  var n = w(p()(d));
+  return n.copy = function() {
+    return c(n, S());
+  }, m.apply(n, arguments);
+}
+function x() {
+  var n = k(p()).domain([1, 10]);
+  return n.copy = function() {
+    return c(n, x()).base(n.base());
+  }, m.apply(n, arguments);
+}
+function I() {
+  var n = b(p());
+  return n.copy = function() {
+    return c(n, I()).constant(n.constant());
+  }, m.apply(n, arguments);
+}
+function q() {
+  var n = M(p());
+  return n.copy = function() {
+    return c(n, q()).exponent(n.exponent());
+  }, m.apply(n, arguments);
+}
+function E() {
+  return q.apply(null, arguments).exponent(0.5);
+}
+export {
+  c as copy,
+  S as default,
+  x as sequentialLog,
+  q as sequentialPow,
+  E as sequentialSqrt,
+  I as sequentialSymlog
+};

package/dist/node_modules/d3-scale/src/sequentialQuantile.js

@@ -0,0 +1,28 @@
+import { identity as u } from "./continuous.js";
+import { initInterpolator as a } from "./init.js";
+import l from "../../d3-array/src/ascending.js";
+import f from "../../d3-array/src/quantile.js";
+import { bisectRight as m } from "../../d3-array/src/bisect.js";
+function p() {
+  var n = [], e = u;
+  function r(t) {
+    if (t != null && !isNaN(t = +t)) return e((m(n, t, 1) - 1) / (n.length - 1));
+  }
+  return r.domain = function(t) {
+    if (!arguments.length) return n.slice();
+    n = [];
+    for (let i of t) i != null && !isNaN(i = +i) && n.push(i);
+    return n.sort(l), r;
+  }, r.interpolator = function(t) {
+    return arguments.length ? (e = t, r) : e;
+  }, r.range = function() {
+    return n.map((t, i) => e(i / (n.length - 1)));
+  }, r.quantiles = function(t) {
+    return Array.from({ length: t + 1 }, (i, o) => f(n, o / t));
+  }, r.copy = function() {
+    return p(e).domain(n);
+  }, a.apply(r, arguments);
+}
+export {
+  p as default
+};

package/dist/node_modules/d3-scale/src/symlog.js

@@ -0,0 +1,29 @@
+import { linearish as u } from "./linear.js";
+import { transformer as i, copy as s } from "./continuous.js";
+import { initRange as c } from "./init.js";
+function o(n) {
+  return function(t) {
+    return Math.sign(t) * Math.log1p(Math.abs(t / n));
+  };
+}
+function a(n) {
+  return function(t) {
+    return Math.sign(t) * Math.expm1(Math.abs(t)) * n;
+  };
+}
+function m(n) {
+  var t = 1, r = n(o(t), a(t));
+  return r.constant = function(e) {
+    return arguments.length ? n(o(t = +e), a(t)) : t;
+  }, u(r);
+}
+function f() {
+  var n = m(i());
+  return n.copy = function() {
+    return s(n, f()).constant(n.constant());
+  }, c.apply(n, arguments);
+}
+export {
+  f as default,
+  m as symlogish
+};

package/dist/node_modules/d3-scale/src/threshold.js

@@ -0,0 +1,23 @@
+import { initRange as a } from "./init.js";
+import { bisectRight as g } from "../../d3-array/src/bisect.js";
+function l() {
+  var r = [0.5], e = [0, 1], i, u = 1;
+  function t(n) {
+    return n != null && n <= n ? e[g(r, n, 0, u)] : i;
+  }
+  return t.domain = function(n) {
+    return arguments.length ? (r = Array.from(n), u = Math.min(r.length, e.length - 1), t) : r.slice();
+  }, t.range = function(n) {
+    return arguments.length ? (e = Array.from(n), u = Math.min(r.length, e.length - 1), t) : e.slice();
+  }, t.invertExtent = function(n) {
+    var o = e.indexOf(n);
+    return [r[o - 1], r[o]];
+  }, t.unknown = function(n) {
+    return arguments.length ? (i = n, t) : i;
+  }, t.copy = function() {
+    return l().domain(r).range(e).unknown(i);
+  }, a.apply(t, arguments);
+}
+export {
+  l as default
+};

package/dist/node_modules/d3-scale/src/tickFormat.js

@@ -0,0 +1,32 @@
+import { tickStep as s } from "../../d3-array/src/ticks.js";
+import c from "../../d3-format/src/formatSpecifier.js";
+import e from "../../d3-format/src/precisionFixed.js";
+import p from "../../d3-format/src/precisionRound.js";
+import l from "../../d3-format/src/precisionPrefix.js";
+import { formatPrefix as u, format as h } from "../../d3-format/src/defaultLocale.js";
+function d(r, t, i, a) {
+  var n = s(r, t, i), o;
+  switch (a = c(a ?? ",f"), a.type) {
+    case "s": {
+      var m = Math.max(Math.abs(r), Math.abs(t));
+      return a.precision == null && !isNaN(o = l(n, m)) && (a.precision = o), u(a, m);
+    }
+    case "":
+    case "e":
+    case "g":
+    case "p":
+    case "r": {
+      a.precision == null && !isNaN(o = p(n, Math.max(Math.abs(r), Math.abs(t)))) && (a.precision = o - (a.type === "e"));
+      break;
+    }
+    case "f":
+    case "%": {
+      a.precision == null && !isNaN(o = e(n)) && (a.precision = o - (a.type === "%") * 2);
+      break;
+    }
+  }
+  return h(a);
+}
+export {
+  d as default
+};

package/dist/node_modules/d3-scale/src/time.js

@@ -0,0 +1,46 @@
+import H, { copy as I } from "./continuous.js";
+import { initRange as T } from "./init.js";
+import x from "./nice.js";
+import { timeFormat as A } from "../../d3-time-format/src/defaultLocale.js";
+import { second as B } from "../../d3-time/src/second.js";
+import { timeMinute as L } from "../../d3-time/src/minute.js";
+import { timeHour as R } from "../../d3-time/src/hour.js";
+import { timeDay as W } from "../../d3-time/src/day.js";
+import { timeSunday as j } from "../../d3-time/src/week.js";
+import { timeMonth as q } from "../../d3-time/src/month.js";
+import { timeYear as v } from "../../d3-time/src/year.js";
+import { timeTickInterval as z, timeTicks as C } from "../../d3-time/src/ticks.js";
+function E(i) {
+  return new Date(i);
+}
+function G(i) {
+  return i instanceof Date ? +i : +/* @__PURE__ */ new Date(+i);
+}
+function g(i, u, e, f, c, p, a, l, D, t) {
+  var r = H(), s = r.invert, m = r.domain, y = t(".%L"), M = t(":%S"), w = t("%I:%M"), h = t("%I %p"), k = t("%a %d"), F = t("%b %d"), S = t("%B"), Y = t("%Y");
+  function b(n) {
+    return (D(n) < n ? y : l(n) < n ? M : a(n) < n ? w : p(n) < n ? h : f(n) < n ? c(n) < n ? k : F : e(n) < n ? S : Y)(n);
+  }
+  return r.invert = function(n) {
+    return new Date(s(n));
+  }, r.domain = function(n) {
+    return arguments.length ? m(Array.from(n, G)) : m().map(E);
+  }, r.ticks = function(n) {
+    var o = m();
+    return i(o[0], o[o.length - 1], n ?? 10);
+  }, r.tickFormat = function(n, o) {
+    return o == null ? b : t(o);
+  }, r.nice = function(n) {
+    var o = m();
+    return (!n || typeof n.range != "function") && (n = u(o[0], o[o.length - 1], n ?? 10)), n ? m(x(o, n)) : r;
+  }, r.copy = function() {
+    return I(r, g(i, u, e, f, c, p, a, l, D, t));
+  }, r;
+}
+function d() {
+  return T.apply(g(C, z, v, q, j, W, R, L, B, A).domain([new Date(2e3, 0, 1), new Date(2e3, 0, 2)]), arguments);
+}
+export {
+  g as calendar,
+  d as default
+};

package/dist/node_modules/d3-scale/src/utcTime.js

@@ -0,0 +1,17 @@
+import { calendar as t } from "./time.js";
+import { initRange as r } from "./init.js";
+import { utcFormat as o } from "../../d3-time-format/src/defaultLocale.js";
+import { second as m } from "../../d3-time/src/second.js";
+import { utcMinute as i } from "../../d3-time/src/minute.js";
+import { utcHour as u } from "../../d3-time/src/hour.js";
+import { utcDay as a } from "../../d3-time/src/day.js";
+import { utcSunday as c } from "../../d3-time/src/week.js";
+import { utcMonth as p } from "../../d3-time/src/month.js";
+import { utcYear as e } from "../../d3-time/src/year.js";
+import { utcTickInterval as f, utcTicks as n } from "../../d3-time/src/ticks.js";
+function h() {
+  return r.apply(t(n, f, e, p, c, a, u, i, m, o).domain([Date.UTC(2e3, 0, 1), Date.UTC(2e3, 0, 2)]), arguments);
+}
+export {
+  h as default
+};

package/dist/node_modules/d3-shape/src/area.js

@@ -0,0 +1,56 @@
+import x from "./array.js";
+import i from "./constant.js";
+import z from "./curve/linear.js";
+import L from "./line.js";
+import { withPath as X } from "./path.js";
+import { x as Y, y as b } from "./point.js";
+function C(u, f, o) {
+  var c = null, g = i(!0), l = null, p = z, r = null, S = X(e);
+  u = typeof u == "function" ? u : u === void 0 ? Y : i(+u), f = typeof f == "function" ? f : f === void 0 ? i(0) : i(+f), o = typeof o == "function" ? o : o === void 0 ? b : i(+o);
+  function e(n) {
+    var t, E, a, h = (n = x(n)).length, m, s = !1, v, w = new Array(h), A = new Array(h);
+    for (l == null && (r = p(v = S())), t = 0; t <= h; ++t) {
+      if (!(t < h && g(m = n[t], t, n)) === s)
+        if (s = !s)
+          E = t, r.areaStart(), r.lineStart();
+        else {
+          for (r.lineEnd(), r.lineStart(), a = t - 1; a >= E; --a)
+            r.point(w[a], A[a]);
+          r.lineEnd(), r.areaEnd();
+        }
+      s && (w[t] = +u(m, t, n), A[t] = +f(m, t, n), r.point(c ? +c(m, t, n) : w[t], o ? +o(m, t, n) : A[t]));
+    }
+    if (v) return r = null, v + "" || null;
+  }
+  function d() {
+    return L().defined(g).curve(p).context(l);
+  }
+  return e.x = function(n) {
+    return arguments.length ? (u = typeof n == "function" ? n : i(+n), c = null, e) : u;
+  }, e.x0 = function(n) {
+    return arguments.length ? (u = typeof n == "function" ? n : i(+n), e) : u;
+  }, e.x1 = function(n) {
+    return arguments.length ? (c = n == null ? null : typeof n == "function" ? n : i(+n), e) : c;
+  }, e.y = function(n) {
+    return arguments.length ? (f = typeof n == "function" ? n : i(+n), o = null, e) : f;
+  }, e.y0 = function(n) {
+    return arguments.length ? (f = typeof n == "function" ? n : i(+n), e) : f;
+  }, e.y1 = function(n) {
+    return arguments.length ? (o = n == null ? null : typeof n == "function" ? n : i(+n), e) : o;
+  }, e.lineX0 = e.lineY0 = function() {
+    return d().x(u).y(f);
+  }, e.lineY1 = function() {
+    return d().x(u).y(o);
+  }, e.lineX1 = function() {
+    return d().x(c).y(f);
+  }, e.defined = function(n) {
+    return arguments.length ? (g = typeof n == "function" ? n : i(!!n), e) : g;
+  }, e.curve = function(n) {
+    return arguments.length ? (p = n, l != null && (r = p(l)), e) : p;
+  }, e.context = function(n) {
+    return arguments.length ? (n == null ? l = r = null : r = p(l = n), e) : l;
+  }, e;
+}
+export {
+  C as default
+};

package/dist/node_modules/d3-shape/src/array.js

@@ -0,0 +1,6 @@
+function t(r) {
+  return typeof r == "object" && "length" in r ? r : Array.from(r);
+}
+export {
+  t as default
+};

package/dist/node_modules/d3-shape/src/constant.js

@@ -0,0 +1,8 @@
+function o(n) {
+  return function() {
+    return n;
+  };
+}
+export {
+  o as default
+};

package/dist/node_modules/d3-shape/src/curve/basis.js

@@ -0,0 +1,60 @@
+function s(i, t, n) {
+  i._context.bezierCurveTo(
+    (2 * i._x0 + i._x1) / 3,
+    (2 * i._y0 + i._y1) / 3,
+    (i._x0 + 2 * i._x1) / 3,
+    (i._y0 + 2 * i._y1) / 3,
+    (i._x0 + 4 * i._x1 + t) / 6,
+    (i._y0 + 4 * i._y1 + n) / 6
+  );
+}
+function _(i) {
+  this._context = i;
+}
+_.prototype = {
+  areaStart: function() {
+    this._line = 0;
+  },
+  areaEnd: function() {
+    this._line = NaN;
+  },
+  lineStart: function() {
+    this._x0 = this._x1 = this._y0 = this._y1 = NaN, this._point = 0;
+  },
+  lineEnd: function() {
+    switch (this._point) {
+      case 3:
+        s(this, this._x1, this._y1);
+      // falls through
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+    }
+    (this._line || this._line !== 0 && this._point === 1) && this._context.closePath(), this._line = 1 - this._line;
+  },
+  point: function(i, t) {
+    switch (i = +i, t = +t, this._point) {
+      case 0:
+        this._point = 1, this._line ? this._context.lineTo(i, t) : this._context.moveTo(i, t);
+        break;
+      case 1:
+        this._point = 2;
+        break;
+      case 2:
+        this._point = 3, this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
+      // falls through
+      default:
+        s(this, i, t);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = i, this._y0 = this._y1, this._y1 = t;
+  }
+};
+function e(i) {
+  return new _(i);
+}
+export {
+  _ as Basis,
+  e as default,
+  s as point
+};