@mui/x-charts-vendor 7.12.0

package/lib-vendor/d3-shape/src/arc.js

@@ -0,0 +1,250 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _constant = _interopRequireDefault(require("./constant.js"));
+var _math = require("./math.js");
+var _path = require("./path.js");
+function arcInnerRadius(d) {
+  return d.innerRadius;
+}
+function arcOuterRadius(d) {
+  return d.outerRadius;
+}
+function arcStartAngle(d) {
+  return d.startAngle;
+}
+function arcEndAngle(d) {
+  return d.endAngle;
+}
+function arcPadAngle(d) {
+  return d && d.padAngle; // Note: optional!
+}
+function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
+  var x10 = x1 - x0,
+    y10 = y1 - y0,
+    x32 = x3 - x2,
+    y32 = y3 - y2,
+    t = y32 * x10 - x32 * y10;
+  if (t * t < _math.epsilon) return;
+  t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
+  return [x0 + t * x10, y0 + t * y10];
+}
+
+// Compute perpendicular offset line of length rc.
+// http://mathworld.wolfram.com/Circle-LineIntersection.html
+function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
+  var x01 = x0 - x1,
+    y01 = y0 - y1,
+    lo = (cw ? rc : -rc) / (0, _math.sqrt)(x01 * x01 + y01 * y01),
+    ox = lo * y01,
+    oy = -lo * x01,
+    x11 = x0 + ox,
+    y11 = y0 + oy,
+    x10 = x1 + ox,
+    y10 = y1 + oy,
+    x00 = (x11 + x10) / 2,
+    y00 = (y11 + y10) / 2,
+    dx = x10 - x11,
+    dy = y10 - y11,
+    d2 = dx * dx + dy * dy,
+    r = r1 - rc,
+    D = x11 * y10 - x10 * y11,
+    d = (dy < 0 ? -1 : 1) * (0, _math.sqrt)((0, _math.max)(0, r * r * d2 - D * D)),
+    cx0 = (D * dy - dx * d) / d2,
+    cy0 = (-D * dx - dy * d) / d2,
+    cx1 = (D * dy + dx * d) / d2,
+    cy1 = (-D * dx + dy * d) / d2,
+    dx0 = cx0 - x00,
+    dy0 = cy0 - y00,
+    dx1 = cx1 - x00,
+    dy1 = cy1 - y00;
+
+  // Pick the closer of the two intersection points.
+  // TODO Is there a faster way to determine which intersection to use?
+  if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
+  return {
+    cx: cx0,
+    cy: cy0,
+    x01: -ox,
+    y01: -oy,
+    x11: cx0 * (r1 / r - 1),
+    y11: cy0 * (r1 / r - 1)
+  };
+}
+function _default() {
+  var innerRadius = arcInnerRadius,
+    outerRadius = arcOuterRadius,
+    cornerRadius = (0, _constant.default)(0),
+    padRadius = null,
+    startAngle = arcStartAngle,
+    endAngle = arcEndAngle,
+    padAngle = arcPadAngle,
+    context = null,
+    path = (0, _path.withPath)(arc);
+  function arc() {
+    var buffer,
+      r,
+      r0 = +innerRadius.apply(this, arguments),
+      r1 = +outerRadius.apply(this, arguments),
+      a0 = startAngle.apply(this, arguments) - _math.halfPi,
+      a1 = endAngle.apply(this, arguments) - _math.halfPi,
+      da = (0, _math.abs)(a1 - a0),
+      cw = a1 > a0;
+    if (!context) context = buffer = path();
+
+    // Ensure that the outer radius is always larger than the inner radius.
+    if (r1 < r0) r = r1, r1 = r0, r0 = r;
+
+    // Is it a point?
+    if (!(r1 > _math.epsilon)) context.moveTo(0, 0);
+
+    // Or is it a circle or annulus?
+    else if (da > _math.tau - _math.epsilon) {
+      context.moveTo(r1 * (0, _math.cos)(a0), r1 * (0, _math.sin)(a0));
+      context.arc(0, 0, r1, a0, a1, !cw);
+      if (r0 > _math.epsilon) {
+        context.moveTo(r0 * (0, _math.cos)(a1), r0 * (0, _math.sin)(a1));
+        context.arc(0, 0, r0, a1, a0, cw);
+      }
+    }
+
+    // Or is it a circular or annular sector?
+    else {
+      var a01 = a0,
+        a11 = a1,
+        a00 = a0,
+        a10 = a1,
+        da0 = da,
+        da1 = da,
+        ap = padAngle.apply(this, arguments) / 2,
+        rp = ap > _math.epsilon && (padRadius ? +padRadius.apply(this, arguments) : (0, _math.sqrt)(r0 * r0 + r1 * r1)),
+        rc = (0, _math.min)((0, _math.abs)(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),
+        rc0 = rc,
+        rc1 = rc,
+        t0,
+        t1;
+
+      // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.
+      if (rp > _math.epsilon) {
+        var p0 = (0, _math.asin)(rp / r0 * (0, _math.sin)(ap)),
+          p1 = (0, _math.asin)(rp / r1 * (0, _math.sin)(ap));
+        if ((da0 -= p0 * 2) > _math.epsilon) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;else da0 = 0, a00 = a10 = (a0 + a1) / 2;
+        if ((da1 -= p1 * 2) > _math.epsilon) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;else da1 = 0, a01 = a11 = (a0 + a1) / 2;
+      }
+      var x01 = r1 * (0, _math.cos)(a01),
+        y01 = r1 * (0, _math.sin)(a01),
+        x10 = r0 * (0, _math.cos)(a10),
+        y10 = r0 * (0, _math.sin)(a10);
+
+      // Apply rounded corners?
+      if (rc > _math.epsilon) {
+        var x11 = r1 * (0, _math.cos)(a11),
+          y11 = r1 * (0, _math.sin)(a11),
+          x00 = r0 * (0, _math.cos)(a00),
+          y00 = r0 * (0, _math.sin)(a00),
+          oc;
+
+        // Restrict the corner radius according to the sector angle. If this
+        // intersection fails, it’s probably because the arc is too small, so
+        // disable the corner radius entirely.
+        if (da < _math.pi) {
+          if (oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10)) {
+            var ax = x01 - oc[0],
+              ay = y01 - oc[1],
+              bx = x11 - oc[0],
+              by = y11 - oc[1],
+              kc = 1 / (0, _math.sin)((0, _math.acos)((ax * bx + ay * by) / ((0, _math.sqrt)(ax * ax + ay * ay) * (0, _math.sqrt)(bx * bx + by * by))) / 2),
+              lc = (0, _math.sqrt)(oc[0] * oc[0] + oc[1] * oc[1]);
+            rc0 = (0, _math.min)(rc, (r0 - lc) / (kc - 1));
+            rc1 = (0, _math.min)(rc, (r1 - lc) / (kc + 1));
+          } else {
+            rc0 = rc1 = 0;
+          }
+        }
+      }
+
+      // Is the sector collapsed to a line?
+      if (!(da1 > _math.epsilon)) context.moveTo(x01, y01);
+
+      // Does the sector’s outer ring have rounded corners?
+      else if (rc1 > _math.epsilon) {
+        t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
+        t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
+        context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);
+
+        // Have the corners merged?
+        if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, (0, _math.atan2)(t0.y01, t0.x01), (0, _math.atan2)(t1.y01, t1.x01), !cw);
+
+        // Otherwise, draw the two corners and the ring.
+        else {
+          context.arc(t0.cx, t0.cy, rc1, (0, _math.atan2)(t0.y01, t0.x01), (0, _math.atan2)(t0.y11, t0.x11), !cw);
+          context.arc(0, 0, r1, (0, _math.atan2)(t0.cy + t0.y11, t0.cx + t0.x11), (0, _math.atan2)(t1.cy + t1.y11, t1.cx + t1.x11), !cw);
+          context.arc(t1.cx, t1.cy, rc1, (0, _math.atan2)(t1.y11, t1.x11), (0, _math.atan2)(t1.y01, t1.x01), !cw);
+        }
+      }
+
+      // Or is the outer ring just a circular arc?
+      else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
+
+      // Is there no inner ring, and it’s a circular sector?
+      // Or perhaps it’s an annular sector collapsed due to padding?
+      if (!(r0 > _math.epsilon) || !(da0 > _math.epsilon)) context.lineTo(x10, y10);
+
+      // Does the sector’s inner ring (or point) have rounded corners?
+      else if (rc0 > _math.epsilon) {
+        t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
+        t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
+        context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);
+
+        // Have the corners merged?
+        if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, (0, _math.atan2)(t0.y01, t0.x01), (0, _math.atan2)(t1.y01, t1.x01), !cw);
+
+        // Otherwise, draw the two corners and the ring.
+        else {
+          context.arc(t0.cx, t0.cy, rc0, (0, _math.atan2)(t0.y01, t0.x01), (0, _math.atan2)(t0.y11, t0.x11), !cw);
+          context.arc(0, 0, r0, (0, _math.atan2)(t0.cy + t0.y11, t0.cx + t0.x11), (0, _math.atan2)(t1.cy + t1.y11, t1.cx + t1.x11), cw);
+          context.arc(t1.cx, t1.cy, rc0, (0, _math.atan2)(t1.y11, t1.x11), (0, _math.atan2)(t1.y01, t1.x01), !cw);
+        }
+      }
+
+      // Or is the inner ring just a circular arc?
+      else context.arc(0, 0, r0, a10, a00, cw);
+    }
+    context.closePath();
+    if (buffer) return context = null, buffer + "" || null;
+  }
+  arc.centroid = function () {
+    var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,
+      a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - _math.pi / 2;
+    return [(0, _math.cos)(a) * r, (0, _math.sin)(a) * r];
+  };
+  arc.innerRadius = function (_) {
+    return arguments.length ? (innerRadius = typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : innerRadius;
+  };
+  arc.outerRadius = function (_) {
+    return arguments.length ? (outerRadius = typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : outerRadius;
+  };
+  arc.cornerRadius = function (_) {
+    return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : cornerRadius;
+  };
+  arc.padRadius = function (_) {
+    return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : padRadius;
+  };
+  arc.startAngle = function (_) {
+    return arguments.length ? (startAngle = typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : startAngle;
+  };
+  arc.endAngle = function (_) {
+    return arguments.length ? (endAngle = typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : endAngle;
+  };
+  arc.padAngle = function (_) {
+    return arguments.length ? (padAngle = typeof _ === "function" ? _ : (0, _constant.default)(+_), arc) : padAngle;
+  };
+  arc.context = function (_) {
+    return arguments.length ? (context = _ == null ? null : _, arc) : context;
+  };
+  return arc;
+}

package/lib-vendor/d3-shape/src/area.js

@@ -0,0 +1,98 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _array = _interopRequireDefault(require("./array.js"));
+var _constant = _interopRequireDefault(require("./constant.js"));
+var _linear = _interopRequireDefault(require("./curve/linear.js"));
+var _line = _interopRequireDefault(require("./line.js"));
+var _path = require("./path.js");
+var _point = require("./point.js");
+function _default(x0, y0, y1) {
+  var x1 = null,
+    defined = (0, _constant.default)(true),
+    context = null,
+    curve = _linear.default,
+    output = null,
+    path = (0, _path.withPath)(area);
+  x0 = typeof x0 === "function" ? x0 : x0 === undefined ? _point.x : (0, _constant.default)(+x0);
+  y0 = typeof y0 === "function" ? y0 : y0 === undefined ? (0, _constant.default)(0) : (0, _constant.default)(+y0);
+  y1 = typeof y1 === "function" ? y1 : y1 === undefined ? _point.y : (0, _constant.default)(+y1);
+  function area(data) {
+    var i,
+      j,
+      k,
+      n = (data = (0, _array.default)(data)).length,
+      d,
+      defined0 = false,
+      buffer,
+      x0z = new Array(n),
+      y0z = new Array(n);
+    if (context == null) output = curve(buffer = path());
+    for (i = 0; i <= n; ++i) {
+      if (!(i < n && defined(d = data[i], i, data)) === defined0) {
+        if (defined0 = !defined0) {
+          j = i;
+          output.areaStart();
+          output.lineStart();
+        } else {
+          output.lineEnd();
+          output.lineStart();
+          for (k = i - 1; k >= j; --k) {
+            output.point(x0z[k], y0z[k]);
+          }
+          output.lineEnd();
+          output.areaEnd();
+        }
+      }
+      if (defined0) {
+        x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);
+        output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);
+      }
+    }
+    if (buffer) return output = null, buffer + "" || null;
+  }
+  function arealine() {
+    return (0, _line.default)().defined(defined).curve(curve).context(context);
+  }
+  area.x = function (_) {
+    return arguments.length ? (x0 = typeof _ === "function" ? _ : (0, _constant.default)(+_), x1 = null, area) : x0;
+  };
+  area.x0 = function (_) {
+    return arguments.length ? (x0 = typeof _ === "function" ? _ : (0, _constant.default)(+_), area) : x0;
+  };
+  area.x1 = function (_) {
+    return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : (0, _constant.default)(+_), area) : x1;
+  };
+  area.y = function (_) {
+    return arguments.length ? (y0 = typeof _ === "function" ? _ : (0, _constant.default)(+_), y1 = null, area) : y0;
+  };
+  area.y0 = function (_) {
+    return arguments.length ? (y0 = typeof _ === "function" ? _ : (0, _constant.default)(+_), area) : y0;
+  };
+  area.y1 = function (_) {
+    return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : (0, _constant.default)(+_), area) : y1;
+  };
+  area.lineX0 = area.lineY0 = function () {
+    return arealine().x(x0).y(y0);
+  };
+  area.lineY1 = function () {
+    return arealine().x(x0).y(y1);
+  };
+  area.lineX1 = function () {
+    return arealine().x(x1).y(y0);
+  };
+  area.defined = function (_) {
+    return arguments.length ? (defined = typeof _ === "function" ? _ : (0, _constant.default)(!!_), area) : defined;
+  };
+  area.curve = function (_) {
+    return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;
+  };
+  area.context = function (_) {
+    return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;
+  };
+  return area;
+}

package/lib-vendor/d3-shape/src/areaRadial.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _radial = _interopRequireWildcard(require("./curve/radial.js"));
+var _area = _interopRequireDefault(require("./area.js"));
+var _lineRadial = require("./lineRadial.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _default() {
+  var a = (0, _area.default)().curve(_radial.curveRadialLinear),
+    c = a.curve,
+    x0 = a.lineX0,
+    x1 = a.lineX1,
+    y0 = a.lineY0,
+    y1 = a.lineY1;
+  a.angle = a.x, delete a.x;
+  a.startAngle = a.x0, delete a.x0;
+  a.endAngle = a.x1, delete a.x1;
+  a.radius = a.y, delete a.y;
+  a.innerRadius = a.y0, delete a.y0;
+  a.outerRadius = a.y1, delete a.y1;
+  a.lineStartAngle = function () {
+    return (0, _lineRadial.lineRadial)(x0());
+  }, delete a.lineX0;
+  a.lineEndAngle = function () {
+    return (0, _lineRadial.lineRadial)(x1());
+  }, delete a.lineX1;
+  a.lineInnerRadius = function () {
+    return (0, _lineRadial.lineRadial)(y0());
+  }, delete a.lineY0;
+  a.lineOuterRadius = function () {
+    return (0, _lineRadial.lineRadial)(y1());
+  }, delete a.lineY1;
+  a.curve = function (_) {
+    return arguments.length ? c((0, _radial.default)(_)) : c()._curve;
+  };
+  return a;
+}

package/lib-vendor/d3-shape/src/array.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.slice = void 0;
+var slice = exports.slice = Array.prototype.slice;
+function _default(x) {
+  return typeof x === "object" && "length" in x ? x // Array, TypedArray, NodeList, array-like
+  : Array.from(x); // Map, Set, iterable, string, or anything else
+}

package/lib-vendor/d3-shape/src/constant.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+function _default(x) {
+  return function constant() {
+    return x;
+  };
+}

package/lib-vendor/d3-shape/src/curve/basis.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Basis = Basis;
+exports.default = _default;
+exports.point = point;
+function point(that, x, y) {
+  that._context.bezierCurveTo((2 * that._x0 + that._x1) / 3, (2 * that._y0 + that._y1) / 3, (that._x0 + 2 * that._x1) / 3, (that._y0 + 2 * that._y1) / 3, (that._x0 + 4 * that._x1 + x) / 6, (that._y0 + 4 * that._y1 + y) / 6);
+}
+function Basis(context) {
+  this._context = context;
+}
+Basis.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:
+        point(this, this._x1, this._y1);
+      // falls through
+      case 2:
+        this._context.lineTo(this._x1, this._y1);
+        break;
+    }
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    this._line = 1 - this._line;
+  },
+  point: function (x, y) {
+    x = +x, y = +y;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y);
+        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:
+        point(this, x, y);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = x;
+    this._y0 = this._y1, this._y1 = y;
+  }
+};
+function _default(context) {
+  return new Basis(context);
+}

package/lib-vendor/d3-shape/src/curve/basisClosed.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _noop = _interopRequireDefault(require("../noop.js"));
+var _basis = require("./basis.js");
+function BasisClosed(context) {
+  this._context = context;
+}
+BasisClosed.prototype = {
+  areaStart: _noop.default,
+  areaEnd: _noop.default,
+  lineStart: function () {
+    this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;
+    this._point = 0;
+  },
+  lineEnd: function () {
+    switch (this._point) {
+      case 1:
+        {
+          this._context.moveTo(this._x2, this._y2);
+          this._context.closePath();
+          break;
+        }
+      case 2:
+        {
+          this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);
+          this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);
+          this._context.closePath();
+          break;
+        }
+      case 3:
+        {
+          this.point(this._x2, this._y2);
+          this.point(this._x3, this._y3);
+          this.point(this._x4, this._y4);
+          break;
+        }
+    }
+  },
+  point: function (x, y) {
+    x = +x, y = +y;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        this._x2 = x, this._y2 = y;
+        break;
+      case 1:
+        this._point = 2;
+        this._x3 = x, this._y3 = y;
+        break;
+      case 2:
+        this._point = 3;
+        this._x4 = x, this._y4 = y;
+        this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6);
+        break;
+      default:
+        (0, _basis.point)(this, x, y);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = x;
+    this._y0 = this._y1, this._y1 = y;
+  }
+};
+function _default(context) {
+  return new BasisClosed(context);
+}

package/lib-vendor/d3-shape/src/curve/basisOpen.js

@@ -0,0 +1,54 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _basis = require("./basis.js");
+function BasisOpen(context) {
+  this._context = context;
+}
+BasisOpen.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 () {
+    if (this._line || this._line !== 0 && this._point === 3) this._context.closePath();
+    this._line = 1 - this._line;
+  },
+  point: function (x, y) {
+    x = +x, y = +y;
+    switch (this._point) {
+      case 0:
+        this._point = 1;
+        break;
+      case 1:
+        this._point = 2;
+        break;
+      case 2:
+        this._point = 3;
+        var x0 = (this._x0 + 4 * this._x1 + x) / 6,
+          y0 = (this._y0 + 4 * this._y1 + y) / 6;
+        this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0);
+        break;
+      case 3:
+        this._point = 4;
+      // falls through
+      default:
+        (0, _basis.point)(this, x, y);
+        break;
+    }
+    this._x0 = this._x1, this._x1 = x;
+    this._y0 = this._y1, this._y1 = y;
+  }
+};
+function _default(context) {
+  return new BasisOpen(context);
+}

package/lib-vendor/d3-shape/src/curve/bump.js

@@ -0,0 +1,81 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.bumpRadial = bumpRadial;
+exports.bumpX = bumpX;
+exports.bumpY = bumpY;
+var _pointRadial = _interopRequireDefault(require("../pointRadial.js"));
+class Bump {
+  constructor(context, x) {
+    this._context = context;
+    this._x = x;
+  }
+  areaStart() {
+    this._line = 0;
+  }
+  areaEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {
+    if (this._line || this._line !== 0 && this._point === 1) this._context.closePath();
+    this._line = 1 - this._line;
+  }
+  point(x, y) {
+    x = +x, y = +y;
+    switch (this._point) {
+      case 0:
+        {
+          this._point = 1;
+          if (this._line) this._context.lineTo(x, y);else this._context.moveTo(x, y);
+          break;
+        }
+      case 1:
+        this._point = 2;
+      // falls through
+      default:
+        {
+          if (this._x) this._context.bezierCurveTo(this._x0 = (this._x0 + x) / 2, this._y0, this._x0, y, x, y);else this._context.bezierCurveTo(this._x0, this._y0 = (this._y0 + y) / 2, x, this._y0, x, y);
+          break;
+        }
+    }
+    this._x0 = x, this._y0 = y;
+  }
+}
+class BumpRadial {
+  constructor(context) {
+    this._context = context;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {}
+  point(x, y) {
+    x = +x, y = +y;
+    if (this._point === 0) {
+      this._point = 1;
+    } else {
+      const p0 = (0, _pointRadial.default)(this._x0, this._y0);
+      const p1 = (0, _pointRadial.default)(this._x0, this._y0 = (this._y0 + y) / 2);
+      const p2 = (0, _pointRadial.default)(x, this._y0);
+      const p3 = (0, _pointRadial.default)(x, y);
+      this._context.moveTo(...p0);
+      this._context.bezierCurveTo(...p1, ...p2, ...p3);
+    }
+    this._x0 = x, this._y0 = y;
+  }
+}
+function bumpX(context) {
+  return new Bump(context, true);
+}
+function bumpY(context) {
+  return new Bump(context, false);
+}
+function bumpRadial(context) {
+  return new BumpRadial(context);
+}