@mui/x-charts-vendor 9.0.0 → 9.4.0

package/lib-vendor/d3-geo/src/projection/azimuthalEqualArea.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.azimuthalEqualAreaRaw = void 0;
+exports.default = _default;
+var _math = require("../math.js");
+var _azimuthal = require("./azimuthal.js");
+var _index = _interopRequireDefault(require("./index.js"));
+var azimuthalEqualAreaRaw = exports.azimuthalEqualAreaRaw = (0, _azimuthal.azimuthalRaw)(function (cxcy) {
+  return (0, _math.sqrt)(2 / (1 + cxcy));
+});
+azimuthalEqualAreaRaw.invert = (0, _azimuthal.azimuthalInvert)(function (z) {
+  return 2 * (0, _math.asin)(z / 2);
+});
+function _default() {
+  return (0, _index.default)(azimuthalEqualAreaRaw).scale(124.75).clipAngle(180 - 1e-3);
+}

package/lib-vendor/d3-geo/src/projection/azimuthalEquidistant.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.azimuthalEquidistantRaw = void 0;
+exports.default = _default;
+var _math = require("../math.js");
+var _azimuthal = require("./azimuthal.js");
+var _index = _interopRequireDefault(require("./index.js"));
+var azimuthalEquidistantRaw = exports.azimuthalEquidistantRaw = (0, _azimuthal.azimuthalRaw)(function (c) {
+  return (c = (0, _math.acos)(c)) && c / (0, _math.sin)(c);
+});
+azimuthalEquidistantRaw.invert = (0, _azimuthal.azimuthalInvert)(function (z) {
+  return z;
+});
+function _default() {
+  return (0, _index.default)(azimuthalEquidistantRaw).scale(79.4188).clipAngle(180 - 1e-3);
+}

package/lib-vendor/d3-geo/src/projection/conic.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conicProjection = conicProjection;
+var _math = require("../math.js");
+var _index = require("./index.js");
+function conicProjection(projectAt) {
+  var phi0 = 0,
+    phi1 = _math.pi / 3,
+    m = (0, _index.projectionMutator)(projectAt),
+    p = m(phi0, phi1);
+  p.parallels = function (_) {
+    return arguments.length ? m(phi0 = _[0] * _math.radians, phi1 = _[1] * _math.radians) : [phi0 * _math.degrees, phi1 * _math.degrees];
+  };
+  return p;
+}

package/lib-vendor/d3-geo/src/projection/conicConformal.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conicConformalRaw = conicConformalRaw;
+exports.default = _default;
+var _math = require("../math.js");
+var _conic = require("./conic.js");
+var _mercator = require("./mercator.js");
+function tany(y) {
+  return (0, _math.tan)((_math.halfPi + y) / 2);
+}
+function conicConformalRaw(y0, y1) {
+  var cy0 = (0, _math.cos)(y0),
+    n = y0 === y1 ? (0, _math.sin)(y0) : (0, _math.log)(cy0 / (0, _math.cos)(y1)) / (0, _math.log)(tany(y1) / tany(y0)),
+    f = cy0 * (0, _math.pow)(tany(y0), n) / n;
+  if (!n) return _mercator.mercatorRaw;
+  function project(x, y) {
+    if (f > 0) {
+      if (y < -_math.halfPi + _math.epsilon) y = -_math.halfPi + _math.epsilon;
+    } else {
+      if (y > _math.halfPi - _math.epsilon) y = _math.halfPi - _math.epsilon;
+    }
+    var r = f / (0, _math.pow)(tany(y), n);
+    return [r * (0, _math.sin)(n * x), f - r * (0, _math.cos)(n * x)];
+  }
+  project.invert = function (x, y) {
+    var fy = f - y,
+      r = (0, _math.sign)(n) * (0, _math.sqrt)(x * x + fy * fy),
+      l = (0, _math.atan2)(x, (0, _math.abs)(fy)) * (0, _math.sign)(fy);
+    if (fy * n < 0) l -= _math.pi * (0, _math.sign)(x) * (0, _math.sign)(fy);
+    return [l / n, 2 * (0, _math.atan)((0, _math.pow)(f / r, 1 / n)) - _math.halfPi];
+  };
+  return project;
+}
+function _default() {
+  return (0, _conic.conicProjection)(conicConformalRaw).scale(109.5).parallels([30, 30]);
+}

package/lib-vendor/d3-geo/src/projection/conicEqualArea.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conicEqualAreaRaw = conicEqualAreaRaw;
+exports.default = _default;
+var _math = require("../math.js");
+var _conic = require("./conic.js");
+var _cylindricalEqualArea = require("./cylindricalEqualArea.js");
+function conicEqualAreaRaw(y0, y1) {
+  var sy0 = (0, _math.sin)(y0),
+    n = (sy0 + (0, _math.sin)(y1)) / 2;
+
+  // Are the parallels symmetrical around the Equator?
+  if ((0, _math.abs)(n) < _math.epsilon) return (0, _cylindricalEqualArea.cylindricalEqualAreaRaw)(y0);
+  var c = 1 + sy0 * (2 * n - sy0),
+    r0 = (0, _math.sqrt)(c) / n;
+  function project(x, y) {
+    var r = (0, _math.sqrt)(c - 2 * n * (0, _math.sin)(y)) / n;
+    return [r * (0, _math.sin)(x *= n), r0 - r * (0, _math.cos)(x)];
+  }
+  project.invert = function (x, y) {
+    var r0y = r0 - y,
+      l = (0, _math.atan2)(x, (0, _math.abs)(r0y)) * (0, _math.sign)(r0y);
+    if (r0y * n < 0) l -= _math.pi * (0, _math.sign)(x) * (0, _math.sign)(r0y);
+    return [l / n, (0, _math.asin)((c - (x * x + r0y * r0y) * n * n) / (2 * n))];
+  };
+  return project;
+}
+function _default() {
+  return (0, _conic.conicProjection)(conicEqualAreaRaw).scale(155.424).center([0, 33.6442]);
+}

package/lib-vendor/d3-geo/src/projection/conicEquidistant.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.conicEquidistantRaw = conicEquidistantRaw;
+exports.default = _default;
+var _math = require("../math.js");
+var _conic = require("./conic.js");
+var _equirectangular = require("./equirectangular.js");
+function conicEquidistantRaw(y0, y1) {
+  var cy0 = (0, _math.cos)(y0),
+    n = y0 === y1 ? (0, _math.sin)(y0) : (cy0 - (0, _math.cos)(y1)) / (y1 - y0),
+    g = cy0 / n + y0;
+  if ((0, _math.abs)(n) < _math.epsilon) return _equirectangular.equirectangularRaw;
+  function project(x, y) {
+    var gy = g - y,
+      nx = n * x;
+    return [gy * (0, _math.sin)(nx), g - gy * (0, _math.cos)(nx)];
+  }
+  project.invert = function (x, y) {
+    var gy = g - y,
+      l = (0, _math.atan2)(x, (0, _math.abs)(gy)) * (0, _math.sign)(gy);
+    if (gy * n < 0) l -= _math.pi * (0, _math.sign)(x) * (0, _math.sign)(gy);
+    return [l / n, g - (0, _math.sign)(n) * (0, _math.sqrt)(x * x + gy * gy)];
+  };
+  return project;
+}
+function _default() {
+  return (0, _conic.conicProjection)(conicEquidistantRaw).scale(131.154).center([0, 13.9389]);
+}

package/lib-vendor/d3-geo/src/projection/cylindricalEqualArea.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cylindricalEqualAreaRaw = cylindricalEqualAreaRaw;
+var _math = require("../math.js");
+function cylindricalEqualAreaRaw(phi0) {
+  var cosPhi0 = (0, _math.cos)(phi0);
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, (0, _math.sin)(phi) / cosPhi0];
+  }
+  forward.invert = function (x, y) {
+    return [x / cosPhi0, (0, _math.asin)(y * cosPhi0)];
+  };
+  return forward;
+}

package/lib-vendor/d3-geo/src/projection/equalEarth.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.equalEarthRaw = equalEarthRaw;
+var _index = _interopRequireDefault(require("./index.js"));
+var _math = require("../math.js");
+var A1 = 1.340264,
+  A2 = -0.081106,
+  A3 = 0.000893,
+  A4 = 0.003796,
+  M = (0, _math.sqrt)(3) / 2,
+  iterations = 12;
+function equalEarthRaw(lambda, phi) {
+  var l = (0, _math.asin)(M * (0, _math.sin)(phi)),
+    l2 = l * l,
+    l6 = l2 * l2 * l2;
+  return [lambda * (0, _math.cos)(l) / (M * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2))), l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2))];
+}
+equalEarthRaw.invert = function (x, y) {
+  var l = y,
+    l2 = l * l,
+    l6 = l2 * l2 * l2;
+  for (var i = 0, delta, fy, fpy; i < iterations; ++i) {
+    fy = l * (A1 + A2 * l2 + l6 * (A3 + A4 * l2)) - y;
+    fpy = A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2);
+    l -= delta = fy / fpy, l2 = l * l, l6 = l2 * l2 * l2;
+    if ((0, _math.abs)(delta) < _math.epsilon2) break;
+  }
+  return [M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2)) / (0, _math.cos)(l), (0, _math.asin)((0, _math.sin)(l) / M)];
+};
+function _default() {
+  return (0, _index.default)(equalEarthRaw).scale(177.158);
+}

package/lib-vendor/d3-geo/src/projection/equirectangular.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.equirectangularRaw = equirectangularRaw;
+var _index = _interopRequireDefault(require("./index.js"));
+function equirectangularRaw(lambda, phi) {
+  return [lambda, phi];
+}
+equirectangularRaw.invert = equirectangularRaw;
+function _default() {
+  return (0, _index.default)(equirectangularRaw).scale(152.63);
+}

package/lib-vendor/d3-geo/src/projection/fit.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fitExtent = fitExtent;
+exports.fitHeight = fitHeight;
+exports.fitSize = fitSize;
+exports.fitWidth = fitWidth;
+var _stream = _interopRequireDefault(require("../stream.js"));
+var _bounds = _interopRequireDefault(require("../path/bounds.js"));
+function fit(projection, fitBounds, object) {
+  var clip = projection.clipExtent && projection.clipExtent();
+  projection.scale(150).translate([0, 0]);
+  if (clip != null) projection.clipExtent(null);
+  (0, _stream.default)(object, projection.stream(_bounds.default));
+  fitBounds(_bounds.default.result());
+  if (clip != null) projection.clipExtent(clip);
+  return projection;
+}
+function fitExtent(projection, extent, object) {
+  return fit(projection, function (b) {
+    var w = extent[1][0] - extent[0][0],
+      h = extent[1][1] - extent[0][1],
+      k = Math.min(w / (b[1][0] - b[0][0]), h / (b[1][1] - b[0][1])),
+      x = +extent[0][0] + (w - k * (b[1][0] + b[0][0])) / 2,
+      y = +extent[0][1] + (h - k * (b[1][1] + b[0][1])) / 2;
+    projection.scale(150 * k).translate([x, y]);
+  }, object);
+}
+function fitSize(projection, size, object) {
+  return fitExtent(projection, [[0, 0], size], object);
+}
+function fitWidth(projection, width, object) {
+  return fit(projection, function (b) {
+    var w = +width,
+      k = w / (b[1][0] - b[0][0]),
+      x = (w - k * (b[1][0] + b[0][0])) / 2,
+      y = -k * b[0][1];
+    projection.scale(150 * k).translate([x, y]);
+  }, object);
+}
+function fitHeight(projection, height, object) {
+  return fit(projection, function (b) {
+    var h = +height,
+      k = h / (b[1][1] - b[0][1]),
+      x = -k * b[0][0],
+      y = (h - k * (b[1][1] + b[0][1])) / 2;
+    projection.scale(150 * k).translate([x, y]);
+  }, object);
+}

package/lib-vendor/d3-geo/src/projection/gnomonic.js

@@ -0,0 +1,20 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.gnomonicRaw = gnomonicRaw;
+var _math = require("../math.js");
+var _azimuthal = require("./azimuthal.js");
+var _index = _interopRequireDefault(require("./index.js"));
+function gnomonicRaw(x, y) {
+  var cy = (0, _math.cos)(y),
+    k = (0, _math.cos)(x) * cy;
+  return [cy * (0, _math.sin)(x) / k, (0, _math.sin)(y) / k];
+}
+gnomonicRaw.invert = (0, _azimuthal.azimuthalInvert)(_math.atan);
+function _default() {
+  return (0, _index.default)(gnomonicRaw).scale(144.049).clipAngle(60);
+}

package/lib-vendor/d3-geo/src/projection/identity.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _rectangle = _interopRequireDefault(require("../clip/rectangle.js"));
+var _identity = _interopRequireDefault(require("../identity.js"));
+var _transform = require("../transform.js");
+var _fit = require("./fit.js");
+var _math = require("../math.js");
+function _default() {
+  var k = 1,
+    tx = 0,
+    ty = 0,
+    sx = 1,
+    sy = 1,
+    // scale, translate and reflect
+    alpha = 0,
+    ca,
+    sa,
+    // angle
+    x0 = null,
+    y0,
+    x1,
+    y1,
+    // clip extent
+    kx = 1,
+    ky = 1,
+    transform = (0, _transform.transformer)({
+      point: function (x, y) {
+        var p = projection([x, y]);
+        this.stream.point(p[0], p[1]);
+      }
+    }),
+    postclip = _identity.default,
+    cache,
+    cacheStream;
+  function reset() {
+    kx = k * sx;
+    ky = k * sy;
+    cache = cacheStream = null;
+    return projection;
+  }
+  function projection(p) {
+    var x = p[0] * kx,
+      y = p[1] * ky;
+    if (alpha) {
+      var t = y * ca - x * sa;
+      x = x * ca + y * sa;
+      y = t;
+    }
+    return [x + tx, y + ty];
+  }
+  projection.invert = function (p) {
+    var x = p[0] - tx,
+      y = p[1] - ty;
+    if (alpha) {
+      var t = y * ca + x * sa;
+      x = x * ca - y * sa;
+      y = t;
+    }
+    return [x / kx, y / ky];
+  };
+  projection.stream = function (stream) {
+    return cache && cacheStream === stream ? cache : cache = transform(postclip(cacheStream = stream));
+  };
+  projection.postclip = function (_) {
+    return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip;
+  };
+  projection.clipExtent = function (_) {
+    return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, _identity.default) : (0, _rectangle.default)(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];
+  };
+  projection.scale = function (_) {
+    return arguments.length ? (k = +_, reset()) : k;
+  };
+  projection.translate = function (_) {
+    return arguments.length ? (tx = +_[0], ty = +_[1], reset()) : [tx, ty];
+  };
+  projection.angle = function (_) {
+    return arguments.length ? (alpha = _ % 360 * _math.radians, sa = (0, _math.sin)(alpha), ca = (0, _math.cos)(alpha), reset()) : alpha * _math.degrees;
+  };
+  projection.reflectX = function (_) {
+    return arguments.length ? (sx = _ ? -1 : 1, reset()) : sx < 0;
+  };
+  projection.reflectY = function (_) {
+    return arguments.length ? (sy = _ ? -1 : 1, reset()) : sy < 0;
+  };
+  projection.fitExtent = function (extent, object) {
+    return (0, _fit.fitExtent)(projection, extent, object);
+  };
+  projection.fitSize = function (size, object) {
+    return (0, _fit.fitSize)(projection, size, object);
+  };
+  projection.fitWidth = function (width, object) {
+    return (0, _fit.fitWidth)(projection, width, object);
+  };
+  projection.fitHeight = function (height, object) {
+    return (0, _fit.fitHeight)(projection, height, object);
+  };
+  return projection;
+}

package/lib-vendor/d3-geo/src/projection/index.js

@@ -0,0 +1,181 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = projection;
+exports.projectionMutator = projectionMutator;
+var _antimeridian = _interopRequireDefault(require("../clip/antimeridian.js"));
+var _circle = _interopRequireDefault(require("../clip/circle.js"));
+var _rectangle = _interopRequireDefault(require("../clip/rectangle.js"));
+var _compose = _interopRequireDefault(require("../compose.js"));
+var _identity = _interopRequireDefault(require("../identity.js"));
+var _math = require("../math.js");
+var _rotation = require("../rotation.js");
+var _transform = require("../transform.js");
+var _fit = require("./fit.js");
+var _resample = _interopRequireDefault(require("./resample.js"));
+var transformRadians = (0, _transform.transformer)({
+  point: function (x, y) {
+    this.stream.point(x * _math.radians, y * _math.radians);
+  }
+});
+function transformRotate(rotate) {
+  return (0, _transform.transformer)({
+    point: function (x, y) {
+      var r = rotate(x, y);
+      return this.stream.point(r[0], r[1]);
+    }
+  });
+}
+function scaleTranslate(k, dx, dy, sx, sy) {
+  function transform(x, y) {
+    x *= sx;
+    y *= sy;
+    return [dx + k * x, dy - k * y];
+  }
+  transform.invert = function (x, y) {
+    return [(x - dx) / k * sx, (dy - y) / k * sy];
+  };
+  return transform;
+}
+function scaleTranslateRotate(k, dx, dy, sx, sy, alpha) {
+  if (!alpha) return scaleTranslate(k, dx, dy, sx, sy);
+  var cosAlpha = (0, _math.cos)(alpha),
+    sinAlpha = (0, _math.sin)(alpha),
+    a = cosAlpha * k,
+    b = sinAlpha * k,
+    ai = cosAlpha / k,
+    bi = sinAlpha / k,
+    ci = (sinAlpha * dy - cosAlpha * dx) / k,
+    fi = (sinAlpha * dx + cosAlpha * dy) / k;
+  function transform(x, y) {
+    x *= sx;
+    y *= sy;
+    return [a * x - b * y + dx, dy - b * x - a * y];
+  }
+  transform.invert = function (x, y) {
+    return [sx * (ai * x - bi * y + ci), sy * (fi - bi * x - ai * y)];
+  };
+  return transform;
+}
+function projection(project) {
+  return projectionMutator(function () {
+    return project;
+  })();
+}
+function projectionMutator(projectAt) {
+  var project,
+    k = 150,
+    // scale
+    x = 480,
+    y = 250,
+    // translate
+    lambda = 0,
+    phi = 0,
+    // center
+    deltaLambda = 0,
+    deltaPhi = 0,
+    deltaGamma = 0,
+    rotate,
+    // pre-rotate
+    alpha = 0,
+    // post-rotate angle
+    sx = 1,
+    // reflectX
+    sy = 1,
+    // reflectX
+    theta = null,
+    preclip = _antimeridian.default,
+    // pre-clip angle
+    x0 = null,
+    y0,
+    x1,
+    y1,
+    postclip = _identity.default,
+    // post-clip extent
+    delta2 = 0.5,
+    // precision
+    projectResample,
+    projectTransform,
+    projectRotateTransform,
+    cache,
+    cacheStream;
+  function projection(point) {
+    return projectRotateTransform(point[0] * _math.radians, point[1] * _math.radians);
+  }
+  function invert(point) {
+    point = projectRotateTransform.invert(point[0], point[1]);
+    return point && [point[0] * _math.degrees, point[1] * _math.degrees];
+  }
+  projection.stream = function (stream) {
+    return cache && cacheStream === stream ? cache : cache = transformRadians(transformRotate(rotate)(preclip(projectResample(postclip(cacheStream = stream)))));
+  };
+  projection.preclip = function (_) {
+    return arguments.length ? (preclip = _, theta = undefined, reset()) : preclip;
+  };
+  projection.postclip = function (_) {
+    return arguments.length ? (postclip = _, x0 = y0 = x1 = y1 = null, reset()) : postclip;
+  };
+  projection.clipAngle = function (_) {
+    return arguments.length ? (preclip = +_ ? (0, _circle.default)(theta = _ * _math.radians) : (theta = null, _antimeridian.default), reset()) : theta * _math.degrees;
+  };
+  projection.clipExtent = function (_) {
+    return arguments.length ? (postclip = _ == null ? (x0 = y0 = x1 = y1 = null, _identity.default) : (0, _rectangle.default)(x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reset()) : x0 == null ? null : [[x0, y0], [x1, y1]];
+  };
+  projection.scale = function (_) {
+    return arguments.length ? (k = +_, recenter()) : k;
+  };
+  projection.translate = function (_) {
+    return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];
+  };
+  projection.center = function (_) {
+    return arguments.length ? (lambda = _[0] % 360 * _math.radians, phi = _[1] % 360 * _math.radians, recenter()) : [lambda * _math.degrees, phi * _math.degrees];
+  };
+  projection.rotate = function (_) {
+    return arguments.length ? (deltaLambda = _[0] % 360 * _math.radians, deltaPhi = _[1] % 360 * _math.radians, deltaGamma = _.length > 2 ? _[2] % 360 * _math.radians : 0, recenter()) : [deltaLambda * _math.degrees, deltaPhi * _math.degrees, deltaGamma * _math.degrees];
+  };
+  projection.angle = function (_) {
+    return arguments.length ? (alpha = _ % 360 * _math.radians, recenter()) : alpha * _math.degrees;
+  };
+  projection.reflectX = function (_) {
+    return arguments.length ? (sx = _ ? -1 : 1, recenter()) : sx < 0;
+  };
+  projection.reflectY = function (_) {
+    return arguments.length ? (sy = _ ? -1 : 1, recenter()) : sy < 0;
+  };
+  projection.precision = function (_) {
+    return arguments.length ? (projectResample = (0, _resample.default)(projectTransform, delta2 = _ * _), reset()) : (0, _math.sqrt)(delta2);
+  };
+  projection.fitExtent = function (extent, object) {
+    return (0, _fit.fitExtent)(projection, extent, object);
+  };
+  projection.fitSize = function (size, object) {
+    return (0, _fit.fitSize)(projection, size, object);
+  };
+  projection.fitWidth = function (width, object) {
+    return (0, _fit.fitWidth)(projection, width, object);
+  };
+  projection.fitHeight = function (height, object) {
+    return (0, _fit.fitHeight)(projection, height, object);
+  };
+  function recenter() {
+    var center = scaleTranslateRotate(k, 0, 0, sx, sy, alpha).apply(null, project(lambda, phi)),
+      transform = scaleTranslateRotate(k, x - center[0], y - center[1], sx, sy, alpha);
+    rotate = (0, _rotation.rotateRadians)(deltaLambda, deltaPhi, deltaGamma);
+    projectTransform = (0, _compose.default)(project, transform);
+    projectRotateTransform = (0, _compose.default)(rotate, projectTransform);
+    projectResample = (0, _resample.default)(projectTransform, delta2);
+    return reset();
+  }
+  function reset() {
+    cache = cacheStream = null;
+    return projection;
+  }
+  return function () {
+    project = projectAt.apply(this, arguments);
+    projection.invert = project.invert && invert;
+    return recenter();
+  };
+}

package/lib-vendor/d3-geo/src/projection/mercator.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.mercatorProjection = mercatorProjection;
+exports.mercatorRaw = mercatorRaw;
+var _math = require("../math.js");
+var _rotation = _interopRequireDefault(require("../rotation.js"));
+var _index = _interopRequireDefault(require("./index.js"));
+function mercatorRaw(lambda, phi) {
+  return [lambda, (0, _math.log)((0, _math.tan)((_math.halfPi + phi) / 2))];
+}
+mercatorRaw.invert = function (x, y) {
+  return [x, 2 * (0, _math.atan)((0, _math.exp)(y)) - _math.halfPi];
+};
+function _default() {
+  return mercatorProjection(mercatorRaw).scale(961 / _math.tau);
+}
+function mercatorProjection(project) {
+  var m = (0, _index.default)(project),
+    center = m.center,
+    scale = m.scale,
+    translate = m.translate,
+    clipExtent = m.clipExtent,
+    x0 = null,
+    y0,
+    x1,
+    y1; // clip extent
+
+  m.scale = function (_) {
+    return arguments.length ? (scale(_), reclip()) : scale();
+  };
+  m.translate = function (_) {
+    return arguments.length ? (translate(_), reclip()) : translate();
+  };
+  m.center = function (_) {
+    return arguments.length ? (center(_), reclip()) : center();
+  };
+  m.clipExtent = function (_) {
+    return arguments.length ? (_ == null ? x0 = y0 = x1 = y1 = null : (x0 = +_[0][0], y0 = +_[0][1], x1 = +_[1][0], y1 = +_[1][1]), reclip()) : x0 == null ? null : [[x0, y0], [x1, y1]];
+  };
+  function reclip() {
+    var k = _math.pi * scale(),
+      t = m((0, _rotation.default)(m.rotate()).invert([0, 0]));
+    return clipExtent(x0 == null ? [[t[0] - k, t[1] - k], [t[0] + k, t[1] + k]] : project === mercatorRaw ? [[Math.max(t[0] - k, x0), y0], [Math.min(t[0] + k, x1), y1]] : [[x0, Math.max(t[1] - k, y0)], [x1, Math.min(t[1] + k, y1)]]);
+  }
+  return reclip();
+}

package/lib-vendor/d3-geo/src/projection/naturalEarth1.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+exports.naturalEarth1Raw = naturalEarth1Raw;
+var _index = _interopRequireDefault(require("./index.js"));
+var _math = require("../math.js");
+function naturalEarth1Raw(lambda, phi) {
+  var phi2 = phi * phi,
+    phi4 = phi2 * phi2;
+  return [lambda * (0.8707 - 0.131979 * phi2 + phi4 * (-0.013791 + phi4 * (0.003971 * phi2 - 0.001529 * phi4))), phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4)))];
+}
+naturalEarth1Raw.invert = function (x, y) {
+  var phi = y,
+    i = 25,
+    delta;
+  do {
+    var phi2 = phi * phi,
+      phi4 = phi2 * phi2;
+    phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - y) / (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 0.005916 * 11 * phi4)));
+  } while ((0, _math.abs)(delta) > _math.epsilon && --i > 0);
+  return [x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (0.003971 - 0.001529 * phi2)))), phi];
+};
+function _default() {
+  return (0, _index.default)(naturalEarth1Raw).scale(175.295);
+}