mapshaper 0.7.44 → 0.7.46

package/mapshaper.js

@@ -78,7 +78,7 @@
     return obj === Object(obj); // via underscore
   }
 
-  function clamp$2(val, min, max) {
+  function clamp$4(val, min, max) {
     return val < min ? min : (val > max ? max : val);
   }
 
@@ -261,36 +261,6 @@
     };
   }
 
-  // Call @iter on each member of an array (similar to Array#reduce(iter))
-  //    iter: function(memo, item, callback)
-  // Call @done when all members have been processed or if an error occurs
-  //    done: function(err, memo)
-  // @memo: Initial value
-  //
-  function reduceAsync(arr, memo, iter, done) {
-    var call = typeof setImmediate == 'undefined' ? setTimeout : setImmediate;
-    var i=0;
-    next(null, memo);
-
-    function next(err, memo) {
-      // Detach next operation from call stack to prevent overflow
-      // Don't use setTimeout(, 0) if setImmediate is available
-      // (setTimeout() can introduce a long delay if previous operation was slow,
-      //    as of Node 0.10.32 -- a bug?)
-      if (err) {
-        return done(err, null);
-      }
-      call(function() {
-        if (i < arr.length === false) {
-          done(null, memo);
-        } else {
-          iter(memo, arr[i++], next);
-        }
-      }, 0);
-    }
-  }
-
-
   // Append elements of @src array to @dest array
   function merge$1(dest, src) {
     if (!isArray(dest) || !isArray(src)) {
@@ -751,7 +721,7 @@
   function findValueByRank(arr, rank) {
     if (!arr.length || rank < 1 || rank > arr.length) error$1("[findValueByRank()] invalid input");
 
-    rank = clamp$2(rank | 0, 1, arr.length);
+    rank = clamp$4(rank | 0, 1, arr.length);
     var k = rank - 1, // conv. rank to array index
         n = arr.length,
         l = 0,
@@ -1125,7 +1095,7 @@
   // self-import and the resulting Rollup circular-dependency warning.
   var utils = {
     addThousandsSep, addslashes, arrayToIndex,
-    clamp: clamp$2, cleanNumericString, contains, copyElements, countValues, createBuffer,
+    clamp: clamp$4, cleanNumericString, contains, copyElements, countValues, createBuffer,
     defaults, difference,
     endsWith, every, expandoBuffer, extend: extend$1, extendBuffer,
     find: find$1, findMedian, findQuantile, findRankByValue, findStringPrefix,
@@ -1145,7 +1115,7 @@
     parseIntlNumber, parseNumber: parseNumber$1, parseString, pickOne, pluck,
     pluralSuffix, promisify,
     quicksort: quicksort$1, quicksortPartition,
-    range, reduceAsync, regexEscape, reorderArray: reorderArray$1, repeat, repeatString,
+    range, regexEscape, reorderArray: reorderArray$1, repeat, repeatString,
     replaceArray, rpad, rtrim,
     shuffle, some, sortArrayIndex, sortOn, splitLines, sum: sum$1,
     toArray: toArray$1, toBuffer, trim, trimQuotes,
@@ -2083,12 +2053,12 @@
   // TODO: remove this constant, use actual data from dataset CRS,
   // also consider using ellipsoidal formulas where greater accuracy might be important.
   var R$3 = WGS84.SEMIMAJOR_AXIS;
-  var D2R$1 = Math.PI / 180;
-  var R2D$1 = 180 / Math.PI;
+  var D2R$7 = Math.PI / 180;
+  var R2D$6 = 180 / Math.PI;
 
   // Equirectangular projection
   function degreesToMeters(deg) {
-    return deg * D2R$1 * R$3;
+    return deg * D2R$7 * R$3;
   }
 
   function distance3D(ax, ay, az, bx, by, bz) {
@@ -2104,7 +2074,7 @@
     return dx * dx + dy * dy;
   }
 
-  function distance2D(ax, ay, bx, by) {
+  function distance2D$1(ax, ay, bx, by) {
     var dx = ax - bx,
         dy = ay - by;
     return Math.sqrt(dx * dx + dy * dy);
@@ -2235,16 +2205,16 @@
 
   function xyzToLngLat(x, y, z, p) {
     var d = distance3D(0, 0, 0, x, y, z); // normalize
-    var lat = Math.asin(z / d) / D2R$1;
-    var lng = Math.atan2(y / d, x / d) / D2R$1;
+    var lat = Math.asin(z / d) / D2R$7;
+    var lng = Math.atan2(y / d, x / d) / D2R$7;
     p[0] = lng;
     p[1] = lat;
   }
 
   function lngLatToXYZ(lng, lat, p) {
     var cosLat;
-    lng *= D2R$1;
-    lat *= D2R$1;
+    lng *= D2R$7;
+    lat *= D2R$7;
     cosLat = Math.cos(lat);
     p[0] = Math.cos(lng) * cosLat * R$3;
     p[1] = Math.sin(lng) * cosLat * R$3;
@@ -2282,7 +2252,7 @@
   }
 
   function cosine(ax, ay, bx, by, cx, cy) {
-    var den = distance2D(ax, ay, bx, by) * distance2D(bx, by, cx, cy),
+    var den = distance2D$1(ax, ay, bx, by) * distance2D$1(bx, by, cx, cy),
         cos = 0;
     if (den > 0) {
       cos = ((ax - bx) * (cx - bx) + (ay - by) * (cy - by)) / den;
@@ -2364,9 +2334,9 @@
 
   var Geom = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    D2R: D2R$1,
+    D2R: D2R$7,
     R: R$3,
-    R2D: R2D$1,
+    R2D: R2D$6,
     bearing: bearing,
     bearing2D: bearing2D,
     containsBounds: containsBounds,
@@ -2374,7 +2344,7 @@
     cosine: cosine,
     cosine3D: cosine3D,
     degreesToMeters: degreesToMeters,
-    distance2D: distance2D,
+    distance2D: distance2D$1,
     distance3D: distance3D,
     distanceSq: distanceSq,
     distanceSq3D: distanceSq3D,
@@ -2525,7 +2495,7 @@
       if (spherical && arcs.isPlanar()) {
         error("Expected lat-long coordinates");
       }
-      calcLen = spherical ? greatCircleDistance : distance2D;
+      calcLen = spherical ? greatCircleDistance : distance2D$1;
       len = 0;
       for (var i=0, n=path.length; i<n; i++) {
         arcs.forEachArcSegment(path[i], addSegLen);
@@ -3311,8 +3281,8 @@
     // angle and seg length ratio thresholds were found by comparing
     // fast and robust outputs on sample data
     if (innerAngle(ax, ay, bx, by, cx, cy, dx, dy) < 0.1) return true;
-    var len1 = distance2D(ax, ay, bx, by);
-    var len2 = distance2D(cx, cy, dx, dy);
+    var len1 = distance2D$1(ax, ay, bx, by);
+    var len2 = distance2D$1(cx, cy, dx, dy);
     var ratio = (len1 < len2 ? len1 / len2 : len2 / len1) || 0;
     if (ratio < 0.001) return true;
     return false;
@@ -3405,7 +3375,7 @@
   }
 
   function snapIfCloser(p, minDist, x, y, x2, y2) {
-    var dist = distance2D(x, y, x2, y2);
+    var dist = distance2D$1(x, y, x2, y2);
     if (dist < minDist) {
       minDist = dist;
       p[0] = x2;
@@ -6287,7 +6257,2291 @@
     probablyDecimalDegreeBounds: probablyDecimalDegreeBounds
   });
 
+  /*
+   * Polyhedral unfolding code adapted from d3-geo-polygon.
+   *
+   * Copyright 2017-2024 Mike Bostock
+   * ISC License: https://github.com/d3/d3-geo-polygon/blob/main/LICENSE
+   */
+
+  var D2R$6 = Math.PI / 180;
+  var R2D$5 = 180 / Math.PI;
+  var EPS$2 = 1e-12;
+
+  // Build a forward-only spherical polyhedral projection.
+  //
+  // config.faces contains spherical polygons in degrees. config.parents defines
+  // a spanning tree of attached faces. faceProjector(face) returns a local
+  // projection accepting radians and returning planar coordinates.
+  function createPolyhedralProjection(config) {
+    var faces = config.faces.map(function(coords, i) {
+      return createFace(coords, i, config.faceSites && config.faceSites[i]);
+    });
+    var parents = config.parents;
+    var attachedPairs = new Set();
+    var faceProjector = config.faceProjector;
+
+    faces.forEach(function(face) {
+      face.project = faceProjector(face);
+    });
+
+    faces.forEach(function(face) {
+      initFaceTransform(face.id);
+    });
+
+    function initFaceTransform(faceId) {
+      var parentId = parents[faceId];
+      var face = faces[faceId];
+      if (face.transform) return;
+      if (parentId < 0) {
+        face.transform = identityMatrix();
+        return;
+      }
+      initFaceTransform(parentId);
+      var parent = faces[parentId];
+      var shared = findSharedEdge(face.coords, parent.coords);
+      if (!shared) {
+        throw new Error('Invalid polyhedral face tree');
+      }
+      var childEdge = shared.map(function(p) {
+        return face.project(p[0] * D2R$6, p[1] * D2R$6);
+      });
+      var parentEdge = shared.map(function(p) {
+        return parent.project(p[0] * D2R$6, p[1] * D2R$6);
+      });
+      face.transform = multiplyMatrices(
+        parent.transform,
+        getEdgeTransform(parentEdge, childEdge)
+      );
+      attachedPairs.add(pairKey(faceId, parentId));
+    }
+
+    var rootEdge = findLongestEdge(faces[0].coords);
+    var rootPlanarEdge = rootEdge.map(function(p) {
+      return faces[0].project(p[0] * D2R$6, p[1] * D2R$6);
+    });
+    var sphericalEdgeLength = angularDistance(rootEdge[0], rootEdge[1]);
+    var planarEdgeLength = distance2D(rootPlanarEdge[0], rootPlanarEdge[1]);
+    var scale = sphericalEdgeLength / planarEdgeLength;
+    var planarAngle = (config.angle || 0) * D2R$6;
+    var edgeIndex = indexEdges(faces, attachedPairs);
+    var outline = buildOutline(faces, attachedPairs).map(function(ring) {
+      return ring.map(transformOutputPoint);
+    });
+    var bounds = getBounds(outline);
+    var centerX = (bounds[0] + bounds[2]) / 2;
+    var centerY = (bounds[1] + bounds[3]) / 2;
+
+    // Centering is calculated after scale and planar rotation.
+    outline.forEach(function(ring) {
+      ring.forEach(function(p) {
+        p[0] -= centerX;
+        p[1] -= centerY;
+      });
+    });
+
+    return {
+      faces: faces,
+      outline: outline,
+      forward: forward,
+      findFace: findFace,
+      findTransitionRegion: findTransitionRegion,
+      getTopology: getTopology
+    };
+
+    function forward(lam, phi) {
+      var rotated = rotateRadians(
+        lam,
+        phi,
+        config.rotation[0] * D2R$6,
+        config.rotation[1] * D2R$6,
+        config.rotation[2] * D2R$6
+      );
+      var face = findFaceRotated(rotated[0], rotated[1]);
+      if (!face) return null;
+      var p = face.project(rotated[0], rotated[1]);
+      p = applyMatrix(face.transform, p);
+      p = transformOutputPoint(p);
+      p[0] -= centerX;
+      p[1] -= centerY;
+      return p;
+    }
+
+    function findFace(lam, phi) {
+      var rotated = rotateRadians(
+        lam,
+        phi,
+        config.rotation[0] * D2R$6,
+        config.rotation[1] * D2R$6,
+        config.rotation[2] * D2R$6
+      );
+      var face = findFaceRotated(rotated[0], rotated[1]);
+      return face ? face.id : -1;
+    }
+
+    function findTransitionRegion(lam, phi) {
+      var rotated = rotateRadians(
+        lam,
+        phi,
+        config.rotation[0] * D2R$6,
+        config.rotation[1] * D2R$6,
+        config.rotation[2] * D2R$6
+      );
+      var face = findFaceRotated(rotated[0], rotated[1]);
+      var region;
+      if (!face) return '-1';
+      region = face.project.findRegion ?
+        face.project.findRegion(rotated[0], rotated[1]) :
+        0;
+      return face.id + ':' + region;
+    }
+
+    function findFaceRotated(lam, phi) {
+      var faceId;
+      if (config.findFace) {
+        faceId = config.findFace(lam, phi);
+        return faceId >= 0 ? faces[faceId] : null;
+      }
+      var p = radiansToVector$1(lam, phi);
+      for (var i = 0; i < faces.length; i++) {
+        if (faceContainsVector(faces[i], p)) return faces[i];
+      }
+      return null;
+    }
+
+    function transformOutputPoint(p) {
+      var x = p[0] * scale;
+      // Local unfolding uses screen-oriented y coordinates to match the D3
+      // Airocean face layout; return conventional projected coordinates (y up).
+      var y = -p[1] * scale;
+      if (planarAngle) {
+        return [
+          x * Math.cos(planarAngle) - y * Math.sin(planarAngle),
+          x * Math.sin(planarAngle) + y * Math.cos(planarAngle)
+        ];
+      }
+      return [x, y];
+    }
+
+    function getTopology(lon0) {
+      var seams = edgeIndex.map(function(edge) {
+        var endpoints = edge.points.map(function(p) {
+          var q = rotateRadians(
+            p[0] * D2R$6,
+            p[1] * D2R$6,
+            config.rotation[0] * D2R$6,
+            config.rotation[1] * D2R$6,
+            config.rotation[2] * D2R$6,
+            true
+          );
+          return [normalizeLongitude$2(q[0] * R2D$5 + lon0), q[1] * R2D$5];
+        });
+        var paths = splitPathAtAntimeridian$2(
+          interpolateGreatCircle(endpoints[0], endpoints[1], 0.05)
+        );
+        paths.forEach(function(path) {
+          // The mask must be wider than the tiny chord error between samples.
+          path.mask_width = 4e-5;
+        });
+        return {
+          type: edge.attached ? 'attached' : 'cut',
+          faces: edge.faces,
+          paths: paths
+        };
+      });
+      var regionPairs = new Map();
+      edgeIndex.forEach(function(edge) {
+        if (edge.faces.length == 2) {
+          regionPairs.set(pairKey(edge.faces[0], edge.faces[1]), edge.attached);
+        }
+      });
+      return {
+        regions: faces.map(function(face) {
+          return {id: face.id};
+        }),
+        seams: seams,
+        findRegion: function(lon, lat) {
+          var lam = normalizeLongitude$2(lon - lon0) * D2R$6;
+          return findFace(lam, lat * D2R$6);
+        },
+        findTransitionRegion: function(lon, lat) {
+          var lam = normalizeLongitude$2(lon - lon0) * D2R$6;
+          return findTransitionRegion(lam, lat * D2R$6);
+        },
+        regionsAreAttached: function(a, b) {
+          return regionPairs.get(pairKey(a, b)) === true;
+        },
+        outline: outline.map(function(ring) {
+          return ring.map(function(p) {
+            return p.concat();
+          });
+        })
+      };
+    }
+  }
+
+  function rotateSphericalRadians(lam, phi, rotation, invert) {
+    return rotateRadians(
+      lam,
+      phi,
+      (rotation[0] || 0) * D2R$6,
+      (rotation[1] || 0) * D2R$6,
+      (rotation[2] || 0) * D2R$6,
+      invert
+    );
+  }
+
+  function createFace(coords, id, site) {
+    var vectors = coords.map(function(p) {
+      return degreesToVector$2(p[0], p[1]);
+    });
+    var inside = normalizeVector$2(vectors.reduce(function(sum, p) {
+      sum[0] += p[0];
+      sum[1] += p[1];
+      sum[2] += p[2];
+      return sum;
+    }, [0, 0, 0]));
+    var edges = [];
+    for (var i = 0; i < vectors.length; i++) {
+      var a = vectors[i];
+      var b = vectors[(i + 1) % vectors.length];
+      var normal = cross$2(a, b);
+      edges.push({
+        normal: normal,
+        sign: dot$2(normal, inside) < 0 ? -1 : 1
+      });
+    }
+    return {
+      id: id,
+      coords: coords,
+      vectors: vectors,
+      edges: edges,
+      centroid: site || vectorToDegrees$2(inside)
+    };
+  }
+
+  function faceContainsVector(face, p) {
+    for (var i = 0; i < face.edges.length; i++) {
+      var edge = face.edges[i];
+      if (dot$2(edge.normal, p) * edge.sign < -EPS$2) return false;
+    }
+    return true;
+  }
+
+  function indexEdges(faces, attachedPairs) {
+    var index = new Map();
+    faces.forEach(function(face) {
+      for (var i = 0; i < face.coords.length; i++) {
+        var a = face.coords[i];
+        var b = face.coords[(i + 1) % face.coords.length];
+        var key = edgeKey(a, b);
+        var edge = index.get(key);
+        if (!edge) {
+          edge = {points: [a, b], faces: []};
+          index.set(key, edge);
+        }
+        edge.faces.push(face.id);
+      }
+    });
+    return Array.from(index.values()).map(function(edge) {
+      edge.attached = edge.faces.length == 2 &&
+        attachedPairs.has(pairKey(edge.faces[0], edge.faces[1]));
+      return edge;
+    });
+  }
+
+  function buildOutline(faces, attachedPairs) {
+    var edges = [];
+    faces.forEach(function(face) {
+      for (var i = 0; i < face.coords.length; i++) {
+        var a = face.coords[i];
+        var b = face.coords[(i + 1) % face.coords.length];
+        var adjacent = findAdjacentFace(faces, face.id, a, b);
+        if (adjacent >= 0 && attachedPairs.has(pairKey(face.id, adjacent))) continue;
+        edges.push([
+          applyMatrix(face.transform, face.project(a[0] * D2R$6, a[1] * D2R$6)),
+          applyMatrix(face.transform, face.project(b[0] * D2R$6, b[1] * D2R$6))
+        ]);
+      }
+    });
+    return connectEdges(edges);
+  }
+
+  function connectEdges(edges) {
+    var unused = edges.concat();
+    var rings = [];
+    while (unused.length) {
+      var edge = unused.pop();
+      var ring = [edge[0], edge[1]];
+      while (!pointsAlmostEqual(ring[0], ring[ring.length - 1])) {
+        var last = ring[ring.length - 1];
+        var found = -1;
+        var next;
+        for (var i = 0; i < unused.length; i++) {
+          if (pointsAlmostEqual(last, unused[i][0])) {
+            found = i;
+            next = unused[i][1];
+            break;
+          }
+          if (pointsAlmostEqual(last, unused[i][1])) {
+            found = i;
+            next = unused[i][0];
+            break;
+          }
+        }
+        if (found < 0) break;
+        unused.splice(found, 1);
+        ring.push(next);
+      }
+      if (ring.length > 3 && pointsAlmostEqual(ring[0], ring[ring.length - 1])) {
+        ring[ring.length - 1] = ring[0].concat();
+        rings.push(ring);
+      }
+    }
+    return rings;
+  }
+
+  function findAdjacentFace(faces, faceId, a, b) {
+    var key = edgeKey(a, b);
+    for (var i = 0; i < faces.length; i++) {
+      if (i == faceId) continue;
+      var coords = faces[i].coords;
+      for (var j = 0; j < coords.length; j++) {
+        if (edgeKey(coords[j], coords[(j + 1) % coords.length]) == key) return i;
+      }
+    }
+    return -1;
+  }
+
+  function findSharedEdge(a, b) {
+    for (var i = 0; i < a.length; i++) {
+      var p = a[i];
+      for (var j = 0; j < b.length; j++) {
+        var q = a[(i + 1) % a.length];
+        var c = b[j];
+        var d = b[(j + 1) % b.length];
+        if (sameSphericalPoint(p, c) && sameSphericalPoint(q, d) ||
+            sameSphericalPoint(p, d) && sameSphericalPoint(q, c)) {
+          return [p, q];
+        }
+      }
+    }
+    return null;
+  }
+
+  function findLongestEdge(coords) {
+    var longest = null;
+    var max = -Infinity;
+    for (var i = 0; i < coords.length; i++) {
+      var edge = [coords[i], coords[(i + 1) % coords.length]];
+      var length = angularDistance(edge[0], edge[1]);
+      if (length > max) {
+        longest = edge;
+        max = length;
+      }
+    }
+    return longest;
+  }
+
+  function getEdgeTransform(dest, src) {
+    var ux = dest[1][0] - dest[0][0];
+    var uy = dest[1][1] - dest[0][1];
+    var vx = src[1][0] - src[0][0];
+    var vy = src[1][1] - src[0][1];
+    var scale = Math.sqrt((ux * ux + uy * uy) / (vx * vx + vy * vy));
+    var angle = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    var cos = Math.cos(angle) * scale;
+    var sin = Math.sin(angle) * scale;
+    return [
+      cos,
+      sin,
+      dest[0][0] - cos * src[0][0] - sin * src[0][1],
+      -sin,
+      cos,
+      dest[0][1] + sin * src[0][0] - cos * src[0][1]
+    ];
+  }
+
+  function identityMatrix() {
+    return [1, 0, 0, 0, 1, 0];
+  }
+
+  function multiplyMatrices(a, b) {
+    return [
+      a[0] * b[0] + a[1] * b[3],
+      a[0] * b[1] + a[1] * b[4],
+      a[0] * b[2] + a[1] * b[5] + a[2],
+      a[3] * b[0] + a[4] * b[3],
+      a[3] * b[1] + a[4] * b[4],
+      a[3] * b[2] + a[4] * b[5] + a[5]
+    ];
+  }
+
+  function applyMatrix(m, p) {
+    return [
+      m[0] * p[0] + m[1] * p[1] + m[2],
+      m[3] * p[0] + m[4] * p[1] + m[5]
+    ];
+  }
+
+  function rotateRadians(lam, phi, deltaLam, deltaPhi, deltaGamma, invert) {
+    if (invert) {
+      var inv = rotatePhiGamma$1(lam, phi, deltaPhi, deltaGamma, true);
+      return [normalizeRadians$2(inv[0] - deltaLam), inv[1]];
+    }
+    lam = normalizeRadians$2(lam + deltaLam);
+    return rotatePhiGamma$1(lam, phi, deltaPhi, deltaGamma, false);
+  }
+
+  // Based on d3-geo spherical rotation (ISC license).
+  function rotatePhiGamma$1(lam, phi, deltaPhi, deltaGamma, invert) {
+    var cosDeltaPhi = Math.cos(deltaPhi);
+    var sinDeltaPhi = Math.sin(deltaPhi);
+    var cosDeltaGamma = Math.cos(deltaGamma);
+    var sinDeltaGamma = Math.sin(deltaGamma);
+    var cosPhi = Math.cos(phi);
+    var x = Math.cos(lam) * cosPhi;
+    var y = Math.sin(lam) * cosPhi;
+    var z = Math.sin(phi);
+    var k;
+    if (invert) {
+      k = z * cosDeltaGamma - y * sinDeltaGamma;
+      return [
+        Math.atan2(y * cosDeltaGamma + z * sinDeltaGamma,
+          x * cosDeltaPhi + k * sinDeltaPhi),
+        Math.asin(clamp$3(k * cosDeltaPhi - x * sinDeltaPhi, -1, 1))
+      ];
+    }
+    k = z * cosDeltaPhi + x * sinDeltaPhi;
+    return [
+      Math.atan2(y * cosDeltaGamma - k * sinDeltaGamma,
+        x * cosDeltaPhi - z * sinDeltaPhi),
+      Math.asin(clamp$3(k * cosDeltaGamma + y * sinDeltaGamma, -1, 1))
+    ];
+  }
+
+  function interpolateGreatCircle(a, b, interval) {
+    var av = degreesToVector$2(a[0], a[1]);
+    var bv = degreesToVector$2(b[0], b[1]);
+    var angle = Math.acos(clamp$3(dot$2(av, bv), -1, 1));
+    var n = Math.max(1, Math.ceil(angle * R2D$5 / interval));
+    var sinAngle = Math.sin(angle);
+    var points = [];
+    for (var i = 0; i <= n; i++) {
+      var t = i / n;
+      var p;
+      if (sinAngle < EPS$2) {
+        p = av;
+      } else {
+        var ka = Math.sin((1 - t) * angle) / sinAngle;
+        var kb = Math.sin(t * angle) / sinAngle;
+        p = [
+          av[0] * ka + bv[0] * kb,
+          av[1] * ka + bv[1] * kb,
+          av[2] * ka + bv[2] * kb
+        ];
+      }
+      points.push(vectorToDegrees$2(normalizeVector$2(p)));
+    }
+    return points;
+  }
+
+  function splitPathAtAntimeridian$2(path) {
+    var paths = [];
+    var part = [path[0]];
+    for (var i = 1; i < path.length; i++) {
+      var a = path[i - 1];
+      var b = path[i];
+      if (Math.abs(a[0] - b[0]) > 180) {
+        var bLon = b[0] + (b[0] < a[0] ? 360 : -360);
+        var edgeLon = a[0] < 0 ? -180 : 180;
+        var t = (edgeLon - a[0]) / (bLon - a[0]);
+        var lat = a[1] + (b[1] - a[1]) * t;
+        part.push([edgeLon, lat]);
+        paths.push(part);
+        part = [[-edgeLon, lat], b];
+      } else {
+        part.push(b);
+      }
+    }
+    if (part.length > 1) paths.push(part);
+    return paths;
+  }
+
+  function getBounds(rings) {
+    var bounds = [Infinity, Infinity, -Infinity, -Infinity];
+    rings.forEach(function(ring) {
+      ring.forEach(function(p) {
+        bounds[0] = Math.min(bounds[0], p[0]);
+        bounds[1] = Math.min(bounds[1], p[1]);
+        bounds[2] = Math.max(bounds[2], p[0]);
+        bounds[3] = Math.max(bounds[3], p[1]);
+      });
+    });
+    return bounds;
+  }
+
+  function angularDistance(a, b) {
+    return Math.acos(clamp$3(dot$2(degreesToVector$2(a[0], a[1]),
+      degreesToVector$2(b[0], b[1])), -1, 1));
+  }
+
+  function degreesToVector$2(lon, lat) {
+    return radiansToVector$1(lon * D2R$6, lat * D2R$6);
+  }
+
+  function radiansToVector$1(lam, phi) {
+    var cosPhi = Math.cos(phi);
+    return [Math.cos(lam) * cosPhi, Math.sin(lam) * cosPhi, Math.sin(phi)];
+  }
+
+  function vectorToDegrees$2(p) {
+    return [
+      Math.atan2(p[1], p[0]) * R2D$5,
+      Math.asin(clamp$3(p[2], -1, 1)) * R2D$5
+    ];
+  }
+
+  function normalizeVector$2(p) {
+    var k = 1 / Math.sqrt(dot$2(p, p));
+    return [p[0] * k, p[1] * k, p[2] * k];
+  }
+
+  function cross$2(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 dot$2(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  }
+
+  function distance2D(a, b) {
+    var dx = b[0] - a[0];
+    var dy = b[1] - a[1];
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+
+  function sameSphericalPoint(a, b) {
+    return Math.abs(a[0] - b[0]) < EPS$2 && Math.abs(a[1] - b[1]) < EPS$2;
+  }
+
+  function pointsAlmostEqual(a, b) {
+    return Math.abs(a[0] - b[0]) < 1e-9 && Math.abs(a[1] - b[1]) < 1e-9;
+  }
+
+  function pointKey$1(p) {
+    return p[0].toFixed(12) + ',' + p[1].toFixed(12);
+  }
+
+  function edgeKey(a, b) {
+    var ka = pointKey$1(a);
+    var kb = pointKey$1(b);
+    return ka < kb ? ka + '|' + kb : kb + '|' + ka;
+  }
+
+  function pairKey(a, b) {
+    return a < b ? a + '~' + b : b + '~' + a;
+  }
+
+  function normalizeRadians$2(lam) {
+    while (lam > Math.PI) lam -= Math.PI * 2;
+    while (lam < -Math.PI) lam += Math.PI * 2;
+    return lam;
+  }
+
+  function normalizeLongitude$2(lon) {
+    while (lon > 180) lon -= 360;
+    while (lon < -180) lon += 360;
+    return lon;
+  }
+
+  function clamp$3(val, min, max) {
+    return Math.max(min, Math.min(max, val));
+  }
+
+  /*
+   * Buckminster Fuller's Airocean arrangement of the icosahedron.
+   *
+   * Face layout adapted from d3-geo-polygon (ISC license):
+   * https://github.com/d3/d3-geo-polygon/blob/main/src/airocean.js
+   *
+   * The Gray-Fuller raw transform below is based on Robert W. Gray's published
+   * equations and Philippe Rivière's public-domain clean-room implementation:
+   * https://github.com/d3/d3-geo-polygon/blob/main/src/grayfuller.js
+   */
+
+
+  var D2R$5 = Math.PI / 180;
+  var R2D$4 = 180 / Math.PI;
+  var SQRT3$1 = Math.sqrt(3);
+  var GRAY_Z = Math.sqrt(5 + 2 * Math.sqrt(5)) / Math.sqrt(15);
+  var GRAY_EL = Math.sqrt(8) / Math.sqrt(5 + Math.sqrt(5));
+  var GRAY_DVE = Math.sqrt(3 + Math.sqrt(5)) / Math.sqrt(5 + Math.sqrt(5));
+  var ROTATION = [-83.65929, 25.44458, -87.45184];
+  var PARENTS = [
+    -1, 0, 1, 11, 13,
+    6, 7, 1, 7, 8,
+    9, 10, 11, 12, 13,
+    6, 8, 10, 17, 21,
+    16, 15, 19, 19
+  ];
+  var engines$2 = {};
+
+  function registerDymaxionProjections(mproj) {
+    // Some unit tests import source modules directly in an ESM context where
+    // optional CommonJS dependencies are intentionally unavailable.
+    if (!mproj) return;
+    register('dymaxion', 'Dymaxion (Gray-Fuller facets)', 'fuller');
+    register('dymaxion2', 'Dymaxion (Gnomonic facets)', 'gnomonic');
+
+    function register(id, name, method) {
+      if (mproj.internal.pj_list[id]) return;
+      mproj.pj_add(function(P) {
+        initDymaxion(P, method);
+      }, id, name);
+    }
+  }
+
+  function getDymaxionEngine(method) {
+    method = method || 'fuller';
+    if (!engines$2[method]) {
+      var data = createAiroceanFaces();
+      engines$2[method] = createPolyhedralProjection({
+        faces: data.faces,
+        faceSites: data.sites,
+        parents: PARENTS,
+        rotation: ROTATION,
+        angle: -60,
+        faceProjector: method == 'gnomonic' ?
+          createGnomonicFaceProjector :
+          createGrayFullerFaceProjector
+      });
+    }
+    return engines$2[method];
+  }
+
+  function initDymaxion(P, method) {
+    var engine = getDymaxionEngine(method);
+    P.es = 0;
+    P.inv = null;
+    P.fwd = function(lp, xy) {
+      var p = engine.forward(lp.lam, lp.phi);
+      if (!p) {
+        xy.x = xy.y = Infinity;
+      } else {
+        xy.x = p[0];
+        xy.y = p[1];
+      }
+    };
+    P.__projection_topology = engine.getTopology(P.lam0 * R2D$4);
+    P.__projected_outline = engine.outline;
+  }
+
+  function createAiroceanFaces() {
+    var theta = Math.atan(0.5) * R2D$4;
+    var vertices = [[0, 90], [0, -90]];
+    var faces;
+    var sites;
+    for (var i = 0; i < 10; i++) {
+      vertices.push([(i * 36 + 180) % 360 - 180, i & 1 ? theta : -theta]);
+    }
+    faces = [
+      [0, 3, 11],
+      [0, 5, 3],
+      [0, 7, 5],
+      [0, 9, 7],
+      [0, 11, 9],
+      [2, 11, 3],
+      [3, 4, 2],
+      [4, 3, 5],
+      [5, 6, 4],
+      [6, 5, 7],
+      [7, 8, 6],
+      [8, 7, 9],
+      [9, 10, 8],
+      [10, 9, 11],
+      [11, 2, 10],
+      [1, 2, 4],
+      [1, 4, 6],
+      [1, 6, 8],
+      [1, 8, 10],
+      [1, 10, 2]
+    ].map(function(ids) {
+      return ids.map(function(id) {
+        return vertices[id];
+      });
+    });
+    sites = faces.map(getSphericalCentroid);
+    splitAiroceanFaces(faces, sites);
+    return {faces: faces, sites: sites};
+  }
+
+  function splitAiroceanFaces(faces, sites) {
+    var face = faces[15];
+    var site = sites[15];
+    var original = face.concat();
+    face[0] = site;
+    faces.push([original[0], site, original[2]]);
+    sites.push(site);
+    faces.push([original[0], original[1], site]);
+    sites.push(site);
+
+    face = faces[14];
+    site = sites[14];
+    original = face.concat();
+    var mid = getGreatCircleMidpoint(face[1], face[2]);
+    face[1] = mid;
+    faces.push([original[0], original[1], mid]);
+    sites.push(site);
+
+    face = faces[19];
+    site = sites[19];
+    original = face.concat();
+    face[1] = mid;
+    faces.push([mid, original[0], original[1]]);
+    sites.push(site);
+  }
+
+  function createGrayFullerFaceProjector(face) {
+    var c = face.centroid;
+    var direction = Math.abs(c[1] - 52.62) < 1 ||
+      Math.abs(c[1] + 10.81) < 1 ? 0 : 60;
+    var rotation = [-c[0], -c[1], direction];
+    return function(lam, phi) {
+      var p = rotateSphericalRadians(lam, phi, rotation);
+      var q = grayFullerRaw(p[0], p[1]);
+      // D3's face projections use screen-oriented local y coordinates; retaining
+      // that convention reproduces the published Airocean unfolding matrices.
+      return [q[0], -q[1]];
+    };
+  }
+
+  function createGnomonicFaceProjector(face) {
+    var c = face.centroid;
+    var rotation = [-c[0], -c[1], 0];
+    return function(lam, phi) {
+      var p = rotateSphericalRadians(lam, phi, rotation);
+      var cosPhi = Math.cos(p[1]);
+      var k = cosPhi * Math.cos(p[0]);
+      return [
+        cosPhi * Math.sin(p[0]) / k,
+        -Math.sin(p[1]) / k
+      ];
+    };
+  }
+
+  function grayFullerRaw(lam, phi) {
+    var cosPhi = Math.cos(phi);
+    var s = GRAY_Z / (cosPhi * Math.cos(lam));
+    var x = cosPhi * Math.sin(lam) * s;
+    var y = Math.sin(phi) * s;
+    var a1p = Math.atan2(2 * y / SQRT3$1 + GRAY_EL / 3 - GRAY_EL / 2, GRAY_DVE);
+    var a2p = Math.atan2(x - y / SQRT3$1 + GRAY_EL / 3 - GRAY_EL / 2, GRAY_DVE);
+    var a3p = Math.atan2(GRAY_EL / 3 - x - y / SQRT3$1 - GRAY_EL / 2, GRAY_DVE);
+    return [SQRT3$1 * (a2p - a3p), 2 * a1p - a2p - a3p];
+  }
+
+  function getSphericalCentroid(coords) {
+    var sum = [0, 0, 0];
+    coords.forEach(function(p) {
+      var v = degreesToVector$1(p);
+      sum[0] += v[0];
+      sum[1] += v[1];
+      sum[2] += v[2];
+    });
+    return vectorToDegrees$1(normalize(sum));
+  }
+
+  function getGreatCircleMidpoint(a, b) {
+    var av = degreesToVector$1(a);
+    var bv = degreesToVector$1(b);
+    return vectorToDegrees$1(normalize([
+      av[0] + bv[0],
+      av[1] + bv[1],
+      av[2] + bv[2]
+    ]));
+  }
+
+  function degreesToVector$1(p) {
+    var lam = p[0] * D2R$5;
+    var phi = p[1] * D2R$5;
+    var cosPhi = Math.cos(phi);
+    return [Math.cos(lam) * cosPhi, Math.sin(lam) * cosPhi, Math.sin(phi)];
+  }
+
+  function vectorToDegrees$1(p) {
+    return [
+      Math.atan2(p[1], p[0]) * R2D$4,
+      Math.asin(Math.max(-1, Math.min(1, p[2]))) * R2D$4
+    ];
+  }
+
+  function normalize(p) {
+    var k = 1 / Math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
+    return [p[0] * k, p[1] * k, p[2] * k];
+  }
+
+  var Dymaxion = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getDymaxionEngine: getDymaxionEngine,
+    registerDymaxionProjections: registerDymaxionProjections
+  });
+
+  /*
+   * Vertex-oriented great-circle "slice-and-dice" projection.
+   *
+   * Based on van Leeuwen and Strebe (2006), with the vector formulation
+   * described by Hall et al. (2020) and implemented independently by DGGAL.
+   * https://doi.org/10.1559/152304006779500687
+   * https://doi.org/10.3390/ijgi9050315
+   */
+
+
+  function createGnomonicProjector(center) {
+    var rotation = [-center[0], -center[1], 0];
+    return function(lam, phi) {
+      var p = rotateSphericalRadians(lam, phi, rotation);
+      var cosPhi = Math.cos(p[1]);
+      var k = cosPhi * Math.cos(p[0]);
+      return [
+        cosPhi * Math.sin(p[0]) / k,
+        -Math.sin(p[1]) / k
+      ];
+    };
+  }
+
+  /*
+   * Cahill-Keyes 12-zone forward transform.
+   *
+   * Implemented in Perl by Mary Jo Graça (2011), ported to D3.js by
+   * Enrico Spinielli (2013), and adapted here from d3-geo-polygon.
+   *
+   * Copyright 2017-2024 Mike Bostock
+   * ISC License: https://github.com/d3/d3-geo-polygon/blob/main/LICENSE
+   */
+
+  var D2R$4 = Math.PI / 180;
+  var R2D$3 = 180 / Math.PI;
+
+  function createCahillKeyesRaw(mg) {
+    return createCahillKeyesTransform(mg, false);
+  }
+
+  function createCahillKeyesTransform(mg, faceOnly) {
+    var CK = {lengthMG: mg};
+    init();
+
+    return function(lambda, phi) {
+      if (faceOnly) {
+        var lon = lambda * R2D$3;
+        var side = lon < 0 ? -1 : lon > 0 ? 1 : 0;
+        var local = mp2xy(Math.abs(lon), Math.abs(phi * R2D$3));
+        return [local[0], side * local[1]];
+      }
+      var res = ll2mp(lambda * R2D$3, phi * R2D$3);
+      var xy = mp2xy(res[0], res[1]);
+      var p = [xy[0], res[2] * xy[1]];
+      return mj2g(p, res[3]);
+    };
+
+    function init() {
+      var k = Math.sqrt(3);
+      var pointN, lengthMB, lengthMN, lengthNG, pointU;
+      var p73a, lF, lT, lM, l, pointV;
+      CK.lengthMA = 0.094 * CK.lengthMG;
+      CK.lengthParallel0to73At0 = CK.lengthMG / 100;
+      CK.lengthParallel73to90At0 =
+        (CK.lengthMG - CK.lengthMA - CK.lengthParallel0to73At0 * 73) / 17;
+      CK.sin60 = k / 2;
+      CK.cos60 = 0.5;
+      CK.pointM = [0, 0];
+      CK.pointG = [CK.lengthMG, 0];
+      pointN = [CK.lengthMG, CK.lengthMG * Math.tan(30 * D2R$4)];
+      CK.pointA = [CK.lengthMA, 0];
+      CK.pointB = lineIntersection(CK.pointM, 30, CK.pointA, 45);
+      CK.lengthAG = distance(CK.pointA, CK.pointG);
+      CK.lengthAB = distance(CK.pointA, CK.pointB);
+      lengthMB = distance(CK.pointM, CK.pointB);
+      lengthMN = distance(CK.pointM, pointN);
+      lengthNG = distance(pointN, CK.pointG);
+      CK.pointD = interpolate(lengthMB, lengthMN, pointN, CK.pointM);
+      CK.pointF = [CK.lengthMG, lengthNG - lengthMB];
+      CK.pointE = [
+        pointN[0] - CK.lengthMA * Math.sin(30 * D2R$4),
+        pointN[1] - CK.lengthMA * Math.cos(30 * D2R$4)
+      ];
+      CK.lengthGF = distance(CK.pointG, CK.pointF);
+      CK.lengthBD = distance(CK.pointB, CK.pointD);
+      CK.lengthGFE = CK.lengthGF + CK.lengthAB;
+      CK.deltaMEq = CK.lengthGFE / 45;
+      CK.lengthAP75 = 15 * CK.lengthParallel73to90At0;
+      CK.lengthAP73 = CK.lengthMG - CK.lengthMA -
+        CK.lengthParallel0to73At0 * 73;
+      pointU = [
+        CK.pointA[0] + CK.lengthAP73 * Math.cos(30 * D2R$4),
+        CK.pointA[1] + CK.lengthAP73 * Math.sin(30 * D2R$4)
+      ];
+      CK.pointT = lineIntersection(pointU, -60, CK.pointB, 30);
+
+      p73a = parallel73(29);
+      lF = p73a.lengthParallel73;
+      lT = lengthTorridSegment(29);
+      lM = lengthMiddleSegment(29);
+      l = 15 * (lT + lM + lF) / 73 - lT;
+      pointV = interpolate(l, lM, jointT(29), jointF(29));
+      CK.pointC = [0, 0];
+      CK.pointC[1] = (
+        pointV[0] * pointV[0] + pointV[1] * pointV[1] -
+        CK.pointD[0] * CK.pointD[0] - CK.pointD[1] * CK.pointD[1]
+      ) / (
+        2 * (k * pointV[0] + pointV[1] -
+          k * CK.pointD[0] - CK.pointD[1])
+      );
+      CK.pointC[0] = k * CK.pointC[1];
+      CK.radius = distance(CK.pointC, CK.pointD);
+    }
+
+    function ll2mp(lon, lat) {
+      var south = [0, 6, 7, 8, 5];
+      var octant = truncate((lon + 180) / 90 + 1);
+      var meridian = (lon + 720) % 90 - 45;
+      var side = meridian < 0 ? -1 : meridian > 0 ? 1 : 0;
+      meridian = Math.abs(meridian);
+      if (octant === 5) octant = 1;
+      if (lat < 0) octant = south[octant];
+      return [meridian, Math.abs(lat), side, octant];
+    }
+
+    function mp2xy(m, p) {
+      if (m === 0) return p >= 75 ? zoneA(m, p) : zoneB(m, p);
+      if (p >= 75) return zoneC(m, p);
+      if (p === 0) return zoneD(m);
+      if (p >= 73 && m <= 30) return zoneE(m, p);
+      if (m === 45) {
+        return p <= 15 ? zoneF(m, p) :
+          p <= 73 ? zoneG(m, p) : zoneH(m, p);
+      }
+      if (m <= 29) return zoneI(m, p);
+      if (p >= 73) return zoneJ(m, p);
+      var lT = lengthTorridSegment(m);
+      var hit = circleLineIntersection(
+        CK.pointC, CK.radius, jointT(m), jointF(m)
+      );
+      var l15;
+      if (hit[0]) {
+        l15 = lT + distance(jointT(m), hit[1]);
+      } else {
+        hit = circleLineIntersection(
+          CK.pointC, CK.radius, jointE(m), jointT(m)
+        );
+        l15 = lT - distance(jointT(m), hit[1]);
+      }
+      return p <= 15 ? zoneK(m, p, l15) : zoneL(m, p, l15);
+    }
+
+    function zoneA(m, p) {
+      return [CK.pointA[0] + (90 - p) * 104, 0];
+    }
+
+    function zoneB(m, p) {
+      return [CK.pointG[0] - p * 100, 0];
+    }
+
+    function zoneC(m, p) {
+      return radialPoint(CK.pointA, 104 * (90 - p), m);
+    }
+
+    function zoneD(m) {
+      return equator(m);
+    }
+
+    function zoneE(m, p) {
+      return radialPoint(CK.pointA, 1560 + (75 - p) * 100, m);
+    }
+
+    function zoneF(m, p) {
+      return interpolate(p, 15, CK.pointE, CK.pointD);
+    }
+
+    function zoneG(m, p) {
+      return interpolate(p - 15, 58, CK.pointD, CK.pointT);
+    }
+
+    function zoneH(m, p) {
+      var p75 = parallel75(45);
+      var p73 = parallel73(m).parallel73;
+      var lF = distance(CK.pointT, CK.pointB);
+      var lF75 = distance(CK.pointB, p75);
+      var l = (75 - p) * (lF75 + lF) / 2;
+      return l <= lF75 ?
+        interpolate(l, lF75, p75, CK.pointB) :
+        interpolate(l - lF75, lF, CK.pointB, p73);
+    }
+
+    function zoneI(m, p) {
+      var p73a = parallel73(m);
+      var lT = lengthTorridSegment(m);
+      var lM = lengthMiddleSegment(m);
+      var l = p * (lT + lM + p73a.lengthParallel73) / 73;
+      if (l <= lT) return interpolate(l, lT, jointE(m), jointT(m));
+      if (l <= lT + lM) {
+        return interpolate(l - lT, lM, jointT(m), jointF(m));
+      }
+      return interpolate(
+        l - lT - lM,
+        p73a.lengthParallel73,
+        jointF(m),
+        p73a.parallel73
+      );
+    }
+
+    function zoneJ(m, p) {
+      var p75 = parallel75(m);
+      var p73a = parallel73(m);
+      var lF75 = distance(jointF(m), p75);
+      var l = (75 - p) * (lF75 - p73a.lengthParallel73) / 2;
+      return l <= lF75 ?
+        interpolate(l, lF75, p75, jointF(m)) :
+        interpolate(
+          l - lF75,
+          -p73a.lengthParallel73,
+          jointF(m),
+          p73a.parallel73
+        );
+    }
+
+    function zoneK(m, p, l15) {
+      var l = p * l15 / 15;
+      var lT = lengthTorridSegment(m);
+      var lM = lengthMiddleSegment(m);
+      return l <= lT ?
+        interpolate(l, lT, jointE(m), jointT(m)) :
+        interpolate(l - lT, lM, jointT(m), jointF(m));
+    }
+
+    function zoneL(m, p, l15) {
+      var p73a = parallel73(m);
+      var lT = lengthTorridSegment(m);
+      var lM = lengthMiddleSegment(m);
+      var lF = p73a.lengthParallel73;
+      var l = l15 + (p - 15) * (lT + lM + lF - l15) / 58;
+      if (l <= lT) return interpolate(l, lT, jointE(m), jointF(m));
+      if (l <= lT + lM) {
+        return interpolate(l - lT, lM, jointT(m), jointF(m));
+      }
+      return interpolate(
+        l - lT - lM, lF, jointF(m), p73a.parallel73
+      );
+    }
+
+    function equator(m) {
+      var l = CK.deltaMEq * m;
+      return l <= CK.lengthGF ?
+        [CK.pointG[0], l] :
+        interpolate(l - CK.lengthGF, CK.lengthAB, CK.pointF, CK.pointE);
+    }
+
+    function jointE(m) {
+      return equator(m);
+    }
+
+    function jointT(m) {
+      return lineIntersection(CK.pointM, 2 * m / 3, jointE(m), m / 3);
+    }
+
+    function jointF(m) {
+      if (m === 0) return [CK.pointA[0] + CK.lengthAB, 0];
+      return lineIntersection(CK.pointA, m, CK.pointM, 2 * m / 3);
+    }
+
+    function lengthTorridSegment(m) {
+      return distance(jointE(m), jointT(m));
+    }
+
+    function lengthMiddleSegment(m) {
+      return distance(jointT(m), jointF(m));
+    }
+
+    function parallel73(m) {
+      var p73, lF, xy;
+      var jF = jointF(m);
+      if (m <= 30) {
+        p73 = radialPoint(CK.pointA, CK.lengthAP73, m);
+        lF = distance(jF, p73);
+      } else {
+        p73 = lineIntersection(CK.pointT, -60, jF, m);
+        lF = distance(jF, p73);
+        if (m > 44) {
+          xy = lineIntersection(CK.pointT, -60, jF, 2 * m / 3);
+          if (xy[0] > p73[0]) {
+            p73 = xy;
+            lF = -distance(jF, p73);
+          }
+        }
+      }
+      return {parallel73: p73, lengthParallel73: lF};
+    }
+
+    function parallel75(m) {
+      return radialPoint(CK.pointA, CK.lengthAP75, m);
+    }
+
+    function mj2g(xy, octant) {
+      var out;
+      if (octant === 0) {
+        out = rotate(xy, -60);
+      } else if (octant === 1) {
+        out = rotate(xy, -120);
+        out[0] -= CK.lengthMG;
+      } else if (octant === 2) {
+        out = rotate(xy, -60);
+        out[0] -= CK.lengthMG;
+      } else if (octant === 3) {
+        out = rotate(xy, -120);
+        out[0] += CK.lengthMG;
+      } else if (octant === 4) {
+        out = rotate(xy, -60);
+        out[0] += CK.lengthMG;
+      } else if (octant === 5) {
+        out = rotate([2 * CK.lengthMG - xy[0], xy[1]], -60);
+        out[0] += CK.lengthMG;
+      } else if (octant === 6) {
+        out = rotate([2 * CK.lengthMG - xy[0], xy[1]], -120);
+        out[0] -= CK.lengthMG;
+      } else if (octant === 7) {
+        out = rotate([2 * CK.lengthMG - xy[0], xy[1]], -60);
+        out[0] -= CK.lengthMG;
+      } else if (octant === 8) {
+        out = rotate([2 * CK.lengthMG - xy[0], xy[1]], -120);
+        out[0] += CK.lengthMG;
+      }
+      return out;
+    }
+
+    function radialPoint(origin, length, angle) {
+      return [
+        origin[0] + length * Math.cos(angle * D2R$4),
+        origin[1] + length * Math.sin(angle * D2R$4)
+      ];
+    }
+
+    function rotate(xy, angle) {
+      if (angle === -60) {
+        return [
+          xy[0] * CK.cos60 + xy[1] * CK.sin60,
+          -xy[0] * CK.sin60 + xy[1] * CK.cos60
+        ];
+      }
+      if (angle === -120) {
+        return [
+          -xy[0] * CK.cos60 + xy[1] * CK.sin60,
+          -xy[0] * CK.sin60 - xy[1] * CK.cos60
+        ];
+      }
+      var cos = Math.cos(angle * D2R$4);
+      var sin = Math.sin(angle * D2R$4);
+      return [xy[0] * cos - xy[1] * sin, xy[0] * sin + xy[1] * cos];
+    }
+  }
+
+  function createCahillKeyesFaceRaw(mg) {
+    return createCahillKeyesTransform(mg, true);
+  }
+
+  function distance(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]);
+  }
+
+  function interpolate(length, total, start, end) {
+    return [
+      start[0] + (end[0] - start[0]) * length / total,
+      start[1] + (end[1] - start[1]) * length / total
+    ];
+  }
+
+  function lineIntersection(p1, slope1, p2, slope2) {
+    var m1 = Math.tan(slope1 * D2R$4);
+    var m2 = Math.tan(slope2 * D2R$4);
+    var x = (m1 * p1[0] - m2 * p2[0] - p1[1] + p2[1]) / (m1 - m2);
+    return [x, m1 * (x - p1[0]) + p1[1]];
+  }
+
+  function circleLineIntersection(center, radius, p1, p2) {
+    var dx = p2[0] - p1[0];
+    var dy = p2[1] - p1[1];
+    var fx = p1[0] - center[0];
+    var fy = p1[1] - center[1];
+    var a = dx * dx + dy * dy;
+    var b = 2 * (dx * fx + dy * fy);
+    var c = fx * fx + fy * fy - radius * radius;
+    var d = b * b - 4 * a * c;
+    if (a === 0 || d < 0) return [0, [0, 0]];
+    var root = Math.sqrt(d);
+    var u1 = (-b + root) / (2 * a);
+    var u2 = (-b - root) / (2 * a);
+    var u = u1 >= 0 && u1 <= 1 ? u1 :
+      u2 >= 0 && u2 <= 1 ? u2 : null;
+    return u === null ? [0, [0, 0]] :
+      [1, [p1[0] + u * dx, p1[1] + u * dy]];
+  }
+
+  function truncate(n) {
+    return n > 0 ? Math.floor(n) : Math.ceil(n);
+  }
+
+  var D2R$3 = Math.PI / 180;
+  var EPS$1 = 1e-12;
+
+  // Create a smooth facet projection from any radial azimuthal projection.
+  // The azimuthal coordinates are warped back to the gnomonic polygon along
+  // the boundary, so adjacent facets retain identical straight edges.
+  function createRadialFacetProjector(coords, options) {
+    options = options || {};
+    var center = options.planarCenter || getSphericalCenter(coords);
+    var gnomonic = createGnomonicProjector(center);
+    var planar = coords.map(function(p) {
+      return gnomonic(p[0] * D2R$3, p[1] * D2R$3);
+    });
+    var edges = createNormalizedEdges(planar);
+    var radial = createRadialFunction(
+      options.radial || 'equal-area',
+      options.radial2,
+      options.radialBlend
+    );
+    var boundaryStrength = options.boundaryStrength || 1;
+    var radialScale = getRadialScale(planar, radial) *
+      (options.radialScale || 1);
+
+    project.radial = options.radial || 'equal-area';
+    project.boundaryStrength = boundaryStrength;
+    return project;
+
+    function project(lam, phi) {
+      var p = gnomonic(lam, phi);
+      var r = Math.hypot(p[0], p[1]);
+      if (r < EPS$1) return [0, 0];
+      var c = Math.atan(r);
+      var azimuthalRadius = radial(c) * radialScale;
+      var boundaryWeight = getBoundaryWeight(p, edges, boundaryStrength);
+      var scale = 1 + boundaryWeight * (azimuthalRadius / r - 1);
+      return [p[0] * scale, p[1] * scale];
+    }
+  }
+
+  function createRadialFunction(radial1, radial2, blend) {
+    var f1 = getRadialFunction(radial1);
+    if (!radial2) return f1;
+    var f2 = getRadialFunction(radial2);
+    var k = Math.max(0, Math.min(1, blend == null ? 0.5 : blend));
+    return function(c) {
+      return f1(c) + (f2(c) - f1(c)) * k;
+    };
+  }
+
+  function getRadialFunction(id) {
+    if (typeof id == 'function') return id;
+    id = normalizeRadialProjectionName(id);
+    if (id == 'aeqd') return function(c) {
+      return c;
+    };
+    if (id == 'stere') return function(c) {
+      return 2 * Math.tan(c / 2);
+    };
+    if (id == 'ortho') return function(c) {
+      return Math.sin(c);
+    };
+    if (id == 'gnom') return function(c) {
+      return Math.tan(c);
+    };
+    // Lambert azimuthal equal-area
+    return function(c) {
+      return 2 * Math.sin(c / 2);
+    };
+  }
+
+  function normalizeRadialProjectionName(id) {
+    id = String(id || '').toLowerCase().replace(/_/g, '-');
+    if (id == 'laea' || id == 'lambert' || id == 'equal-area') return 'laea';
+    if (id == 'aeqd' || id == 'equidistant') return 'aeqd';
+    if (id == 'stere' || id == 'stereographic') return 'stere';
+    if (id == 'ortho' || id == 'orthographic') return 'ortho';
+    if (id == 'gnom' || id == 'gnomonic') return 'gnom';
+    throw new Error('Unsupported facet projection: ' + id);
+  }
+
+  function getRadialScale(planar, radial) {
+    var sum = 0;
+    planar.forEach(function(p) {
+      var r = Math.hypot(p[0], p[1]);
+      sum += r / radial(Math.atan(r));
+    });
+    return sum / planar.length;
+  }
+
+  function createNormalizedEdges(planar) {
+    var center = [0, 0];
+    return planar.map(function(a, i) {
+      var b = planar[(i + 1) % planar.length];
+      var dx = b[0] - a[0];
+      var dy = b[1] - a[1];
+      var centerCross = dx * (center[1] - a[1]) -
+        dy * (center[0] - a[0]);
+      return {
+        a: a,
+        dx: dx,
+        dy: dy,
+        denominator: centerCross
+      };
+    });
+  }
+
+  function getBoundaryWeight(p, edges, strength) {
+    var product = 1;
+    for (var i = 0; i < edges.length; i++) {
+      var edge = edges[i];
+      var cross = edge.dx * (p[1] - edge.a[1]) -
+        edge.dy * (p[0] - edge.a[0]);
+      product *= Math.max(0, cross / edge.denominator);
+    }
+    product = Math.max(0, Math.min(1, product));
+    return 1 - Math.pow(1 - product, strength);
+  }
+
+  function getSphericalCenter(coords) {
+    var sum = coords.reduce(function(memo, p) {
+      var lam = p[0] * D2R$3;
+      var phi = p[1] * D2R$3;
+      var cosPhi = Math.cos(phi);
+      memo[0] += Math.cos(lam) * cosPhi;
+      memo[1] += Math.sin(lam) * cosPhi;
+      memo[2] += Math.sin(phi);
+      return memo;
+    }, [0, 0, 0]);
+    return [
+      Math.atan2(sum[1], sum[0]) / D2R$3,
+      Math.atan2(sum[2], Math.hypot(sum[0], sum[1])) / D2R$3
+    ];
+  }
+
+  /*
+   * Octahedral butterfly projections.
+   *
+   * Face layouts are adapted from d3-geo-polygon (ISC license):
+   * https://github.com/d3/d3-geo-polygon
+   *
+   * Copyright 2017-2024 Mike Bostock
+   * ISC License: https://github.com/d3/d3-geo-polygon/blob/main/LICENSE
+   */
+
+
+  var D2R$2 = Math.PI / 180;
+  var R2D$2 = 180 / Math.PI;
+  var RADIAL_BOUNDARY_STRENGTH = 1;
+  var OCTAHEDRON = createOctahedron();
+  var BUTTERFLY_PARENTS = [-1, 0, 0, 1, 0, 1, 4, 5];
+  var DEFAULT_LON0 = {
+    butterfly: 157.5,
+    butterfly2: -20,
+    cahill_keyes: -20
+  };
+  var engines$1 = {};
+
+  function registerButterflyProjections(mproj) {
+    if (!mproj) return;
+    register('butterfly', 'Butterfly projection (Pacific aspect)', 'butterfly');
+    register('butterfly2', 'Butterfly projection (Atlantic aspect)', 'butterfly2');
+    register('cahill_keyes', 'Cahill-Keyes butterfly', 'cahill_keyes');
+
+    function register(id, name, method) {
+      if (mproj.internal.pj_list[id]) return;
+      mproj.pj_add(function(P) {
+        initButterfly(P, method);
+      }, id, name);
+    }
+  }
+
+  function getButterflyEngine(method) {
+    var key = method == 'butterfly2' ? 'butterfly' : method;
+    if (!engines$1[key]) {
+      if (key == 'cahill_keyes') {
+        engines$1[key] = createCahillKeyesEngine();
+      } else if (key == 'butterfly') {
+        engines$1[key] = createButterflyEngine();
+      } else {
+        throw new Error('Unknown butterfly projection: ' + method);
+      }
+    }
+    return engines$1[key];
+  }
+
+  function initButterfly(P, method) {
+    var engine = getButterflyEngine(method);
+    if (!P.params.lon_0) {
+      P.lam0 = DEFAULT_LON0[method] * D2R$2;
+    }
+    P.es = 0;
+    P.inv = null;
+    P.fwd = function(lp, xy) {
+      var p = engine.forward(lp.lam, lp.phi);
+      if (!p) {
+        xy.x = xy.y = Infinity;
+      } else {
+        xy.x = p[0];
+        xy.y = p[1];
+      }
+    };
+    P.__projection_topology = engine.getTopology(P.lam0 * R2D$2);
+    if (engine.removeOutlineExtremeConnectors) {
+      P.__remove_outline_extreme_connectors = true;
+    }
+    if (engine.useProjectedOutline !== false) {
+      P.__projected_outline = engine.outline;
+    }
+  }
+
+  function createButterflyEngine() {
+    var faceCenters = [-45, 45, -45, 45, -135, 135, -135, 135];
+    // Reuse the Cahill-Keyes polar incisions and 12-zone octant transform,
+    // then unfold the faces with the butterfly attachment tree.
+    var data = createTruncatedOctahedronFaces(
+      Math.cos(17 * D2R$2),
+      Math.sin(17 * D2R$2),
+      BUTTERFLY_PARENTS
+    );
+    var faceRaw = createCahillKeyesFaceRaw(10000);
+    var engine = createPolyhedralProjection({
+      faces: data.faces,
+      parents: data.parents,
+      rotation: [0, 0, 0],
+      // Face-local CK coordinates point opposite the root face.
+      angle: 150,
+      findFace: createTruncatedFaceFinder(data.cornerNormals),
+      faceProjector: function(face) {
+        var baseId = face.id < 8 ? face.id : data.parents[face.id];
+        var center = faceCenters[baseId] * D2R$2;
+        var raw = function(lam, phi) {
+          return faceRaw(normalizeRadians$1(lam - center), phi);
+        };
+        return createNormalizedFacetProjector(face.coords, raw);
+      }
+    });
+    engine.facetProjection = 'cahill_keyes';
+    return engine;
+  }
+
+  function createNormalizedFacetProjector(coords, raw) {
+    // Remove the global placement and scale of a raw facet while preserving its
+    // internal shape. The polyhedral engine then controls how facets unfold.
+    var points = coords.map(function(p) {
+      return raw(p[0] * D2R$2, p[1] * D2R$2);
+    });
+    var edge = 0;
+    var maxLengthSq = -1;
+    for (var i = 0; i < points.length; i++) {
+      var a = points[i];
+      var b = points[(i + 1) % points.length];
+      var dx = b[0] - a[0];
+      var dy = b[1] - a[1];
+      var lengthSq = dx * dx + dy * dy;
+      if (lengthSq > maxLengthSq) {
+        maxLengthSq = lengthSq;
+        edge = i;
+      }
+    }
+    var origin = points[edge];
+    var end = points[(edge + 1) % points.length];
+    var ux = end[0] - origin[0];
+    var uy = end[1] - origin[1];
+    var center = points.reduce(function(sum, p) {
+      sum[0] += p[0] / points.length;
+      sum[1] += p[1] / points.length;
+      return sum;
+    }, [0, 0]);
+    var side = ux * (center[1] - origin[1]) -
+      uy * (center[0] - origin[0]) < 0 ? -1 : 1;
+    return function(lam, phi) {
+      var p = raw(lam, phi);
+      var x = p[0] - origin[0];
+      var y = p[1] - origin[1];
+      return [
+        (x * ux + y * uy) / maxLengthSq,
+        side * (ux * y - uy * x) / maxLengthSq
+      ];
+    };
+  }
+
+  function createRadialButterflyEngine(options) {
+    options = normalizeRadialFacetOptions(options);
+    var data = createRadialButterflyFaces();
+    var radialOptions = {
+      radial: options.projection,
+      radial2: options.projection2,
+      radialBlend: options.blend,
+      boundaryStrength: RADIAL_BOUNDARY_STRENGTH
+    };
+    var squareProjectors = createSquareProjectors(data.faces, radialOptions);
+    var engine = createPolyhedralProjection({
+      faces: data.faces,
+      parents: data.parents,
+      rotation: [0, 0, 0],
+      angle: -30,
+      findFace: createTruncatedFaceFinder(data.cornerNormals),
+      faceProjector: function(face) {
+        if (face.id < 8) {
+          return createRadialFacetProjector(face.coords, radialOptions);
+        }
+        return squareProjectors.get(pointKey(face.coords[0]));
+      }
+    });
+    engine.radialFacet = {
+      projection: options.projection,
+      projection2: options.projection2,
+      blend: options.blend,
+      boundaryStrength: RADIAL_BOUNDARY_STRENGTH
+    };
+    return engine;
+  }
+
+  function normalizeRadialFacetOptions(options) {
+    options = options || {};
+    var projection2 = options.projection2 ?
+      normalizeRadialProjectionName(options.projection2) :
+      null;
+    var blend = projection2 ?
+      options.blend == null ? 0.5 : Number(options.blend) :
+      0;
+    if (!Number.isFinite(blend) || blend < 0 || blend > 1) {
+      throw new Error('Facet projection blend must be between 0 and 1');
+    }
+    return {
+      projection: normalizeRadialProjectionName(options.projection || 'laea'),
+      projection2: projection2,
+      blend: blend
+    };
+  }
+
+  function createCahillKeyesEngine() {
+    var data = createTruncatedOctahedronFaces(
+      Math.cos(17 * D2R$2),
+      Math.sin(17 * D2R$2),
+      [-1, 3, 0, 2, 0, 1, 4, 5]
+    );
+    var raw = createCahillKeyesRaw(10000);
+    var engine = createPolyhedralProjection({
+      faces: data.faces,
+      parents: data.parents,
+      rotation: [0, 0, 0],
+      angle: 0,
+      findFace: createTruncatedFaceFinder(data.cornerNormals),
+      faceProjector: function() {
+        return function(lam, phi) {
+          var p = raw(lam, phi);
+          return [p[0], -p[1]];
+        };
+      }
+    });
+    // The 12-zone transform positions all octants directly in its M-profile.
+    // Its face-tree boundary retraces several edges, so derive graticule
+    // footprints through the normal spherical clipping path instead.
+    engine.useProjectedOutline = false;
+    engine.removeOutlineExtremeConnectors = true;
+    return engine;
+  }
+
+  function createRadialButterflyFaces() {
+    return createTruncatedOctahedronFaces(
+      Math.sqrt(0.9),
+      Math.sqrt(0.1),
+      BUTTERFLY_PARENTS
+    );
+  }
+
+  function createTruncatedOctahedronFaces(edgeWeight, vertexWeight, baseParents) {
+    var cornerNormals = [];
+    var faces = OCTAHEDRON.map(function(face) {
+      var vectors = face.map(degreesToVector);
+      var hexagon = [];
+      var a = vectors[vectors.length - 1];
+      vectors.forEach(function(b) {
+        hexagon.push(
+          vectorToDegrees(normalizeVector$1(addScaledVectors(
+            a, edgeWeight, b, vertexWeight
+          ))),
+          vectorToDegrees(normalizeVector$1(addScaledVectors(
+            b, edgeWeight, a, vertexWeight
+          )))
+        );
+        a = b;
+      });
+      return hexagon;
+    });
+    canonicalizeVertices(faces);
+    faces.forEach(function(hexagon) {
+      var normals = [];
+      for (var i = 0; i < 3; i++) {
+        normals.push(crossVectors(
+          degreesToVector(hexagon[(i * 2 + 2) % 6]),
+          degreesToVector(hexagon[(i * 2 + 1) % 6])
+        ));
+      }
+      cornerNormals.push(normals);
+    });
+    var parents = baseParents.concat();
+    faces.slice().forEach(function(hexagon, j) {
+      var face = OCTAHEDRON[j];
+      for (var i = 0; i < 3; i++) {
+        faces.push([
+          face[i],
+          hexagon[(i * 2 + 2) % 6],
+          hexagon[(i * 2 + 1) % 6]
+        ]);
+        parents.push(j);
+      }
+    });
+    return {faces: faces, parents: parents, cornerNormals: cornerNormals};
+  }
+
+  function createTruncatedFaceFinder(cornerNormals) {
+    return function(lam, phi) {
+      var cosPhi = Math.cos(phi);
+      var p = [cosPhi * Math.cos(lam), cosPhi * Math.sin(lam), Math.sin(phi)];
+      var face = lam < -Math.PI / 2 ?
+        phi < 0 ? 6 : 4 :
+        lam < 0 ?
+          phi < 0 ? 2 : 0 :
+          lam < Math.PI / 2 ?
+            phi < 0 ? 3 : 1 :
+            phi < 0 ? 7 : 5;
+      var normals = cornerNormals[face];
+      if (dotVectors(normals[0], p) < 0) return 8 + 3 * face;
+      if (dotVectors(normals[1], p) < 0) return 8 + 3 * face + 1;
+      if (dotVectors(normals[2], p) < 0) return 8 + 3 * face + 2;
+      return face;
+    };
+  }
+
+  function canonicalizeVertices(faces) {
+    var index = new Map();
+    faces.forEach(function(face) {
+      face.forEach(function(p, i) {
+        var v = degreesToVector(p);
+        var key = v.map(function(x) {
+          return x.toFixed(12);
+        }).join(',');
+        if (index.has(key)) {
+          face[i] = index.get(key);
+        } else {
+          index.set(key, p);
+        }
+      });
+    });
+  }
+
+  function createSquareProjectors(faces, radialOptions) {
+    var verticesByCenter = new Map();
+    var projectors = new Map();
+    faces.slice(8).forEach(function(face) {
+      var key = pointKey(face[0]);
+      var vertices = verticesByCenter.get(key);
+      if (!vertices) {
+        vertices = new Map();
+        verticesByCenter.set(key, vertices);
+      }
+      vertices.set(pointKey(face[1]), face[1]);
+      vertices.set(pointKey(face[2]), face[2]);
+    });
+    verticesByCenter.forEach(function(vertices, key) {
+      var center = key.split(',').map(Number);
+      var gnomonic = createGnomonicProjector(center);
+      var coords = Array.from(vertices.values()).sort(function(a, b) {
+        return planarAngle(a, gnomonic) - planarAngle(b, gnomonic);
+      });
+      projectors.set(key, createRadialFacetProjector(coords, {
+        planarCenter: center,
+        radial: radialOptions.radial,
+        radial2: radialOptions.radial2,
+        radialBlend: radialOptions.radialBlend,
+        boundaryStrength: radialOptions.boundaryStrength
+      }));
+    });
+    return projectors;
+  }
+
+  function planarAngle(p, project) {
+    var q = project(p[0] * D2R$2, p[1] * D2R$2);
+    return Math.atan2(q[1], q[0]);
+  }
+
+  function createOctahedron() {
+    var vertices = [
+      [0, 90],
+      [-90, 0],
+      [0, 0],
+      [90, 0],
+      [180, 0],
+      [0, -90]
+    ];
+    return [
+      [0, 2, 1],
+      [0, 3, 2],
+      [5, 1, 2],
+      [5, 2, 3],
+      [0, 1, 4],
+      [0, 4, 3],
+      [5, 4, 1],
+      [5, 3, 4]
+    ].map(function(ids) {
+      return ids.map(function(id) {
+        return vertices[id];
+      });
+    });
+  }
+
+  function pointKey(p) {
+    return p[0] + ',' + p[1];
+  }
+
+  function degreesToVector(p) {
+    var lam = p[0] * D2R$2;
+    var phi = p[1] * D2R$2;
+    var cosPhi = Math.cos(phi);
+    return [Math.cos(lam) * cosPhi, Math.sin(lam) * cosPhi, Math.sin(phi)];
+  }
+
+  function vectorToDegrees(p) {
+    return [
+      Math.atan2(p[1], p[0]) * R2D$2,
+      Math.asin(Math.max(-1, Math.min(1, p[2]))) * R2D$2
+    ];
+  }
+
+  function addScaledVectors(a, ka, b, kb) {
+    return [
+      a[0] * ka + b[0] * kb,
+      a[1] * ka + b[1] * kb,
+      a[2] * ka + b[2] * kb
+    ];
+  }
+
+  function crossVectors(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 dotVectors(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  }
+
+  function normalizeVector$1(p) {
+    var k = 1 / Math.sqrt(p[0] * p[0] + p[1] * p[1] + p[2] * p[2]);
+    return [p[0] * k, p[1] * k, p[2] * k];
+  }
+
+  function normalizeRadians$1(lam) {
+    return (lam + Math.PI * 3) % (Math.PI * 2) - Math.PI;
+  }
+
+  var ButterflyProjections = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    createRadialButterflyEngine: createRadialButterflyEngine,
+    getButterflyEngine: getButterflyEngine,
+    registerButterflyProjections: registerButterflyProjections
+  });
+
+  /*
+   * Forward implementation of Hajime Narukawa's 2022 mathematical
+   * approximation of the AuthaGraph construction.
+   *
+   * Facet formula:
+   *   H. Narukawa, "Formulation of AuthaGraph Map Projection" (2022)
+   *   https://www.jstage.jst.go.jp/article/jjca/60/1/60_1/_article/-char/en
+   *
+   * The rectangular facet routing follows the public Imago arrangement by
+   * Justin Kunimune. The face transform itself uses Narukawa's published
+   * equations, not Imago's power-law approximation.
+   */
+
+  var D2R$1 = Math.PI / 180;
+  var R2D$1 = 180 / Math.PI;
+  var HALF_PI = Math.PI / 2;
+  var SQRT2 = Math.sqrt(2);
+  var SQRT3 = Math.sqrt(3);
+  var ASIN_ONE_THIRD = Math.asin(1 / 3);
+  var EDGE_SCALE = Math.acos(-1 / 3) / 2;
+  var XMIN = -2 * SQRT3;
+  var XMAX = 2 * SQRT3;
+  var YMIN = -1.5;
+  var YMAX = 1.5;
+  var BLOCK_HEIGHT = 2 * SQRT3;
+  var LAYOUT_SHIFT = 1.16;
+  var EPS = 1e-12;
+  var engines = {};
+
+  // The four tetrahedron vertices published by Narukawa, in latitude-longitude
+  // order. The extra precision preserves the regular tetrahedron to about 1e-9
+  // in vector dot products.
+  var GEOGRAPHIC_VERTICES = [
+    [76.8810628, 149.4509913],
+    [-27.9527772, 97.3570035],
+    [-6.6370473, -18.8522325],
+    [-22.9282364, -133.2827588]
+  ];
+
+  // D3 Imago's vertex-oriented tetrahedral block. Each entry contains the
+  // spherical center, local meridian, planar rotation and planar center.
+  var FACET_DEFS = [
+    [0, SQRT3, HALF_PI, 0, 0, -HALF_PI],
+    [0, -SQRT3, -ASIN_ONE_THIRD, 0, Math.PI, HALF_PI],
+    [3, 0, -ASIN_ONE_THIRD, 2 * Math.PI / 3, Math.PI, 5 * Math.PI / 6],
+    [-3, 0, -ASIN_ONE_THIRD, -2 * Math.PI / 3, Math.PI, Math.PI / 6]
+  ];
+
+  function registerNarukawa2022Projection(mproj) {
+    if (!mproj || mproj.internal.pj_list.narukawa2022) return;
+    mproj.pj_add(function(P) {
+      initNarukawa2022(P);
+    }, 'narukawa2022', 'Narukawa 2022 tetrahedral world map');
+  }
+
+  function getNarukawa2022Engine() {
+    if (!engines.default) {
+      engines.default = createNarukawa2022Engine();
+    }
+    return engines.default;
+  }
+
+  function initNarukawa2022(P) {
+    var engine = getNarukawa2022Engine();
+    P.es = 0;
+    P.inv = null;
+    P.fwd = function(lp, xy) {
+      var p = engine.forward(lp.lam, lp.phi);
+      xy.x = p[0];
+      xy.y = p[1];
+    };
+    P.__projection_topology = engine.getTopology(P.lam0 * R2D$1);
+    P.__projected_outline = engine.outline;
+  }
+
+  function createNarukawa2022Engine() {
+    var orientation = createPublishedOrientation();
+    var facets = FACET_DEFS.map(function(def, i) {
+      return {
+        id: i,
+        x: def[0],
+        y: def[1],
+        lat: def[2],
+        lon: def[3],
+        meridian: def[4],
+        rotation: def[5]
+      };
+    });
+    var outline = [[
+      [XMIN * EDGE_SCALE, YMIN * EDGE_SCALE],
+      [XMAX * EDGE_SCALE, YMIN * EDGE_SCALE],
+      [XMAX * EDGE_SCALE, YMAX * EDGE_SCALE],
+      [XMIN * EDGE_SCALE, YMAX * EDGE_SCALE],
+      [XMIN * EDGE_SCALE, YMIN * EDGE_SCALE]
+    ]];
+
+    return {
+      forward: forward,
+      inverse: inverse,
+      outline: outline,
+      getTopology: getTopology
+    };
+
+    function forward(lam, phi) {
+      var state = projectState(lam, phi);
+      return [state.x * EDGE_SCALE, state.y * EDGE_SCALE];
+    }
+
+    // Internal inverse used only for tracing the geographic rectangular cut.
+    // P.inv remains null because the full Mapshaper inverse path is unsupported.
+    function inverse(x, y) {
+      var p = invertLayout(x / EDGE_SCALE, y / EDGE_SCALE, facets);
+      if (!p) return null;
+      return fromCanonical(p[0], p[1], orientation);
+    }
+
+    function projectState(lam, phi) {
+      var p = toCanonical(lam, phi, orientation);
+      var state = projectCanonical(p[0], p[1], facets);
+      state.region = encodeRegion(state);
+      return state;
+    }
+
+    function getTopology(lon0) {
+      var paths = createCutPaths(inverse, lon0);
+      return {
+        regions: createRegionIndex(),
+        seams: [{
+          type: 'cut',
+          paths: paths
+        }],
+        findRegion: findRegion,
+        findTransitionRegion: findRegion,
+        outline: outline.map(function(ring) {
+          return ring.map(function(p) {
+            return p.concat();
+          });
+        })
+      };
+
+      function findRegion(lon, lat) {
+        var lam = normalizeRadians((lon - lon0) * D2R$1);
+        return projectState(lam, lat * D2R$1).region;
+      }
+    }
+  }
+
+  function projectCanonical(lam, phi, facets) {
+    var facet = findForwardFacet(lam, phi, facets);
+    var relative = obliquifySpherical(phi, lam, facet);
+    var sector = Math.floor((relative[1] + Math.PI / 3) / (2 * Math.PI / 3));
+    var base = sector * 2 * Math.PI / 3;
+    var polar = narukawaFaceForward(relative[1] - base, relative[0]);
+    var angle = polar[1] + facet.rotation + base / 2;
+    var x = polar[0] * Math.cos(angle) + facet.x;
+    var y = polar[0] * Math.sin(angle) + facet.y;
+    var oob = 0;
+    var folded = 0;
+    var wrap = 0;
+
+    if (Math.abs(x) > 3 + EPS) {
+      x = 2 * facet.x - x;
+      y = -y;
+      oob = 1;
+    } else if (Math.abs(y) > SQRT3 + EPS) {
+      x = -x;
+      y = BLOCK_HEIGHT * Math.sign(y) - y;
+      oob = 2;
+    }
+
+    var qx = y;
+    var qy = -x;
+    if (qy > EPS) {
+      qx = BLOCK_HEIGHT - qx;
+      qy = -qy;
+      folded = 1;
+    }
+    qx += LAYOUT_SHIFT;
+    if (qx < 0) {
+      qx += 2 * BLOCK_HEIGHT;
+      wrap = 1;
+    }
+    x = qx - BLOCK_HEIGHT;
+    y = qy + 1.5;
+    x = clamp$2(x, XMIN, XMAX);
+    y = clamp$2(y, YMIN, YMAX);
+    return {
+      x: x,
+      y: y,
+      facet: facet.id,
+      sector: mod(sector, 3),
+      oob: oob,
+      folded: folded,
+      wrap: wrap
+    };
+  }
+
+  function findForwardFacet(lam, phi, facets) {
+    var best = null;
+    var bestLat = -Infinity;
+    for (var i = 0; i < 4; i++) {
+      var facet = facets[i];
+      var relative = obliquifySpherical(phi, lam, facet);
+      if (relative[0] > bestLat) {
+        bestLat = relative[0];
+        best = facet;
+      }
+    }
+    return best;
+  }
+
+  function narukawaFaceForward(lam, phi) {
+    var a = lam - Math.asin(Math.sin(lam) / SQRT3);
+    var theta = Math.atan(2 * SQRT3 / Math.PI * a);
+    var denominator = 2 + SQRT2 * Math.tan(phi);
+    var q = denominator > 0 ? (2 + Math.cos(lam)) / denominator : 0;
+    var r = q * SQRT3 / Math.cos(theta);
+    return [r, theta];
+  }
+
+  function narukawaFaceInverse(r, theta) {
+    var target = Math.tan(theta) * Math.PI / (2 * SQRT3);
+    var lo = -Math.PI / 3;
+    var hi = Math.PI / 3;
+    var lam;
+    for (var i = 0; i < 55; i++) {
+      lam = (lo + hi) / 2;
+      var a = lam - Math.asin(Math.sin(lam) / SQRT3);
+      if (a < target) lo = lam;
+      else hi = lam;
+    }
+    lam = (lo + hi) / 2;
+    var q = r * Math.cos(theta) / SQRT3;
+    var phi = q < EPS ? HALF_PI :
+      Math.atan(((2 + Math.cos(lam)) / q - 2) / SQRT2);
+    return [phi, lam];
+  }
+
+  function invertLayout(x, y, facets) {
+    var qx = x + BLOCK_HEIGHT;
+    var qy = y - 1.5;
+    var normalizedX = (qx - LAYOUT_SHIFT) / BLOCK_HEIGHT;
+    if (normalizedX > 1.5) normalizedX -= 2;
+    if (normalizedX > 0.5) {
+      normalizedX = 1 - normalizedX;
+      qy *= -1;
+    }
+    x = -qy;
+    y = normalizedX * BLOCK_HEIGHT;
+
+    var facet = findInverseFacet(x, y, facets);
+    var dx = x - facet.x;
+    var dy = y - facet.y;
+    var r = Math.hypot(dx, dy);
+    var theta = normalizeRadians(Math.atan2(dy, dx) - facet.rotation);
+    var base = Math.floor((theta + Math.PI / 6) / (Math.PI / 3)) *
+      Math.PI / 3;
+    var relative = narukawaFaceInverse(r, theta - base);
+    relative[1] += base * 2;
+    var p = deobliquifySpherical(relative[0], relative[1], facet);
+    return [p[1], p[0]];
+  }
+
+  function findInverseFacet(x, y, facets) {
+    var best = null;
+    var minDistance = Infinity;
+    facets.forEach(function(facet) {
+      var d = Math.hypot(x - facet.x, y - facet.y);
+      if (d < minDistance) {
+        minDistance = d;
+        best = facet;
+      }
+    });
+    return best;
+  }
+
+  function createPublishedOrientation() {
+    // Match the D3 Imago arrangement: the third published vertex is the
+    // canonical southern vertex at longitude zero.
+    var north = latLonToVector(GEOGRAPHIC_VERTICES[0]);
+    var south = latLonToVector(GEOGRAPHIC_VERTICES[2]);
+    var tangent = normalizeVector(subtract(
+      south,
+      multiply(north, dot$1(south, north))
+    ));
+    var x = tangent;
+    var y = cross$1(north, tangent);
+    return {x: x, y: y, z: north};
+  }
+
+  function toCanonical(lam, phi, orientation) {
+    var v = radiansToVector(lam, phi);
+    return [
+      Math.atan2(dot$1(v, orientation.y), dot$1(v, orientation.x)),
+      Math.asin(clamp$2(dot$1(v, orientation.z), -1, 1))
+    ];
+  }
+
+  function fromCanonical(lam, phi, orientation) {
+    var v = radiansToVector(lam, phi);
+    var p = [
+      orientation.x[0] * v[0] + orientation.y[0] * v[1] + orientation.z[0] * v[2],
+      orientation.x[1] * v[0] + orientation.y[1] * v[1] + orientation.z[1] * v[2],
+      orientation.x[2] * v[0] + orientation.y[2] * v[1] + orientation.z[2] * v[2]
+    ];
+    return [Math.atan2(p[1], p[0]), Math.asin(clamp$2(p[2], -1, 1))];
+  }
+
+  // Adapted from Justin Kunimune's Imago implementation.
+  function obliquifySpherical(lat, lon, pole) {
+    var lat0 = pole.lat;
+    var lon0 = pole.lon;
+    var theta0 = pole.meridian;
+    var lat1;
+    var lon1;
+    if (Math.abs(lat0 - HALF_PI) < EPS) {
+      lat1 = lat;
+      lon1 = lon - lon0;
+    } else {
+      lat1 = Math.asin(clamp$2(
+        Math.sin(lat0) * Math.sin(lat) +
+        Math.cos(lat0) * Math.cos(lat) * Math.cos(lon0 - lon),
+        -1,
+        1
+      ));
+      var denominator = Math.cos(lat1);
+      var value = denominator < EPS ? 1 :
+        (Math.cos(lat0) * Math.sin(lat) -
+          Math.sin(lat0) * Math.cos(lat) * Math.cos(lon0 - lon)) /
+        denominator;
+      lon1 = Math.acos(clamp$2(value, -1, 1)) - Math.PI;
+      if (Math.sin(lon - lon0) > 0) lon1 = -lon1;
+    }
+    return [lat1, normalizeRadians(lon1 - theta0)];
+  }
+
+  function deobliquifySpherical(lat, lon, pole) {
+    var lat0 = pole.lat;
+    var lon0 = pole.lon;
+    lon += pole.meridian;
+    var latOut = Math.asin(clamp$2(
+      Math.sin(lat0) * Math.sin(lat) -
+      Math.cos(lat0) * Math.cos(lon) * Math.cos(lat),
+      -1,
+      1
+    ));
+    var lonOut;
+    if (Math.abs(lat0 - HALF_PI) < EPS) {
+      lonOut = lon + lon0;
+    } else {
+      var value = Math.sin(lat) / Math.cos(lat0) / Math.cos(latOut) -
+        Math.tan(lat0) * Math.tan(latOut);
+      if (Math.sin(lon) > 0) lonOut = lon0 + Math.acos(clamp$2(value, -1, 1));
+      else lonOut = lon0 - Math.acos(clamp$2(value, -1, 1));
+    }
+    return [latOut, normalizeRadians(lonOut)];
+  }
+
+  function createCutPaths(inverse, lon0) {
+    // The rectangular edges become moderately curved geographic seams. Sampling
+    // at about 0.03 degrees prevents straight mask chords from missing crossings.
+    var n = 6000;
+    var epsilon = 1e-8;
+    var edges = [
+      [[XMIN + epsilon, YMIN], [XMIN + epsilon, YMAX]],
+      [[XMIN, YMAX - epsilon], [XMAX, YMAX - epsilon]],
+      [[XMIN, YMIN + epsilon], [XMAX, YMIN + epsilon]]
+    ];
+    var paths = edges.reduce(function(memo, edge) {
+      var path = [];
+      for (var i = 0; i <= n; i++) {
+        var t = i / n;
+        var x = edge[0][0] + (edge[1][0] - edge[0][0]) * t;
+        var y = edge[0][1] + (edge[1][1] - edge[0][1]) * t;
+        var p = inverse(x * EDGE_SCALE, y * EDGE_SCALE);
+        path.push([
+          normalizeLongitude$1(p[0] * R2D$1 + lon0),
+          p[1] * R2D$1
+        ]);
+      }
+      return memo.concat(splitPathAtAntimeridian$1(path));
+    }, []);
+    return paths.map(function(part) {
+      part.mask_width = 4e-5;
+      return part;
+    });
+  }
+
+  function splitPathAtAntimeridian$1(path) {
+    var paths = [];
+    var part = [path[0]];
+    for (var i = 1; i < path.length; i++) {
+      var a = path[i - 1];
+      var b = path[i];
+      if (Math.abs(a[0] - b[0]) > 180) {
+        var adjusted = b[0] + (b[0] < a[0] ? 360 : -360);
+        var edge = a[0] < 0 ? -180 : 180;
+        var t = (edge - a[0]) / (adjusted - a[0]);
+        var lat = a[1] + (b[1] - a[1]) * t;
+        part.push([edge, lat]);
+        paths.push(part);
+        part = [[-edge, lat], b];
+      } else {
+        part.push(b);
+      }
+    }
+    if (part.length > 1) paths.push(part);
+    return paths;
+  }
+
+  function encodeRegion(state) {
+    return ((((state.facet * 3 + state.sector) * 3 + state.oob) * 2 +
+      state.folded) * 2 + state.wrap);
+  }
+
+  function createRegionIndex() {
+    var regions = [];
+    for (var i = 0; i < 144; i++) {
+      regions.push({id: i});
+    }
+    return regions;
+  }
+
+  function latLonToVector(p) {
+    return radiansToVector(p[1] * D2R$1, p[0] * D2R$1);
+  }
+
+  function radiansToVector(lam, phi) {
+    var cosPhi = Math.cos(phi);
+    return [Math.cos(lam) * cosPhi, Math.sin(lam) * cosPhi, Math.sin(phi)];
+  }
+
+  function subtract(a, b) {
+    return [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+  }
+
+  function multiply(a, k) {
+    return [a[0] * k, a[1] * k, a[2] * k];
+  }
+
+  function normalizeVector(a) {
+    var k = 1 / Math.hypot(a[0], a[1], a[2]);
+    return multiply(a, k);
+  }
+
+  function cross$1(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 dot$1(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+  }
+
+  function mod(a, n) {
+    return (a % n + n) % n;
+  }
+
+  function normalizeRadians(lam) {
+    while (lam > Math.PI) lam -= 2 * Math.PI;
+    while (lam < -Math.PI) lam += 2 * Math.PI;
+    return lam;
+  }
+
+  function normalizeLongitude$1(lon) {
+    while (lon > 180) lon -= 360;
+    while (lon < -180) lon += 360;
+    return lon;
+  }
+
+  function clamp$2(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+  }
+
+  var Narukawa2022 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    getNarukawa2022Engine: getNarukawa2022Engine,
+    registerNarukawa2022Projection: registerNarukawa2022Projection
+  });
+
   var mproj$1 = require$1('mproj');
+  registerDymaxionProjections(mproj$1);
+  registerButterflyProjections(mproj$1);
+  registerNarukawa2022Projection(mproj$1);
 
   var asyncLoader = null;
 
@@ -6456,9 +8710,18 @@
     if (!defn) {
       stop$1("Unknown projection definition:", str);
     }
+    if (utils.isString(defn)) {
+      defn = addDefaultProjectionParams(defn);
+    }
     return defn;
   }
 
+  function addDefaultProjectionParams(defn) {
+    var oceanic = /(^| )\+proj=(igh_o|imoll_o)(?= |$)/.test(defn);
+    var hasLon0 = /(^| )\+lon_0=/.test(defn);
+    return oceanic && !hasLon0 ? defn + ' +lon_0=-160' : defn;
+  }
+
   function looksLikeInitString(str) {
     return /^(esri|epsg|nad83|nad27):[0-9]+$/i.test(String(str));
   }
@@ -9266,7 +11529,7 @@
   function layerNameIsUnsafeFilename(name) {
     name = String(name);
     // path separators (directory traversal on any OS) or NUL
-    if (/[\/\\\0]/.test(name)) return true;
+    if (/[/\\\0]/.test(name)) return true;
     // Windows drive-relative prefix, e.g. "C:foo" can write to another drive
     if (/^[A-Za-z]:/.test(name)) return true;
     return false;
@@ -39161,7 +41424,9 @@ ${svg}
     return finalizeImportedDataset(dataset, dataFmt, data, opts);
   }
 
-  async function importContentAsync(obj, opts) {
+  // Canonical content import interface. Always resolves to an array because some
+  // formats (notably GeoPackage) may contain datasets that cannot be merged.
+  async function importDatasetsFromContent(obj, opts) {
     var dataset, dataFmt, data;
     opts = opts || {};
     if (obj.fgb) {
@@ -39185,14 +41450,16 @@ ${svg}
       data = obj[dataFmt];
       dataset = await importImageRaster(obj, opts);
     } else {
-      return importContent(obj, opts);
-    }
-    if (Array.isArray(dataset)) {
-      return dataset.map(function(ds) {
-        return finalizeImportedDataset(ds, dataFmt, data, opts);
-      });
+      return normalizeImportedDatasets$1(importContent(obj, opts));
     }
-    return finalizeImportedDataset(dataset, dataFmt, data, opts);
+    return normalizeImportedDatasets$1(dataset).map(function(ds) {
+      return finalizeImportedDataset(ds, dataFmt, data, opts);
+    });
+  }
+
+  // Compatibility facade for callers that expect one dataset when possible.
+  async function importContentAsync(obj, opts) {
+    return denormalizeImportedDatasets$1(await importDatasetsFromContent(obj, opts));
   }
 
   // Deprecated (included for compatibility with older tests)
@@ -39203,6 +41470,14 @@ ${svg}
     return importContent(input, opts);
   }
 
+  function normalizeImportedDatasets$1(datasetOrArray) {
+    return Array.isArray(datasetOrArray) ? datasetOrArray : [datasetOrArray];
+  }
+
+  function denormalizeImportedDatasets$1(datasets) {
+    return datasets.length == 1 ? datasets[0] : datasets;
+  }
+
 
   function importShapefile(obj, opts) {
     var shpSrc = obj.shp.content || obj.shp.filename, // read from a file if (binary) content is missing
@@ -39285,6 +41560,7 @@ ${svg}
     __proto__: null,
     importContent: importContent,
     importContentAsync: importContentAsync,
+    importDatasetsFromContent: importDatasetsFromContent,
     importFileContent: importFileContent
   });
 
@@ -39453,8 +41729,7 @@ ${svg}
     var dataset, datasets, target;
 
     if (opts.stdin) {
-      dataset = await importFileAsync('/dev/stdin', opts);
-      datasets = normalizeImportedDatasets(dataset);
+      datasets = await importDatasetsFromFile('/dev/stdin', opts);
       catalog.addDatasets(datasets);
       if (datasets.length > 1) {
         catalog.setDefaultTargets(datasets.map(function(ds) {
@@ -39492,11 +41767,11 @@ ${svg}
     }
 
     if (files.length == 1) {
-      dataset = await importFileAsync(files[0], opts);
+      datasets = await importDatasetsFromFile(files[0], opts);
     } else {
       dataset = await importFilesTogetherAsync(files, opts);
+      datasets = [dataset];
     }
-    datasets = normalizeImportedDatasets(dataset);
     datasets = validateAndCleanGpkgSelection(datasets, opts);
 
     if (opts.merge_files && files.length > 1) {
@@ -39613,9 +41888,12 @@ ${svg}
     });
   }
 
-  // Let the web UI replace importFile() with a browser-friendly version
+  // Let the web UI replace path-based imports with a browser-friendly resolver.
   function replaceImportFile(func) {
     _importFile = func;
+    _importDatasetsFromFile = async function(path, opts) {
+      return normalizeImportedDatasets(await func(path, opts));
+    };
   }
 
   function importFile(path, opts) {
@@ -39623,69 +41901,29 @@ ${svg}
   }
 
   async function importFileAsync(path, opts) {
-    return _importFileAsync(path, opts);
+    return denormalizeImportedDatasets(await importDatasetsFromFile(path, opts));
   }
 
-  var _importFile = function(path, opts) {
-    var fileType = guessInputFileType(path),
-        input = {},
-        encoding = opts && opts.encoding || null,
-        cache = opts && opts.input || null,
-        cached = cache && (path in cache),
-        content;
-
-    cli.checkFileExists(path, cache);
-
-    if ((fileType == 'shp' || fileType == 'json' || fileType == 'text' || fileType == 'dbf' ||
-        fileType == 'gpkg') && !cached) {
-      // these file types are read incrementally
-      content = null;
-
-    } else if (fileType && isSupportedBinaryInputType(path)) {
-      content = cli.readFile(path, null, cache);
-      if (utils.isString(content)) {
-        // Fix for issue #264 (applyCommands() input is file path instead of binary content)
-        stop$1('Expected binary content, received a string');
-      }
-
-    } else if (fileType) { // string type, e.g. kml, geojson
-      content = cli.readFile(path, encoding || 'utf-8', cache);
-
-    } else if (getFileExtension(path) == 'gz') {
-      var pathgz = path;
-      path = pathgz.replace(/\.gz$/, '');
-      fileType = guessInputFileType(path);
-      if (!fileType) {
-        stop$1('Unrecognized file type:', path);
-      }
-      content = gunzipSync(cli.readFile(pathgz, null, cache), path);
-
-    } else { // type can't be inferred from filename -- try reading as text
-      content = cli.readFile(path, encoding || 'utf-8', cache);
-      fileType = guessInputContentType(content);
-      if (fileType == 'text' && content.indexOf('\ufffd') > -1) {
-        // invalidate string data that contains the 'replacement character'
-        fileType = null;
-      }
-    }
+  // Canonical path import interface.
+  async function importDatasetsFromFile(path, opts) {
+    return _importDatasetsFromFile(path, opts);
+  }
 
-    if (!fileType) {
-      stop$1(getUnsupportedFileMessage(path));
-    }
-    input[fileType] = {filename: path, content: content};
-    content = null; // for g.c.
-    if (fileType == 'shp' || fileType == 'dbf') {
-      readShapefileAuxFiles(path, input, cache);
-    } else if (isRasterImageInputType(fileType)) {
-      readRasterImageAuxFiles(path, input, cache);
-    }
-    if (fileType == 'shp' && !input.dbf) {
-      message(utils.format("[%s] .dbf file is missing - shapes imported without attribute data.", path));
-    }
+  var _importFile = function(path, opts) {
+    var input = prepareImportFile(path, opts);
     return importContent(input, opts);
   };
 
-  async function _importFileAsync(path, opts) {
+  var _importDatasetsFromFile = async function(path, opts) {
+    var input = prepareImportFile(path, opts);
+    return importDatasetsFromContent(input, opts);
+  };
+
+  // Read a file (or cache entry) and collect any sidecars into the normalized
+  // content-group shape consumed by the content importers.
+  // File acquisition is currently synchronous in both import paths; only some
+  // format parsers require asynchronous work.
+  function prepareImportFile(path, opts) {
     var fileType = guessInputFileType(path),
         input = {},
         encoding = opts && opts.encoding || null,
@@ -39695,7 +41933,8 @@ ${svg}
 
     cli.checkFileExists(path, cache);
 
-    if ((fileType == 'shp' || fileType == 'json' || fileType == 'text' || fileType == 'dbf') && !cached) {
+    if ((fileType == 'shp' || fileType == 'json' || fileType == 'text' || fileType == 'dbf' ||
+        fileType == 'gpkg') && !cached) {
       // these file types are read incrementally
       content = null;
 
@@ -39738,37 +41977,10 @@ ${svg}
     if (fileType == 'shp' && !input.dbf) {
       message(utils.format("[%s] .dbf file is missing - shapes imported without attribute data.", path));
     }
-    return fileType == 'gpkg' || fileType == 'fgb' || fileType == 'parquet' || fileType == 'geotiff' || isRasterImageInputType(fileType) ? importContentAsync(input, opts) : importContent(input, opts);
-  }
-
-  // Import multiple files to a single dataset
-  function importFilesTogether(files, opts) {
-    var unbuiltTopology = false;
-    var datasets = files.reduce(function(memo, fname) {
-      // import without topology or snapping
-      var importOpts = utils.defaults({no_topology: true, snap: false, snap_interval: null, files: [fname]}, opts);
-      var imported = normalizeImportedDatasets(importFile(fname, importOpts));
-      // check if dataset contains non-topological paths
-      // TODO: may also need to rebuild topology if multiple topojson files are merged
-      imported.forEach(function(dataset) {
-        if (dataset.arcs && dataset.arcs.size() > 0 && dataset.info.input_formats[0] != 'topojson') {
-          unbuiltTopology = true;
-        }
-        memo.push(dataset);
-      });
-      return memo;
-    }, []);
-    var combined = mergeDatasets(datasets);
-    // Build topology, if needed
-    // TODO: consider updating topology of TopoJSON files instead of concatenating arcs
-    // (but problem of mismatched coordinates due to quantization in input files.)
-    if (unbuiltTopology && !opts.no_topology) {
-      cleanPathsAfterImport(combined, opts);
-      buildTopology(combined);
-    }
-    return combined;
+    return input;
   }
 
+  // Import multiple files to a single dataset.
   async function importFilesTogetherAsync(files, opts) {
     var unbuiltTopology = false;
     var datasets = [];
@@ -39776,7 +41988,7 @@ ${svg}
     for (var fname of files) {
       // import without topology or snapping
       var importOpts = utils.defaults({no_topology: true, snap: false, snap_interval: null, files: [fname]}, opts);
-      var imported = normalizeImportedDatasets(await importFileAsync(fname, importOpts));
+      var imported = await importDatasetsFromFile(fname, importOpts);
       imported.forEach(function(dataset) {
         if (dataset.arcs && dataset.arcs.size() > 0 && dataset.info.input_formats[0] != 'topojson') {
           unbuiltTopology = true;
@@ -39838,6 +42050,10 @@ ${svg}
     return Array.isArray(datasetOrArray) ? datasetOrArray : [datasetOrArray];
   }
 
+  function denormalizeImportedDatasets(datasets) {
+    return datasets.length == 1 ? datasets[0] : datasets;
+  }
+
   function normalizeImportedTarget(datasets) {
     if (datasets.length == 1) return datasets[0];
     return {
@@ -39937,9 +42153,9 @@ ${svg}
 
   var FileImport = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    importDatasetsFromFile: importDatasetsFromFile,
     importFile: importFile,
     importFileAsync: importFileAsync,
-    importFilesTogether: importFilesTogether,
     importFilesTogetherAsync: importFilesTogetherAsync,
     replaceImportFile: replaceImportFile
   });
@@ -39969,31 +42185,37 @@ ${svg}
     return /[$][{]/.test(name);
   }
 
-  function findCommandSource(sourceName, catalog, opts) {
+  async function findCommandSourceAsync(sourceName, catalog, opts) {
     var source = catalog.findSingleLayer(sourceName);
-    var sourceDataset;
+    var sourceDatasets;
     if (!source) {
-      // assuming opts.source is a filename
-      // don't need to build topology, because:
-      //    join -- don't need topology
-      //    clip/erase -- topology is built later, when datasets are combined
-      sourceDataset = importFile(sourceName, utils.defaults({no_topology: true}, opts));
-      if (!sourceDataset) {
-        stop$1(utils.format('Unable to find source [%s]', sourceName));
-      } else if (sourceDataset.layers.length > 1) {
-        stop$1('Multiple-layer sources are not supported');
-      }
-      // mark as disposable to indicate that data can be mutated
-      source = {dataset: sourceDataset, layer: sourceDataset.layers[0], disposable: true};
+      // Source-file topology is built later if it is needed by the command.
+      sourceDatasets = await importDatasetsFromFile(sourceName, utils.defaults({no_topology: true}, opts));
+      source = getImportedSource(sourceDatasets, sourceName);
     }
     return source;
   }
 
+  function getImportedSource(sourceDatasets, sourceName) {
+    if (sourceDatasets.length != 1) {
+      if (sourceDatasets.length > 1) {
+        stop$1('Multiple-dataset sources are not supported');
+      }
+      stop$1(utils.format('Unable to find source [%s]', sourceName));
+    }
+    var sourceDataset = sourceDatasets[0];
+    if (sourceDataset.layers.length > 1) {
+      stop$1('Multiple-layer sources are not supported');
+    }
+    // mark as disposable to indicate that data can be mutated
+    return {dataset: sourceDataset, layer: sourceDataset.layers[0], disposable: true};
+  }
+
   var SourceUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     convertInterpolatedName: convertInterpolatedName,
     convertSourceName: convertSourceName,
-    findCommandSource: findCommandSource
+    findCommandSourceAsync: findCommandSourceAsync
   });
 
   // Catalog contains zero or more multi-layer datasets
@@ -41375,7 +43597,7 @@ ${svg}
 
   function getPlanarFilter(interval) {
     return function(a, b) {
-      return distance2D(a[0], a[1], b[0], b[1]) <= interval;
+      return distance2D$1(a[0], a[1], b[0], b[1]) <= interval;
     };
   }
 
@@ -41808,7 +44030,7 @@ ${svg}
   }
 
   function probeIsExposed(index, skipA, skipB, vx, vy, p) {
-    var r = distance2D(vx, vy, p[0], p[1]);
+    var r = distance2D$1(vx, vy, p[0], p[1]);
     if (!(r > 0)) return false;
     var r2 = r * r * 0.98 * 0.98;
     var px = p[0], py = p[1];
@@ -41848,6 +44070,13 @@ ${svg}
     return new GeographicLib.Geodesic.Geodesic(P.a, f);
   }
 
+  function getGeodesicDistanceFunction(P) {
+    var geod = getGeodesic(P);
+    return function(lng, lat, lng2, lat2) {
+      return geod.Inverse(lat, lng, lat2, lng2).s12;
+    };
+  }
+
   function interpolatePoint2D(ax, ay, bx, by, k) {
     var j = 1 - k;
     return [ax * j + bx * k, ay * j + by * k];
@@ -41950,6 +44179,7 @@ ${svg}
     bearingDegrees2D: bearingDegrees2D,
     getBearingFunction: getBearingFunction,
     getFastGeodeticSegmentFunction: getFastGeodeticSegmentFunction,
+    getGeodesicDistanceFunction: getGeodesicDistanceFunction,
     getGeodeticSegmentFunction: getGeodeticSegmentFunction,
     getInterpolationFunction: getInterpolationFunction,
     getPlanarSegmentEndpoint: getPlanarSegmentEndpoint,
@@ -43390,7 +45620,7 @@ ${svg}
 
     function stopIfBufferReachesPole(shape, dist) {
       var maxAbsLat = 0;
-      var angularDist = dist / R$3 * R2D$1;
+      var angularDist = dist / R$3 * R2D$6;
       (shape || []).forEach(function(path) {
         latLngPathIter.init(path);
         while (latLngPathIter.hasNext()) {
@@ -43881,11 +46111,11 @@ ${svg}
         if (a[0] === b[0] && a[1] === b[1]) continue;
         bearing = bearingDegrees2D(a[0], a[1], b[0], b[1]);
         probe = getOffsetPoint(a[0], a[1], bearing - 90, dist);
-        rUnits = distance2D(a[0], a[1], probe[0], probe[1]);
+        rUnits = distance2D$1(a[0], a[1], probe[0], probe[1]);
         // perpendicular stab lines every ~0.35r along the band, so cuts
         // affecting only part of a long segment cannot slip between them
         m = Math.max(1, Math.min(60,
-          Math.ceil(distance2D(a[0], a[1], b[0], b[1]) / (rUnits * 0.35))));
+          Math.ceil(distance2D$1(a[0], a[1], b[0], b[1]) / (rUnits * 0.35))));
         for (ti = 0; ti < m; ti++) {
           t = (ti + 0.5) / m;
           base = [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
@@ -43919,14 +46149,14 @@ ${svg}
     function findAtRiskSegments(verts, dist) {
       var n = verts.length;
       var probe0 = getOffsetPoint(verts[0][0], verts[0][1], 0, dist);
-      var rUnits = distance2D(verts[0][0], verts[0][1], probe0[0], probe0[1]);
+      var rUnits = distance2D$1(verts[0][0], verts[0][1], probe0[0], probe0[1]);
       var cumLen = new Float64Array(n);
       var riskVert = new Uint8Array(n);
       var any = false;
       var i, j, k;
       for (i = 1; i < n; i++) {
         cumLen[i] = cumLen[i - 1] +
-          distance2D(verts[i - 1][0], verts[i - 1][1], verts[i][0], verts[i][1]);
+          distance2D$1(verts[i - 1][0], verts[i - 1][1], verts[i][0], verts[i][1]);
       }
       // the ring's start radial and cap-closing radial can cut nearby bands
       riskVert[0] = riskVert[n - 1] = 1;
@@ -43998,7 +46228,7 @@ ${svg}
               j = ids[k];
               if (j <= i) continue;
               var pathDist = cumLen[j] - cumLen[i];
-              var d = distance2D(verts[i][0], verts[i][1], verts[j][0], verts[j][1]);
+              var d = distance2D$1(verts[i][0], verts[i][1], verts[j][0], verts[j][1]);
               // 0.8 flags vertex pairs whose intervening path bends by
               // ~130 degrees or more (a circle's chord/arc ratio is 2/pi,
               // so even gentle loops qualify)
@@ -44050,7 +46280,7 @@ ${svg}
     // at the near end is seeded by an upward ray over those same edges.
     function getRingStabber(rings, dist) {
       var probe0 = getOffsetPoint(rings[0][0][0], rings[0][0][1], 0, dist);
-      var slabW = distance2D(rings[0][0][0], rings[0][0][1], probe0[0], probe0[1]);
+      var slabW = distance2D$1(rings[0][0][0], rings[0][0][1], probe0[0], probe0[1]);
       var ex = [], ey = [], fx = [], fy = []; // edge data
       var slabs = new Map();
       rings.forEach(function(ring) {
@@ -44150,8 +46380,8 @@ ${svg}
       var eps = dist * 1e-4;
       var aIn = getOffsetPoint(a[0], a[1], bearing, eps);
       var bIn = getOffsetPoint(b[0], b[1], bearing - 180, eps);
-      if (distance2D(a[0], a[1], b[0], b[1]) <
-          distance2D(a[0], a[1], aIn[0], aIn[1]) * 3) {
+      if (distance2D$1(a[0], a[1], b[0], b[1]) <
+          distance2D$1(a[0], a[1], aIn[0], aIn[1]) * 3) {
         return; // segment too short to inset
       }
       rings.push([
@@ -44548,7 +46778,7 @@ ${svg}
     }
 
     function shallowAngleJoin(a, b, cx, cy, dist) {
-      var gap = distance2D(a[0], a[1], b[0], b[1]);
+      var gap = distance2D$1(a[0], a[1], b[0], b[1]);
       var radius = getJoinExtensionDistance(cx, cy, a, b, dist);
       if (gap > radius * 1e-3) return null;
       return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
@@ -45507,12 +47737,12 @@ ${svg}
   }
 
   function projectBufferPoint(x, y, spherical) {
-    return spherical ? [x * D2R$1 * R$3, Math.log(Math.tan(Math.PI / 4 + y * D2R$1 / 2)) * R$3] :
+    return spherical ? [x * D2R$7 * R$3, Math.log(Math.tan(Math.PI / 4 + y * D2R$7 / 2)) * R$3] :
       [x, y];
   }
 
   function unprojectBufferPoint(x, y, spherical) {
-    return spherical ? [x / (D2R$1 * R$3), (2 * Math.atan(Math.exp(y / R$3)) - Math.PI / 2) / (D2R$1)] :
+    return spherical ? [x / (D2R$7 * R$3), (2 * Math.atan(Math.exp(y / R$3)) - Math.PI / 2) / (D2R$7)] :
       [x, y];
   }
 
@@ -50183,7 +52413,7 @@ ${svg}
     var maxAbsLat = Math.max(Math.abs(bounds.ymin), Math.abs(bounds.ymax));
     var maxPositiveDistance = getMaxPositiveBufferDistance(lyr, dataset, opts);
     if (!(maxPositiveDistance > 0)) return false;
-    return maxAbsLat + maxPositiveDistance / R$3 * R2D$1 >= 90 - POLAR_BUFFER_MARGIN_DEGREES;
+    return maxAbsLat + maxPositiveDistance / R$3 * R2D$6 >= 90 - POLAR_BUFFER_MARGIN_DEGREES;
   }
 
   function getMaxPositiveBufferDistance(lyr, dataset, opts) {
@@ -51435,7 +53665,7 @@ ${svg}
   }
 
   function getCoordinateDistance(distance, arcs) {
-    return arcs.isPlanar() ? distance : distance / R$3 * R2D$1;
+    return arcs.isPlanar() ? distance : distance / R$3 * R2D$6;
   }
 
   // @shapeIndex: chunk-bounds index of the source shape (see buildShapeSegmentIndex)
@@ -52103,7 +54333,8 @@ ${svg}
     // TODO: consider projections that may or may not be aligned,
     // depending on parameters
     if (inList(P, 'cassini,gnom,bertin1953,chamb,ob_tran,tpeqd,healpix,rhealpix,' +
-      'ocea,omerc,tmerc,etmerc,nicol')) {
+      'ocea,omerc,tmerc,etmerc,nicol,dymaxion,dymaxion2,butterfly,butterfly2,' +
+      'cahill_keyes,narukawa2022')) {
       return false;
     }
     if (isAzimuthal(P)) {
@@ -52155,16 +54386,16 @@ ${svg}
   }
 
   function getRotationFunction2(rotation, inv) {
-    var a = (rotation[0] || 0) * D2R$1,
-        b = (rotation[1] || 0) * D2R$1,
-        c = (rotation[2] || 0) * D2R$1;
+    var a = (rotation[0] || 0) * D2R$7,
+        b = (rotation[1] || 0) * D2R$7,
+        c = (rotation[2] || 0) * D2R$7;
     return function(p) {
-      p[0] *= D2R$1;
-      p[1] *= D2R$1;
+      p[0] *= D2R$7;
+      p[1] *= D2R$7;
       var rotate = inv ? rotatePointInv : rotatePoint;
       rotate(p, a, b, c);
-      p[0] *= R2D$1;
-      p[1] *= R2D$1;
+      p[0] *= R2D$6;
+      p[1] *= R2D$6;
       return p;
     };
   }
@@ -52623,6 +54854,9 @@ ${svg}
   };
 
   function getProjectionTopology(P) {
+    if (P && P.__projection_topology) {
+      return P.__projection_topology;
+    }
     var defn = P && projectionTopologies[getCrsSlug(P)];
     if (!defn) return null;
     var lon0 = P.lam0 * 180 / Math.PI;
@@ -52646,6 +54880,11 @@ ${svg}
   }
 
   function isInterruptedProjection(P) {
+    if (P && P.__projection_topology) {
+      return P.__projection_topology.seams.some(function(o) {
+        return o.type == 'cut';
+      });
+    }
     var defn = P && projectionTopologies[getCrsSlug(P)];
     return !!defn && defn.seams.some(function(o) {
       return o.type == 'cut';
@@ -52719,6 +54958,9 @@ ${svg}
 
   // Return projected polygon extent of both clipped and unclipped projections
   function getPolygonDataset$1(src, dest, opts) {
+    if (dest.__projected_outline) {
+      return getCustomProjectedOutline(dest, 'polygon');
+    }
     // use clipping area if projection is clipped
     var dataset = getUnprojectedBoundingPolygon(src, dest, opts);
     if (!dataset) {
@@ -52734,6 +54976,9 @@ ${svg}
 
   // Return projected outline of clipped projections
   function getOutlineDataset(src, dest, opts) {
+    if (dest.__projected_outline) {
+      return getCustomProjectedOutline(dest, 'polyline');
+    }
     var dataset = getUnprojectedBoundingPolygon(src, dest, opts);
     if (!dataset && isInterruptedProjection(dest)) {
       dataset = getBoundingRectangle(dest, {clip_bbox: [-180, -90, 180, 90]});
@@ -52745,10 +54990,33 @@ ${svg}
         removeTinyFootprintRings(dataset);
       }
       dataset.layers[0].geometry_type = 'polyline';
+      if (dest.__remove_outline_extreme_connectors) {
+        dataset = removeOutlineExtremeConnectors(dataset);
+      }
     }
     return dataset || null;
   }
 
+  function getCustomProjectedOutline(P, geometryType) {
+    var rings = P.__projected_outline.map(function(ring) {
+      return ring.map(function(p) {
+        return [
+          P.fr_meter * (P.a * p[0] + P.x0),
+          P.fr_meter * (P.a * p[1] + P.y0)
+        ];
+      });
+    });
+    var dataset = importGeoJSON({
+      type: rings.length == 1 ? 'Polygon' : 'MultiPolygon',
+      coordinates: rings.length == 1 ? rings : rings.map(function(ring) {
+        return [ring];
+      })
+    });
+    dataset.layers[0].geometry_type = geometryType;
+    dataset.info.crs = P;
+    return dataset;
+  }
+
   // Narrow pre-projection gutters can leave zero-area rings after a rotated
   // world boundary is cleaned. Remove only rings that are negligible relative
   // to the main footprint; legitimate disconnected lobes are retained.
@@ -52770,6 +55038,54 @@ ${svg}
     dissolveArcs(dataset);
   }
 
+  // Polygon clipping closes open interrupted-projection boundaries to form valid
+  // rings. In Cahill-Keyes, some closures connect unrelated polar facet images.
+  // Remove only long, nearly horizontal segments at the map's vertical extent.
+  function removeOutlineExtremeConnectors(dataset) {
+    var bounds = getDatasetBounds(dataset);
+    var width = bounds.width();
+    var height = bounds.height();
+    var edgeTolerance = height * 1e-3;
+    var flatTolerance = height * 1e-4;
+    var arcs = dataset.arcs;
+    var lyr = dataset.layers[0];
+    var paths = [];
+    var removed = 0;
+    lyr.shapes.forEach(function(shp) {
+      (shp || []).forEach(function(path) {
+        var points = [];
+        var iter = arcs.getShapeIter(path);
+        while (iter.hasNext()) {
+          points.push([iter.x, iter.y]);
+        }
+        var part = [points[0]];
+        for (var i = 1; i < points.length; i++) {
+          var a = points[i - 1];
+          var b = points[i];
+          var atTop = Math.min(a[1], b[1]) >= bounds.ymax - edgeTolerance;
+          var atBottom = Math.max(a[1], b[1]) <= bounds.ymin + edgeTolerance;
+          var isFlat = Math.abs(a[1] - b[1]) <= flatTolerance;
+          var isWide = Math.abs(a[0] - b[0]) >= width * 0.02;
+          if ((atTop || atBottom) && isFlat && isWide) {
+            if (part.length > 1) paths.push(part);
+            part = [b];
+            removed++;
+          } else {
+            part.push(b);
+          }
+        }
+        if (part.length > 1) paths.push(part);
+      });
+    });
+    if (removed === 0) return dataset;
+    var cleaned = importGeoJSON({
+      type: paths.length == 1 ? 'LineString' : 'MultiLineString',
+      coordinates: paths.length == 1 ? paths[0] : paths
+    });
+    cleaned.info = dataset.info;
+    return cleaned;
+  }
+
   function getBoundingRectangle(dest, opts) {
     var bbox = opts.clip_bbox || getDefaultClipBBox(dest);
     var rotation = getRotationParams(dest);
@@ -52949,19 +55265,79 @@ ${svg}
     var pathLayers = dataset.layers.filter(layerHasPaths);
     var cutPaths, geojson, clip;
     if (!topology || pathLayers.length === 0) return false;
+    insertProjectionTopologyVertices(dataset, topology);
     cutPaths = topology.seams
       .filter(function(o) { return o.type == 'cut'; })
       .reduce(function(memo, o) {
+        if (o.paths) return memo.concat(o.paths);
         return memo.concat(getCutSeamPaths(o.coordinates));
       }, []);
     if (cutPaths.length === 0) return false;
     geojson = getCutMaskGeoJSON(cutPaths);
     if (geojson.features.length === 0) return false;
     clip = importGeoJSON(geojson);
+    if (topology.findRegion) {
+      // Polyhedral cut masks meet and overlap at facet vertices. Union them before
+      // clipping so overlapping source polygons are not interpreted as holes.
+      addIntersectionCuts(clip, {});
+      clip.layers[0] = dissolvePolygonLayer2(clip.layers[0], clip, {quiet: true});
+    }
     clipLayersInPlace(pathLayers, clip, dataset, 'erase', getInternalClipOpts());
     return true;
   }
 
+  // Add a vertex wherever a path changes projection regions. This preserves a
+  // bend at attached polyhedral edges without opening a gap; cut edges are
+  // subsequently disconnected by the narrow seam masks below.
+  function insertProjectionTopologyVertices(dataset, topology) {
+    if (!dataset.arcs || !topology.findRegion) return;
+    var findRegion = topology.findTransitionRegion || topology.findRegion;
+    editArcs(dataset.arcs, function(append, x, y, prevX, prevY, i) {
+      if (i > 0) {
+        findRegionTransitions(prevX, prevY, x, y, findRegion).forEach(append);
+      }
+      append([x, y]);
+    });
+  }
+
+  function findRegionTransitions(ax, ay, bx, by, findRegion) {
+    var interval = 0.5;
+    var n = Math.max(1, Math.ceil(Math.max(Math.abs(bx - ax), Math.abs(by - ay)) / interval));
+    var points = [];
+    var t0 = 0;
+    var region0 = findRegion(ax, ay);
+    for (var i = 1; i <= n; i++) {
+      var t1 = i / n;
+      var x1 = ax + (bx - ax) * t1;
+      var y1 = ay + (by - ay) * t1;
+      var region1 = findRegion(x1, y1);
+      if (region0 != region1 && region0 >= 0 && region1 >= 0) {
+        var t = findRegionBoundary(ax, ay, bx, by, t0, region0, t1, findRegion);
+        var p = [ax + (bx - ax) * t, ay + (by - ay) * t];
+        if (!points.length || Math.abs(t - points[points.length - 1].t) > 1e-10) {
+          p.t = t;
+          points.push(p);
+        }
+      }
+      t0 = t1;
+      region0 = region1;
+    }
+    return points;
+  }
+
+  function findRegionBoundary(ax, ay, bx, by, ta, regionA, tb, findRegion) {
+    for (var i = 0; i < 45; i++) {
+      var tm = (ta + tb) / 2;
+      var regionM = findRegion(ax + (bx - ax) * tm, ay + (by - ay) * tm);
+      if (regionM == regionA) {
+        ta = tm;
+      } else {
+        tb = tm;
+      }
+    }
+    return (ta + tb) / 2;
+  }
+
   function clampDataset(dataset, bbox) {
     transformPoints(dataset, function(x, y) {
       return [utils.clamp(x, bbox[0], bbox[2]), utils.clamp(y, bbox[1], bbox[3])];
@@ -53016,8 +55392,8 @@ ${svg}
   // their projected edges follow the projection instead of becoming straight
   // chords between seam endpoints.
   function getCutMaskGeoJSON(paths) {
-    var e = 1e-8;
     var features = paths.map(function(coords) {
+      var e = coords.mask_width || 1e-8;
       var ring = getCutMaskRing(densifyPathByInterval(coords, 0.5), e);
       return {
         type: 'Feature',
@@ -53030,6 +55406,33 @@ ${svg}
     }).filter(function(feature) {
       return feature.geometry.coordinates[0].length > 3;
     });
+    // Give finite seams a small end cap. Without this, a path passing exactly
+    // through a polyhedral vertex can touch only the boundary of several masks
+    // and remain connected across an interruption.
+    paths.forEach(function(coords) {
+      var endpoints = [coords[0], coords[coords.length - 1]];
+      endpoints.forEach(function(p) {
+        var e2 = Math.max(1e-7, (coords.mask_width || 0) * 2);
+        var xmin = Math.max(-180, p[0] - e2);
+        var xmax = Math.min(180, p[0] + e2);
+        var ymin = Math.max(-90, p[1] - e2);
+        var ymax = Math.min(90, p[1] + e2);
+        features.push({
+          type: 'Feature',
+          properties: {},
+          geometry: {
+            type: 'Polygon',
+            coordinates: [[
+              [xmin, ymin],
+              [xmax, ymin],
+              [xmax, ymax],
+              [xmin, ymax],
+              [xmin, ymin]
+            ]]
+          }
+        });
+      });
+    });
     return {
       type: 'FeatureCollection',
       features: features
@@ -53048,8 +55451,8 @@ ${svg}
       if (len === 0) continue;
       var nx = -dy / len * width;
       var ny = dx / len * width;
-      left.push([coords[i][0] + nx, coords[i][1] + ny]);
-      right.push([coords[i][0] - nx, coords[i][1] - ny]);
+      left.push([utils.clamp(coords[i][0] + nx, -180, 180), coords[i][1] + ny]);
+      right.push([utils.clamp(coords[i][0] - nx, -180, 180), coords[i][1] - ny]);
     }
     var ring = left.concat(right.reverse());
     if (ring.length > 0) ring.push(ring[0].concat());
@@ -57459,7 +59862,7 @@ ${svg}
   function getSplitLineFunction(crs, dashLen, gapLen, opts) {
     var planar = !!opts.planar;
     var interpolate = getInterpolationFunction(planar ? null : crs);
-    var distance =  isLatLngCRS(crs) ? greatCircleDistance : distance2D;
+    var distance =  isLatLngCRS(crs) ? greatCircleDistance : distance2D$1;
     var inDash, parts2, interval, scale;
     function addPart(coords) {
       if (inDash) parts2.push(coords);
@@ -58330,7 +60733,7 @@ ${svg}
   // Isometric ("Mercator-stretched") latitude in degrees-in; returns +/-Infinity at
   // the poles.
   function isometricLatitude(latDeg) {
-    return Math.log(Math.tan(Math.PI / 4 + latDeg * D2R$1 / 2));
+    return Math.log(Math.tan(Math.PI / 4 + latDeg * D2R$7 / 2));
   }
 
   // Rhumb-line (loxodrome) interpolation, fraction k of the way from A to B.
@@ -58355,9 +60758,9 @@ ${svg}
   // Rhumb-line distance in meters, using the raw longitude delta (so a full-parallel
   // sweep returns the parallel's length rather than 0).
   function rhumbDistance(a, b) {
-    var phi1 = a[1] * D2R$1, phi2 = b[1] * D2R$1;
+    var phi1 = a[1] * D2R$7, phi2 = b[1] * D2R$7;
     var dPhi = phi2 - phi1;
-    var dLambda = (b[0] - a[0]) * D2R$1; // raw
+    var dLambda = (b[0] - a[0]) * D2R$7; // raw
     var dPsi = Math.log(Math.tan(Math.PI / 4 + phi2 / 2) / Math.tan(Math.PI / 4 + phi1 / 2));
     var q = Math.abs(dPsi) > 1e-12 ? dPhi / dPsi : Math.cos(phi1);
     return Math.sqrt(dPhi * dPhi + q * q * dLambda * dLambda) * R$3;
@@ -62022,9 +64425,11 @@ ${svg}
       // project graticule to match dataset
       destInfo = getDatasetCrsInfo(dataset);
       if (!destInfo.crs) stop$1("Coordinate system is unknown, unable to create a graticule");
-      graticule = boundary ?
-        createProjectedPolygon(destInfo.crs, opts) :
-        createProjectedGraticule(destInfo.crs, opts);
+      graticule = opts.outline ?
+        createProjectedOutline(destInfo.crs, opts) :
+        opts.polygon ?
+          createProjectedPolygon(destInfo.crs, opts) :
+          createProjectedGraticule(destInfo.crs, opts);
       setDatasetCrsInfo(graticule, destInfo);
     } else {
       graticule = boundary ?
@@ -62049,6 +64454,12 @@ ${svg}
     return getPolygonDataset$1(src, dest, opts);
   }
 
+  function createProjectedOutline(dest, opts) {
+    var src = parseCrsString$1('wgs84');
+    return getOutlineDataset(src, dest, opts) ||
+      getPolygonDataset$1(src, dest, opts);
+  }
+
   function createUnprojectedGraticule(opts) {
     var src = parseCrsString$1('wgs84');
     var graticule = importGeoJSON(createGraticule(src, false, opts));
@@ -62130,12 +64541,15 @@ ${svg}
     // extended: meridian extends to pole
     function createMeridian(x, extended) {
       var y0 = ystep <= 15 ? ystep : 0;
+      // An exact pole can have several images in a polyhedral projection.
+      // The separate outline supplies the missing, negligible end interval.
+      var poleInset = outlined ? 1e-4 : 0;
       createMeridianPart(x, -90 + y0, 90 - y0);
       if (extended && y0 > 0) {
         // adding extensions as separate parts, so if the polar coordinates
         // fail to project, at least the rest of the meridian line will remain
-        createMeridianPart(x, -90, -90 + y0);
-        createMeridianPart(x, 90 - y0, 90);
+        createMeridianPart(x, -90 + poleInset, -90 + y0);
+        createMeridianPart(x, 90 - y0, 90 - poleInset);
       }
     }
 
@@ -62145,7 +64559,14 @@ ${svg}
     }
 
     function createParallel(y) {
-      var coords = densifyPathByInterval([[-180, y], [180, y]], precision);
+      // Avoid joining distinct images of the antimeridian (and the degenerate
+      // polar parallels) when a projected outline is generated separately.
+      var edgeInset = outlined ? 1e-4 : 0;
+      if (outlined && Math.abs(y) == 90) return;
+      var coords = densifyPathByInterval([
+        [-180 + edgeInset, y],
+        [180 - edgeInset, y]
+      ], precision);
       parallels.push(graticuleFeature(coords, {type: 'parallel', value: y}));
     }
   }
@@ -62744,7 +65165,7 @@ ${svg}
       if (halfLen > 0 === false) {
         return [a, b];
       }
-      var segLen = distance2D(a, b, c, d);
+      var segLen = distance2D$1(a, b, c, d);
       var k;
       if (partialLen + segLen >= halfLen) {
         k = (halfLen - partialLen) / segLen;
@@ -64665,7 +67086,7 @@ ${svg}
 
   // Source: https://diego.assencio.com/?index=8d6ca3d82151bad815f78addf9b5c1c6
   function twoCircleIntersection(c1, r1, c2, r2) {
-    var d = distance2D(c1[0], c1[1], c2[0], c2[1]);
+    var d = distance2D$1(c1[0], c1[1], c2[0], c2[1]);
     if (d >= r1 + r2) return 0;
     var r1sq = r1 * r1,
         r2sq = r2 * r2,
@@ -65498,6 +67919,9 @@ ${svg}
     var commands;
     try {
       commands = parseCommands(commandStr);
+      if (opts && opts.validate_commands) {
+        opts.validate_commands(commands);
+      }
     } catch(e) {
       e.message = 'Error in command file ' + file + ': ' + e.message;
       throw e;
@@ -65519,6 +67943,9 @@ ${svg}
       }
       if (c.name == 'run') {
         c.options._run_depth = depth;
+        if (opts && opts.validate_commands) {
+          c.options.validate_commands = opts.validate_commands;
+        }
       }
     });
 
@@ -65556,6 +67983,9 @@ ${svg}
     ctx = getBaseContext();
     // io proxy adds ability to add datasets dynamically in a required function
     ctx.io = getIOProxy();
+    if (opts.input) {
+      Object.assign(ctx.io._cache, opts.input);
+    }
     tmp = await evalTemplateExpression(opts.expression, targets, ctx);
     if (tmp && !utils.isString(tmp)) {
       stop$1('Expected a string containing mapshaper commands; received:', tmp);
@@ -65564,6 +67994,9 @@ ${svg}
       // truncate message (command might include a large GeoJSON string in an -i command)
       message(`command: [${truncateString(tmp, 150)}]`);
       commands = parseCommands(tmp);
+      if (opts.validate_commands) {
+        opts.validate_commands(commands);
+      }
 
       // TODO: remove duplication with mapshaper-run-commands.mjs
       var outputArr = opts && opts.output || null;
@@ -65578,6 +68011,9 @@ ${svg}
             cmd.name == 'info' && cmd.options.save_to)) {
           cmd.options.output = outputArr;
         }
+        if (cmd.name == 'run' && opts.validate_commands) {
+          cmd.options.validate_commands = opts.validate_commands;
+        }
       });
 
       await utils.promisify(runParsedCommands)(commands, job);
@@ -66660,7 +69096,7 @@ ${svg}
     if (totalSegs < 1) return 0;
     var MAX_SAMPLES = 100000;
     var stride = Math.ceil(totalSegs / MAX_SAMPLES);
-    var distFn = spherical ? greatCircleDistance : distance2D;
+    var distFn = spherical ? greatCircleDistance : distance2D$1;
     var lens = [];
     var counter = 0;
     arcs.forEach3(function(xx, yy) {
@@ -68114,7 +70550,7 @@ ${svg}
       if (Object.prototype.hasOwnProperty.call(command, '_sourceOverride')) {
         source = command._sourceOverride;
       } else if (opts.source) {
-        source = findCommandSource(convertSourceName(opts.source, targets), job.catalog, opts);
+        source = await findCommandSourceAsync(convertSourceName(opts.source, targets), job.catalog, opts);
       }
 
       // identify command target/input (for postprocessing)
@@ -68520,7 +70956,7 @@ ${svg}
     var disposableSourceTargetIndex = -1;
 
     if (command.options.source && !sourceNameIsInterpolated(command.options.source)) {
-      source = resolveSourceForTargets(command, job, targets);
+      source = await resolveSourceForTargets(command, job, targets);
       items = moveSourceTargetLast(items, source);
       disposableSourceTargetIndex = findLastDisposableSourceTarget(
         items,
@@ -68555,10 +70991,10 @@ ${svg}
     return job;
   }
 
-  function resolveSourceForTargets(command, job, targets) {
+  async function resolveSourceForTargets(command, job, targets) {
     job.startCommand(command);
     try {
-      return findCommandSource(
+      return await findCommandSourceAsync(
         convertSourceName(command.options.source, targets),
         job.catalog,
         command.options
@@ -68660,7 +71096,7 @@ ${svg}
     return name == 'rectangle' || name == 'rectangles' || name == 'filter' && opts.cleanup;
   }
 
-  var version = "0.7.44";
+  var version = "0.7.46";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.
@@ -68690,7 +71126,6 @@ ${svg}
       if (err) {
         return callback(err);
       }
-      if (opts.legacy) return callback(null, toLegacyOutputFormat(outputArr));
       return callback(null, toOutputFormat(outputArr));
     });
     if (opts.promise) return opts.promise;
@@ -68732,9 +71167,6 @@ ${svg}
       opts.callback = arg1;
     } else if (utils.isFunction(arg2)) {
       opts.callback = arg2;
-      // identify legacy input format (used by some tests)
-      opts.legacy = arg1 && guessInputContentType(arg1) != null;
-      opts.input = arg1;
     } else {
       // if no callback, create a promise and a callback for resolving the promise
       opts.promise = new Promise(function(resolve, reject) {
@@ -68744,7 +71176,7 @@ ${svg}
         };
       });
     }
-    if (!opts.legacy && utils.isObject(arg1)) {
+    if (utils.isObject(arg1)) {
       if (arg1.xl) {
         // options for runCommandsXL()
         opts.options = arg1;
@@ -68777,12 +71209,6 @@ ${svg}
       return callback(e);
     }
 
-    if (opts.legacy) {
-      message("Warning: deprecated input format");
-      commands = convertLegacyCommands(commands, inputObj);
-      inputObj = null;
-    }
-
     if (commands.length === 0) {
       return callback(new UserError("No commands to run"));
     }
@@ -68819,13 +71245,22 @@ ${svg}
     // (e.g. `mapshaper *.shp batch-mode -o out.json` writing all inputs to the
     // same target on disk).
     var sharedOutputs = [];
-    utils.reduceAsync(batches, null, nextGroup, done);
+    runBatches().then(function(job) {
+      done(null, job);
+    }, done);
 
-    function nextGroup(prevJob, commands, next) {
-      runParsedCommands(commands, new Job(null, {output_files: sharedOutputs}), function(err, job) {
-        err = handleNonFatalError(err);
-        next(err, job);
-      });
+    async function runBatches() {
+      var job;
+      for (var batch of batches) {
+        try {
+          job = await runParsedCommands(batch, new Job(null, {output_files: sharedOutputs}));
+        } catch (e) {
+          var fatalError = handleNonFatalError(e);
+          if (fatalError) throw fatalError;
+          job = undefined;
+        }
+      }
+      return job;
     }
 
     function done(err, job) {
@@ -68839,33 +71274,6 @@ ${svg}
   }
 
 
-  function toLegacyOutputFormat(arr) {
-    if (arr.length > 1) {
-      // Return an array if multiple files are output
-      return utils.pluck(arr, 'content');
-    }
-    if (arr.length == 1) {
-      // Return content if a single file is output
-      return arr[0].content;
-    }
-    return null;
-  }
-
-  function convertLegacyCommands(arr, inputObj) {
-    var i = utils.find(arr, function(cmd) {return cmd.name == 'i';});
-    var o = utils.find(arr, function(cmd) {return cmd.name == 'o';});
-    if (!i) {
-      i = {name: 'i', options: {}};
-      arr.unshift(i);
-    }
-    i.options.files = ['__input__'];
-    i.options.input = {__input__: inputObj};
-    if (!o) {
-      arr.push({name: 'o', options: {}});
-    }
-    return arr;
-  }
-
   // TODO: rewrite tests and remove this function
   function testCommands(argv, done) {
     _runCommands(argv, {}, function(err, job) {
@@ -68883,9 +71291,20 @@ ${svg}
   // Execute a sequence of parsed commands
   // @commands Array of parsed commands
   // @job: Job object containing previously imported data
-  // @done: function([error], [job])
+  // @done: optional function([error], [job]); returns a Promise if omitted
   //
   function runParsedCommands(commands, job, done) {
+    var promise = runParsedCommandsAsync(commands, job);
+    if (done) {
+      promise.then(function(job) {
+        done(null, job);
+      }, done);
+      return;
+    }
+    return promise;
+  }
+
+  async function runParsedCommandsAsync(commands, job) {
     if (!job) job = new Job();
     commands = readAndRemoveSettings(job, commands);
     if (!runningInBrowser()) {
@@ -68893,26 +71312,16 @@ ${svg}
     }
     commands = runAndRemoveInfoCommands(commands);
     if (commands.length === 0) {
-      return done(null);
+      return;
     }
     // we're no longer using the same Job for all batches -- no reset needed
     // // resetting closes any unterminated -if blocks from a previous command sequence
     // resetControlFlow(job);
-    utils.reduceAsync(commands, job, nextCommand, done);
-
-    function nextCommand(job, cmd, next) {
-      var resolved;
-      try {
-        resolved = maybeInterpolateCommand(cmd, job);
-      } catch(e) {
-        return next(e);
-      }
-      runCommand(resolved, job).then(function(result) {
-        next(null, result);
-      }).catch(function(e) {
-        next(e);
-      });
+    for (var command of commands) {
+      var resolved = maybeInterpolateCommand(command, job);
+      job = await runCommand(resolved, job);
     }
+    return job;
   }
 
   // Late-binding interpolation: just before each command runs, replace any
@@ -70524,6 +72933,9 @@ ${svg}
     ClipPoints,
     Colorizer,
     CustomProjections,
+    Dymaxion,
+    ButterflyProjections,
+    Narukawa2022,
     DataAggregation,
     DatasetUtils,
     DataUtils,