@mui/x-charts-vendor 9.0.0 → 9.4.0

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

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.areaStream = exports.areaRingSum = void 0;
+exports.default = _default;
+var _index = require("../../d3-array/src/index.js");
+var _math = require("./math.js");
+var _noop = _interopRequireDefault(require("./noop.js"));
+var _stream = _interopRequireDefault(require("./stream.js"));
+var areaRingSum = exports.areaRingSum = new _index.Adder();
+
+// hello?
+
+var areaSum = new _index.Adder(),
+  lambda00,
+  phi00,
+  lambda0,
+  cosPhi0,
+  sinPhi0;
+var areaStream = exports.areaStream = {
+  point: _noop.default,
+  lineStart: _noop.default,
+  lineEnd: _noop.default,
+  polygonStart: function () {
+    exports.areaRingSum = areaRingSum = new _index.Adder();
+    areaStream.lineStart = areaRingStart;
+    areaStream.lineEnd = areaRingEnd;
+  },
+  polygonEnd: function () {
+    var areaRing = +areaRingSum;
+    areaSum.add(areaRing < 0 ? _math.tau + areaRing : areaRing);
+    this.lineStart = this.lineEnd = this.point = _noop.default;
+  },
+  sphere: function () {
+    areaSum.add(_math.tau);
+  }
+};
+function areaRingStart() {
+  areaStream.point = areaPointFirst;
+}
+function areaRingEnd() {
+  areaPoint(lambda00, phi00);
+}
+function areaPointFirst(lambda, phi) {
+  areaStream.point = areaPoint;
+  lambda00 = lambda, phi00 = phi;
+  lambda *= _math.radians, phi *= _math.radians;
+  lambda0 = lambda, cosPhi0 = (0, _math.cos)(phi = phi / 2 + _math.quarterPi), sinPhi0 = (0, _math.sin)(phi);
+}
+function areaPoint(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  phi = phi / 2 + _math.quarterPi; // half the angular distance from south pole
+
+  // Spherical excess E for a spherical triangle with vertices: south pole,
+  // previous point, current point.  Uses a formula derived from Cagnoli’s
+  // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).
+  var dLambda = lambda - lambda0,
+    sdLambda = dLambda >= 0 ? 1 : -1,
+    adLambda = sdLambda * dLambda,
+    cosPhi = (0, _math.cos)(phi),
+    sinPhi = (0, _math.sin)(phi),
+    k = sinPhi0 * sinPhi,
+    u = cosPhi0 * cosPhi + k * (0, _math.cos)(adLambda),
+    v = k * sdLambda * (0, _math.sin)(adLambda);
+  areaRingSum.add((0, _math.atan2)(v, u));
+
+  // Advance the previous points.
+  lambda0 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;
+}
+function _default(object) {
+  areaSum = new _index.Adder();
+  (0, _stream.default)(object, areaStream);
+  return areaSum * 2;
+}

package/lib-vendor/d3-geo/src/bounds.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _index = require("../../d3-array/src/index.js");
+var _area = require("./area.js");
+var _cartesian = require("./cartesian.js");
+var _math = require("./math.js");
+var _stream = _interopRequireDefault(require("./stream.js"));
+var lambda0, phi0, lambda1, phi1,
+  // bounds
+  lambda2,
+  // previous lambda-coordinate
+  lambda00, phi00,
+  // first point
+  p0,
+  // previous 3D point
+  deltaSum, ranges, range;
+var boundsStream = {
+  point: boundsPoint,
+  lineStart: boundsLineStart,
+  lineEnd: boundsLineEnd,
+  polygonStart: function () {
+    boundsStream.point = boundsRingPoint;
+    boundsStream.lineStart = boundsRingStart;
+    boundsStream.lineEnd = boundsRingEnd;
+    deltaSum = new _index.Adder();
+    _area.areaStream.polygonStart();
+  },
+  polygonEnd: function () {
+    _area.areaStream.polygonEnd();
+    boundsStream.point = boundsPoint;
+    boundsStream.lineStart = boundsLineStart;
+    boundsStream.lineEnd = boundsLineEnd;
+    if (_area.areaRingSum < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);else if (deltaSum > _math.epsilon) phi1 = 90;else if (deltaSum < -_math.epsilon) phi0 = -90;
+    range[0] = lambda0, range[1] = lambda1;
+  },
+  sphere: function () {
+    lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);
+  }
+};
+function boundsPoint(lambda, phi) {
+  ranges.push(range = [lambda0 = lambda, lambda1 = lambda]);
+  if (phi < phi0) phi0 = phi;
+  if (phi > phi1) phi1 = phi;
+}
+function linePoint(lambda, phi) {
+  var p = (0, _cartesian.cartesian)([lambda * _math.radians, phi * _math.radians]);
+  if (p0) {
+    var normal = (0, _cartesian.cartesianCross)(p0, p),
+      equatorial = [normal[1], -normal[0], 0],
+      inflection = (0, _cartesian.cartesianCross)(equatorial, normal);
+    (0, _cartesian.cartesianNormalizeInPlace)(inflection);
+    inflection = (0, _cartesian.spherical)(inflection);
+    var delta = lambda - lambda2,
+      sign = delta > 0 ? 1 : -1,
+      lambdai = inflection[0] * _math.degrees * sign,
+      phii,
+      antimeridian = (0, _math.abs)(delta) > 180;
+    if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {
+      phii = inflection[1] * _math.degrees;
+      if (phii > phi1) phi1 = phii;
+    } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {
+      phii = -inflection[1] * _math.degrees;
+      if (phii < phi0) phi0 = phii;
+    } else {
+      if (phi < phi0) phi0 = phi;
+      if (phi > phi1) phi1 = phi;
+    }
+    if (antimeridian) {
+      if (lambda < lambda2) {
+        if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;
+      } else {
+        if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;
+      }
+    } else {
+      if (lambda1 >= lambda0) {
+        if (lambda < lambda0) lambda0 = lambda;
+        if (lambda > lambda1) lambda1 = lambda;
+      } else {
+        if (lambda > lambda2) {
+          if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;
+        } else {
+          if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;
+        }
+      }
+    }
+  } else {
+    ranges.push(range = [lambda0 = lambda, lambda1 = lambda]);
+  }
+  if (phi < phi0) phi0 = phi;
+  if (phi > phi1) phi1 = phi;
+  p0 = p, lambda2 = lambda;
+}
+function boundsLineStart() {
+  boundsStream.point = linePoint;
+}
+function boundsLineEnd() {
+  range[0] = lambda0, range[1] = lambda1;
+  boundsStream.point = boundsPoint;
+  p0 = null;
+}
+function boundsRingPoint(lambda, phi) {
+  if (p0) {
+    var delta = lambda - lambda2;
+    deltaSum.add((0, _math.abs)(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);
+  } else {
+    lambda00 = lambda, phi00 = phi;
+  }
+  _area.areaStream.point(lambda, phi);
+  linePoint(lambda, phi);
+}
+function boundsRingStart() {
+  _area.areaStream.lineStart();
+}
+function boundsRingEnd() {
+  boundsRingPoint(lambda00, phi00);
+  _area.areaStream.lineEnd();
+  if ((0, _math.abs)(deltaSum) > _math.epsilon) lambda0 = -(lambda1 = 180);
+  range[0] = lambda0, range[1] = lambda1;
+  p0 = null;
+}
+
+// Finds the left-right distance between two longitudes.
+// This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want
+// the distance between ±180° to be 360°.
+function angle(lambda0, lambda1) {
+  return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;
+}
+function rangeCompare(a, b) {
+  return a[0] - b[0];
+}
+function rangeContains(range, x) {
+  return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+}
+function _default(feature) {
+  var i, n, a, b, merged, deltaMax, delta;
+  phi1 = lambda1 = -(lambda0 = phi0 = Infinity);
+  ranges = [];
+  (0, _stream.default)(feature, boundsStream);
+
+  // First, sort ranges by their minimum longitudes.
+  if (n = ranges.length) {
+    ranges.sort(rangeCompare);
+
+    // Then, merge any ranges that overlap.
+    for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {
+      b = ranges[i];
+      if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {
+        if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+        if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+      } else {
+        merged.push(a = b);
+      }
+    }
+
+    // Finally, find the largest gap between the merged ranges.
+    // The final bounding box will be the inverse of this gap.
+    for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {
+      b = merged[i];
+      if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0 = b[0], lambda1 = a[1];
+    }
+  }
+  ranges = range = null;
+  return lambda0 === Infinity || phi0 === Infinity ? [[NaN, NaN], [NaN, NaN]] : [[lambda0, phi0], [lambda1, phi1]];
+}

package/lib-vendor/d3-geo/src/cartesian.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cartesian = cartesian;
+exports.cartesianAddInPlace = cartesianAddInPlace;
+exports.cartesianCross = cartesianCross;
+exports.cartesianDot = cartesianDot;
+exports.cartesianNormalizeInPlace = cartesianNormalizeInPlace;
+exports.cartesianScale = cartesianScale;
+exports.spherical = spherical;
+var _math = require("./math.js");
+function spherical(cartesian) {
+  return [(0, _math.atan2)(cartesian[1], cartesian[0]), (0, _math.asin)(cartesian[2])];
+}
+function cartesian(spherical) {
+  var lambda = spherical[0],
+    phi = spherical[1],
+    cosPhi = (0, _math.cos)(phi);
+  return [cosPhi * (0, _math.cos)(lambda), cosPhi * (0, _math.sin)(lambda), (0, _math.sin)(phi)];
+}
+function cartesianDot(a, b) {
+  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+function cartesianCross(a, b) {
+  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+}
+
+// TODO return a
+function cartesianAddInPlace(a, b) {
+  a[0] += b[0], a[1] += b[1], a[2] += b[2];
+}
+function cartesianScale(vector, k) {
+  return [vector[0] * k, vector[1] * k, vector[2] * k];
+}
+
+// TODO return d
+function cartesianNormalizeInPlace(d) {
+  var l = (0, _math.sqrt)(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+  d[0] /= l, d[1] /= l, d[2] /= l;
+}

package/lib-vendor/d3-geo/src/centroid.js

@@ -0,0 +1,134 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _index = require("../../d3-array/src/index.js");
+var _math = require("./math.js");
+var _noop = _interopRequireDefault(require("./noop.js"));
+var _stream = _interopRequireDefault(require("./stream.js"));
+var W0, W1, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, lambda00, phi00,
+  // first point
+  x0, y0, z0; // previous point
+
+var centroidStream = {
+  sphere: _noop.default,
+  point: centroidPoint,
+  lineStart: centroidLineStart,
+  lineEnd: centroidLineEnd,
+  polygonStart: function () {
+    centroidStream.lineStart = centroidRingStart;
+    centroidStream.lineEnd = centroidRingEnd;
+  },
+  polygonEnd: function () {
+    centroidStream.lineStart = centroidLineStart;
+    centroidStream.lineEnd = centroidLineEnd;
+  }
+};
+
+// Arithmetic mean of Cartesian vectors.
+function centroidPoint(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  var cosPhi = (0, _math.cos)(phi);
+  centroidPointCartesian(cosPhi * (0, _math.cos)(lambda), cosPhi * (0, _math.sin)(lambda), (0, _math.sin)(phi));
+}
+function centroidPointCartesian(x, y, z) {
+  ++W0;
+  X0 += (x - X0) / W0;
+  Y0 += (y - Y0) / W0;
+  Z0 += (z - Z0) / W0;
+}
+function centroidLineStart() {
+  centroidStream.point = centroidLinePointFirst;
+}
+function centroidLinePointFirst(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  var cosPhi = (0, _math.cos)(phi);
+  x0 = cosPhi * (0, _math.cos)(lambda);
+  y0 = cosPhi * (0, _math.sin)(lambda);
+  z0 = (0, _math.sin)(phi);
+  centroidStream.point = centroidLinePoint;
+  centroidPointCartesian(x0, y0, z0);
+}
+function centroidLinePoint(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  var cosPhi = (0, _math.cos)(phi),
+    x = cosPhi * (0, _math.cos)(lambda),
+    y = cosPhi * (0, _math.sin)(lambda),
+    z = (0, _math.sin)(phi),
+    w = (0, _math.atan2)((0, _math.sqrt)((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
+  W1 += w;
+  X1 += w * (x0 + (x0 = x));
+  Y1 += w * (y0 + (y0 = y));
+  Z1 += w * (z0 + (z0 = z));
+  centroidPointCartesian(x0, y0, z0);
+}
+function centroidLineEnd() {
+  centroidStream.point = centroidPoint;
+}
+
+// See J. E. Brock, The Inertia Tensor for a Spherical Triangle,
+// J. Applied Mechanics 42, 239 (1975).
+function centroidRingStart() {
+  centroidStream.point = centroidRingPointFirst;
+}
+function centroidRingEnd() {
+  centroidRingPoint(lambda00, phi00);
+  centroidStream.point = centroidPoint;
+}
+function centroidRingPointFirst(lambda, phi) {
+  lambda00 = lambda, phi00 = phi;
+  lambda *= _math.radians, phi *= _math.radians;
+  centroidStream.point = centroidRingPoint;
+  var cosPhi = (0, _math.cos)(phi);
+  x0 = cosPhi * (0, _math.cos)(lambda);
+  y0 = cosPhi * (0, _math.sin)(lambda);
+  z0 = (0, _math.sin)(phi);
+  centroidPointCartesian(x0, y0, z0);
+}
+function centroidRingPoint(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  var cosPhi = (0, _math.cos)(phi),
+    x = cosPhi * (0, _math.cos)(lambda),
+    y = cosPhi * (0, _math.sin)(lambda),
+    z = (0, _math.sin)(phi),
+    cx = y0 * z - z0 * y,
+    cy = z0 * x - x0 * z,
+    cz = x0 * y - y0 * x,
+    m = (0, _math.hypot)(cx, cy, cz),
+    w = (0, _math.asin)(m),
+    // line weight = angle
+    v = m && -w / m; // area weight multiplier
+  X2.add(v * cx);
+  Y2.add(v * cy);
+  Z2.add(v * cz);
+  W1 += w;
+  X1 += w * (x0 + (x0 = x));
+  Y1 += w * (y0 + (y0 = y));
+  Z1 += w * (z0 + (z0 = z));
+  centroidPointCartesian(x0, y0, z0);
+}
+function _default(object) {
+  W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = 0;
+  X2 = new _index.Adder();
+  Y2 = new _index.Adder();
+  Z2 = new _index.Adder();
+  (0, _stream.default)(object, centroidStream);
+  var x = +X2,
+    y = +Y2,
+    z = +Z2,
+    m = (0, _math.hypot)(x, y, z);
+
+  // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.
+  if (m < _math.epsilon2) {
+    x = X1, y = Y1, z = Z1;
+    // If the feature has zero length, fall back to arithmetic mean of point vectors.
+    if (W1 < _math.epsilon) x = X0, y = Y0, z = Z0;
+    m = (0, _math.hypot)(x, y, z);
+    // If the feature still has an undefined ccentroid, then return.
+    if (m < _math.epsilon2) return [NaN, NaN];
+  }
+  return [(0, _math.atan2)(y, x) * _math.degrees, (0, _math.asin)(z / m) * _math.degrees];
+}

package/lib-vendor/d3-geo/src/circle.js

@@ -0,0 +1,77 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.circleStream = circleStream;
+exports.default = _default;
+var _cartesian = require("./cartesian.js");
+var _constant = _interopRequireDefault(require("./constant.js"));
+var _math = require("./math.js");
+var _rotation = require("./rotation.js");
+// Generates a circle centered at [0°, 0°], with a given radius and precision.
+function circleStream(stream, radius, delta, direction, t0, t1) {
+  if (!delta) return;
+  var cosRadius = (0, _math.cos)(radius),
+    sinRadius = (0, _math.sin)(radius),
+    step = direction * delta;
+  if (t0 == null) {
+    t0 = radius + direction * _math.tau;
+    t1 = radius - step / 2;
+  } else {
+    t0 = circleRadius(cosRadius, t0);
+    t1 = circleRadius(cosRadius, t1);
+    if (direction > 0 ? t0 < t1 : t0 > t1) t0 += direction * _math.tau;
+  }
+  for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {
+    point = (0, _cartesian.spherical)([cosRadius, -sinRadius * (0, _math.cos)(t), -sinRadius * (0, _math.sin)(t)]);
+    stream.point(point[0], point[1]);
+  }
+}
+
+// Returns the signed angle of a cartesian point relative to [cosRadius, 0, 0].
+function circleRadius(cosRadius, point) {
+  point = (0, _cartesian.cartesian)(point), point[0] -= cosRadius;
+  (0, _cartesian.cartesianNormalizeInPlace)(point);
+  var radius = (0, _math.acos)(-point[1]);
+  return ((-point[2] < 0 ? -radius : radius) + _math.tau - _math.epsilon) % _math.tau;
+}
+function _default() {
+  var center = (0, _constant.default)([0, 0]),
+    radius = (0, _constant.default)(90),
+    precision = (0, _constant.default)(2),
+    ring,
+    rotate,
+    stream = {
+      point: point
+    };
+  function point(x, y) {
+    ring.push(x = rotate(x, y));
+    x[0] *= _math.degrees, x[1] *= _math.degrees;
+  }
+  function circle() {
+    var c = center.apply(this, arguments),
+      r = radius.apply(this, arguments) * _math.radians,
+      p = precision.apply(this, arguments) * _math.radians;
+    ring = [];
+    rotate = (0, _rotation.rotateRadians)(-c[0] * _math.radians, -c[1] * _math.radians, 0).invert;
+    circleStream(stream, r, p, 1);
+    c = {
+      type: "Polygon",
+      coordinates: [ring]
+    };
+    ring = rotate = null;
+    return c;
+  }
+  circle.center = function (_) {
+    return arguments.length ? (center = typeof _ === "function" ? _ : (0, _constant.default)([+_[0], +_[1]]), circle) : center;
+  };
+  circle.radius = function (_) {
+    return arguments.length ? (radius = typeof _ === "function" ? _ : (0, _constant.default)(+_), circle) : radius;
+  };
+  circle.precision = function (_) {
+    return arguments.length ? (precision = typeof _ === "function" ? _ : (0, _constant.default)(+_), circle) : precision;
+  };
+  return circle;
+}

package/lib-vendor/d3-geo/src/clip/antimeridian.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = _interopRequireDefault(require("./index.js"));
+var _math = require("../math.js");
+var _default = exports.default = (0, _index.default)(function () {
+  return true;
+}, clipAntimeridianLine, clipAntimeridianInterpolate, [-_math.pi, -_math.halfPi]); // Takes a line and cuts into visible segments. Return values: 0 - there were
+// intersections or the line was empty; 1 - no intersections; 2 - there were
+// intersections, and the first and last segments should be rejoined.
+function clipAntimeridianLine(stream) {
+  var lambda0 = NaN,
+    phi0 = NaN,
+    sign0 = NaN,
+    clean; // no intersections
+
+  return {
+    lineStart: function () {
+      stream.lineStart();
+      clean = 1;
+    },
+    point: function (lambda1, phi1) {
+      var sign1 = lambda1 > 0 ? _math.pi : -_math.pi,
+        delta = (0, _math.abs)(lambda1 - lambda0);
+      if ((0, _math.abs)(delta - _math.pi) < _math.epsilon) {
+        // line crosses a pole
+        stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? _math.halfPi : -_math.halfPi);
+        stream.point(sign0, phi0);
+        stream.lineEnd();
+        stream.lineStart();
+        stream.point(sign1, phi0);
+        stream.point(lambda1, phi0);
+        clean = 0;
+      } else if (sign0 !== sign1 && delta >= _math.pi) {
+        // line crosses antimeridian
+        if ((0, _math.abs)(lambda0 - sign0) < _math.epsilon) lambda0 -= sign0 * _math.epsilon; // handle degeneracies
+        if ((0, _math.abs)(lambda1 - sign1) < _math.epsilon) lambda1 -= sign1 * _math.epsilon;
+        phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);
+        stream.point(sign0, phi0);
+        stream.lineEnd();
+        stream.lineStart();
+        stream.point(sign1, phi0);
+        clean = 0;
+      }
+      stream.point(lambda0 = lambda1, phi0 = phi1);
+      sign0 = sign1;
+    },
+    lineEnd: function () {
+      stream.lineEnd();
+      lambda0 = phi0 = NaN;
+    },
+    clean: function () {
+      return 2 - clean; // if intersections, rejoin first and last segments
+    }
+  };
+}
+function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {
+  var cosPhi0,
+    cosPhi1,
+    sinLambda0Lambda1 = (0, _math.sin)(lambda0 - lambda1);
+  return (0, _math.abs)(sinLambda0Lambda1) > _math.epsilon ? (0, _math.atan)(((0, _math.sin)(phi0) * (cosPhi1 = (0, _math.cos)(phi1)) * (0, _math.sin)(lambda1) - (0, _math.sin)(phi1) * (cosPhi0 = (0, _math.cos)(phi0)) * (0, _math.sin)(lambda0)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
+}
+function clipAntimeridianInterpolate(from, to, direction, stream) {
+  var phi;
+  if (from == null) {
+    phi = direction * _math.halfPi;
+    stream.point(-_math.pi, phi);
+    stream.point(0, phi);
+    stream.point(_math.pi, phi);
+    stream.point(_math.pi, 0);
+    stream.point(_math.pi, -phi);
+    stream.point(0, -phi);
+    stream.point(-_math.pi, -phi);
+    stream.point(-_math.pi, 0);
+    stream.point(-_math.pi, phi);
+  } else if ((0, _math.abs)(from[0] - to[0]) > _math.epsilon) {
+    var lambda = from[0] < to[0] ? _math.pi : -_math.pi;
+    phi = direction * lambda / 2;
+    stream.point(-lambda, phi);
+    stream.point(0, phi);
+    stream.point(lambda, phi);
+  } else {
+    stream.point(to[0], to[1]);
+  }
+}

package/lib-vendor/d3-geo/src/clip/buffer.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _noop = _interopRequireDefault(require("../noop.js"));
+function _default() {
+  var lines = [],
+    line;
+  return {
+    point: function (x, y, m) {
+      line.push([x, y, m]);
+    },
+    lineStart: function () {
+      lines.push(line = []);
+    },
+    lineEnd: _noop.default,
+    rejoin: function () {
+      if (lines.length > 1) lines.push(lines.pop().concat(lines.shift()));
+    },
+    result: function () {
+      var result = lines;
+      lines = [];
+      line = null;
+      return result;
+    }
+  };
+}