@mui/x-charts-vendor 9.0.0 → 9.4.0

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

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = noop;
+function noop() {}

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

@@ -0,0 +1,50 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = require("../../../d3-array/src/index.js");
+var _math = require("../math.js");
+var _noop = _interopRequireDefault(require("../noop.js"));
+var areaSum = new _index.Adder(),
+  areaRingSum = new _index.Adder(),
+  x00,
+  y00,
+  x0,
+  y0;
+var areaStream = {
+  point: _noop.default,
+  lineStart: _noop.default,
+  lineEnd: _noop.default,
+  polygonStart: function () {
+    areaStream.lineStart = areaRingStart;
+    areaStream.lineEnd = areaRingEnd;
+  },
+  polygonEnd: function () {
+    areaStream.lineStart = areaStream.lineEnd = areaStream.point = _noop.default;
+    areaSum.add((0, _math.abs)(areaRingSum));
+    areaRingSum = new _index.Adder();
+  },
+  result: function () {
+    var area = areaSum / 2;
+    areaSum = new _index.Adder();
+    return area;
+  }
+};
+function areaRingStart() {
+  areaStream.point = areaPointFirst;
+}
+function areaPointFirst(x, y) {
+  areaStream.point = areaPoint;
+  x00 = x0 = x, y00 = y0 = y;
+}
+function areaPoint(x, y) {
+  areaRingSum.add(y0 * x - x0 * y);
+  x0 = x, y0 = y;
+}
+function areaRingEnd() {
+  areaPoint(x00, y00);
+}
+var _default = exports.default = areaStream;

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

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _noop = _interopRequireDefault(require("../noop.js"));
+var x0 = Infinity,
+  y0 = x0,
+  x1 = -x0,
+  y1 = x1;
+var boundsStream = {
+  point: boundsPoint,
+  lineStart: _noop.default,
+  lineEnd: _noop.default,
+  polygonStart: _noop.default,
+  polygonEnd: _noop.default,
+  result: function () {
+    var bounds = [[x0, y0], [x1, y1]];
+    x1 = y1 = -(y0 = x0 = Infinity);
+    return bounds;
+  }
+};
+function boundsPoint(x, y) {
+  if (x < x0) x0 = x;
+  if (x > x1) x1 = x;
+  if (y < y0) y0 = y;
+  if (y > y1) y1 = y;
+}
+var _default = exports.default = boundsStream;

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

@@ -0,0 +1,89 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _math = require("../math.js");
+// TODO Enforce positive area for exterior, negative area for interior?
+
+var X0 = 0,
+  Y0 = 0,
+  Z0 = 0,
+  X1 = 0,
+  Y1 = 0,
+  Z1 = 0,
+  X2 = 0,
+  Y2 = 0,
+  Z2 = 0,
+  x00,
+  y00,
+  x0,
+  y0;
+var centroidStream = {
+  point: centroidPoint,
+  lineStart: centroidLineStart,
+  lineEnd: centroidLineEnd,
+  polygonStart: function () {
+    centroidStream.lineStart = centroidRingStart;
+    centroidStream.lineEnd = centroidRingEnd;
+  },
+  polygonEnd: function () {
+    centroidStream.point = centroidPoint;
+    centroidStream.lineStart = centroidLineStart;
+    centroidStream.lineEnd = centroidLineEnd;
+  },
+  result: function () {
+    var centroid = Z2 ? [X2 / Z2, Y2 / Z2] : Z1 ? [X1 / Z1, Y1 / Z1] : Z0 ? [X0 / Z0, Y0 / Z0] : [NaN, NaN];
+    X0 = Y0 = Z0 = X1 = Y1 = Z1 = X2 = Y2 = Z2 = 0;
+    return centroid;
+  }
+};
+function centroidPoint(x, y) {
+  X0 += x;
+  Y0 += y;
+  ++Z0;
+}
+function centroidLineStart() {
+  centroidStream.point = centroidPointFirstLine;
+}
+function centroidPointFirstLine(x, y) {
+  centroidStream.point = centroidPointLine;
+  centroidPoint(x0 = x, y0 = y);
+}
+function centroidPointLine(x, y) {
+  var dx = x - x0,
+    dy = y - y0,
+    z = (0, _math.sqrt)(dx * dx + dy * dy);
+  X1 += z * (x0 + x) / 2;
+  Y1 += z * (y0 + y) / 2;
+  Z1 += z;
+  centroidPoint(x0 = x, y0 = y);
+}
+function centroidLineEnd() {
+  centroidStream.point = centroidPoint;
+}
+function centroidRingStart() {
+  centroidStream.point = centroidPointFirstRing;
+}
+function centroidRingEnd() {
+  centroidPointRing(x00, y00);
+}
+function centroidPointFirstRing(x, y) {
+  centroidStream.point = centroidPointRing;
+  centroidPoint(x00 = x0 = x, y00 = y0 = y);
+}
+function centroidPointRing(x, y) {
+  var dx = x - x0,
+    dy = y - y0,
+    z = (0, _math.sqrt)(dx * dx + dy * dy);
+  X1 += z * (x0 + x) / 2;
+  Y1 += z * (y0 + y) / 2;
+  Z1 += z;
+  z = y0 * x - x0 * y;
+  X2 += z * (x0 + x);
+  Y2 += z * (y0 + y);
+  Z2 += z * 3;
+  centroidPoint(x0 = x, y0 = y);
+}
+var _default = exports.default = centroidStream;

package/lib-vendor/d3-geo/src/path/context.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = PathContext;
+var _math = require("../math.js");
+var _noop = _interopRequireDefault(require("../noop.js"));
+function PathContext(context) {
+  this._context = context;
+}
+PathContext.prototype = {
+  _radius: 4.5,
+  pointRadius: function (_) {
+    return this._radius = _, this;
+  },
+  polygonStart: function () {
+    this._line = 0;
+  },
+  polygonEnd: function () {
+    this._line = NaN;
+  },
+  lineStart: function () {
+    this._point = 0;
+  },
+  lineEnd: function () {
+    if (this._line === 0) this._context.closePath();
+    this._point = NaN;
+  },
+  point: function (x, y) {
+    switch (this._point) {
+      case 0:
+        {
+          this._context.moveTo(x, y);
+          this._point = 1;
+          break;
+        }
+      case 1:
+        {
+          this._context.lineTo(x, y);
+          break;
+        }
+      default:
+        {
+          this._context.moveTo(x + this._radius, y);
+          this._context.arc(x, y, this._radius, 0, _math.tau);
+          break;
+        }
+    }
+  },
+  result: _noop.default
+};

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

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _identity = _interopRequireDefault(require("../identity.js"));
+var _stream = _interopRequireDefault(require("../stream.js"));
+var _area = _interopRequireDefault(require("./area.js"));
+var _bounds = _interopRequireDefault(require("./bounds.js"));
+var _centroid = _interopRequireDefault(require("./centroid.js"));
+var _context = _interopRequireDefault(require("./context.js"));
+var _measure = _interopRequireDefault(require("./measure.js"));
+var _string = _interopRequireDefault(require("./string.js"));
+function _default(projection, context) {
+  let digits = 3,
+    pointRadius = 4.5,
+    projectionStream,
+    contextStream;
+  function path(object) {
+    if (object) {
+      if (typeof pointRadius === "function") contextStream.pointRadius(+pointRadius.apply(this, arguments));
+      (0, _stream.default)(object, projectionStream(contextStream));
+    }
+    return contextStream.result();
+  }
+  path.area = function (object) {
+    (0, _stream.default)(object, projectionStream(_area.default));
+    return _area.default.result();
+  };
+  path.measure = function (object) {
+    (0, _stream.default)(object, projectionStream(_measure.default));
+    return _measure.default.result();
+  };
+  path.bounds = function (object) {
+    (0, _stream.default)(object, projectionStream(_bounds.default));
+    return _bounds.default.result();
+  };
+  path.centroid = function (object) {
+    (0, _stream.default)(object, projectionStream(_centroid.default));
+    return _centroid.default.result();
+  };
+  path.projection = function (_) {
+    if (!arguments.length) return projection;
+    projectionStream = _ == null ? (projection = null, _identity.default) : (projection = _).stream;
+    return path;
+  };
+  path.context = function (_) {
+    if (!arguments.length) return context;
+    contextStream = _ == null ? (context = null, new _string.default(digits)) : new _context.default(context = _);
+    if (typeof pointRadius !== "function") contextStream.pointRadius(pointRadius);
+    return path;
+  };
+  path.pointRadius = function (_) {
+    if (!arguments.length) return pointRadius;
+    pointRadius = typeof _ === "function" ? _ : (contextStream.pointRadius(+_), +_);
+    return path;
+  };
+  path.digits = function (_) {
+    if (!arguments.length) return digits;
+    if (_ == null) digits = null;else {
+      const d = Math.floor(_);
+      if (!(d >= 0)) throw new RangeError(`invalid digits: ${_}`);
+      digits = d;
+    }
+    if (context === null) contextStream = new _string.default(digits);
+    return path;
+  };
+  return path.projection(projection).digits(digits).context(context);
+}

package/lib-vendor/d3-geo/src/path/measure.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _index = require("../../../d3-array/src/index.js");
+var _math = require("../math.js");
+var _noop = _interopRequireDefault(require("../noop.js"));
+var lengthSum = new _index.Adder(),
+  lengthRing,
+  x00,
+  y00,
+  x0,
+  y0;
+var lengthStream = {
+  point: _noop.default,
+  lineStart: function () {
+    lengthStream.point = lengthPointFirst;
+  },
+  lineEnd: function () {
+    if (lengthRing) lengthPoint(x00, y00);
+    lengthStream.point = _noop.default;
+  },
+  polygonStart: function () {
+    lengthRing = true;
+  },
+  polygonEnd: function () {
+    lengthRing = null;
+  },
+  result: function () {
+    var length = +lengthSum;
+    lengthSum = new _index.Adder();
+    return length;
+  }
+};
+function lengthPointFirst(x, y) {
+  lengthStream.point = lengthPoint;
+  x00 = x0 = x, y00 = y0 = y;
+}
+function lengthPoint(x, y) {
+  x0 -= x, y0 -= y;
+  lengthSum.add((0, _math.sqrt)(x0 * x0 + y0 * y0));
+  x0 = x, y0 = y;
+}
+var _default = exports.default = lengthStream;

package/lib-vendor/d3-geo/src/path/string.js

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// Simple caching for constant-radius points.
+let cacheDigits, cacheAppend, cacheRadius, cacheCircle;
+class PathString {
+  constructor(digits) {
+    this._append = digits == null ? append : appendRound(digits);
+    this._radius = 4.5;
+    this._ = "";
+  }
+  pointRadius(_) {
+    this._radius = +_;
+    return this;
+  }
+  polygonStart() {
+    this._line = 0;
+  }
+  polygonEnd() {
+    this._line = NaN;
+  }
+  lineStart() {
+    this._point = 0;
+  }
+  lineEnd() {
+    if (this._line === 0) this._ += "Z";
+    this._point = NaN;
+  }
+  point(x, y) {
+    switch (this._point) {
+      case 0:
+        {
+          this._append`M${x},${y}`;
+          this._point = 1;
+          break;
+        }
+      case 1:
+        {
+          this._append`L${x},${y}`;
+          break;
+        }
+      default:
+        {
+          this._append`M${x},${y}`;
+          if (this._radius !== cacheRadius || this._append !== cacheAppend) {
+            const r = this._radius;
+            const s = this._;
+            this._ = ""; // stash the old string so we can cache the circle path fragment
+            this._append`m0,${r}a${r},${r} 0 1,1 0,${-2 * r}a${r},${r} 0 1,1 0,${2 * r}z`;
+            cacheRadius = r;
+            cacheAppend = this._append;
+            cacheCircle = this._;
+            this._ = s;
+          }
+          this._ += cacheCircle;
+          break;
+        }
+    }
+  }
+  result() {
+    const result = this._;
+    this._ = "";
+    return result.length ? result : null;
+  }
+}
+exports.default = PathString;
+function append(strings) {
+  let i = 1;
+  this._ += strings[0];
+  for (const j = strings.length; i < j; ++i) {
+    this._ += arguments[i] + strings[i];
+  }
+}
+function appendRound(digits) {
+  const d = Math.floor(digits);
+  if (!(d >= 0)) throw new RangeError(`invalid digits: ${digits}`);
+  if (d > 15) return append;
+  if (d !== cacheDigits) {
+    const k = 10 ** d;
+    cacheDigits = d;
+    cacheAppend = function append(strings) {
+      let i = 1;
+      this._ += strings[0];
+      for (const j = strings.length; i < j; ++i) {
+        this._ += Math.round(arguments[i] * k) / k + strings[i];
+      }
+    };
+  }
+  return cacheAppend;
+}

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

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _math = require("./math.js");
+function _default(a, b) {
+  return (0, _math.abs)(a[0] - b[0]) < _math.epsilon && (0, _math.abs)(a[1] - b[1]) < _math.epsilon;
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _index = require("../../d3-array/src/index.js");
+var _cartesian = require("./cartesian.js");
+var _math = require("./math.js");
+function longitude(point) {
+  return (0, _math.abs)(point[0]) <= _math.pi ? point[0] : (0, _math.sign)(point[0]) * (((0, _math.abs)(point[0]) + _math.pi) % _math.tau - _math.pi);
+}
+function _default(polygon, point) {
+  var lambda = longitude(point),
+    phi = point[1],
+    sinPhi = (0, _math.sin)(phi),
+    normal = [(0, _math.sin)(lambda), -(0, _math.cos)(lambda), 0],
+    angle = 0,
+    winding = 0;
+  var sum = new _index.Adder();
+  if (sinPhi === 1) phi = _math.halfPi + _math.epsilon;else if (sinPhi === -1) phi = -_math.halfPi - _math.epsilon;
+  for (var i = 0, n = polygon.length; i < n; ++i) {
+    if (!(m = (ring = polygon[i]).length)) continue;
+    var ring,
+      m,
+      point0 = ring[m - 1],
+      lambda0 = longitude(point0),
+      phi0 = point0[1] / 2 + _math.quarterPi,
+      sinPhi0 = (0, _math.sin)(phi0),
+      cosPhi0 = (0, _math.cos)(phi0);
+    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {
+      var point1 = ring[j],
+        lambda1 = longitude(point1),
+        phi1 = point1[1] / 2 + _math.quarterPi,
+        sinPhi1 = (0, _math.sin)(phi1),
+        cosPhi1 = (0, _math.cos)(phi1),
+        delta = lambda1 - lambda0,
+        sign = delta >= 0 ? 1 : -1,
+        absDelta = sign * delta,
+        antimeridian = absDelta > _math.pi,
+        k = sinPhi0 * sinPhi1;
+      sum.add((0, _math.atan2)(k * sign * (0, _math.sin)(absDelta), cosPhi0 * cosPhi1 + k * (0, _math.cos)(absDelta)));
+      angle += antimeridian ? delta + sign * _math.tau : delta;
+
+      // Are the longitudes either side of the point’s meridian (lambda),
+      // and are the latitudes smaller than the parallel (phi)?
+      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {
+        var arc = (0, _cartesian.cartesianCross)((0, _cartesian.cartesian)(point0), (0, _cartesian.cartesian)(point1));
+        (0, _cartesian.cartesianNormalizeInPlace)(arc);
+        var intersection = (0, _cartesian.cartesianCross)(normal, arc);
+        (0, _cartesian.cartesianNormalizeInPlace)(intersection);
+        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * (0, _math.asin)(intersection[2]);
+        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
+          winding += antimeridian ^ delta >= 0 ? 1 : -1;
+        }
+      }
+    }
+  }
+
+  // First, determine whether the South pole is inside or outside:
+  //
+  // It is inside if:
+  // * the polygon winds around it in a clockwise direction.
+  // * the polygon does not (cumulatively) wind around it, but has a negative
+  //   (counter-clockwise) area.
+  //
+  // Second, count the (signed) number of times a segment crosses a lambda
+  // from the point to the South pole.  If it is zero, then the point is the
+  // same side as the South pole.
+
+  return (angle < -_math.epsilon || angle < _math.epsilon && sum < -_math.epsilon2) ^ winding & 1;
+}

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

@@ -0,0 +1,11 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _conicEqualArea = _interopRequireDefault(require("./conicEqualArea.js"));
+function _default() {
+  return (0, _conicEqualArea.default)().parallels([29.5, 45.5]).scale(1070).translate([480, 250]).rotate([96, 0]).center([-0.6, 38.7]);
+}

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

@@ -0,0 +1,118 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _math = require("../math.js");
+var _albers = _interopRequireDefault(require("./albers.js"));
+var _conicEqualArea = _interopRequireDefault(require("./conicEqualArea.js"));
+var _fit = require("./fit.js");
+// The projections must have mutually exclusive clip regions on the sphere,
+// as this will avoid emitting interleaving lines and polygons.
+function multiplex(streams) {
+  var n = streams.length;
+  return {
+    point: function (x, y) {
+      var i = -1;
+      while (++i < n) streams[i].point(x, y);
+    },
+    sphere: function () {
+      var i = -1;
+      while (++i < n) streams[i].sphere();
+    },
+    lineStart: function () {
+      var i = -1;
+      while (++i < n) streams[i].lineStart();
+    },
+    lineEnd: function () {
+      var i = -1;
+      while (++i < n) streams[i].lineEnd();
+    },
+    polygonStart: function () {
+      var i = -1;
+      while (++i < n) streams[i].polygonStart();
+    },
+    polygonEnd: function () {
+      var i = -1;
+      while (++i < n) streams[i].polygonEnd();
+    }
+  };
+}
+
+// A composite projection for the United States, configured by default for
+// 960×500. The projection also works quite well at 960×600 if you change the
+// scale to 1285 and adjust the translate accordingly. The set of standard
+// parallels for each region comes from USGS, which is published here:
+// http://egsc.usgs.gov/isb/pubs/MapProjections/projections.html#albers
+function _default() {
+  var cache,
+    cacheStream,
+    lower48 = (0, _albers.default)(),
+    lower48Point,
+    alaska = (0, _conicEqualArea.default)().rotate([154, 0]).center([-2, 58.5]).parallels([55, 65]),
+    alaskaPoint,
+    // EPSG:3338
+    hawaii = (0, _conicEqualArea.default)().rotate([157, 0]).center([-3, 19.9]).parallels([8, 18]),
+    hawaiiPoint,
+    // ESRI:102007
+    point,
+    pointStream = {
+      point: function (x, y) {
+        point = [x, y];
+      }
+    };
+  function albersUsa(coordinates) {
+    var x = coordinates[0],
+      y = coordinates[1];
+    return point = null, (lower48Point.point(x, y), point) || (alaskaPoint.point(x, y), point) || (hawaiiPoint.point(x, y), point);
+  }
+  albersUsa.invert = function (coordinates) {
+    var k = lower48.scale(),
+      t = lower48.translate(),
+      x = (coordinates[0] - t[0]) / k,
+      y = (coordinates[1] - t[1]) / k;
+    return (y >= 0.120 && y < 0.234 && x >= -0.425 && x < -0.214 ? alaska : y >= 0.166 && y < 0.234 && x >= -0.214 && x < -0.115 ? hawaii : lower48).invert(coordinates);
+  };
+  albersUsa.stream = function (stream) {
+    return cache && cacheStream === stream ? cache : cache = multiplex([lower48.stream(cacheStream = stream), alaska.stream(stream), hawaii.stream(stream)]);
+  };
+  albersUsa.precision = function (_) {
+    if (!arguments.length) return lower48.precision();
+    lower48.precision(_), alaska.precision(_), hawaii.precision(_);
+    return reset();
+  };
+  albersUsa.scale = function (_) {
+    if (!arguments.length) return lower48.scale();
+    lower48.scale(_), alaska.scale(_ * 0.35), hawaii.scale(_);
+    return albersUsa.translate(lower48.translate());
+  };
+  albersUsa.translate = function (_) {
+    if (!arguments.length) return lower48.translate();
+    var k = lower48.scale(),
+      x = +_[0],
+      y = +_[1];
+    lower48Point = lower48.translate(_).clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]).stream(pointStream);
+    alaskaPoint = alaska.translate([x - 0.307 * k, y + 0.201 * k]).clipExtent([[x - 0.425 * k + _math.epsilon, y + 0.120 * k + _math.epsilon], [x - 0.214 * k - _math.epsilon, y + 0.234 * k - _math.epsilon]]).stream(pointStream);
+    hawaiiPoint = hawaii.translate([x - 0.205 * k, y + 0.212 * k]).clipExtent([[x - 0.214 * k + _math.epsilon, y + 0.166 * k + _math.epsilon], [x - 0.115 * k - _math.epsilon, y + 0.234 * k - _math.epsilon]]).stream(pointStream);
+    return reset();
+  };
+  albersUsa.fitExtent = function (extent, object) {
+    return (0, _fit.fitExtent)(albersUsa, extent, object);
+  };
+  albersUsa.fitSize = function (size, object) {
+    return (0, _fit.fitSize)(albersUsa, size, object);
+  };
+  albersUsa.fitWidth = function (width, object) {
+    return (0, _fit.fitWidth)(albersUsa, width, object);
+  };
+  albersUsa.fitHeight = function (height, object) {
+    return (0, _fit.fitHeight)(albersUsa, height, object);
+  };
+  function reset() {
+    cache = cacheStream = null;
+    return albersUsa;
+  }
+  return albersUsa.scale(1070);
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.azimuthalInvert = azimuthalInvert;
+exports.azimuthalRaw = azimuthalRaw;
+var _math = require("../math.js");
+function azimuthalRaw(scale) {
+  return function (x, y) {
+    var cx = (0, _math.cos)(x),
+      cy = (0, _math.cos)(y),
+      k = scale(cx * cy);
+    if (k === Infinity) return [2, 0];
+    return [k * cy * (0, _math.sin)(x), k * (0, _math.sin)(y)];
+  };
+}
+function azimuthalInvert(angle) {
+  return function (x, y) {
+    var z = (0, _math.sqrt)(x * x + y * y),
+      c = angle(z),
+      sc = (0, _math.sin)(c),
+      cc = (0, _math.cos)(c);
+    return [(0, _math.atan2)(x * sc, z * cc), (0, _math.asin)(z && y * sc / z)];
+  };
+}