@veritone-ce/design-system 2.8.12 → 2.8.13-next.1

package/dist/cjs/bundled_modules/d3-geo/src/projection/conic.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var math = require('../math.js');
+var index = require('./index.js');
+
+function conicProjection(projectAt) {
+  var phi0 = 0,
+      phi1 = math.pi / 3,
+      m = 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;
+}
+
+exports.conicProjection = conicProjection;

package/dist/cjs/bundled_modules/d3-geo/src/projection/conicConformal.js

@@ -0,0 +1,45 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var conic = require('./conic.js');
+var mercator = require('./mercator.js');
+
+function tany(y) {
+  return math.tan((math.halfPi + y) / 2);
+}
+
+function conicConformalRaw(y0, y1) {
+  var cy0 = math.cos(y0),
+      n = y0 === y1 ? math.sin(y0) : math.log(cy0 / math.cos(y1)) / math.log(tany(y1) / tany(y0)),
+      f = cy0 * 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 / math.pow(tany(y), n);
+    return [r * math.sin(n * x), f - r * math.cos(n * x)];
+  }
+
+  project.invert = function(x, y) {
+    var fy = f - y, r = math.sign(n) * math.sqrt(x * x + fy * fy),
+      l = math.atan2(x, math.abs(fy)) * math.sign(fy);
+    if (fy * n < 0)
+      l -= math.pi * math.sign(x) * math.sign(fy);
+    return [l / n, 2 * math.atan(math.pow(f / r, 1 / n)) - math.halfPi];
+  };
+
+  return project;
+}
+
+function geoConicConformal() {
+  return conic.conicProjection(conicConformalRaw)
+      .scale(109.5)
+      .parallels([30, 30]);
+}
+
+exports.conicConformalRaw = conicConformalRaw;
+exports.default = geoConicConformal;

package/dist/cjs/bundled_modules/d3-geo/src/projection/conicEqualArea.js

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

package/dist/cjs/bundled_modules/d3-geo/src/projection/conicEquidistant.js

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

package/dist/cjs/bundled_modules/d3-geo/src/projection/cylindricalEqualArea.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var math = require('../math.js');
+
+function cylindricalEqualAreaRaw(phi0) {
+  var cosPhi0 = math.cos(phi0);
+
+  function forward(lambda, phi) {
+    return [lambda * cosPhi0, math.sin(phi) / cosPhi0];
+  }
+
+  forward.invert = function(x, y) {
+    return [x / cosPhi0, math.asin(y * cosPhi0)];
+  };
+
+  return forward;
+}
+
+exports.cylindricalEqualAreaRaw = cylindricalEqualAreaRaw;

package/dist/cjs/bundled_modules/d3-geo/src/projection/equalEarth.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./index.js');
+var math = require('../math.js');
+
+var A1 = 1.340264,
+    A2 = -0.081106,
+    A3 = 0.000893,
+    A4 = 0.003796,
+    M = math.sqrt(3) / 2,
+    iterations = 12;
+
+function equalEarthRaw(lambda, phi) {
+  var l = math.asin(M * math.sin(phi)), l2 = l * l, l6 = l2 * l2 * l2;
+  return [
+    lambda * 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 (math.abs(delta) < math.epsilon2) break;
+  }
+  return [
+    M * x * (A1 + 3 * A2 * l2 + l6 * (7 * A3 + 9 * A4 * l2)) / math.cos(l),
+    math.asin(math.sin(l) / M)
+  ];
+};
+
+function geoEqualEarth() {
+  return index.default(equalEarthRaw)
+      .scale(177.158);
+}
+
+exports.default = geoEqualEarth;
+exports.equalEarthRaw = equalEarthRaw;

package/dist/cjs/bundled_modules/d3-geo/src/projection/equirectangular.js

@@ -0,0 +1,19 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = require('./index.js');
+
+function equirectangularRaw(lambda, phi) {
+  return [lambda, phi];
+}
+
+equirectangularRaw.invert = equirectangularRaw;
+
+function geoEquirectangular() {
+  return index.default(equirectangularRaw)
+      .scale(152.63);
+}
+
+exports.default = geoEquirectangular;
+exports.equirectangularRaw = equirectangularRaw;

package/dist/cjs/bundled_modules/d3-geo/src/projection/fit.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var stream = require('../stream.js');
+var bounds = 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);
+  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);
+}
+
+exports.fitExtent = fitExtent;
+exports.fitHeight = fitHeight;
+exports.fitSize = fitSize;
+exports.fitWidth = fitWidth;

package/dist/cjs/bundled_modules/d3-geo/src/projection/gnomonic.js

@@ -0,0 +1,23 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var azimuthal = require('./azimuthal.js');
+var index = require('./index.js');
+
+function gnomonicRaw(x, y) {
+  var cy = math.cos(y), k = math.cos(x) * cy;
+  return [cy * math.sin(x) / k, math.sin(y) / k];
+}
+
+gnomonicRaw.invert = azimuthal.azimuthalInvert(math.atan);
+
+function geoGnomonic() {
+  return index.default(gnomonicRaw)
+      .scale(144.049)
+      .clipAngle(60);
+}
+
+exports.default = geoGnomonic;
+exports.gnomonicRaw = gnomonicRaw;

package/dist/cjs/bundled_modules/d3-geo/src/projection/identity.js

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var rectangle = require('../clip/rectangle.js');
+var identity = require('../identity.js');
+var transform = require('../transform.js');
+var fit = require('./fit.js');
+var math = require('../math.js');
+
+function geoIdentity() {
+  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$1 = 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$1(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) : 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 = math.sin(alpha), ca = 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 fit.fitExtent(projection, extent, object);
+  };
+  projection.fitSize = function(size, object) {
+    return fit.fitSize(projection, size, object);
+  };
+  projection.fitWidth = function(width, object) {
+    return fit.fitWidth(projection, width, object);
+  };
+  projection.fitHeight = function(height, object) {
+    return fit.fitHeight(projection, height, object);
+  };
+
+  return projection;
+}
+
+exports.default = geoIdentity;

package/dist/cjs/bundled_modules/d3-geo/src/projection/index.js

@@ -0,0 +1,184 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var antimeridian = require('../clip/antimeridian.js');
+var circle = require('../clip/circle.js');
+var rectangle = require('../clip/rectangle.js');
+var compose = require('../compose.js');
+var identity = 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 = require('./resample.js');
+
+var transformRadians = transform.transformer({
+  point: function(x, y) {
+    this.stream.point(x * math.radians, y * math.radians);
+  }
+});
+
+function transformRotate(rotate) {
+  return 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 = math.cos(alpha),
+      sinAlpha = 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 = +_ ? 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) : 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 = resample.default(projectTransform, delta2 = _ * _), reset()) : math.sqrt(delta2);
+  };
+
+  projection.fitExtent = function(extent, object) {
+    return fit.fitExtent(projection, extent, object);
+  };
+
+  projection.fitSize = function(size, object) {
+    return fit.fitSize(projection, size, object);
+  };
+
+  projection.fitWidth = function(width, object) {
+    return fit.fitWidth(projection, width, object);
+  };
+
+  projection.fitHeight = function(height, object) {
+    return 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 = rotation.rotateRadians(deltaLambda, deltaPhi, deltaGamma);
+    projectTransform = compose.default(project, transform);
+    projectRotateTransform = compose.default(rotate, projectTransform);
+    projectResample = 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();
+  };
+}
+
+exports.default = projection;
+exports.projectionMutator = projectionMutator;

package/dist/cjs/bundled_modules/d3-geo/src/projection/mercator.js

@@ -0,0 +1,60 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var math = require('../math.js');
+var rotation = require('../rotation.js');
+var index = require('./index.js');
+
+function mercatorRaw(lambda, phi) {
+  return [lambda, math.log(math.tan((math.halfPi + phi) / 2))];
+}
+
+mercatorRaw.invert = function(x, y) {
+  return [x, 2 * math.atan(math.exp(y)) - math.halfPi];
+};
+
+function geoMercator() {
+  return mercatorProjection(mercatorRaw)
+      .scale(961 / math.tau);
+}
+
+function mercatorProjection(project) {
+  var m = 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(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();
+}
+
+exports.default = geoMercator;
+exports.mercatorProjection = mercatorProjection;
+exports.mercatorRaw = mercatorRaw;

package/dist/cjs/bundled_modules/d3-geo/src/projection/naturalEarth1.js

@@ -0,0 +1,35 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var index = 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 (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 geoNaturalEarth1() {
+  return index.default(naturalEarth1Raw)
+      .scale(175.295);
+}
+
+exports.default = geoNaturalEarth1;
+exports.naturalEarth1Raw = naturalEarth1Raw;