mirage2d 1.1.2 → 1.1.4

package/dist/js/_d3-geo@1.7.1@d3-geo/_d3-geo@1.7.1@d3-geo.7d357be1.js

@@ -1,1094 +0,0 @@
-import { m as merge } from "../_d3-array@1.2.4@d3-array/_d3-array@1.2.4@d3-array.d606df6b.js";
-function adder() {
-  return new Adder();
-}
-function Adder() {
-  this.reset();
-}
-Adder.prototype = {
-  constructor: Adder,
-  reset: function() {
-    this.s = this.t = 0;
-  },
-  add: function(y) {
-    add(temp, y, this.t);
-    add(this, temp.s, this.s);
-    if (this.s)
-      this.t += temp.t;
-    else
-      this.s = temp.t;
-  },
-  valueOf: function() {
-    return this.s;
-  }
-};
-var temp = new Adder();
-function add(adder2, a, b) {
-  var x = adder2.s = a + b, bv = x - a, av = x - bv;
-  adder2.t = a - av + (b - bv);
-}
-var epsilon = 1e-6;
-var pi = Math.PI;
-var halfPi = pi / 2;
-var quarterPi = pi / 4;
-var tau = pi * 2;
-var degrees = 180 / pi;
-var radians = pi / 180;
-var abs = Math.abs;
-var atan = Math.atan;
-var atan2 = Math.atan2;
-var cos = Math.cos;
-var sin = Math.sin;
-var sqrt = Math.sqrt;
-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 noop() {
-}
-function streamGeometry(geometry, stream) {
-  if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {
-    streamGeometryType[geometry.type](geometry, stream);
-  }
-}
-var streamObjectType = {
-  Feature: function(object, stream) {
-    streamGeometry(object.geometry, stream);
-  },
-  FeatureCollection: function(object, stream) {
-    var features = object.features, i = -1, n = features.length;
-    while (++i < n)
-      streamGeometry(features[i].geometry, stream);
-  }
-};
-var streamGeometryType = {
-  Sphere: function(object, stream) {
-    stream.sphere();
-  },
-  Point: function(object, stream) {
-    object = object.coordinates;
-    stream.point(object[0], object[1], object[2]);
-  },
-  MultiPoint: function(object, stream) {
-    var coordinates = object.coordinates, i = -1, n = coordinates.length;
-    while (++i < n)
-      object = coordinates[i], stream.point(object[0], object[1], object[2]);
-  },
-  LineString: function(object, stream) {
-    streamLine(object.coordinates, stream, 0);
-  },
-  MultiLineString: function(object, stream) {
-    var coordinates = object.coordinates, i = -1, n = coordinates.length;
-    while (++i < n)
-      streamLine(coordinates[i], stream, 0);
-  },
-  Polygon: function(object, stream) {
-    streamPolygon(object.coordinates, stream);
-  },
-  MultiPolygon: function(object, stream) {
-    var coordinates = object.coordinates, i = -1, n = coordinates.length;
-    while (++i < n)
-      streamPolygon(coordinates[i], stream);
-  },
-  GeometryCollection: function(object, stream) {
-    var geometries = object.geometries, i = -1, n = geometries.length;
-    while (++i < n)
-      streamGeometry(geometries[i], stream);
-  }
-};
-function streamLine(coordinates, stream, closed) {
-  var i = -1, n = coordinates.length - closed, coordinate;
-  stream.lineStart();
-  while (++i < n)
-    coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
-  stream.lineEnd();
-}
-function streamPolygon(coordinates, stream) {
-  var i = -1, n = coordinates.length;
-  stream.polygonStart();
-  while (++i < n)
-    streamLine(coordinates[i], stream, 1);
-  stream.polygonEnd();
-}
-function geoStream(object, stream) {
-  if (object && streamObjectType.hasOwnProperty(object.type)) {
-    streamObjectType[object.type](object, stream);
-  } else {
-    streamGeometry(object, stream);
-  }
-}
-adder();
-adder();
-function spherical(cartesian2) {
-  return [atan2(cartesian2[1], cartesian2[0]), asin(cartesian2[2])];
-}
-function cartesian(spherical2) {
-  var lambda = spherical2[0], phi = spherical2[1], cosPhi = cos(phi);
-  return [cosPhi * cos(lambda), cosPhi * sin(lambda), sin(phi)];
-}
-function cartesianDot(a, b) {
-  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-}
-function cartesianCross(a, b) {
-  return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
-}
-function cartesianAddInPlace(a, b) {
-  a[0] += b[0], a[1] += b[1], a[2] += b[2];
-}
-function cartesianScale(vector, k) {
-  return [vector[0] * k, vector[1] * k, vector[2] * k];
-}
-function cartesianNormalizeInPlace(d) {
-  var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
-  d[0] /= l, d[1] /= l, d[2] /= l;
-}
-adder();
-function compose(a, b) {
-  function compose2(x, y) {
-    return x = a(x, y), b(x[0], x[1]);
-  }
-  if (a.invert && b.invert)
-    compose2.invert = function(x, y) {
-      return x = b.invert(x, y), x && a.invert(x[0], x[1]);
-    };
-  return compose2;
-}
-function rotationIdentity(lambda, phi) {
-  return [lambda > pi ? lambda - tau : lambda < -pi ? lambda + tau : lambda, phi];
-}
-rotationIdentity.invert = rotationIdentity;
-function rotateRadians(deltaLambda, deltaPhi, deltaGamma) {
-  return (deltaLambda %= tau) ? deltaPhi || deltaGamma ? compose(rotationLambda(deltaLambda), rotationPhiGamma(deltaPhi, deltaGamma)) : rotationLambda(deltaLambda) : deltaPhi || deltaGamma ? rotationPhiGamma(deltaPhi, deltaGamma) : rotationIdentity;
-}
-function forwardRotationLambda(deltaLambda) {
-  return function(lambda, phi) {
-    return lambda += deltaLambda, [lambda > pi ? lambda - tau : lambda < -pi ? lambda + tau : lambda, phi];
-  };
-}
-function rotationLambda(deltaLambda) {
-  var rotation = forwardRotationLambda(deltaLambda);
-  rotation.invert = forwardRotationLambda(-deltaLambda);
-  return rotation;
-}
-function rotationPhiGamma(deltaPhi, deltaGamma) {
-  var cosDeltaPhi = cos(deltaPhi), sinDeltaPhi = sin(deltaPhi), cosDeltaGamma = cos(deltaGamma), sinDeltaGamma = sin(deltaGamma);
-  function rotation(lambda, phi) {
-    var cosPhi = cos(phi), x = cos(lambda) * cosPhi, y = sin(lambda) * cosPhi, z = sin(phi), k = z * cosDeltaPhi + x * sinDeltaPhi;
-    return [
-      atan2(y * cosDeltaGamma - k * sinDeltaGamma, x * cosDeltaPhi - z * sinDeltaPhi),
-      asin(k * cosDeltaGamma + y * sinDeltaGamma)
-    ];
-  }
-  rotation.invert = function(lambda, phi) {
-    var cosPhi = cos(phi), x = cos(lambda) * cosPhi, y = sin(lambda) * cosPhi, z = sin(phi), k = z * cosDeltaGamma - y * sinDeltaGamma;
-    return [
-      atan2(y * cosDeltaGamma + z * sinDeltaGamma, x * cosDeltaPhi + k * sinDeltaPhi),
-      asin(k * cosDeltaPhi - x * sinDeltaPhi)
-    ];
-  };
-  return rotation;
-}
-function circleStream(stream, radius, delta, direction, t0, t1) {
-  if (!delta)
-    return;
-  var cosRadius = cos(radius), sinRadius = sin(radius), step = direction * delta;
-  if (t0 == null) {
-    t0 = radius + direction * tau;
-    t1 = radius - step / 2;
-  } else {
-    t0 = circleRadius(cosRadius, t0);
-    t1 = circleRadius(cosRadius, t1);
-    if (direction > 0 ? t0 < t1 : t0 > t1)
-      t0 += direction * tau;
-  }
-  for (var point, t = t0; direction > 0 ? t > t1 : t < t1; t -= step) {
-    point = spherical([cosRadius, -sinRadius * cos(t), -sinRadius * sin(t)]);
-    stream.point(point[0], point[1]);
-  }
-}
-function circleRadius(cosRadius, point) {
-  point = cartesian(point), point[0] -= cosRadius;
-  cartesianNormalizeInPlace(point);
-  var radius = acos(-point[1]);
-  return ((-point[2] < 0 ? -radius : radius) + tau - epsilon) % tau;
-}
-function clipBuffer() {
-  var lines = [], line;
-  return {
-    point: function(x, y) {
-      line.push([x, y]);
-    },
-    lineStart: function() {
-      lines.push(line = []);
-    },
-    lineEnd: noop,
-    rejoin: function() {
-      if (lines.length > 1)
-        lines.push(lines.pop().concat(lines.shift()));
-    },
-    result: function() {
-      var result = lines;
-      lines = [];
-      line = null;
-      return result;
-    }
-  };
-}
-function clipLine(a, b, x02, y02, x12, y12) {
-  var ax = a[0], ay = a[1], bx = b[0], by = b[1], t0 = 0, t1 = 1, dx = bx - ax, dy = by - ay, r;
-  r = x02 - ax;
-  if (!dx && r > 0)
-    return;
-  r /= dx;
-  if (dx < 0) {
-    if (r < t0)
-      return;
-    if (r < t1)
-      t1 = r;
-  } else if (dx > 0) {
-    if (r > t1)
-      return;
-    if (r > t0)
-      t0 = r;
-  }
-  r = x12 - ax;
-  if (!dx && r < 0)
-    return;
-  r /= dx;
-  if (dx < 0) {
-    if (r > t1)
-      return;
-    if (r > t0)
-      t0 = r;
-  } else if (dx > 0) {
-    if (r < t0)
-      return;
-    if (r < t1)
-      t1 = r;
-  }
-  r = y02 - ay;
-  if (!dy && r > 0)
-    return;
-  r /= dy;
-  if (dy < 0) {
-    if (r < t0)
-      return;
-    if (r < t1)
-      t1 = r;
-  } else if (dy > 0) {
-    if (r > t1)
-      return;
-    if (r > t0)
-      t0 = r;
-  }
-  r = y12 - ay;
-  if (!dy && r < 0)
-    return;
-  r /= dy;
-  if (dy < 0) {
-    if (r > t1)
-      return;
-    if (r > t0)
-      t0 = r;
-  } else if (dy > 0) {
-    if (r < t0)
-      return;
-    if (r < t1)
-      t1 = r;
-  }
-  if (t0 > 0)
-    a[0] = ax + t0 * dx, a[1] = ay + t0 * dy;
-  if (t1 < 1)
-    b[0] = ax + t1 * dx, b[1] = ay + t1 * dy;
-  return true;
-}
-function pointEqual(a, b) {
-  return abs(a[0] - b[0]) < epsilon && abs(a[1] - b[1]) < epsilon;
-}
-function Intersection(point, points, other, entry) {
-  this.x = point;
-  this.z = points;
-  this.o = other;
-  this.e = entry;
-  this.v = false;
-  this.n = this.p = null;
-}
-function clipPolygon(segments, compareIntersection2, startInside, interpolate, stream) {
-  var subject = [], clip2 = [], i, n;
-  segments.forEach(function(segment) {
-    if ((n2 = segment.length - 1) <= 0)
-      return;
-    var n2, p0 = segment[0], p1 = segment[n2], x;
-    if (pointEqual(p0, p1)) {
-      stream.lineStart();
-      for (i = 0; i < n2; ++i)
-        stream.point((p0 = segment[i])[0], p0[1]);
-      stream.lineEnd();
-      return;
-    }
-    subject.push(x = new Intersection(p0, segment, null, true));
-    clip2.push(x.o = new Intersection(p0, null, x, false));
-    subject.push(x = new Intersection(p1, segment, null, false));
-    clip2.push(x.o = new Intersection(p1, null, x, true));
-  });
-  if (!subject.length)
-    return;
-  clip2.sort(compareIntersection2);
-  link(subject);
-  link(clip2);
-  for (i = 0, n = clip2.length; i < n; ++i) {
-    clip2[i].e = startInside = !startInside;
-  }
-  var start = subject[0], points, point;
-  while (1) {
-    var current = start, isSubject = true;
-    while (current.v)
-      if ((current = current.n) === start)
-        return;
-    points = current.z;
-    stream.lineStart();
-    do {
-      current.v = current.o.v = true;
-      if (current.e) {
-        if (isSubject) {
-          for (i = 0, n = points.length; i < n; ++i)
-            stream.point((point = points[i])[0], point[1]);
-        } else {
-          interpolate(current.x, current.n.x, 1, stream);
-        }
-        current = current.n;
-      } else {
-        if (isSubject) {
-          points = current.p.z;
-          for (i = points.length - 1; i >= 0; --i)
-            stream.point((point = points[i])[0], point[1]);
-        } else {
-          interpolate(current.x, current.p.x, -1, stream);
-        }
-        current = current.p;
-      }
-      current = current.o;
-      points = current.z;
-      isSubject = !isSubject;
-    } while (!current.v);
-    stream.lineEnd();
-  }
-}
-function link(array) {
-  if (!(n = array.length))
-    return;
-  var n, i = 0, a = array[0], b;
-  while (++i < n) {
-    a.n = b = array[i];
-    b.p = a;
-    a = b;
-  }
-  a.n = b = array[0];
-  b.p = a;
-}
-var clipMax = 1e9, clipMin = -clipMax;
-function clipExtent(x02, y02, x12, y12) {
-  function visible(x, y) {
-    return x02 <= x && x <= x12 && y02 <= y && y <= y12;
-  }
-  function interpolate(from, to, direction, stream) {
-    var a = 0, a1 = 0;
-    if (from == null || (a = corner(from, direction)) !== (a1 = corner(to, direction)) || comparePoint(from, to) < 0 ^ direction > 0) {
-      do
-        stream.point(a === 0 || a === 3 ? x02 : x12, a > 1 ? y12 : y02);
-      while ((a = (a + direction + 4) % 4) !== a1);
-    } else {
-      stream.point(to[0], to[1]);
-    }
-  }
-  function corner(p, direction) {
-    return abs(p[0] - x02) < epsilon ? direction > 0 ? 0 : 3 : abs(p[0] - x12) < epsilon ? direction > 0 ? 2 : 1 : abs(p[1] - y02) < epsilon ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2;
-  }
-  function compareIntersection2(a, b) {
-    return comparePoint(a.x, b.x);
-  }
-  function comparePoint(a, b) {
-    var ca = corner(a, 1), cb = corner(b, 1);
-    return ca !== cb ? ca - cb : ca === 0 ? b[1] - a[1] : ca === 1 ? a[0] - b[0] : ca === 2 ? a[1] - b[1] : b[0] - a[0];
-  }
-  return function(stream) {
-    var activeStream = stream, bufferStream = clipBuffer(), segments, polygon, ring, x__, y__, v__, x_, y_, v_, first, clean;
-    var clipStream = {
-      point,
-      lineStart,
-      lineEnd,
-      polygonStart,
-      polygonEnd
-    };
-    function point(x, y) {
-      if (visible(x, y))
-        activeStream.point(x, y);
-    }
-    function polygonInside() {
-      var winding = 0;
-      for (var i = 0, n = polygon.length; i < n; ++i) {
-        for (var ring2 = polygon[i], j = 1, m = ring2.length, point2 = ring2[0], a0, a1, b0 = point2[0], b1 = point2[1]; j < m; ++j) {
-          a0 = b0, a1 = b1, point2 = ring2[j], b0 = point2[0], b1 = point2[1];
-          if (a1 <= y12) {
-            if (b1 > y12 && (b0 - a0) * (y12 - a1) > (b1 - a1) * (x02 - a0))
-              ++winding;
-          } else {
-            if (b1 <= y12 && (b0 - a0) * (y12 - a1) < (b1 - a1) * (x02 - a0))
-              --winding;
-          }
-        }
-      }
-      return winding;
-    }
-    function polygonStart() {
-      activeStream = bufferStream, segments = [], polygon = [], clean = true;
-    }
-    function polygonEnd() {
-      var startInside = polygonInside(), cleanInside = clean && startInside, visible2 = (segments = merge(segments)).length;
-      if (cleanInside || visible2) {
-        stream.polygonStart();
-        if (cleanInside) {
-          stream.lineStart();
-          interpolate(null, null, 1, stream);
-          stream.lineEnd();
-        }
-        if (visible2) {
-          clipPolygon(segments, compareIntersection2, startInside, interpolate, stream);
-        }
-        stream.polygonEnd();
-      }
-      activeStream = stream, segments = polygon = ring = null;
-    }
-    function lineStart() {
-      clipStream.point = linePoint;
-      if (polygon)
-        polygon.push(ring = []);
-      first = true;
-      v_ = false;
-      x_ = y_ = NaN;
-    }
-    function lineEnd() {
-      if (segments) {
-        linePoint(x__, y__);
-        if (v__ && v_)
-          bufferStream.rejoin();
-        segments.push(bufferStream.result());
-      }
-      clipStream.point = point;
-      if (v_)
-        activeStream.lineEnd();
-    }
-    function linePoint(x, y) {
-      var v = visible(x, y);
-      if (polygon)
-        ring.push([x, y]);
-      if (first) {
-        x__ = x, y__ = y, v__ = v;
-        first = false;
-        if (v) {
-          activeStream.lineStart();
-          activeStream.point(x, y);
-        }
-      } else {
-        if (v && v_)
-          activeStream.point(x, y);
-        else {
-          var a = [x_ = Math.max(clipMin, Math.min(clipMax, x_)), y_ = Math.max(clipMin, Math.min(clipMax, y_))], b = [x = Math.max(clipMin, Math.min(clipMax, x)), y = Math.max(clipMin, Math.min(clipMax, y))];
-          if (clipLine(a, b, x02, y02, x12, y12)) {
-            if (!v_) {
-              activeStream.lineStart();
-              activeStream.point(a[0], a[1]);
-            }
-            activeStream.point(b[0], b[1]);
-            if (!v)
-              activeStream.lineEnd();
-            clean = false;
-          } else if (v) {
-            activeStream.lineStart();
-            activeStream.point(x, y);
-            clean = false;
-          }
-        }
-      }
-      x_ = x, y_ = y, v_ = v;
-    }
-    return clipStream;
-  };
-}
-var sum = adder();
-function polygonContains(polygon, point) {
-  var lambda = point[0], phi = point[1], normal = [sin(lambda), -cos(lambda), 0], angle = 0, winding = 0;
-  sum.reset();
-  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 = point0[0], phi0 = point0[1] / 2 + quarterPi, sinPhi0 = sin(phi0), cosPhi0 = cos(phi0);
-    for (var j = 0; j < m; ++j, lambda0 = lambda1, sinPhi0 = sinPhi1, cosPhi0 = cosPhi1, point0 = point1) {
-      var point1 = ring[j], lambda1 = point1[0], phi1 = point1[1] / 2 + quarterPi, sinPhi1 = sin(phi1), cosPhi1 = cos(phi1), delta = lambda1 - lambda0, sign = delta >= 0 ? 1 : -1, absDelta = sign * delta, antimeridian = absDelta > pi, k = sinPhi0 * sinPhi1;
-      sum.add(atan2(k * sign * sin(absDelta), cosPhi0 * cosPhi1 + k * cos(absDelta)));
-      angle += antimeridian ? delta + sign * tau : delta;
-      if (antimeridian ^ lambda0 >= lambda ^ lambda1 >= lambda) {
-        var arc = cartesianCross(cartesian(point0), cartesian(point1));
-        cartesianNormalizeInPlace(arc);
-        var intersection = cartesianCross(normal, arc);
-        cartesianNormalizeInPlace(intersection);
-        var phiArc = (antimeridian ^ delta >= 0 ? -1 : 1) * asin(intersection[2]);
-        if (phi > phiArc || phi === phiArc && (arc[0] || arc[1])) {
-          winding += antimeridian ^ delta >= 0 ? 1 : -1;
-        }
-      }
-    }
-  }
-  return (angle < -epsilon || angle < epsilon && sum < -epsilon) ^ winding & 1;
-}
-adder();
-function identity(x) {
-  return x;
-}
-adder();
-adder();
-var x0 = Infinity, y0 = x0, x1 = -x0, y1 = x1;
-var boundsStream = {
-  point: boundsPoint,
-  lineStart: noop,
-  lineEnd: noop,
-  polygonStart: noop,
-  polygonEnd: noop,
-  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;
-}
-adder();
-function clip(pointVisible, clipLine2, interpolate, start) {
-  return function(rotate, sink) {
-    var line = clipLine2(sink), rotatedStart = rotate.invert(start[0], start[1]), ringBuffer = clipBuffer(), ringSink = clipLine2(ringBuffer), polygonStarted = false, polygon, segments, ring;
-    var clip2 = {
-      point,
-      lineStart,
-      lineEnd,
-      polygonStart: function() {
-        clip2.point = pointRing;
-        clip2.lineStart = ringStart;
-        clip2.lineEnd = ringEnd;
-        segments = [];
-        polygon = [];
-      },
-      polygonEnd: function() {
-        clip2.point = point;
-        clip2.lineStart = lineStart;
-        clip2.lineEnd = lineEnd;
-        segments = merge(segments);
-        var startInside = polygonContains(polygon, rotatedStart);
-        if (segments.length) {
-          if (!polygonStarted)
-            sink.polygonStart(), polygonStarted = true;
-          clipPolygon(segments, compareIntersection, startInside, interpolate, sink);
-        } else if (startInside) {
-          if (!polygonStarted)
-            sink.polygonStart(), polygonStarted = true;
-          sink.lineStart();
-          interpolate(null, null, 1, sink);
-          sink.lineEnd();
-        }
-        if (polygonStarted)
-          sink.polygonEnd(), polygonStarted = false;
-        segments = polygon = null;
-      },
-      sphere: function() {
-        sink.polygonStart();
-        sink.lineStart();
-        interpolate(null, null, 1, sink);
-        sink.lineEnd();
-        sink.polygonEnd();
-      }
-    };
-    function point(lambda, phi) {
-      var point2 = rotate(lambda, phi);
-      if (pointVisible(lambda = point2[0], phi = point2[1]))
-        sink.point(lambda, phi);
-    }
-    function pointLine(lambda, phi) {
-      var point2 = rotate(lambda, phi);
-      line.point(point2[0], point2[1]);
-    }
-    function lineStart() {
-      clip2.point = pointLine;
-      line.lineStart();
-    }
-    function lineEnd() {
-      clip2.point = point;
-      line.lineEnd();
-    }
-    function pointRing(lambda, phi) {
-      ring.push([lambda, phi]);
-      var point2 = rotate(lambda, phi);
-      ringSink.point(point2[0], point2[1]);
-    }
-    function ringStart() {
-      ringSink.lineStart();
-      ring = [];
-    }
-    function ringEnd() {
-      pointRing(ring[0][0], ring[0][1]);
-      ringSink.lineEnd();
-      var clean = ringSink.clean(), ringSegments = ringBuffer.result(), i, n = ringSegments.length, m, segment, point2;
-      ring.pop();
-      polygon.push(ring);
-      ring = null;
-      if (!n)
-        return;
-      if (clean & 1) {
-        segment = ringSegments[0];
-        if ((m = segment.length - 1) > 0) {
-          if (!polygonStarted)
-            sink.polygonStart(), polygonStarted = true;
-          sink.lineStart();
-          for (i = 0; i < m; ++i)
-            sink.point((point2 = segment[i])[0], point2[1]);
-          sink.lineEnd();
-        }
-        return;
-      }
-      if (n > 1 && clean & 2)
-        ringSegments.push(ringSegments.pop().concat(ringSegments.shift()));
-      segments.push(ringSegments.filter(validSegment));
-    }
-    return clip2;
-  };
-}
-function validSegment(segment) {
-  return segment.length > 1;
-}
-function compareIntersection(a, b) {
-  return ((a = a.x)[0] < 0 ? a[1] - halfPi - epsilon : halfPi - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi - epsilon : halfPi - b[1]);
-}
-var clipAntimeridian = clip(
-  function() {
-    return true;
-  },
-  clipAntimeridianLine,
-  clipAntimeridianInterpolate,
-  [-pi, -halfPi]
-);
-function clipAntimeridianLine(stream) {
-  var lambda0 = NaN, phi0 = NaN, sign0 = NaN, clean;
-  return {
-    lineStart: function() {
-      stream.lineStart();
-      clean = 1;
-    },
-    point: function(lambda1, phi1) {
-      var sign1 = lambda1 > 0 ? pi : -pi, delta = abs(lambda1 - lambda0);
-      if (abs(delta - pi) < epsilon) {
-        stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi : -halfPi);
-        stream.point(sign0, phi0);
-        stream.lineEnd();
-        stream.lineStart();
-        stream.point(sign1, phi0);
-        stream.point(lambda1, phi0);
-        clean = 0;
-      } else if (sign0 !== sign1 && delta >= pi) {
-        if (abs(lambda0 - sign0) < epsilon)
-          lambda0 -= sign0 * epsilon;
-        if (abs(lambda1 - sign1) < epsilon)
-          lambda1 -= sign1 * epsilon;
-        phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);
-        stream.point(sign0, phi0);
-        stream.lineEnd();
-        stream.lineStart();
-        stream.point(sign1, phi0);
-        clean = 0;
-      }
-      stream.point(lambda0 = lambda1, phi0 = phi1);
-      sign0 = sign1;
-    },
-    lineEnd: function() {
-      stream.lineEnd();
-      lambda0 = phi0 = NaN;
-    },
-    clean: function() {
-      return 2 - clean;
-    }
-  };
-}
-function clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1) {
-  var cosPhi0, cosPhi1, sinLambda0Lambda1 = sin(lambda0 - lambda1);
-  return abs(sinLambda0Lambda1) > epsilon ? atan((sin(phi0) * (cosPhi1 = cos(phi1)) * sin(lambda1) - sin(phi1) * (cosPhi0 = cos(phi0)) * sin(lambda0)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
-}
-function clipAntimeridianInterpolate(from, to, direction, stream) {
-  var phi;
-  if (from == null) {
-    phi = direction * halfPi;
-    stream.point(-pi, phi);
-    stream.point(0, phi);
-    stream.point(pi, phi);
-    stream.point(pi, 0);
-    stream.point(pi, -phi);
-    stream.point(0, -phi);
-    stream.point(-pi, -phi);
-    stream.point(-pi, 0);
-    stream.point(-pi, phi);
-  } else if (abs(from[0] - to[0]) > epsilon) {
-    var lambda = from[0] < to[0] ? pi : -pi;
-    phi = direction * lambda / 2;
-    stream.point(-lambda, phi);
-    stream.point(0, phi);
-    stream.point(lambda, phi);
-  } else {
-    stream.point(to[0], to[1]);
-  }
-}
-function clipCircle(radius, delta) {
-  var cr = cos(radius), smallRadius = cr > 0, notHemisphere = abs(cr) > epsilon;
-  function interpolate(from, to, direction, stream) {
-    circleStream(stream, radius, delta, direction, from, to);
-  }
-  function visible(lambda, phi) {
-    return cos(lambda) * cos(phi) > cr;
-  }
-  function clipLine2(stream) {
-    var point0, c0, v0, v00, clean;
-    return {
-      lineStart: function() {
-        v00 = v0 = false;
-        clean = 1;
-      },
-      point: function(lambda, phi) {
-        var point1 = [lambda, phi], point2, v = visible(lambda, phi), c = smallRadius ? v ? 0 : code(lambda, phi) : v ? code(lambda + (lambda < 0 ? pi : -pi), phi) : 0;
-        if (!point0 && (v00 = v0 = v))
-          stream.lineStart();
-        if (v !== v0) {
-          point2 = intersect(point0, point1);
-          if (!point2 || pointEqual(point0, point2) || pointEqual(point1, point2)) {
-            point1[0] += epsilon;
-            point1[1] += epsilon;
-            v = visible(point1[0], point1[1]);
-          }
-        }
-        if (v !== v0) {
-          clean = 0;
-          if (v) {
-            stream.lineStart();
-            point2 = intersect(point1, point0);
-            stream.point(point2[0], point2[1]);
-          } else {
-            point2 = intersect(point0, point1);
-            stream.point(point2[0], point2[1]);
-            stream.lineEnd();
-          }
-          point0 = point2;
-        } else if (notHemisphere && point0 && smallRadius ^ v) {
-          var t;
-          if (!(c & c0) && (t = intersect(point1, point0, true))) {
-            clean = 0;
-            if (smallRadius) {
-              stream.lineStart();
-              stream.point(t[0][0], t[0][1]);
-              stream.point(t[1][0], t[1][1]);
-              stream.lineEnd();
-            } else {
-              stream.point(t[1][0], t[1][1]);
-              stream.lineEnd();
-              stream.lineStart();
-              stream.point(t[0][0], t[0][1]);
-            }
-          }
-        }
-        if (v && (!point0 || !pointEqual(point0, point1))) {
-          stream.point(point1[0], point1[1]);
-        }
-        point0 = point1, v0 = v, c0 = c;
-      },
-      lineEnd: function() {
-        if (v0)
-          stream.lineEnd();
-        point0 = null;
-      },
-      clean: function() {
-        return clean | (v00 && v0) << 1;
-      }
-    };
-  }
-  function intersect(a, b, two) {
-    var pa = cartesian(a), pb = cartesian(b);
-    var n1 = [1, 0, 0], n2 = cartesianCross(pa, pb), n2n2 = cartesianDot(n2, n2), n1n2 = n2[0], determinant = n2n2 - n1n2 * n1n2;
-    if (!determinant)
-      return !two && a;
-    var c1 = cr * n2n2 / determinant, c2 = -cr * n1n2 / determinant, n1xn2 = cartesianCross(n1, n2), A = cartesianScale(n1, c1), B = cartesianScale(n2, c2);
-    cartesianAddInPlace(A, B);
-    var u = n1xn2, w = cartesianDot(A, u), uu = cartesianDot(u, u), t2 = w * w - uu * (cartesianDot(A, A) - 1);
-    if (t2 < 0)
-      return;
-    var t = sqrt(t2), q = cartesianScale(u, (-w - t) / uu);
-    cartesianAddInPlace(q, A);
-    q = spherical(q);
-    if (!two)
-      return q;
-    var lambda0 = a[0], lambda1 = b[0], phi0 = a[1], phi1 = b[1], z;
-    if (lambda1 < lambda0)
-      z = lambda0, lambda0 = lambda1, lambda1 = z;
-    var delta2 = lambda1 - lambda0, polar = abs(delta2 - pi) < epsilon, meridian = polar || delta2 < epsilon;
-    if (!polar && phi1 < phi0)
-      z = phi0, phi0 = phi1, phi1 = z;
-    if (meridian ? polar ? phi0 + phi1 > 0 ^ q[1] < (abs(q[0] - lambda0) < epsilon ? phi0 : phi1) : phi0 <= q[1] && q[1] <= phi1 : delta2 > pi ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
-      var q1 = cartesianScale(u, (-w + t) / uu);
-      cartesianAddInPlace(q1, A);
-      return [q, spherical(q1)];
-    }
-  }
-  function code(lambda, phi) {
-    var r = smallRadius ? radius : pi - radius, code2 = 0;
-    if (lambda < -r)
-      code2 |= 1;
-    else if (lambda > r)
-      code2 |= 2;
-    if (phi < -r)
-      code2 |= 4;
-    else if (phi > r)
-      code2 |= 8;
-    return code2;
-  }
-  return clip(visible, clipLine2, interpolate, smallRadius ? [0, -radius] : [-pi, radius - pi]);
-}
-function transformer(methods) {
-  return function(stream) {
-    var s = new TransformStream();
-    for (var key in methods)
-      s[key] = methods[key];
-    s.stream = stream;
-    return s;
-  };
-}
-function TransformStream() {
-}
-TransformStream.prototype = {
-  constructor: TransformStream,
-  point: function(x, y) {
-    this.stream.point(x, y);
-  },
-  sphere: function() {
-    this.stream.sphere();
-  },
-  lineStart: function() {
-    this.stream.lineStart();
-  },
-  lineEnd: function() {
-    this.stream.lineEnd();
-  },
-  polygonStart: function() {
-    this.stream.polygonStart();
-  },
-  polygonEnd: function() {
-    this.stream.polygonEnd();
-  }
-};
-function fitExtent(projection2, extent, object) {
-  var w = extent[1][0] - extent[0][0], h = extent[1][1] - extent[0][1], clip2 = projection2.clipExtent && projection2.clipExtent();
-  projection2.scale(150).translate([0, 0]);
-  if (clip2 != null)
-    projection2.clipExtent(null);
-  geoStream(object, projection2.stream(boundsStream));
-  var b = boundsStream.result(), 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;
-  if (clip2 != null)
-    projection2.clipExtent(clip2);
-  return projection2.scale(k * 150).translate([x, y]);
-}
-function fitSize(projection2, size, object) {
-  return fitExtent(projection2, [[0, 0], size], object);
-}
-var maxDepth = 16, cosMinDistance = cos(30 * radians);
-function resample(project, delta2) {
-  return +delta2 ? resample$1(project, delta2) : resampleNone(project);
-}
-function resampleNone(project) {
-  return transformer({
-    point: function(x, y) {
-      x = project(x, y);
-      this.stream.point(x[0], x[1]);
-    }
-  });
-}
-function resample$1(project, delta2) {
-  function resampleLineTo(x02, y02, lambda0, a0, b0, c0, x12, y12, lambda1, a1, b1, c1, depth, stream) {
-    var dx = x12 - x02, dy = y12 - y02, d2 = dx * dx + dy * dy;
-    if (d2 > 4 * delta2 && depth--) {
-      var a = a0 + a1, b = b0 + b1, c = c0 + c1, m = sqrt(a * a + b * b + c * c), phi2 = asin(c /= m), lambda2 = abs(abs(c) - 1) < epsilon || abs(lambda0 - lambda1) < epsilon ? (lambda0 + lambda1) / 2 : atan2(b, a), p = project(lambda2, phi2), x2 = p[0], y2 = p[1], dx2 = x2 - x02, dy2 = y2 - y02, dz = dy * dx2 - dx * dy2;
-      if (dz * dz / d2 > delta2 || abs((dx * dx2 + dy * dy2) / d2 - 0.5) > 0.3 || a0 * a1 + b0 * b1 + c0 * c1 < cosMinDistance) {
-        resampleLineTo(x02, y02, lambda0, a0, b0, c0, x2, y2, lambda2, a /= m, b /= m, c, depth, stream);
-        stream.point(x2, y2);
-        resampleLineTo(x2, y2, lambda2, a, b, c, x12, y12, lambda1, a1, b1, c1, depth, stream);
-      }
-    }
-  }
-  return function(stream) {
-    var lambda00, x00, y00, a00, b00, c00, lambda0, x02, y02, a0, b0, c0;
-    var resampleStream = {
-      point,
-      lineStart,
-      lineEnd,
-      polygonStart: function() {
-        stream.polygonStart();
-        resampleStream.lineStart = ringStart;
-      },
-      polygonEnd: function() {
-        stream.polygonEnd();
-        resampleStream.lineStart = lineStart;
-      }
-    };
-    function point(x, y) {
-      x = project(x, y);
-      stream.point(x[0], x[1]);
-    }
-    function lineStart() {
-      x02 = NaN;
-      resampleStream.point = linePoint;
-      stream.lineStart();
-    }
-    function linePoint(lambda, phi) {
-      var c = cartesian([lambda, phi]), p = project(lambda, phi);
-      resampleLineTo(x02, y02, lambda0, a0, b0, c0, x02 = p[0], y02 = p[1], lambda0 = lambda, a0 = c[0], b0 = c[1], c0 = c[2], maxDepth, stream);
-      stream.point(x02, y02);
-    }
-    function lineEnd() {
-      resampleStream.point = point;
-      stream.lineEnd();
-    }
-    function ringStart() {
-      lineStart();
-      resampleStream.point = ringPoint;
-      resampleStream.lineEnd = ringEnd;
-    }
-    function ringPoint(lambda, phi) {
-      linePoint(lambda00 = lambda, phi), x00 = x02, y00 = y02, a00 = a0, b00 = b0, c00 = c0;
-      resampleStream.point = linePoint;
-    }
-    function ringEnd() {
-      resampleLineTo(x02, y02, lambda0, a0, b0, c0, x00, y00, lambda00, a00, b00, c00, maxDepth, stream);
-      resampleStream.lineEnd = lineEnd;
-      lineEnd();
-    }
-    return resampleStream;
-  };
-}
-var transformRadians = transformer({
-  point: function(x, y) {
-    this.stream.point(x * radians, y * radians);
-  }
-});
-function projection(project) {
-  return projectionMutator(function() {
-    return project;
-  })();
-}
-function projectionMutator(projectAt) {
-  var project, k = 150, x = 480, y = 250, dx, dy, lambda = 0, phi = 0, deltaLambda = 0, deltaPhi = 0, deltaGamma = 0, rotate, projectRotate, theta = null, preclip = clipAntimeridian, x02 = null, y02, x12, y12, postclip = identity, delta2 = 0.5, projectResample = resample(projectTransform, delta2), cache, cacheStream;
-  function projection2(point) {
-    point = projectRotate(point[0] * radians, point[1] * radians);
-    return [point[0] * k + dx, dy - point[1] * k];
-  }
-  function invert(point) {
-    point = projectRotate.invert((point[0] - dx) / k, (dy - point[1]) / k);
-    return point && [point[0] * degrees, point[1] * degrees];
-  }
-  function projectTransform(x2, y2) {
-    return x2 = project(x2, y2), [x2[0] * k + dx, dy - x2[1] * k];
-  }
-  projection2.stream = function(stream) {
-    return cache && cacheStream === stream ? cache : cache = transformRadians(preclip(rotate, projectResample(postclip(cacheStream = stream))));
-  };
-  projection2.clipAngle = function(_) {
-    return arguments.length ? (preclip = +_ ? clipCircle(theta = _ * radians, 6 * radians) : (theta = null, clipAntimeridian), reset()) : theta * degrees;
-  };
-  projection2.clipExtent = function(_) {
-    return arguments.length ? (postclip = _ == null ? (x02 = y02 = x12 = y12 = null, identity) : clipExtent(x02 = +_[0][0], y02 = +_[0][1], x12 = +_[1][0], y12 = +_[1][1]), reset()) : x02 == null ? null : [[x02, y02], [x12, y12]];
-  };
-  projection2.scale = function(_) {
-    return arguments.length ? (k = +_, recenter()) : k;
-  };
-  projection2.translate = function(_) {
-    return arguments.length ? (x = +_[0], y = +_[1], recenter()) : [x, y];
-  };
-  projection2.center = function(_) {
-    return arguments.length ? (lambda = _[0] % 360 * radians, phi = _[1] % 360 * radians, recenter()) : [lambda * degrees, phi * degrees];
-  };
-  projection2.rotate = function(_) {
-    return arguments.length ? (deltaLambda = _[0] % 360 * radians, deltaPhi = _[1] % 360 * radians, deltaGamma = _.length > 2 ? _[2] % 360 * radians : 0, recenter()) : [deltaLambda * degrees, deltaPhi * degrees, deltaGamma * degrees];
-  };
-  projection2.precision = function(_) {
-    return arguments.length ? (projectResample = resample(projectTransform, delta2 = _ * _), reset()) : sqrt(delta2);
-  };
-  projection2.fitExtent = function(extent, object) {
-    return fitExtent(projection2, extent, object);
-  };
-  projection2.fitSize = function(size, object) {
-    return fitSize(projection2, size, object);
-  };
-  function recenter() {
-    projectRotate = compose(rotate = rotateRadians(deltaLambda, deltaPhi, deltaGamma), project);
-    var center = project(lambda, phi);
-    dx = x - center[0] * k;
-    dy = y + center[1] * k;
-    return reset();
-  }
-  function reset() {
-    cache = cacheStream = null;
-    return projection2;
-  }
-  return function() {
-    project = projectAt.apply(this, arguments);
-    projection2.invert = project.invert && invert;
-    return recenter();
-  };
-}
-function azimuthalRaw(scale) {
-  return function(x, y) {
-    var cx = cos(x), cy = cos(y), k = scale(cx * cy);
-    return [
-      k * cy * sin(x),
-      k * sin(y)
-    ];
-  };
-}
-function azimuthalInvert(angle) {
-  return function(x, y) {
-    var z = sqrt(x * x + y * y), c = angle(z), sc = sin(c), cc = cos(c);
-    return [
-      atan2(x * sc, z * cc),
-      asin(z && y * sc / z)
-    ];
-  };
-}
-var azimuthalEqualAreaRaw = azimuthalRaw(function(cxcy) {
-  return sqrt(2 / (1 + cxcy));
-});
-azimuthalEqualAreaRaw.invert = azimuthalInvert(function(z) {
-  return 2 * asin(z / 2);
-});
-var azimuthalEquidistantRaw = azimuthalRaw(function(c) {
-  return (c = acos(c)) && c / sin(c);
-});
-azimuthalEquidistantRaw.invert = azimuthalInvert(function(z) {
-  return z;
-});
-function geoAzimuthalEquidistant() {
-  return projection(azimuthalEquidistantRaw).scale(79.4188).clipAngle(180 - 1e-3);
-}
-function equirectangularRaw(lambda, phi) {
-  return [lambda, phi];
-}
-equirectangularRaw.invert = equirectangularRaw;
-export { geoAzimuthalEquidistant as g };