@mui/x-charts-vendor 9.0.0 → 9.4.0

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

@@ -0,0 +1,95 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _polygonContains = _interopRequireDefault(require("./polygonContains.js"));
+var _distance = _interopRequireDefault(require("./distance.js"));
+var _math = require("./math.js");
+var containsObjectType = {
+  Feature: function (object, point) {
+    return containsGeometry(object.geometry, point);
+  },
+  FeatureCollection: function (object, point) {
+    var features = object.features,
+      i = -1,
+      n = features.length;
+    while (++i < n) if (containsGeometry(features[i].geometry, point)) return true;
+    return false;
+  }
+};
+var containsGeometryType = {
+  Sphere: function () {
+    return true;
+  },
+  Point: function (object, point) {
+    return containsPoint(object.coordinates, point);
+  },
+  MultiPoint: function (object, point) {
+    var coordinates = object.coordinates,
+      i = -1,
+      n = coordinates.length;
+    while (++i < n) if (containsPoint(coordinates[i], point)) return true;
+    return false;
+  },
+  LineString: function (object, point) {
+    return containsLine(object.coordinates, point);
+  },
+  MultiLineString: function (object, point) {
+    var coordinates = object.coordinates,
+      i = -1,
+      n = coordinates.length;
+    while (++i < n) if (containsLine(coordinates[i], point)) return true;
+    return false;
+  },
+  Polygon: function (object, point) {
+    return containsPolygon(object.coordinates, point);
+  },
+  MultiPolygon: function (object, point) {
+    var coordinates = object.coordinates,
+      i = -1,
+      n = coordinates.length;
+    while (++i < n) if (containsPolygon(coordinates[i], point)) return true;
+    return false;
+  },
+  GeometryCollection: function (object, point) {
+    var geometries = object.geometries,
+      i = -1,
+      n = geometries.length;
+    while (++i < n) if (containsGeometry(geometries[i], point)) return true;
+    return false;
+  }
+};
+function containsGeometry(geometry, point) {
+  return geometry && containsGeometryType.hasOwnProperty(geometry.type) ? containsGeometryType[geometry.type](geometry, point) : false;
+}
+function containsPoint(coordinates, point) {
+  return (0, _distance.default)(coordinates, point) === 0;
+}
+function containsLine(coordinates, point) {
+  var ao, bo, ab;
+  for (var i = 0, n = coordinates.length; i < n; i++) {
+    bo = (0, _distance.default)(coordinates[i], point);
+    if (bo === 0) return true;
+    if (i > 0) {
+      ab = (0, _distance.default)(coordinates[i], coordinates[i - 1]);
+      if (ab > 0 && ao <= ab && bo <= ab && (ao + bo - ab) * (1 - Math.pow((ao - bo) / ab, 2)) < _math.epsilon2 * ab) return true;
+    }
+    ao = bo;
+  }
+  return false;
+}
+function containsPolygon(coordinates, point) {
+  return !!(0, _polygonContains.default)(coordinates.map(ringRadians), pointRadians(point));
+}
+function ringRadians(ring) {
+  return ring = ring.map(pointRadians), ring.pop(), ring;
+}
+function pointRadians(point) {
+  return [point[0] * _math.radians, point[1] * _math.radians];
+}
+function _default(object, point) {
+  return (object && containsObjectType.hasOwnProperty(object.type) ? containsObjectType[object.type] : containsGeometry)(object, point);
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _length = _interopRequireDefault(require("./length.js"));
+var coordinates = [null, null],
+  object = {
+    type: "LineString",
+    coordinates: coordinates
+  };
+function _default(a, b) {
+  coordinates[0] = a;
+  coordinates[1] = b;
+  return (0, _length.default)(object);
+}

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

@@ -0,0 +1,118 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = graticule;
+exports.graticule10 = graticule10;
+var _index = require("../../d3-array/src/index.js");
+var _math = require("./math.js");
+function graticuleX(y0, y1, dy) {
+  var y = (0, _index.range)(y0, y1 - _math.epsilon, dy).concat(y1);
+  return function (x) {
+    return y.map(function (y) {
+      return [x, y];
+    });
+  };
+}
+function graticuleY(x0, x1, dx) {
+  var x = (0, _index.range)(x0, x1 - _math.epsilon, dx).concat(x1);
+  return function (y) {
+    return x.map(function (x) {
+      return [x, y];
+    });
+  };
+}
+function graticule() {
+  var x1,
+    x0,
+    X1,
+    X0,
+    y1,
+    y0,
+    Y1,
+    Y0,
+    dx = 10,
+    dy = dx,
+    DX = 90,
+    DY = 360,
+    x,
+    y,
+    X,
+    Y,
+    precision = 2.5;
+  function graticule() {
+    return {
+      type: "MultiLineString",
+      coordinates: lines()
+    };
+  }
+  function lines() {
+    return (0, _index.range)((0, _math.ceil)(X0 / DX) * DX, X1, DX).map(X).concat((0, _index.range)((0, _math.ceil)(Y0 / DY) * DY, Y1, DY).map(Y)).concat((0, _index.range)((0, _math.ceil)(x0 / dx) * dx, x1, dx).filter(function (x) {
+      return (0, _math.abs)(x % DX) > _math.epsilon;
+    }).map(x)).concat((0, _index.range)((0, _math.ceil)(y0 / dy) * dy, y1, dy).filter(function (y) {
+      return (0, _math.abs)(y % DY) > _math.epsilon;
+    }).map(y));
+  }
+  graticule.lines = function () {
+    return lines().map(function (coordinates) {
+      return {
+        type: "LineString",
+        coordinates: coordinates
+      };
+    });
+  };
+  graticule.outline = function () {
+    return {
+      type: "Polygon",
+      coordinates: [X(X0).concat(Y(Y1).slice(1), X(X1).reverse().slice(1), Y(Y0).reverse().slice(1))]
+    };
+  };
+  graticule.extent = function (_) {
+    if (!arguments.length) return graticule.extentMinor();
+    return graticule.extentMajor(_).extentMinor(_);
+  };
+  graticule.extentMajor = function (_) {
+    if (!arguments.length) return [[X0, Y0], [X1, Y1]];
+    X0 = +_[0][0], X1 = +_[1][0];
+    Y0 = +_[0][1], Y1 = +_[1][1];
+    if (X0 > X1) _ = X0, X0 = X1, X1 = _;
+    if (Y0 > Y1) _ = Y0, Y0 = Y1, Y1 = _;
+    return graticule.precision(precision);
+  };
+  graticule.extentMinor = function (_) {
+    if (!arguments.length) return [[x0, y0], [x1, y1]];
+    x0 = +_[0][0], x1 = +_[1][0];
+    y0 = +_[0][1], y1 = +_[1][1];
+    if (x0 > x1) _ = x0, x0 = x1, x1 = _;
+    if (y0 > y1) _ = y0, y0 = y1, y1 = _;
+    return graticule.precision(precision);
+  };
+  graticule.step = function (_) {
+    if (!arguments.length) return graticule.stepMinor();
+    return graticule.stepMajor(_).stepMinor(_);
+  };
+  graticule.stepMajor = function (_) {
+    if (!arguments.length) return [DX, DY];
+    DX = +_[0], DY = +_[1];
+    return graticule;
+  };
+  graticule.stepMinor = function (_) {
+    if (!arguments.length) return [dx, dy];
+    dx = +_[0], dy = +_[1];
+    return graticule;
+  };
+  graticule.precision = function (_) {
+    if (!arguments.length) return precision;
+    precision = +_;
+    x = graticuleX(y0, y1, 90);
+    y = graticuleY(x0, x1, precision);
+    X = graticuleX(Y0, Y1, 90);
+    Y = graticuleY(X0, X1, precision);
+    return graticule;
+  };
+  return graticule.extentMajor([[-180, -90 + _math.epsilon], [180, 90 - _math.epsilon]]).extentMinor([[-180, -80 - _math.epsilon], [180, 80 + _math.epsilon]]);
+}
+function graticule10() {
+  return graticule()();
+}

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

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = x => x;
+exports.default = _default;

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

@@ -0,0 +1,335 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard").default;
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "geoAlbers", {
+  enumerable: true,
+  get: function () {
+    return _albers.default;
+  }
+});
+Object.defineProperty(exports, "geoAlbersUsa", {
+  enumerable: true,
+  get: function () {
+    return _albersUsa.default;
+  }
+});
+Object.defineProperty(exports, "geoArea", {
+  enumerable: true,
+  get: function () {
+    return _area.default;
+  }
+});
+Object.defineProperty(exports, "geoAzimuthalEqualArea", {
+  enumerable: true,
+  get: function () {
+    return _azimuthalEqualArea.default;
+  }
+});
+Object.defineProperty(exports, "geoAzimuthalEqualAreaRaw", {
+  enumerable: true,
+  get: function () {
+    return _azimuthalEqualArea.azimuthalEqualAreaRaw;
+  }
+});
+Object.defineProperty(exports, "geoAzimuthalEquidistant", {
+  enumerable: true,
+  get: function () {
+    return _azimuthalEquidistant.default;
+  }
+});
+Object.defineProperty(exports, "geoAzimuthalEquidistantRaw", {
+  enumerable: true,
+  get: function () {
+    return _azimuthalEquidistant.azimuthalEquidistantRaw;
+  }
+});
+Object.defineProperty(exports, "geoBounds", {
+  enumerable: true,
+  get: function () {
+    return _bounds.default;
+  }
+});
+Object.defineProperty(exports, "geoCentroid", {
+  enumerable: true,
+  get: function () {
+    return _centroid.default;
+  }
+});
+Object.defineProperty(exports, "geoCircle", {
+  enumerable: true,
+  get: function () {
+    return _circle.default;
+  }
+});
+Object.defineProperty(exports, "geoClipAntimeridian", {
+  enumerable: true,
+  get: function () {
+    return _antimeridian.default;
+  }
+});
+Object.defineProperty(exports, "geoClipCircle", {
+  enumerable: true,
+  get: function () {
+    return _circle2.default;
+  }
+});
+Object.defineProperty(exports, "geoClipExtent", {
+  enumerable: true,
+  get: function () {
+    return _extent.default;
+  }
+});
+Object.defineProperty(exports, "geoClipRectangle", {
+  enumerable: true,
+  get: function () {
+    return _rectangle.default;
+  }
+});
+Object.defineProperty(exports, "geoConicConformal", {
+  enumerable: true,
+  get: function () {
+    return _conicConformal.default;
+  }
+});
+Object.defineProperty(exports, "geoConicConformalRaw", {
+  enumerable: true,
+  get: function () {
+    return _conicConformal.conicConformalRaw;
+  }
+});
+Object.defineProperty(exports, "geoConicEqualArea", {
+  enumerable: true,
+  get: function () {
+    return _conicEqualArea.default;
+  }
+});
+Object.defineProperty(exports, "geoConicEqualAreaRaw", {
+  enumerable: true,
+  get: function () {
+    return _conicEqualArea.conicEqualAreaRaw;
+  }
+});
+Object.defineProperty(exports, "geoConicEquidistant", {
+  enumerable: true,
+  get: function () {
+    return _conicEquidistant.default;
+  }
+});
+Object.defineProperty(exports, "geoConicEquidistantRaw", {
+  enumerable: true,
+  get: function () {
+    return _conicEquidistant.conicEquidistantRaw;
+  }
+});
+Object.defineProperty(exports, "geoContains", {
+  enumerable: true,
+  get: function () {
+    return _contains.default;
+  }
+});
+Object.defineProperty(exports, "geoDistance", {
+  enumerable: true,
+  get: function () {
+    return _distance.default;
+  }
+});
+Object.defineProperty(exports, "geoEqualEarth", {
+  enumerable: true,
+  get: function () {
+    return _equalEarth.default;
+  }
+});
+Object.defineProperty(exports, "geoEqualEarthRaw", {
+  enumerable: true,
+  get: function () {
+    return _equalEarth.equalEarthRaw;
+  }
+});
+Object.defineProperty(exports, "geoEquirectangular", {
+  enumerable: true,
+  get: function () {
+    return _equirectangular.default;
+  }
+});
+Object.defineProperty(exports, "geoEquirectangularRaw", {
+  enumerable: true,
+  get: function () {
+    return _equirectangular.equirectangularRaw;
+  }
+});
+Object.defineProperty(exports, "geoGnomonic", {
+  enumerable: true,
+  get: function () {
+    return _gnomonic.default;
+  }
+});
+Object.defineProperty(exports, "geoGnomonicRaw", {
+  enumerable: true,
+  get: function () {
+    return _gnomonic.gnomonicRaw;
+  }
+});
+Object.defineProperty(exports, "geoGraticule", {
+  enumerable: true,
+  get: function () {
+    return _graticule.default;
+  }
+});
+Object.defineProperty(exports, "geoGraticule10", {
+  enumerable: true,
+  get: function () {
+    return _graticule.graticule10;
+  }
+});
+Object.defineProperty(exports, "geoIdentity", {
+  enumerable: true,
+  get: function () {
+    return _identity.default;
+  }
+});
+Object.defineProperty(exports, "geoInterpolate", {
+  enumerable: true,
+  get: function () {
+    return _interpolate.default;
+  }
+});
+Object.defineProperty(exports, "geoLength", {
+  enumerable: true,
+  get: function () {
+    return _length.default;
+  }
+});
+Object.defineProperty(exports, "geoMercator", {
+  enumerable: true,
+  get: function () {
+    return _mercator.default;
+  }
+});
+Object.defineProperty(exports, "geoMercatorRaw", {
+  enumerable: true,
+  get: function () {
+    return _mercator.mercatorRaw;
+  }
+});
+Object.defineProperty(exports, "geoNaturalEarth1", {
+  enumerable: true,
+  get: function () {
+    return _naturalEarth.default;
+  }
+});
+Object.defineProperty(exports, "geoNaturalEarth1Raw", {
+  enumerable: true,
+  get: function () {
+    return _naturalEarth.naturalEarth1Raw;
+  }
+});
+Object.defineProperty(exports, "geoOrthographic", {
+  enumerable: true,
+  get: function () {
+    return _orthographic.default;
+  }
+});
+Object.defineProperty(exports, "geoOrthographicRaw", {
+  enumerable: true,
+  get: function () {
+    return _orthographic.orthographicRaw;
+  }
+});
+Object.defineProperty(exports, "geoPath", {
+  enumerable: true,
+  get: function () {
+    return _index.default;
+  }
+});
+Object.defineProperty(exports, "geoProjection", {
+  enumerable: true,
+  get: function () {
+    return _index2.default;
+  }
+});
+Object.defineProperty(exports, "geoProjectionMutator", {
+  enumerable: true,
+  get: function () {
+    return _index2.projectionMutator;
+  }
+});
+Object.defineProperty(exports, "geoRotation", {
+  enumerable: true,
+  get: function () {
+    return _rotation.default;
+  }
+});
+Object.defineProperty(exports, "geoStereographic", {
+  enumerable: true,
+  get: function () {
+    return _stereographic.default;
+  }
+});
+Object.defineProperty(exports, "geoStereographicRaw", {
+  enumerable: true,
+  get: function () {
+    return _stereographic.stereographicRaw;
+  }
+});
+Object.defineProperty(exports, "geoStream", {
+  enumerable: true,
+  get: function () {
+    return _stream.default;
+  }
+});
+Object.defineProperty(exports, "geoTransform", {
+  enumerable: true,
+  get: function () {
+    return _transform.default;
+  }
+});
+Object.defineProperty(exports, "geoTransverseMercator", {
+  enumerable: true,
+  get: function () {
+    return _transverseMercator.default;
+  }
+});
+Object.defineProperty(exports, "geoTransverseMercatorRaw", {
+  enumerable: true,
+  get: function () {
+    return _transverseMercator.transverseMercatorRaw;
+  }
+});
+var _area = _interopRequireDefault(require("./area.js"));
+var _bounds = _interopRequireDefault(require("./bounds.js"));
+var _centroid = _interopRequireDefault(require("./centroid.js"));
+var _circle = _interopRequireDefault(require("./circle.js"));
+var _antimeridian = _interopRequireDefault(require("./clip/antimeridian.js"));
+var _circle2 = _interopRequireDefault(require("./clip/circle.js"));
+var _extent = _interopRequireDefault(require("./clip/extent.js"));
+var _rectangle = _interopRequireDefault(require("./clip/rectangle.js"));
+var _contains = _interopRequireDefault(require("./contains.js"));
+var _distance = _interopRequireDefault(require("./distance.js"));
+var _graticule = _interopRequireWildcard(require("./graticule.js"));
+var _interpolate = _interopRequireDefault(require("./interpolate.js"));
+var _length = _interopRequireDefault(require("./length.js"));
+var _index = _interopRequireDefault(require("./path/index.js"));
+var _albers = _interopRequireDefault(require("./projection/albers.js"));
+var _albersUsa = _interopRequireDefault(require("./projection/albersUsa.js"));
+var _azimuthalEqualArea = _interopRequireWildcard(require("./projection/azimuthalEqualArea.js"));
+var _azimuthalEquidistant = _interopRequireWildcard(require("./projection/azimuthalEquidistant.js"));
+var _conicConformal = _interopRequireWildcard(require("./projection/conicConformal.js"));
+var _conicEqualArea = _interopRequireWildcard(require("./projection/conicEqualArea.js"));
+var _conicEquidistant = _interopRequireWildcard(require("./projection/conicEquidistant.js"));
+var _equalEarth = _interopRequireWildcard(require("./projection/equalEarth.js"));
+var _equirectangular = _interopRequireWildcard(require("./projection/equirectangular.js"));
+var _gnomonic = _interopRequireWildcard(require("./projection/gnomonic.js"));
+var _identity = _interopRequireDefault(require("./projection/identity.js"));
+var _index2 = _interopRequireWildcard(require("./projection/index.js"));
+var _mercator = _interopRequireWildcard(require("./projection/mercator.js"));
+var _naturalEarth = _interopRequireWildcard(require("./projection/naturalEarth1.js"));
+var _orthographic = _interopRequireWildcard(require("./projection/orthographic.js"));
+var _stereographic = _interopRequireWildcard(require("./projection/stereographic.js"));
+var _transverseMercator = _interopRequireWildcard(require("./projection/transverseMercator.js"));
+var _rotation = _interopRequireDefault(require("./rotation.js"));
+var _stream = _interopRequireDefault(require("./stream.js"));
+var _transform = _interopRequireDefault(require("./transform.js"));

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

@@ -0,0 +1,35 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = _default;
+var _math = require("./math.js");
+function _default(a, b) {
+  var x0 = a[0] * _math.radians,
+    y0 = a[1] * _math.radians,
+    x1 = b[0] * _math.radians,
+    y1 = b[1] * _math.radians,
+    cy0 = (0, _math.cos)(y0),
+    sy0 = (0, _math.sin)(y0),
+    cy1 = (0, _math.cos)(y1),
+    sy1 = (0, _math.sin)(y1),
+    kx0 = cy0 * (0, _math.cos)(x0),
+    ky0 = cy0 * (0, _math.sin)(x0),
+    kx1 = cy1 * (0, _math.cos)(x1),
+    ky1 = cy1 * (0, _math.sin)(x1),
+    d = 2 * (0, _math.asin)((0, _math.sqrt)((0, _math.haversin)(y1 - y0) + cy0 * cy1 * (0, _math.haversin)(x1 - x0))),
+    k = (0, _math.sin)(d);
+  var interpolate = d ? function (t) {
+    var B = (0, _math.sin)(t *= d) / k,
+      A = (0, _math.sin)(d - t) / k,
+      x = A * kx0 + B * kx1,
+      y = A * ky0 + B * ky1,
+      z = A * sy0 + B * sy1;
+    return [(0, _math.atan2)(y, x) * _math.degrees, (0, _math.atan2)(z, (0, _math.sqrt)(x * x + y * y)) * _math.degrees];
+  } : function () {
+    return [x0 * _math.degrees, y0 * _math.degrees];
+  };
+  interpolate.distance = d;
+  return interpolate;
+}

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

@@ -0,0 +1,50 @@
+"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 lengthSum, lambda0, sinPhi0, cosPhi0;
+var lengthStream = {
+  sphere: _noop.default,
+  point: _noop.default,
+  lineStart: lengthLineStart,
+  lineEnd: _noop.default,
+  polygonStart: _noop.default,
+  polygonEnd: _noop.default
+};
+function lengthLineStart() {
+  lengthStream.point = lengthPointFirst;
+  lengthStream.lineEnd = lengthLineEnd;
+}
+function lengthLineEnd() {
+  lengthStream.point = lengthStream.lineEnd = _noop.default;
+}
+function lengthPointFirst(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  lambda0 = lambda, sinPhi0 = (0, _math.sin)(phi), cosPhi0 = (0, _math.cos)(phi);
+  lengthStream.point = lengthPoint;
+}
+function lengthPoint(lambda, phi) {
+  lambda *= _math.radians, phi *= _math.radians;
+  var sinPhi = (0, _math.sin)(phi),
+    cosPhi = (0, _math.cos)(phi),
+    delta = (0, _math.abs)(lambda - lambda0),
+    cosDelta = (0, _math.cos)(delta),
+    sinDelta = (0, _math.sin)(delta),
+    x = cosPhi * sinDelta,
+    y = cosPhi0 * sinPhi - sinPhi0 * cosPhi * cosDelta,
+    z = sinPhi0 * sinPhi + cosPhi0 * cosPhi * cosDelta;
+  lengthSum.add((0, _math.atan2)((0, _math.sqrt)(x * x + y * y), z));
+  lambda0 = lambda, sinPhi0 = sinPhi, cosPhi0 = cosPhi;
+}
+function _default(object) {
+  lengthSum = new _index.Adder();
+  (0, _stream.default)(object, lengthStream);
+  return +lengthSum;
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.abs = void 0;
+exports.acos = acos;
+exports.asin = asin;
+exports.halfPi = exports.floor = exports.exp = exports.epsilon2 = exports.epsilon = exports.degrees = exports.cos = exports.ceil = exports.atan2 = exports.atan = void 0;
+exports.haversin = haversin;
+exports.tau = exports.tan = exports.sqrt = exports.sin = exports.sign = exports.radians = exports.quarterPi = exports.pow = exports.pi = exports.log = exports.hypot = void 0;
+var epsilon = exports.epsilon = 1e-6;
+var epsilon2 = exports.epsilon2 = 1e-12;
+var pi = exports.pi = Math.PI;
+var halfPi = exports.halfPi = pi / 2;
+var quarterPi = exports.quarterPi = pi / 4;
+var tau = exports.tau = pi * 2;
+var degrees = exports.degrees = 180 / pi;
+var radians = exports.radians = pi / 180;
+var abs = exports.abs = Math.abs;
+var atan = exports.atan = Math.atan;
+var atan2 = exports.atan2 = Math.atan2;
+var cos = exports.cos = Math.cos;
+var ceil = exports.ceil = Math.ceil;
+var exp = exports.exp = Math.exp;
+var floor = exports.floor = Math.floor;
+var hypot = exports.hypot = Math.hypot;
+var log = exports.log = Math.log;
+var pow = exports.pow = Math.pow;
+var sin = exports.sin = Math.sin;
+var sign = exports.sign = Math.sign || function (x) {
+  return x > 0 ? 1 : x < 0 ? -1 : 0;
+};
+var sqrt = exports.sqrt = Math.sqrt;
+var tan = exports.tan = Math.tan;
+function acos(x) {
+  return x > 1 ? 0 : x < -1 ? pi : Math.acos(x);
+}
+function asin(x) {
+  return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);
+}
+function haversin(x) {
+  return (x = sin(x / 2)) * x;
+}