mapshaper 0.6.117 → 0.6.119

package/www/mapshaper.js

@@ -19,7 +19,7 @@
     get expandoBuffer () { return expandoBuffer; },
     get extend () { return extend$1; },
     get extendBuffer () { return extendBuffer; },
-    get find () { return find; },
+    get find () { return find$1; },
     get findMedian () { return findMedian; },
     get findQuantile () { return findQuantile; },
     get findRankByValue () { return findRankByValue; },
@@ -442,7 +442,7 @@
     }, true);
   }
 
-  function find(arr, test, ctx) {
+  function find$1(arr, test, ctx) {
     var matches = arr.filter(test, ctx);
     return matches.length === 0 ? null : matches[0];
   }
@@ -3208,6 +3208,25 @@
 
   //import { findCrossIntersection_big } from '../geom/mapshaper-segment-geom-big';
 
+  // Ad-hoc counters (reset by segmentIntersectionStatsReset, inspected by
+  // segmentIntersectionStats). Cheap when unused, so safe to leave in.
+  var STATS = {
+    calls: 0,            // segmentIntersection() invocations
+    touches: 0,          // pairs that returned a T-touch result
+    endpointHits: 0,     // pairs that returned null via testEndpointHit
+    crossCandidates: 0,  // pairs that reached findCrossIntersection()
+    crossRejectedFast: 0,// rejected by segmentHit_fast early-out
+    crossRobust: 0,      // useRobustCross() === true, ran BigInt math
+    crossFast: 0,        // useRobustCross() === false, ran fp math
+    crossNull: 0         // findCrossIntersection returned null (e.g. collinear)
+  };
+  function segmentIntersectionStatsReset() {
+    for (var k in STATS) STATS[k] = 0;
+  }
+  function segmentIntersectionStats() {
+    return Object.assign({}, STATS);
+  }
+
   // Find the intersection between two 2D segments
   // Returns 0, 1 or 2 [x, y] locations as null, [x, y], or [x1, y1, x2, y2]
   // Special cases:
@@ -3217,6 +3236,7 @@
   //    is counted as an intersection (there will be either one or two)
   //
   function segmentIntersection(ax, ay, bx, by, cx, cy, dx, dy, epsArg) {
+    STATS.calls++;
     // Use a small tolerance interval, so collinear segments and T-intersections
     // are detected (floating point rounding often causes exact functions to fail)
     var eps = epsArg > 0 ? epsArg :
@@ -3230,8 +3250,10 @@
     // segments that share an endpoint. Two touches indicates overlapping
     // collinear segments that do not share an endpoint.
     touches = findPointSegTouches(epsSq, ax, ay, bx, by, cx, cy, dx, dy);
+    if (touches) STATS.touches++;
     // Ignore endpoint-only intersections
     if (!touches && testEndpointHit(epsSq, ax, ay, bx, by, cx, cy, dx, dy)) {
+      STATS.endpointHits++;
       return null;
     }
     // Detect cross intersection
@@ -3243,6 +3265,7 @@
   }
 
   function findCrossIntersection(ax, ay, bx, by, cx, cy, dx, dy, eps) {
+    STATS.crossCandidates++;
     var p;
     // The normal-precision hit function works for all inputs when eps > 0 because
     // the geometries that cause the ordinary function fails are detected as
@@ -3250,8 +3273,10 @@
     // data samples that were tested).
     //
     if (eps > 0 && !segmentHit_fast(ax, ay, bx, by, cx, cy, dx, dy)) {
+      STATS.crossRejectedFast++;
       return null;
     } else if (eps === 0 && !segmentHit_robust(ax, ay, bx, by, cx, cy, dx, dy)) {
+      STATS.crossRejectedFast++;
       return null;
     }
 
@@ -3260,17 +3285,13 @@
     // the positional error within a small interval (e.g. 50% of eps)
     //
     if (useRobustCross(ax, ay, bx, by, cx, cy, dx, dy)) {
+      STATS.crossRobust++;
       p = findCrossIntersection_robust(ax, ay, bx, by, cx, cy, dx, dy);
-      // var p2 = findCrossIntersection_big(ax, ay, bx, by, cx, cy, dx, dy);
-      // var dx = p[0] - p2[0];
-      // var dy = p[1] - p2[1];
-      // if (dx != 0 || dy != 0) {
-      //   console.log(dx, dy)
-      // }
     } else {
+      STATS.crossFast++;
       p = findCrossIntersection_fast(ax, ay, bx, by, cx, cy, dx, dy);
     }
-    if (!p) return null;
+    if (!p) { STATS.crossNull++; return null; }
 
     // Snap p to a vertex if very close to one
     // This avoids tiny segments caused by T-intersection overshoots and prevents
@@ -3590,6 +3611,8 @@
     orient2D_robust: orient2D_robust,
     segmentHit_fast: segmentHit_fast,
     segmentIntersection: segmentIntersection,
+    segmentIntersectionStats: segmentIntersectionStats,
+    segmentIntersectionStatsReset: segmentIntersectionStatsReset,
     segmentTurn: segmentTurn
   });
 
@@ -6399,41 +6422,52 @@
     };
   }
 
-  // Used for building topology
+  // Used for building topology.
+  //
+  // Every arc is stored as a reference into some source coordinate arrays
+  // (srcXX/srcYY) plus an inclusive [start..end] index range. The caller
+  // decides which buffer to hand in: the shared xx/yy for normal arcs, or
+  // a freshly-allocated merged buffer for split/wrap-around arcs. ArcIndex
+  // doesn't care which — no sentinels, no special cases in its own code.
   //
   function ArcIndex(pointCount) {
     var hashTableSize = Math.floor(pointCount * 0.25 + 1),
         hash = getXYHash(hashTableSize),
         hashTable = new Int32Array(hashTableSize),
         chainIds = [],
-        arcs = [],
+        arcSrcXX = [],
+        arcSrcYY = [],
+        arcStart = [],
+        arcEnd = [],
         arcPoints = 0;
 
-    utils.initializeArray(hashTable, -1);
+    initializeArray(hashTable, -1);
 
-    this.addArc = function(xx, yy) {
-      var end = xx.length - 1,
-          key = hash(xx[end], yy[end]),
-          chainId = hashTable[key],
-          arcId = arcs.length;
+    // Register an arc whose coordinates are `srcXX[start..end]`, `srcYY[start..end]`
+    // (inclusive). Returns the new arc id.
+    this.addArc = function(srcXX, srcYY, start, end) {
+      var arcId = arcSrcXX.length,
+          key = hash(srcXX[end], srcYY[end]);
+      chainIds.push(hashTable[key]);
       hashTable[key] = arcId;
-      arcs.push([xx, yy]);
-      arcPoints += xx.length;
-      chainIds.push(chainId);
+      arcSrcXX.push(srcXX);
+      arcSrcYY.push(srcYY);
+      arcStart.push(start);
+      arcEnd.push(end);
+      arcPoints += end - start + 1;
       return arcId;
     };
 
-    // Look for a previously generated arc with the same sequence of coords, but in the
-    // opposite direction. (This program uses the convention of CW for space-enclosing rings, CCW for holes,
-    // so coincident boundaries should contain the same points in reverse sequence).
+    // Look for a previously generated arc with the same sequence of coords, but
+    // in the opposite direction. (This program uses the convention of CW for
+    // space-enclosing rings, CCW for holes, so coincident boundaries should
+    // contain the same points in reverse sequence.)
     //
     this.findDuplicateArc = function(xx, yy, start, end, getNext, getPrev) {
-      // First, look for a reverse match
       var arcId = findArcNeighbor(xx, yy, start, end, getNext);
       if (arcId === null) {
-        // Look for forward match
-        // (Abnormal topology, but we're accepting it because in-the-wild
-        // Shapefiles sometimes have duplicate paths)
+        // Look for forward match (abnormal topology, but we accept it because
+        // in-the-wild Shapefiles sometimes have duplicate paths).
         arcId = findArcNeighbor(xx, yy, end, start, getPrev);
       } else {
         arcId = ~arcId;
@@ -6445,17 +6479,14 @@
       var next = getNext(start),
           key = hash(xx[start], yy[start]),
           arcId = hashTable[key],
-          arcX, arcY, len;
-
+          sx, sy, s, e;
       while (arcId != -1) {
-        // check endpoints and one segment...
-        // it would be more rigorous but slower to identify a match
-        // by comparing all segments in the coordinate sequence
-        arcX = arcs[arcId][0];
-        arcY = arcs[arcId][1];
-        len = arcX.length;
-        if (arcX[0] === xx[end] && arcX[len-1] === xx[start] && arcX[len-2] === xx[next] &&
-            arcY[0] === yy[end] && arcY[len-1] === yy[start] && arcY[len-2] === yy[next]) {
+        sx = arcSrcXX[arcId]; sy = arcSrcYY[arcId];
+        s = arcStart[arcId];  e = arcEnd[arcId];
+        // Check endpoints and one segment. A more rigorous match would compare
+        // every segment, but that's slower and this is sufficient in practice.
+        if (sx[s] === xx[end] && sx[e] === xx[start] && sx[e - 1] === xx[next] &&
+            sy[s] === yy[end] && sy[e] === yy[start] && sy[e - 1] === yy[next]) {
           return arcId;
         }
         arcId = chainIds[arcId];
@@ -6464,22 +6495,31 @@
     }
 
     this.getVertexData = function() {
-      var xx = new Float64Array(arcPoints),
-          yy = new Float64Array(arcPoints),
-          nn = new Uint32Array(arcs.length),
+      var arcCount = arcSrcXX.length,
+          destXX = new Float64Array(arcPoints),
+          destYY = new Float64Array(arcPoints),
+          nn = new Uint32Array(arcCount),
           copied = 0,
-          arc, len;
-      for (var i=0, n=arcs.length; i<n; i++) {
-        arc = arcs[i];
-        len = arc[0].length;
-        utils.copyElements(arc[0], 0, xx, copied, len);
-        utils.copyElements(arc[1], 0, yy, copied, len);
+          sx, sy, s, e, len, i;
+      for (i = 0; i < arcCount; i++) {
+        sx = arcSrcXX[i]; sy = arcSrcYY[i];
+        s = arcStart[i];  e = arcEnd[i];
+        len = e - s + 1;
+        if (sx.subarray) {
+          destXX.set(sx.subarray(s, e + 1), copied);
+          destYY.set(sy.subarray(s, e + 1), copied);
+        } else {
+          for (var k = 0; k < len; k++) {
+            destXX[copied + k] = sx[s + k];
+            destYY[copied + k] = sy[s + k];
+          }
+        }
         nn[i] = len;
         copied += len;
       }
       return {
-        xx: xx,
-        yy: yy,
+        xx: destXX,
+        yy: destYY,
         nn: nn
       };
     };
@@ -6578,18 +6618,15 @@
     var pointCount = xx.length,
         chainIds = initPointChains(xx, yy),
         pathIds = initPathIds(pointCount, nn),
+        pathIsRing = initPathIsRing(nn, xx, yy),
+        isNode = computeIsNode(nn, xx, yy, chainIds, pathIds, pathIsRing),
         index = new ArcIndex(pointCount),
-        slice = usingTypedArrays() ? xx.subarray : Array.prototype.slice,
         paths, retn;
     paths = convertPaths(nn);
     retn = index.getVertexData();
     retn.paths = paths;
     return retn;
 
-    function usingTypedArrays() {
-      return !!(xx.subarray && yy.subarray);
-    }
-
     function convertPaths(nn) {
       var paths = [],
           pointId = 0,
@@ -6602,28 +6639,28 @@
       return paths;
     }
 
+    // Fast neighbour lookups using the precomputed pathIsRing cache.
+    // Used by findDuplicateArc (via addEdge/addSplitEdge) and by addRing.
     function nextPoint(id) {
       var partId = pathIds[id],
           nextId = id + 1;
       if (nextId < pointCount && pathIds[nextId] === partId) {
-        return id + 1;
+        return nextId;
       }
-      var len = nn[partId];
-      return sameXY(id, id - len + 1) ? id - len + 2 : -1;
+      return pathIsRing[partId] ? id - nn[partId] + 2 : -1;
     }
 
     function prevPoint(id) {
       var partId = pathIds[id],
           prevId = id - 1;
       if (prevId >= 0 && pathIds[prevId] === partId) {
-        return id - 1;
+        return prevId;
       }
-      var len = nn[partId];
-      return sameXY(id, id + len - 1) ? id + len - 2 : -1;
+      return pathIsRing[partId] ? id + nn[partId] - 2 : -1;
     }
 
-    function sameXY(a, b) {
-      return xx[a] == xx[b] && yy[a] == yy[b];
+    function pointIsArcEndpoint(id) {
+      return isNode[id] === 1;
     }
 
     // Convert a non-topological path to one or more topological arcs
@@ -6666,49 +6703,9 @@
       return arcIds;
     }
 
-    // Test if a point @id is an endpoint of a topological path
-    function pointIsArcEndpoint(id) {
-      var id2 = chainIds[id],
-          prev = prevPoint(id),
-          next = nextPoint(id),
-          prev2, next2;
-      if (prev == -1 || next == -1) {
-        // @id is an endpoint if it is the start or end of an open path
-        return true;
-      }
-      while (id != id2) {
-        prev2 = prevPoint(id2);
-        next2 = nextPoint(id2);
-        if (prev2 == -1 || next2 == -1 || brokenEdge(prev, next, prev2, next2)) {
-          // there is a discontinuity at @id -- point is arc endpoint
-          return true;
-        }
-        id2 = chainIds[id2];
-      }
-      return false;
-    }
-
-    // a and b are two vertices with the same x, y coordinates
-    // test if the segments on either side of them are also identical
-    function brokenEdge(aprev, anext, bprev, bnext) {
-      var apx = xx[aprev],
-          anx = xx[anext],
-          bpx = xx[bprev],
-          bnx = xx[bnext],
-          apy = yy[aprev],
-          any = yy[anext],
-          bpy = yy[bprev],
-          bny = yy[bnext];
-      if (apx == bnx && anx == bpx && apy == bny && any == bpy ||
-          apx == bpx && anx == bnx && apy == bpy && any == bny) {
-        return false;
-      }
-      return true;
-    }
-
     function mergeArcParts(src, startId, endId, startId2, endId2) {
       var len = endId - startId + endId2 - startId2 + 2,
-          ArrayClass = usingTypedArrays() ? Float64Array : Array,
+          ArrayClass = src.subarray ? Float64Array : Array,
           dest = new ArrayClass(len),
           j = 0, i;
       for (i=startId; i <= endId; i++) {
@@ -6723,8 +6720,12 @@
     function addSplitEdge(start1, end1, start2, end2) {
       var arcId = index.findDuplicateArc(xx, yy, start1, end2, nextPoint, prevPoint);
       if (arcId === null) {
-        arcId = index.addArc(mergeArcParts(xx, start1, end1, start2, end2),
-            mergeArcParts(yy, start1, end1, start2, end2));
+        // Coordinates for a split (wrap-around) edge don't form a contiguous
+        // slice of xx/yy, so we build a standalone buffer and hand it to the
+        // index as the arc's source.
+        var mx = mergeArcParts(xx, start1, end1, start2, end2),
+            my = mergeArcParts(yy, start1, end1, start2, end2);
+        arcId = index.addArc(mx, my, 0, mx.length - 1);
       }
       return arcId;
     }
@@ -6733,8 +6734,7 @@
       // search for a matching edge that has already been generated
       var arcId = index.findDuplicateArc(xx, yy, start, end, nextPoint, prevPoint);
       if (arcId === null) {
-        arcId = index.addArc(slice.call(xx, start, end + 1),
-            slice.call(yy, start, end + 1));
+        arcId = index.addArc(xx, yy, start, end);
       }
       return arcId;
     }
@@ -6777,6 +6777,87 @@
     return pathIds;
   }
 
+  // Per-path flag: 1 if the path is a closed ring (first vertex coincides with
+  // last vertex), else 0. Computed once so that prevPoint()/nextPoint() don't
+  // need to call sameXY() at path boundaries.
+  //
+  function initPathIsRing(nn, xx, yy) {
+    var pathCount = nn.length,
+        pathIsRing = new Uint8Array(pathCount),
+        pstart = 0, len;
+    for (var p = 0; p < pathCount; p++) {
+      len = nn[p];
+      if (len > 1 &&
+          xx[pstart] === xx[pstart + len - 1] &&
+          yy[pstart] === yy[pstart + len - 1]) {
+        pathIsRing[p] = 1;
+      }
+      pstart += len;
+    }
+    return pathIsRing;
+  }
+
+  // Decide, for every point, whether it is a topological node (an arc
+  // endpoint). Being a node is a property of the entire coincident-point
+  // chain: all points sharing a location agree on the answer. So we walk
+  // each chain at most once — O(n) total — instead of doing the walk
+  // independently at every point (O(n * K), quadratic per chain).
+  //
+  // A chain's points are nodes iff:
+  //   - any member has a missing neighbour (open-path endpoint), or
+  //   - two members disagree on the unordered pair of neighbour coords.
+  //
+  function computeIsNode(nn, xx, yy, chainIds, pathIds, pathIsRing) {
+    var n = xx.length,
+        isNode = new Uint8Array(n),
+        done = new Uint8Array(n);
+
+    function nextPoint(id) {
+      var part = pathIds[id], nid = id + 1;
+      if (nid < n && pathIds[nid] === part) return nid;
+      return pathIsRing[part] ? id - nn[part] + 2 : -1;
+    }
+
+    function prevPoint(id) {
+      var part = pathIds[id], pid = id - 1;
+      if (pid >= 0 && pathIds[pid] === part) return pid;
+      return pathIsRing[part] ? id + nn[part] - 2 : -1;
+    }
+
+    for (var i = 0; i < n; i++) {
+      if (done[i]) continue;
+      var result = chainIsBroken(i);
+      var id = i;
+      do {
+        isNode[id] = result;
+        done[id] = 1;
+        id = chainIds[id];
+      } while (id !== i);
+    }
+    return isNode;
+
+    // Returns 1 if the chain containing `start` has any broken neighbour
+    // signature (i.e. all members are nodes), else 0.
+    function chainIsBroken(start) {
+      var prev = prevPoint(start),
+          next = nextPoint(start);
+      if (prev === -1 || next === -1) return 1;
+      var refPX = xx[prev], refPY = yy[prev],
+          refNX = xx[next], refNY = yy[next];
+      var id = chainIds[start];
+      while (id !== start) {
+        var p = prevPoint(id), q = nextPoint(id);
+        if (p === -1 || q === -1) return 1;
+        var px = xx[p], py = yy[p], qx = xx[q], qy = yy[q];
+        var fwd = px === refPX && py === refPY && qx === refNX && qy === refNY;
+        var rev = px === refNX && py === refNY && qx === refPX && qy === refPY;
+        if (!fwd && !rev) return 1;
+        id = chainIds[id];
+      }
+      return 0;
+    }
+  }
+
   function replaceArcIds(src, replacements) {
     return src.map(function(shape) {
       return replaceArcsInShape(shape, replacements);
@@ -7262,15 +7343,201 @@
     };
   }
 
+  // Lightweight hierarchical profiler.
+  // Intended for ad-hoc performance work on hot pipelines (e.g. addIntersectionCuts).
+  //
+  // Usage:
+  //   import { profileStart, profileEnd, profileWrap, ... } from './utils/mapshaper-profile';
+  //   profileStart('phase'); doWork(); profileEnd('phase');
+  //   var result = profileWrap('phase', () => doWork());
+  //
+  // When disabled (the default) every call short-circuits in ~one comparison; safe
+  // to leave in hot code paths. Enable from the CLI with the `-profile` command,
+  // from JS with enableProfiling(), or by setting the MAPSHAPER_PROFILE env var.
+  //
+  // The profiler tracks a stack of currently-open phases so calls can nest. Each
+  // unique stack path accumulates ms-elapsed and a call count. profileReport()
+  // returns a flat array; formatProfileReport() pretty-prints a tree.
+
+  var ENABLED = false;
+  var ROOT = makeNode('<root>');
+  var STACK = [ROOT];
+  var WALL_START = 0;
+
+  function makeNode(label) {
+    return {
+      label: label,
+      totalMs: 0,
+      selfMs: 0,
+      calls: 0,
+      childMsAccum: 0,
+      children: Object.create(null)
+    };
+  }
+
+  function nowMs() {
+    if (typeof process !== 'undefined' && process.hrtime && process.hrtime.bigint) {
+      // bigint -> number division: precision down to 1 microsecond is fine for our needs
+      return Number(process.hrtime.bigint()) / 1e6;
+    }
+    if (typeof performance !== 'undefined' && performance.now) {
+      return performance.now();
+    }
+    return Date.now();
+  }
+
+  function enableProfiling() {
+    ENABLED = true;
+    WALL_START = nowMs();
+  }
+
+  function disableProfiling() {
+    ENABLED = false;
+  }
+
+  function profileEnabled() {
+    return ENABLED;
+  }
+
+  function profileReset() {
+    ROOT = makeNode('<root>');
+    STACK = [ROOT];
+    WALL_START = ENABLED ? nowMs() : 0;
+  }
+
+  // Open a new phase. Cheap (~one branch) when disabled.
+  function profileStart(label) {
+    if (!ENABLED) return;
+    var parent = STACK[STACK.length - 1];
+    var node = parent.children[label];
+    if (!node) {
+      node = makeNode(label);
+      parent.children[label] = node;
+    }
+    node._t0 = nowMs();
+    STACK.push(node);
+  }
+
+  function profileEnd(label) {
+    if (!ENABLED) return;
+    var node = STACK[STACK.length - 1];
+    if (label && node.label !== label) {
+      // Mismatched labels usually mean an early return forgot to call profileEnd().
+      // Walk up the stack until we find a match, closing the intervening frames.
+      while (STACK.length > 1 && STACK[STACK.length - 1].label !== label) {
+        profileEnd(STACK[STACK.length - 1].label);
+      }
+      node = STACK[STACK.length - 1];
+      if (node.label !== label) return; // give up rather than throw
+    }
+    var elapsed = nowMs() - node._t0;
+    node._t0 = 0;
+    node.totalMs += elapsed;
+    node.calls += 1;
+    STACK.pop();
+    var parent = STACK[STACK.length - 1];
+    parent.childMsAccum += elapsed;
+  }
+
+  // Wrap a function call. Re-throws if the callback throws but still closes the
+  // phase so the stack stays consistent.
+  function profileWrap(label, fn) {
+    if (!ENABLED) return fn();
+    profileStart(label);
+    try {
+      return fn();
+    } finally {
+      profileEnd(label);
+    }
+  }
+
+  // Build a flat tree report: array of {depth, label, totalMs, selfMs, calls}.
+  function profileReport() {
+    var rows = [];
+    function visit(node, depth) {
+      if (depth > 0) {
+        rows.push({
+          depth: depth - 1,
+          label: node.label,
+          totalMs: node.totalMs,
+          selfMs: Math.max(0, node.totalMs - node.childMsAccum),
+          calls: node.calls
+        });
+      }
+      var keys = Object.keys(node.children);
+      keys.sort(function(a, b) {
+        return node.children[b].totalMs - node.children[a].totalMs;
+      });
+      for (var i = 0; i < keys.length; i++) {
+        visit(node.children[keys[i]], depth + 1);
+      }
+    }
+    visit(ROOT, 0);
+    return rows;
+  }
+
+  function profileWallElapsedMs() {
+    return ENABLED && WALL_START ? nowMs() - WALL_START : 0;
+  }
+
+  // Pretty-print the current report as a column-aligned tree.
+  function formatProfileReport(opts) {
+    var rows = profileReport();
+    if (rows.length === 0) return '(profile is empty)';
+    opts = opts || {};
+    var indent = '  ';
+    var lines = [];
+    // header
+    lines.push(['phase', 'total ms', 'self ms', 'calls'].join('\t'));
+    for (var i = 0; i < rows.length; i++) {
+      var r = rows[i];
+      var label = '';
+      for (var j = 0; j < r.depth; j++) label += indent;
+      label += r.label;
+      lines.push([
+        label,
+        r.totalMs.toFixed(2),
+        r.selfMs.toFixed(2),
+        String(r.calls)
+      ].join('\t'));
+    }
+    if (opts.includeWall) {
+      lines.push('');
+      lines.push('wall elapsed ms: ' + profileWallElapsedMs().toFixed(2));
+    }
+    return lines.join('\n');
+  }
+
+  // Honour an env var so users (and CI harnesses) can opt in without code changes.
+  if (typeof process !== 'undefined' && process.env && process.env.MAPSHAPER_PROFILE) {
+    enableProfiling();
+  }
+
+  var Profile = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    disableProfiling: disableProfiling,
+    enableProfiling: enableProfiling,
+    formatProfileReport: formatProfileReport,
+    profileEnabled: profileEnabled,
+    profileEnd: profileEnd,
+    profileReport: profileReport,
+    profileReset: profileReset,
+    profileStart: profileStart,
+    profileWallElapsedMs: profileWallElapsedMs,
+    profileWrap: profileWrap
+  });
+
   // Dissolve arcs that can be merged without affecting topology of layers
   // remove arcs that are not referenced by any layer; remap arc ids
   // in layers. (dataset.arcs is replaced).
   function dissolveArcs(dataset) {
+    profileStart('dissolveArcs.body');
     var arcs = dataset.arcs,
         layers = dataset.layers.filter(layerHasPaths);
 
     if (!arcs || !layers.length) {
       dataset.arcs = null;
+      profileEnd('dissolveArcs.body');
       return;
     }
 
@@ -7280,14 +7547,17 @@
         arcIndex = new Int32Array(arcs.size()), // maps old arc ids to new ids
         arcStatus = new Uint8Array(arcs.size());
         // arcStatus: 0 = unvisited, 1 = dropped, 2 = remapped, 3 = remapped + reversed
+    profileStart('dissolveArcs.translatePaths');
     layers.forEach(function(lyr) {
-      // modify copies of the original shapes; original shapes should be unmodified
-      // (need to test this)
       lyr.shapes = lyr.shapes.map(function(shape, i) {
         return editShapeParts(shape && shape.concat(), translatePath);
       });
     });
+    profileEnd('dissolveArcs.translatePaths');
+    profileStart('dissolveArcs.dissolveArcCollection');
     dataset.arcs = dissolveArcCollection(arcs, newArcs, totalPoints);
+    profileEnd('dissolveArcs.dissolveArcCollection');
+    profileEnd('dissolveArcs.body');
 
     function translatePath(path) {
       var pointCount = 0;
@@ -12449,14 +12719,22 @@
 
     function testPointInRing(p, cand) {
       if (!cand.bounds.containsPoint(p[0], p[1])) return false;
-      if (!cand.index && cand.bounds.area() > totalArea * 0.01) {
-        // index larger polygons (because they are slower to test via pointInRing()
-        //    and they are more likely to be involved in repeated hit tests).
-        cand.index = new PolygonIndex([cand.ids], arcs);
+      if (!cand.index) {
+        // Build a per-ring scanline index when (a) the ring is large relative to
+        // the dataset (likely involved in many hit tests anyway) or (b) the same
+        // ring has already been tested at least once, indicating it lies in a
+        // hot spot for repeated point-in-polygon queries (e.g. coastal counties
+        // tested by every offshore-island CCW ring during mosaic enclosure
+        // detection). Building on the second hit avoids paying the index build
+        // cost for rings that are tested only once.
+        if (cand._tested || cand.bounds.area() > totalArea * 0.01) {
+          cand.index = new PolygonIndex([cand.ids], arcs);
+        } else {
+          cand._tested = true;
+          return geom.testPointInRing(p[0], p[1], cand.ids, arcs);
+        }
       }
-      return cand.index ?
-          cand.index.pointInPolygon(p[0], p[1]) :
-          geom.testPointInRing(p[0], p[1], cand.ids, arcs);
+      return cand.index.pointInPolygon(p[0], p[1]);
     }
 
     //
@@ -13476,6 +13754,7 @@
 
     function singleStripeId(y) {return 0;}
     // Count segments in each stripe
+    profileStart('stripeSetup');
     arcs.forEachSegment(function(id1, id2, xx, yy) {
       var s1 = stripeId(yy[id1]),
           s2 = stripeId(yy[id2]);
@@ -13512,8 +13791,10 @@
         s1 += s2 > s1 ? 1 : -1;
       }
     });
+    profileEnd('stripeSetup');
 
     // Detect intersections among segments in each stripe.
+    profileStart('intersectSegments');
     var raw = arcs.getVertexData(),
         intersections = [],
         arr;
@@ -13523,7 +13804,11 @@
         intersections.push(arr[j]);
       }
     }
-    return dedupIntersections(intersections, opts.unique ? getUniqueIntersectionKey : null);
+    profileEnd('intersectSegments');
+    profileStart('dedupIntersections');
+    var deduped = dedupIntersections(intersections, opts.unique ? getUniqueIntersectionKey : null);
+    profileEnd('dedupIntersections');
+    return deduped;
   }
 
 
@@ -13536,22 +13821,42 @@
 
 
   function dedupIntersections(arr, keyFunction) {
-    var index = {};
-    var getKey = keyFunction || getIntersectionKey;
-    return arr.filter(function(o) {
-      var key = getKey(o);
-      if (key in index) {
-        return false;
+    if (keyFunction) {
+      var index = new Map();
+      var out = [];
+      for (var i = 0, n = arr.length; i < n; i++) {
+        var o = arr[i];
+        var k = keyFunction(o);
+        if (index.has(k)) continue;
+        index.set(k, true);
+        out.push(o);
       }
-      index[key] = true;
-      return true;
-    });
-  }
-
-  // Get an indexable key from an intersection object
-  // Assumes that vertex ids of o.a and o.b are sorted
-  function getIntersectionKey(o) {
-    return o.a.join(',') + ';' + o.b.join(',');
+      return out;
+    }
+    // Default key is the pair of segments (a, b). Each segment is a vertex id
+    // pair where the second id is either equal to or one greater than the first
+    // (see formatIntersectingSegment). Pack each segment into a single number
+    // (id * 2 + isMidSegment) and use a two-level Map keyed by integers, which
+    // avoids the per-call string allocation of the previous Array#join key.
+    var outer = new Map();
+    var result = [];
+    for (var ii = 0, nn = arr.length; ii < nn; ii++) {
+      var o2 = arr[ii];
+      var a = o2.a, b = o2.b;
+      var ak = a[0] * 2 + (a[0] === a[1] ? 0 : 1);
+      var bk = b[0] * 2 + (b[0] === b[1] ? 0 : 1);
+      var inner = outer.get(ak);
+      if (inner) {
+        if (inner.has(bk)) continue;
+        inner.add(bk);
+      } else {
+        inner = new Set();
+        inner.add(bk);
+        outer.set(ak, inner);
+      }
+      result.push(o2);
+    }
+    return result;
   }
 
   function getUniqueIntersectionKey(o) {
@@ -16945,16 +17250,26 @@
   // Remove any unused arcs from the dataset's ArcCollection.
   // Return a NodeCollection
   function cleanArcReferences(dataset) {
+    profileStart('NodeCollection#1');
     var nodes = new NodeCollection(dataset.arcs);
+    profileEnd('NodeCollection#1');
+    profileStart('findDuplicateArcs');
     var map = findDuplicateArcs(nodes);
+    profileEnd('findDuplicateArcs');
     var dropCount;
     if (map) {
+      profileStart('replaceIndexedArcIds');
       replaceIndexedArcIds(dataset, map);
+      profileEnd('replaceIndexedArcIds');
     }
+    profileStart('deleteUnusedArcs');
     dropCount = deleteUnusedArcs(dataset);
+    profileEnd('deleteUnusedArcs');
     if (dropCount > 0) {
       // rebuild nodes if arcs have changed
+      profileStart('NodeCollection#2');
       nodes = new NodeCollection(dataset.arcs);
+      profileEnd('NodeCollection#2');
     }
     return nodes;
   }
@@ -17014,11 +17329,13 @@
   // and re-index the paths of all the layers that reference the arc collection.
   // (in-place)
   function addIntersectionCuts(dataset, _opts) {
+    profileStart('addIntersectionCuts');
     var opts = _opts || {};
     var arcs = dataset.arcs;
     var arcBounds = arcs && arcs.getBounds();
     var snapDist, nodes;
     if (!arcBounds || !arcBounds.hasBounds()) {
+      profileEnd('addIntersectionCuts');
       return new NodeCollection([]);
     }
 
@@ -17033,46 +17350,74 @@
 
     // bake-in any simplification (bug fix; before, -simplify followed by dissolve2
     // used to reset simplification)
+    profileStart('flatten');
     arcs.flatten();
+    profileEnd('flatten');
 
     var changed = snapAndCut(dataset, snapDist);
 
     // Detect topology again if coordinates have changed
     if (changed || opts.rebuild_topology) {
+      profileStart('buildTopology');
       buildTopology(dataset);
+      profileEnd('buildTopology');
     }
     // Remove degenerate shapes
     // Without this step, pathfinder function would encounter dead ends.
+    profileStart('cleanShapes');
     dataset.layers.forEach(function(lyr) {
       if (layerHasPaths(lyr)) {
         cleanShapes(lyr.shapes, arcs, lyr.geometry_type);
       }
     });
+    profileEnd('cleanShapes');
     // Further clean-up -- remove duplicate and unused arcs, etc.
+    profileStart('cleanArcReferences');
     nodes = cleanArcReferences(dataset);
+    profileEnd('cleanArcReferences');
+    profileEnd('addIntersectionCuts');
     return nodes;
   }
 
   function snapAndCut(dataset, snapDist) {
+    profileStart('snapAndCut');
     var arcs = dataset.arcs;
     var cutOpts = snapDist > 0 ? {tolerance: snapDist} : {tolerance: 0};
     var coordsHaveChanged = false;
-    var snapCount, dupeCount, cutCount;
+    var snapCount = 0, dupeCount, cutCount;
     var maxLoops = 4, loopCount = 0;
+    // After pass 1, snap & dedup can be skipped IF pass 1 snap moved nothing:
+    // cuts inserted exact intersection coordinates that match either an existing
+    // vertex (handled by formatIntersectingSegment) or a fresh point. The only
+    // way a fresh cut point could need re-snapping is if it falls within snap
+    // interval of a third (unrelated) vertex by coincidence; in clean data that
+    // didn't happen on pass 1 either, so we skip the redundant O(V log V) sort.
+    var skipFollowupSnap;
 
-    // snap + cut until no more cuts are needed
     do {
       loopCount++;
       cutCount = 0;
-      snapCount = snapCoordsByInterval(arcs, snapDist);
-      dupeCount = arcs.dedupCoords();
+      skipFollowupSnap = loopCount > 1 && snapCount === 0;
+      if (!skipFollowupSnap) {
+        profileStart('snap');
+        snapCount = snapCoordsByInterval(arcs, snapDist);
+        profileEnd('snap');
+        profileStart('dedupCoords');
+        dupeCount = arcs.dedupCoords();
+        profileEnd('dedupCoords');
+      } else {
+        snapCount = 0;
+        dupeCount = 0;
+      }
       if (snapCount > 0 || cutCount > 0 || loopCount == 1) {
-        // cut arcs at points where segments intersect
+        profileStart('cutPathsAtIntersections');
         cutCount = cutPathsAtIntersections(dataset, cutOpts);
+        profileEnd('cutPathsAtIntersections');
       }
       coordsHaveChanged |= (snapCount + dupeCount + cutCount) > 0;
-      debug("[snapAndCut] pass:", loopCount, "snaps:", snapCount, "dupes:", dupeCount, "cuts:", cutCount);
+      debug("[snapAndCut] pass:", loopCount, "snaps:", snapCount, "dupes:", dupeCount, "cuts:", cutCount, skipFollowupSnap ? "(skipped snap)" : "");
     } while (loopCount < maxLoops && cutCount > 0);
+    profileEnd('snapAndCut');
 
     // should this be added?
     // if (cutCount > 0 && loopCount == maxLoops) {
@@ -17137,9 +17482,13 @@
   // Divides a collection of arcs at points where arc paths cross each other
   // Returns array for remapping arc ids
   function divideArcs(arcs, opts) {
+    profileStart('findClippingPoints');
     var points = findClippingPoints(arcs, opts);
+    profileEnd('findClippingPoints');
     // TODO: avoid the following if no points need to be added
+    profileStart('insertCutPoints');
     var map = insertCutPoints(points, arcs);
+    profileEnd('insertCutPoints');
     // segment-point intersections currently create duplicate points
     // TODO: consider dedup in a later cleanup pass?
     // arcs.dedupCoords();
@@ -17147,9 +17496,14 @@
   }
 
   function findClippingPoints(arcs, opts) {
-    var intersections = findSegmentIntersections(arcs, opts),
-        data = arcs.getVertexData();
-    return convertIntersectionsToCutPoints(intersections, data.xx, data.yy);
+    profileStart('findSegmentIntersections');
+    var intersections = findSegmentIntersections(arcs, opts);
+    profileEnd('findSegmentIntersections');
+    profileStart('convertIntersectionsToCutPoints');
+    var data = arcs.getVertexData();
+    var points = convertIntersectionsToCutPoints(intersections, data.xx, data.yy);
+    profileEnd('convertIntersectionsToCutPoints');
+    return points;
   }
 
   // Inserts array of cutting points into an ArcCollection
@@ -17163,9 +17517,24 @@
         i1 = 0,
         nn1 = [],
         srcArcTotal = arcs.size(),
-        map = new Uint32Array(srcArcTotal),
-        points = filterSortedCutPoints(sortCutPoints(unfilteredPoints, xx0, yy0), arcs),
-        destPointTotal = arcs.getPointCount() + points.length * 2,
+        map = new Uint32Array(srcArcTotal);
+    profileStart('sortCutPoints');
+    var sorted = sortCutPoints(unfilteredPoints, xx0, yy0);
+    profileEnd('sortCutPoints');
+    profileStart('filterSortedCutPoints');
+    var points = filterSortedCutPoints(sorted, arcs);
+    profileEnd('filterSortedCutPoints');
+    // Skip the full xx/yy rewrite when nothing actually needs cutting.
+    // map[k] stores the destination arc-id at which source arc k begins; with no
+    // cuts, source arc k becomes destination arc k (map is the identity).
+    if (points.length === 0) {
+      for (var k = 0; k < srcArcTotal; k++) {
+        map[k] = k;
+      }
+      return map;
+    }
+    profileStart('rewriteVertexData');
+    var destPointTotal = arcs.getPointCount() + points.length * 2,
         xx1 = new Float64Array(destPointTotal),
         yy1 = new Float64Array(destPointTotal),
         n0, n1, arcLen, p;
@@ -17207,6 +17576,7 @@
 
     if (i1 != destPointTotal) error("[insertCutPoints()] Counting error");
     arcs.updateVertexData(nn1, xx1, yy1, null);
+    profileEnd('rewriteVertexData');
     return map;
   }
 
@@ -17249,14 +17619,35 @@
   // Insertion order: ascending id of first endpoint of containing segment and
   //   ascending distance from same endpoint.
   function sortCutPoints(points, xx, yy) {
-    points.sort(function(a, b) {
-      if (a.i != b.i) return a.i - b.i;
-      return geom.distanceSq(xx[a.i], yy[a.i], a.x, a.y) - geom.distanceSq(xx[b.i], yy[b.i], b.x, b.y);
-      // The old code below is no longer reliable, now that out-of-range intersection
-      // points are allowed.
-      // return Math.abs(a.x - xx[a.i]) - Math.abs(b.x - xx[b.i]) ||
-      // Math.abs(a.y - yy[a.i]) - Math.abs(b.y - yy[b.i]);
-    });
+    var len = points.length;
+    // Precompute the sort key once per point. The comparator below would
+    // otherwise do 2*log(n) distanceSq evaluations per element. Distances are
+    // kept in a parallel array so we don't mutate the caller's point objects.
+    var dists = xx ? new Float64Array(len) : null;
+    if (dists) {
+      for (var k = 0; k < len; k++) {
+        var p = points[k];
+        var dx = p.x - xx[p.i];
+        var dy = p.y - yy[p.i];
+        dists[k] = dx * dx + dy * dy;
+      }
+      // Decorate-sort-undecorate: attach (point, dist) tuples, sort by (i, dist),
+      // then write back. Avoids closing over `dists` lookup-by-identity.
+      var tagged = new Array(len);
+      for (var t = 0; t < len; t++) {
+        tagged[t] = [points[t], dists[t]];
+      }
+      tagged.sort(function(a, b) {
+        return a[0].i - b[0].i || a[1] - b[1];
+      });
+      for (var u = 0; u < len; u++) {
+        points[u] = tagged[u][0];
+      }
+    } else {
+      points.sort(function(a, b) {
+        return a.i - b.i;
+      });
+    }
     return points;
   }
 
@@ -17368,31 +17759,32 @@
   //
   function buildPolygonMosaic(nodes) {
     T$1.start();
-    // Detach any acyclic paths (spikes) from arc graph (these would interfere with
-    //    the ring finding operation). This modifies @nodes -- a side effect.
+    profileStart('bpm.detachAcyclicArcs');
     nodes.detachAcyclicArcs();
+    profileEnd('bpm.detachAcyclicArcs');
+    profileStart('bpm.findMosaicRings');
     var data = findMosaicRings(nodes);
+    profileEnd('bpm.findMosaicRings');
 
-    // Process CW rings: these are indivisible space-enclosing boundaries of mosaic tiles
     var mosaic = data.cw.map(function(ring) {return [ring];});
     debug('Find mosaic rings', T$1.stop());
     T$1.start();
 
-    // Process CCW rings: these are either holes or enclosure
-    // TODO: optimize -- testing CCW path of every island is costly
     var enclosures = [];
-    var index = new PathIndex(mosaic, nodes.arcs); // index CW rings to help identify holes
+    profileStart('bpm.PathIndex');
+    var index = new PathIndex(mosaic, nodes.arcs);
+    profileEnd('bpm.PathIndex');
+    profileStart('bpm.findEnclosingForCCW');
     data.ccw.forEach(function(ring) {
       var id = index.findSmallestEnclosingPolygon(ring);
       if (id > -1) {
-        // Enclosed CCW rings are holes in the enclosing mosaic tile
         mosaic[id].push(ring);
       } else {
-        // Non-enclosed CCW rings are outer boundaries -- add to enclosures layer
         reversePath(ring);
         enclosures.push([ring]);
       }
     });
+    profileEnd('bpm.findEnclosingForCCW');
     debug(utils.format("Detect holes (holes: %d, enclosures: %d)", data.ccw.length - enclosures.length, enclosures.length), T$1.stop());
 
     return {mosaic: mosaic, enclosures: enclosures, lostArcs: data.lostArcs};
@@ -17692,23 +18084,22 @@
   });
 
   function MosaicIndex(lyr, nodes, optsArg) {
+    profileStart('MosaicIndex.ctor');
     var opts = optsArg || {};
     var shapes = lyr.shapes;
+    profileStart('mi.buildPolygonMosaic');
     var mosaic = buildPolygonMosaic(nodes).mosaic;
-    // map arc ids to tile ids
+    profileEnd('mi.buildPolygonMosaic');
+    profileStart('mi.ShapeArcIndex');
     var arcTileIndex = new ShapeArcIndex(mosaic, nodes.arcs);
-    // keep track of which tiles have been assigned to shapes
+    profileEnd('mi.ShapeArcIndex');
     var fetchedTileIndex = new IdTestIndex(mosaic.length);
-    // bidirection index of tile ids <=> shape ids
     var tileShapeIndex = new TileShapeIndex(mosaic, opts);
-    // assign tiles to shapes
+    profileStart('mi.PolygonTiler.ctor');
     var shapeTiler = new PolygonTiler(mosaic, arcTileIndex, nodes, opts);
+    profileEnd('mi.PolygonTiler.ctor');
     var weightFunction = null;
     if (!opts.simple && opts.flat) {
-      // opts.simple is an optimization when dissolving everything into one polygon
-      // using -dissolve2. In this situation, we don't need a weight function.
-      // Otherwise, if polygons are being dissolved into multiple groups,
-      // we use a function to assign tiles in overlapping areas to a single shape.
       weightFunction = getOverlapPriorityFunction(lyr.shapes, nodes.arcs, opts.overlap_rule);
     }
     this.mosaic = mosaic;
@@ -17716,16 +18107,19 @@
     this.getSourceIdsByTileId = tileShapeIndex.getShapeIdsByTileId; // expose for -mosaic command
     this.getTileIdsByShapeId = tileShapeIndex.getTileIdsByShapeId;
 
-    // Assign shape ids to mosaic tile shapes.
+    profileStart('mi.assignTilesToShapes');
     shapes.forEach(function(shp, shapeId) {
       var tileIds = shapeTiler.getTilesInShape(shp, shapeId);
       tileShapeIndex.indexTileIdsByShapeId(shapeId, tileIds, weightFunction);
     });
+    profileEnd('mi.assignTilesToShapes');
 
-    // ensure each tile is assigned to only one shape
     if (opts.flat) {
+      profileStart('mi.tileShapeIndex.flatten');
       tileShapeIndex.flatten();
+      profileEnd('mi.tileShapeIndex.flatten');
     }
+    profileEnd('MosaicIndex.ctor');
 
     // fill gaps
     // (assumes that tiles have been allocated to shapes and mosaic has been flattened)
@@ -17905,22 +18299,30 @@
   }
 
   function dissolvePolygonGroups2(groups, lyr, dataset, opts) {
+    profileStart('dissolvePolygonGroups2');
+    profileStart('dpg2.NodeCollection');
     var arcFilter = getArcPresenceTest(lyr.shapes, dataset.arcs);
     var nodes = new NodeCollection(dataset.arcs, arcFilter);
+    profileEnd('dpg2.NodeCollection');
     var mosaicOpts = {
       flat: !opts.allow_overlaps,
       simple: groups.length == 1,
       overlap_rule: opts.overlap_rule
     };
+    profileStart('dpg2.MosaicIndex');
     var mosaicIndex = new MosaicIndex(lyr, nodes, mosaicOpts);
+    profileEnd('dpg2.MosaicIndex');
     // gap fill doesn't work yet with overlapping shapes
     var fillGaps = !opts.allow_overlaps && (opts.sliver_control || opts.gap_fill_area);
     var cleanupData, filterData;
     if (fillGaps) {
+      profileStart('dpg2.removeGaps');
       var sliverOpts = utils.extend({sliver_control: 1}, opts);
       filterData = getSliverFilter(lyr, dataset, sliverOpts);
       cleanupData = mosaicIndex.removeGaps(filterData.filter);
+      profileEnd('dpg2.removeGaps');
     }
+    profileStart('dpg2.dissolveTiles');
     var pathfind = getRingIntersector(mosaicIndex.nodes);
     var dissolvedShapes = groups.map(function(shapeIds) {
       var tiles = mosaicIndex.getTilesByShapeIds(shapeIds);
@@ -17931,14 +18333,16 @@
       }
       return dissolveTileGroup2(tiles, pathfind);
     });
-    // convert self-intersecting rings to outer/inner rings, for OGC
-    // Simple Features compliance
+    profileEnd('dpg2.dissolveTiles');
+    profileStart('dpg2.fixTangentHoles');
     dissolvedShapes = fixTangentHoles(dissolvedShapes, pathfind);
+    profileEnd('dpg2.fixTangentHoles');
 
     if (fillGaps && !opts.quiet) {
       var msg = getGapRemovalMessage(cleanupData.removed, cleanupData.remaining, filterData.label);
       if (msg) message(msg);
     }
+    profileEnd('dissolvePolygonGroups2');
     return dissolvedShapes;
   }
 
@@ -18158,40 +18562,52 @@
   cmd.cleanLayers = cleanLayers;
 
   function cleanLayers(layers, dataset, optsArg) {
+    profileStart('cleanLayers');
     var opts = optsArg || {};
     var deepClean = !opts.only_arcs;
     var pathClean = utils.some(layers, layerHasPaths);
     var nodes;
     if (opts.debug) {
       addIntersectionCuts(dataset, opts);
+      profileEnd('cleanLayers');
       return;
     }
     layers.forEach(function(lyr) {
       if (!layerHasGeometry(lyr)) return;
       if (lyr.geometry_type == 'polygon' && opts.rewind) {
+        profileStart('rewindPolygons');
         rewindPolygons(lyr, dataset.arcs);
+        profileEnd('rewindPolygons');
       }
       if (deepClean) {
         if (!nodes) {
           nodes = addIntersectionCuts(dataset, opts);
         }
         if (lyr.geometry_type == 'polygon') {
+          profileStart('cleanPolygonLayerGeometry');
           cleanPolygonLayerGeometry(lyr, dataset, opts);
+          profileEnd('cleanPolygonLayerGeometry');
         } else if (lyr.geometry_type == 'polyline') {
+          profileStart('cleanPolylineLayerGeometry');
           cleanPolylineLayerGeometry(lyr, dataset);
+          profileEnd('cleanPolylineLayerGeometry');
         } else if (lyr.geometry_type == 'point') {
           cleanPointLayerGeometry(lyr);
         }
       }
       if (!opts.allow_empty) {
+        profileStart('filterFeatures');
         cmd.filterFeatures(lyr, dataset.arcs, {remove_empty: true, verbose: opts.verbose});
+        profileEnd('filterFeatures');
       }
     });
 
     if (!opts.no_arc_dissolve && pathClean && dataset.arcs) {
-      // remove leftover endpoints within contiguous lines
+      profileStart('dissolveArcs');
       dissolveArcs(dataset);
+      profileEnd('dissolveArcs');
     }
+    profileEnd('cleanLayers');
   }
 
   function cleanPolygonLayerGeometry(lyr, dataset, opts) {
@@ -18724,13 +19140,13 @@
     // default is true iff layers contain attributes
     return utils.some(layers, function(lyr) {
       var fields = lyr.data ? lyr.data.getFields() : [];
-      var haveData = useFeatureProperties(fields, opts);
+      var haveData = useFeatureProperties$1(fields, opts);
       var haveId = !!getIdField(fields, opts);
       return haveData || haveId;
     });
   }
 
-  function useFeatureProperties(fields, opts) {
+  function useFeatureProperties$1(fields, opts) {
     return !(opts.drop_table || opts.cut_table || fields.length === 0 ||
         fields.length == 1 && fields[0] == GeoJSON.ID_FIELD);
   }
@@ -18739,7 +19155,7 @@
     var fields = table ? table.getFields() : [],
         idField = getIdField(fields, opts),
         properties, records;
-    if (!useFeatureProperties(fields, opts)) {
+    if (!useFeatureProperties$1(fields, opts)) {
       return null;
     }
     records = table.getRecords();
@@ -24500,12 +24916,10 @@ ${svg}
   }
 
   async function exportLayerToGeoPackage(lyr, dataset, gpkg, opts) {
-    var features, fields, columns, tableName, targetSrs;
+    var fields, columns, tableName, targetSrs, state;
     if (!lyr.geometry_type) return;
-    features = exportLayerAsGeoJSON(lyr, dataset, opts, true, null)
-      .filter(feat => !!(feat && feat.geometry));
-    if (features.length === 0) return;
-    fields = inferFieldTypes(features);
+    fields = inferFieldTypesFromLayer(lyr, dataset, opts);
+    if (!fields) return;
     tableName = getTableName(lyr.name);
     columns = fields.map(function(field) {
       return {
@@ -24522,8 +24936,11 @@ ${svg}
     // GeoJSON is EPSG:4326 and reprojects unless given EPSG:4326 metadata.
     // Mapshaper output coords are already in target CRS, so suppress reprojection.
     var srs = getSourceSrsWithoutReprojection(featureDao && featureDao.srs, targetSrs);
-    for (var i = 0; i < features.length; i++) {
-      var feat = features[i];
+    state = initLayerFeatureExportState(lyr, dataset, opts);
+    var featureIndex = 0;
+    for (var i = 0; i < state.count; i++) {
+      var feat = exportFeatureAtIndex(state, i);
+      if (!feat || !feat.geometry) continue;
       var normalized = normalizeFeature(feat, fields);
       try {
         await gpkg.addGeoJSONFeatureToGeoPackageWithFeatureDaoAndSrs(
@@ -24533,8 +24950,9 @@ ${svg}
         );
       } catch (e) {
         throw Error('GeoPackage insert failed at layer "' + tableName +
-          '", feature ' + i + ': ' + e.message);
+          '", feature ' + featureIndex + ': ' + e.message);
       }
+      featureIndex++;
     }
   }
 
@@ -24561,9 +24979,11 @@ ${svg}
     stop$1('Unable to export GeoPackage bytes');
   }
 
-  function inferFieldTypes(features) {
+  function inferFieldTypesFromLayer(lyr, dataset, opts) {
+    var sawFeature = false;
     var index = {};
-    features.forEach(function(feat) {
+    forEachLayerExportFeature(lyr, dataset, opts, function(feat) {
+      sawFeature = true;
       var props = feat.properties || {};
       Object.keys(props).forEach(function(name) {
         if (!isSupportedPropertyName(name)) return;
@@ -24577,11 +24997,79 @@ ${svg}
         }
       });
     });
+    if (!sawFeature) return null;
     return Object.keys(index).map(function(name) {
       return {name: name, type: index[name]};
     });
   }
 
+  function forEachLayerExportFeature(lyr, dataset, opts, cb) {
+    var state = initLayerFeatureExportState(lyr, dataset, opts);
+    var featureIndex = 0;
+    for (var i = 0; i < state.count; i++) {
+      var feature = exportFeatureAtIndex(state, i);
+      if (!feature || !feature.geometry) continue;
+      cb(feature, featureIndex++, i);
+    }
+  }
+
+  function initLayerFeatureExportState(lyr, dataset, opts) {
+    var records = lyr.data ? lyr.data.getRecords() : null;
+    var fields = lyr.data ? lyr.data.getFields() : [];
+    var shapes = lyr.shapes || null;
+    if (records && shapes && records.length !== shapes.length) {
+      stop$1('Mismatch between number of properties and number of shapes');
+    }
+    return {
+      lyr: lyr,
+      dataset: dataset,
+      opts: opts || {},
+      fields: fields,
+      records: records,
+      shapes: shapes,
+      count: Math.max(records ? records.length : 0, shapes ? shapes.length : 0),
+      idField: getIdField(fields, opts || {}),
+      useProps: useFeatureProperties(fields, opts || {})
+    };
+  }
+
+  function exportFeatureAtIndex(state, i) {
+    var shape = state.shapes ? state.shapes[i] : null;
+    var geom = shape ? GeoJSON.exporters[state.lyr.geometry_type](shape, state.dataset.arcs, state.opts) : null;
+    var rec = state.records ? state.records[i] : null;
+    var props = null;
+    if (state.useProps && rec) {
+      if (state.idField == GeoJSON.ID_FIELD) {
+        props = Object.assign({}, rec);
+        delete props[state.idField];
+      } else {
+        props = rec;
+      }
+    }
+    var feat = GeoJSON.toFeature(geom, props);
+    if (state.idField && rec) {
+      feat.id = state.idField in rec ? rec[state.idField] : null;
+    }
+    if (state.opts.no_null_props && !feat.properties) {
+      feat.properties = {};
+    }
+    if (Array.isArray(state.opts.hoist) && feat.properties) {
+      feat.properties = Object.assign({}, feat.properties);
+      state.opts.hoist.forEach(function(field) {
+        if (Object.prototype.hasOwnProperty.call(feat.properties, field)) {
+          feat[field] = feat.properties[field];
+          delete feat.properties[field];
+        }
+      });
+    }
+    return feat;
+  }
+
+  function useFeatureProperties(fields, opts) {
+    return !(opts.drop_table || opts.cut_table || fields.length === 0 ||
+        fields.length == 1 && fields[0] == GeoJSON.ID_FIELD);
+  }
+
   function inferValueType(value) {
     if (value === null || value === undefined) return null;
     if (value instanceof Date) return 'DATETIME';
@@ -24600,10 +25088,6 @@ ${svg}
   }
 
   function normalizeFeature(feature, fields) {
-    fields.reduce(function(memo, field) {
-      memo[field.name] = field.type;
-      return memo;
-    }, {});
     var props = {};
     fields.forEach(function(field) {
       var value = feature.properties && Object.prototype.hasOwnProperty.call(feature.properties, field.name) ?
@@ -24622,11 +25106,8 @@ ${svg}
 
   function getExportSrs(dataset) {
     var info = dataset.info || {};
-    var gpkgCrs = normalizeSrsForInsert(info.geopackage_crs);
+    var gpkgCrs = resolveExportSrs(normalizeSrsForInsert(info.geopackage_crs), info.wkt1);
     if (gpkgCrs) {
-      if (!gpkgCrs.definition && info.wkt1) {
-        gpkgCrs.definition = info.wkt1;
-      }
       return gpkgCrs;
     }
     var parsed = parseCrsString(info.crs_string);
@@ -24642,13 +25123,83 @@ ${svg}
     if (info.wkt1) {
       return buildCustomSrsFromWkt(info.wkt1);
     }
+    // If the dataset has an in-memory CRS object (e.g. set by -proj) but no
+    // metadata source, derive a WKT1 definition from it so a projected CRS
+    // isn't lost on round-trip.
+    var derivedWkt = getWktFromDatasetCrs(dataset);
+    if (derivedWkt) {
+      return buildCustomSrsFromWkt(derivedWkt);
+    }
+    // Unknown CRS fallback:
+    // - probable decimal-degree coordinates => allow WGS84 assumption
+    // - otherwise use undefined cartesian CRS (null/unknown projection)
+    if (probablyDecimalDegreeBounds(getDatasetBounds(dataset))) {
+      return {
+        srs_id: 4326,
+        organization: 'EPSG',
+        organization_coordsys_id: 4326
+      };
+    }
     return {
-      srs_id: 4326,
-      organization: 'EPSG',
-      organization_coordsys_id: 4326
+      srs_id: -1,
+      srs_name: 'Undefined Cartesian SRS',
+      organization: 'NONE',
+      organization_coordsys_id: -1
     };
   }
 
+  function getWktFromDatasetCrs(dataset) {
+    // Only derive from an explicitly-set CRS object (e.g. from -proj).
+    // This avoids building a custom SRS for lat/lon datasets that were
+    // auto-defaulted to WGS84 by getDatasetCRS().
+    var info = dataset && dataset.info;
+    if (!info || !info.crs) return null;
+    try {
+      return crsToPrj(info.crs) || null;
+    } catch (e) {
+      return null;
+    }
+  }
+
+  function resolveExportSrs(srs, fallbackWkt) {
+    if (!srs) return null;
+    var out = Object.assign({}, srs);
+    if (!out.definition && fallbackWkt) {
+      out.definition = fallbackWkt;
+    }
+    if (out.srs_id == null && out.organization_coordsys_id != null) {
+      out.srs_id = out.organization_coordsys_id;
+    }
+    if (out.srs_id == null) {
+      var fromWkt = parseWktAuthority(out.definition);
+      if (fromWkt) {
+        out.srs_id = fromWkt.srs_id;
+        if (!out.organization) out.organization = fromWkt.organization;
+        if (out.organization_coordsys_id == null) {
+          out.organization_coordsys_id = fromWkt.organization_coordsys_id;
+        }
+      }
+    }
+    if (out.srs_id == null && out.definition) {
+      var custom = buildCustomSrsFromWkt(out.definition);
+      out.srs_id = custom.srs_id;
+      if (!out.srs_name) out.srs_name = custom.srs_name;
+      if (!out.organization) out.organization = custom.organization;
+      if (out.organization_coordsys_id == null) {
+        out.organization_coordsys_id = custom.organization_coordsys_id;
+      }
+      if (!out.description) out.description = custom.description;
+    }
+    if (out.srs_id == null) return null;
+    if (out.organization_coordsys_id == null) {
+      out.organization_coordsys_id = out.srs_id;
+    }
+    if (!out.organization) {
+      out.organization = 'NONE';
+    }
+    return out;
+  }
+
   function parseCrsString(str) {
     if (!str || typeof str != 'string') return null;
     var match = str.match(/^([a-z]+):(\d+)$/i);
@@ -24740,9 +25291,10 @@ ${svg}
     var geopackage = require$1('@ngageoint/geopackage');
     var spatialReferenceSystem = new geopackage.SpatialReferenceSystem();
     spatialReferenceSystem.srs_id = srs.srs_id;
-    spatialReferenceSystem.srs_name = srs.srs_name || (srs.organization + ':' + srs.organization_coordsys_id);
-    spatialReferenceSystem.organization = srs.organization;
-    spatialReferenceSystem.organization_coordsys_id = srs.organization_coordsys_id;
+    spatialReferenceSystem.srs_name = srs.srs_name || (String(srs.organization || 'NONE') + ':' + srs.organization_coordsys_id);
+    spatialReferenceSystem.organization = srs.organization || 'NONE';
+    spatialReferenceSystem.organization_coordsys_id = srs.organization_coordsys_id != null ?
+      srs.organization_coordsys_id : srs.srs_id;
     spatialReferenceSystem.definition = srs.definition;
     spatialReferenceSystem.description = srs.description || null;
     gpkg.createSpatialReferenceSystem(spatialReferenceSystem);
@@ -24751,7 +25303,9 @@ ${svg}
   function getSourceSrsWithoutReprojection(tableSrs, fallbackSrs) {
     var target = normalizeSrsForInsert(tableSrs) || normalizeSrsForInsert(fallbackSrs);
     return {
-      srs_id: target.srs_id,
+      // geopackage writer rejects negative srs_id for source metadata;
+      // use 0 (undefined geographic) when target is undefined cartesian (-1).
+      srs_id: target.srs_id < 0 ? 0 : target.srs_id,
       organization: 'EPSG',
       organization_coordsys_id: 4326
     };
@@ -24828,18 +25382,21 @@ ${svg}
     if (normalized.organization_coordsys_id == null && normalized.organizationCoordsysId != null) {
       normalized.organization_coordsys_id = normalized.organizationCoordsysId;
     }
-    if (normalized.srs_id == null) {
-      normalized.srs_id = normalized.organization_coordsys_id || 4326;
+    if (normalized.srs_id != null) {
+      normalized.srs_id = +normalized.srs_id;
+      if (!Number.isFinite(normalized.srs_id)) {
+        normalized.srs_id = null;
+      }
     }
-    normalized.srs_id = +normalized.srs_id || 4326;
-    if (!normalized.organization) {
-      normalized.organization = 'EPSG';
+    if (normalized.organization) {
+      normalized.organization = String(normalized.organization).toUpperCase();
     }
-    normalized.organization = String(normalized.organization).toUpperCase();
-    if (normalized.organization_coordsys_id == null) {
-      normalized.organization_coordsys_id = normalized.srs_id || 4326;
+    if (normalized.organization_coordsys_id != null) {
+      normalized.organization_coordsys_id = +normalized.organization_coordsys_id;
+      if (!Number.isFinite(normalized.organization_coordsys_id)) {
+        normalized.organization_coordsys_id = null;
+      }
     }
-    normalized.organization_coordsys_id = +normalized.organization_coordsys_id || 4326;
     return normalized;
   }
 
@@ -26869,6 +27426,10 @@ ${svg}
       .option('name', {
         describe: 'rename the imported layer(s)'
       })
+      .option('layers', {
+        type: 'strings',
+        describe: '[GPKG] comma-sep. list of layers to import'
+      })
       .option('geometry-type', {
         // undocumented; GeoJSON import rejects all but one kind of geometry
         // describe: '[GeoJSON] Import one kind of geometry (point|polygon|polyline)'
@@ -31463,24 +32024,35 @@ ${svg}
     var geopackage = require$1('@ngageoint/geopackage');
     var gpkg;
     var datasets;
-    var source;
     var tmpPath = null;
 
     if (!geopackage || !geopackage.GeoPackageAPI) {
       stop$1('GeoPackage library is not loaded');
     }
 
-    if (utils.isString(content)) {
-      source = content;
-    } else if (!runningInBrowser()) {
-      tmpPath = writeGeoPackageTempFile(content);
-      source = tmpPath;
-    } else {
-      source = new Uint8Array(content);
-    }
-    gpkg = await geopackage.GeoPackageAPI.open(source);
+    ({gpkg, tmpPath} = await openGeoPackage(content, geopackage));
+    var availableLayers;
+    var filterApplied;
     try {
-      datasets = readFeatureTableDatasets(gpkg, opts);
+      try {
+        ({datasets, availableLayers, filterApplied} = readFeatureTableDatasets(gpkg, opts));
+      } catch (e) {
+        if (!runningInBrowser() && isLocalCsProjError(e)) {
+          gpkg.close();
+          if (tmpPath) {
+            sanitizeGeoPackageCrsMetadata(tmpPath);
+          } else if (utils.isString(content)) {
+            tmpPath = copyGeoPackageTempFile(content);
+            sanitizeGeoPackageCrsMetadata(tmpPath);
+          } else {
+            throw e;
+          }
+          gpkg = await geopackage.GeoPackageAPI.open(tmpPath);
+          ({datasets, availableLayers, filterApplied} = readFeatureTableDatasets(gpkg, opts));
+        } else {
+          throw e;
+        }
+      }
     } finally {
       gpkg.close();
       removeTempGeoPackageFile(tmpPath);
@@ -31489,13 +32061,72 @@ ${svg}
     if (datasets.length === 0) {
       return {
         layers: [{name: '', data: null}],
-        info: {}
+        info: {
+          _gpkg_available_layers: availableLayers,
+          _gpkg_placeholder: !!filterApplied
+        }
       };
     }
 
     await initProjLib(datasets);
+    var merged = mergeGeoPackageDatasets(datasets);
+    var mergedArr = Array.isArray(merged) ? merged : [merged];
+    mergedArr.forEach(function(ds) {
+      ds.info = ds.info || {};
+      ds.info._gpkg_available_layers = availableLayers;
+    });
+    return merged;
+  }
 
-    return mergeDatasets(datasets);
+  async function openGeoPackage(content, geopackage) {
+    var source;
+    var tmpPath = null;
+    if (utils.isString(content)) {
+      if (!runningInBrowser()) {
+        try {
+          return {
+            gpkg: await geopackage.GeoPackageAPI.open(content),
+            tmpPath: null
+          };
+        } catch (e) {
+          if (!isLocalCsProjError(e)) throw e;
+          tmpPath = copyGeoPackageTempFile(content);
+          sanitizeGeoPackageCrsMetadata(tmpPath);
+          return {
+            gpkg: await geopackage.GeoPackageAPI.open(tmpPath),
+            tmpPath: tmpPath
+          };
+        }
+      }
+      source = content;
+    } else if (!runningInBrowser()) {
+      tmpPath = writeGeoPackageTempFile(content);
+      try {
+        return {
+          gpkg: await geopackage.GeoPackageAPI.open(tmpPath),
+          tmpPath: tmpPath
+        };
+      } catch (e) {
+        if (!isLocalCsProjError(e)) throw e;
+        sanitizeGeoPackageCrsMetadata(tmpPath);
+        return {
+          gpkg: await geopackage.GeoPackageAPI.open(tmpPath),
+          tmpPath: tmpPath
+        };
+      }
+    } else {
+      source = new Uint8Array(content);
+    }
+    return {
+      gpkg: await geopackage.GeoPackageAPI.open(source),
+      tmpPath: null
+    };
+  }
+
+  function isLocalCsProjError(err) {
+    var msg = err && err.message ? String(err.message) : '';
+    return msg.includes("havn't handled \"_\" in keyword yet") ||
+      msg.includes('LOCAL_CS');
   }
 
   function writeGeoPackageTempFile(content) {
@@ -31504,10 +32135,40 @@ ${svg}
     var path = require$1('path');
     var unique = Date.now() + '-' + process.pid + '-' + Math.random().toString(36).slice(2);
     var tmpPath = path.join(os.tmpdir(), 'mapshaper-gpkg-import-' + unique + '.gpkg');
-    fs.writeFileSync(tmpPath, Buffer.from(new Uint8Array(content)));
+    if (Buffer.isBuffer(content)) {
+      fs.writeFileSync(tmpPath, content);
+    } else if (content instanceof Uint8Array) {
+      fs.writeFileSync(tmpPath, Buffer.from(content.buffer, content.byteOffset, content.byteLength));
+    } else if (content instanceof ArrayBuffer) {
+      fs.writeFileSync(tmpPath, Buffer.from(content));
+    } else {
+      fs.writeFileSync(tmpPath, Buffer.from(new Uint8Array(content)));
+    }
     return tmpPath;
   }
 
+  function copyGeoPackageTempFile(filepath) {
+    var fs = require$1('fs');
+    var os = require$1('os');
+    var path = require$1('path');
+    var unique = Date.now() + '-' + process.pid + '-' + Math.random().toString(36).slice(2);
+    var tmpPath = path.join(os.tmpdir(), 'mapshaper-gpkg-import-' + unique + '.gpkg');
+    fs.copyFileSync(filepath, tmpPath);
+    return tmpPath;
+  }
+
+  function sanitizeGeoPackageCrsMetadata(filepath) {
+    var Database = require$1('better-sqlite3');
+    var db = new Database(filepath);
+    try {
+      // GDAL may write LOCAL_CS definitions that proj4 can't parse.
+      // Normalize to 'undefined' so GeoPackageAPI.open() won't throw.
+      db.prepare("UPDATE gpkg_spatial_ref_sys SET definition = 'undefined' WHERE definition LIKE 'LOCAL_CS[%'").run();
+    } finally {
+      db.close();
+    }
+  }
+
   function removeTempGeoPackageFile(filepath) {
     if (!filepath) return;
     var fs = require$1('fs');
@@ -31526,13 +32187,207 @@ ${svg}
   }
 
   function readFeatureTableDatasets(gpkg, opts) {
-    var tables = gpkg.getFeatureTables() || [];
-    return tables.map(function(table) {
+    var selected = getSelectedGeoPackageLayers(opts);
+    var availableLayers = gpkg.getFeatureTables() || [];
+    var tables = filterGeoPackageTables(availableLayers, selected);
+    var filterApplied = Array.isArray(selected) && selected.length > 0;
+    var datasets = tables.map(function(table) {
       return readFeatureTable(gpkg, table, opts);
     });
+    return {datasets: datasets, availableLayers: availableLayers, filterApplied: filterApplied};
+  }
+
+  function getSelectedGeoPackageLayers(opts) {
+    if (!opts) return null;
+    return opts.gpkg_layers || opts.layers || null;
+  }
+
+  function filterGeoPackageTables(tables, selected) {
+    if (!Array.isArray(selected) || selected.length === 0) return tables;
+    var index = selected.reduce(function(memo, name) {
+      memo[name] = true;
+      return memo;
+    }, {});
+    return tables.filter(function(name) {
+      return !!index[name];
+    });
+  }
+
+  function mergeGeoPackageDatasets(datasets) {
+    var groups = groupGeoPackageDatasets(datasets);
+    var merged = groups.reduce(function(memo, group) {
+      return memo.concat(mergeGeoPackageDatasetGroup(group));
+    }, []);
+    return merged.length == 1 ? merged[0] : merged;
   }
 
-  function convertOrgToProj4(crs) {
+  function mergeGeoPackageDatasetGroup(group) {
+    var pathDatasets = [];
+    var pointDatasets = [];
+    var dataDatasets = [];
+
+    group.forEach(function(dataset) {
+      var kind = getDatasetGeometryKind(dataset);
+      if (kind == 'path') {
+        pathDatasets.push(dataset);
+      } else if (kind == 'point') {
+        pointDatasets.push(dataset);
+      } else {
+        dataDatasets.push(dataset);
+      }
+    });
+
+    var output = [];
+    if (dataDatasets.length > 0) {
+      output.push(dataDatasets.length == 1 ? dataDatasets[0] : mergeDatasets(dataDatasets));
+    }
+    if (pointDatasets.length > 0) {
+      output.push(pointDatasets.length == 1 ? pointDatasets[0] : mergeDatasets(pointDatasets));
+    }
+    if (pathDatasets.length > 0) {
+      var groupedPaths = groupPathDatasetsBySharedArcs(pathDatasets);
+      if (groupedPaths.mergedDataset) {
+        output.push(groupedPaths.mergedDataset);
+      } else {
+        groupedPaths.components.forEach(function(component) {
+          output.push(component.length == 1 ? component[0] : mergeDatasets(component));
+        });
+      }
+    }
+    return output;
+  }
+
+  function groupGeoPackageDatasets(datasets) {
+    var index = {};
+    datasets.forEach(function(dataset) {
+      var key = getGeoPackageDatasetGroupKey(dataset);
+      if (!index[key]) index[key] = [];
+      index[key].push(dataset);
+    });
+    return Object.keys(index).map(function(key) {
+      return index[key];
+    });
+  }
+
+  function getGeoPackageDatasetGroupKey(dataset) {
+    var info = dataset.info || {};
+    var crs = info.geopackage_crs || null;
+    if (isDataOnlyDataset(dataset)) {
+      return 'data-only';
+    }
+    if (crs) {
+      var org = normalizeCrsOrg(crs.organization);
+      var code = normalizeNumericCode(crs.organization_coordsys_id);
+      if (isTrustedCrsAuthority(org) && code !== null && !(org == 'NONE' && code <= 0)) {
+        return 'crs:' + org + ':' + code;
+      }
+      if (isUsableWkt1Definition(crs.definition)) {
+        return 'wkt:' + crs.definition;
+      }
+    }
+    return probablyDecimalDegreeBounds(getDatasetBounds(dataset)) ?
+      'unknown:unprojected' :
+      'unknown:projected';
+  }
+
+  function isDataOnlyDataset(dataset) {
+    return (dataset.layers || []).every(function(lyr) {
+      return !lyr.geometry_type;
+    });
+  }
+
+  function getDatasetGeometryKind(dataset) {
+    if (isDataOnlyDataset(dataset)) return 'data';
+    if (datasetHasPaths(dataset)) return 'path';
+    var hasPoints = (dataset.layers || []).some(function(lyr) {
+      return layerHasPoints(lyr);
+    });
+    return hasPoints ? 'point' : 'data';
+  }
+
+  function groupPathDatasetsBySharedArcs(datasets) {
+    if (datasets.length < 2) {
+      return {
+        mergedDataset: datasets[0] || null,
+        components: []
+      };
+    }
+    var copy = datasets.map(copyDatasetForExport);
+    var merged = mergeDatasets(copy);
+    if (!merged.arcs || merged.arcs.size() === 0) {
+      return {
+        mergedDataset: null,
+        components: datasets.map(function(dataset) { return [dataset]; })
+      };
+    }
+    buildTopology(merged);
+    var parent = datasets.map(function(_, i) { return i; });
+    var arcOwner = new Map();
+    merged.layers.forEach(function(layer, layerIdx) {
+      var seen = new Set();
+      forEachArcId(layer.shapes || [], function(arcId) {
+        seen.add(arcId < 0 ? ~arcId : arcId);
+      });
+      seen.forEach(function(absId) {
+        if (!arcOwner.has(absId)) {
+          arcOwner.set(absId, layerIdx);
+        } else {
+          union(parent, layerIdx, arcOwner.get(absId));
+        }
+      });
+    });
+    var components = {};
+    datasets.forEach(function(dataset, i) {
+      var root = find(parent, i);
+      if (!components[root]) components[root] = [];
+      components[root].push(dataset);
+    });
+    var grouped = Object.keys(components).map(function(key) {
+      return components[key];
+    });
+    if (grouped.length == 1) {
+      return {
+        mergedDataset: merged,
+        components: []
+      };
+    }
+    return {
+      mergedDataset: null,
+      components: grouped
+    };
+  }
+
+  function find(parent, i) {
+    var p = parent[i];
+    if (p !== i) {
+      parent[i] = find(parent, p);
+    }
+    return parent[i];
+  }
+
+  function union(parent, a, b) {
+    var ra = find(parent, a);
+    var rb = find(parent, b);
+    if (ra !== rb) {
+      parent[rb] = ra;
+    }
+  }
+
+  function normalizeNumericCode(val) {
+    var n = +val;
+    return Number.isFinite(n) ? n : null;
+  }
+
+  function normalizeCrsOrg(org) {
+    if (!org || org == 'undefined') return null;
+    return String(org).toUpperCase();
+  }
+
+  function isTrustedCrsAuthority(org) {
+    return org == 'EPSG' || org == 'ESRI' || org == 'NONE';
+  }
+
+  function convertOrgToProjString(crs) {
     var org = crs.organization.toLowerCase();
     if (org == 'epsg' || org == 'esri') {
       return org + ':' + crs.organization_coordsys_id;
@@ -31560,14 +32415,25 @@ ${svg}
     });
     dataset.info = dataset.info || {};
     dataset.info.geopackage_crs = crs;
-    if (crs?.definition && crs.definition !== 'undefined') {
+    if (isUsableWkt1Definition(crs?.definition)) {
       dataset.info.wkt1 = crs.definition;
     } else if (crs?.organization && crs.organization !== 'undefined') {
-      dataset.info.crs_string = convertOrgToProj4(crs);
+      var crsString = convertOrgToProjString(crs);
+      if (crsString) {
+        dataset.info.crs_string = crsString;
+      }
     }
     return dataset;
   }
 
+  function isUsableWkt1Definition(defn) {
+    if (!defn || defn === 'undefined') return false;
+    // GDAL may emit LOCAL_CS["Undefined SRS", ...] for null CRS;
+    // this is not a usable projected/geographic CRS for mapshaper.
+    if (/^\s*LOCAL_CS\[/i.test(defn)) return false;
+    return true;
+  }
+
   function convertFeatureRow(featureRow) {
     var feature = {
       type: 'Feature',
@@ -31583,8 +32449,7 @@ ${svg}
       // skip feature if geometry can't be parsed
       return null;
     }
-    if (!feature.geometry) return null;
-    var geomColName = featureRow.geometryColumn.name;
+    var geomColName = featureRow.geometryColumn && featureRow.geometryColumn.name;
     for (var key in featureRow.values) {
       if (Object.prototype.hasOwnProperty.call(featureRow.values, key) &&
           key !== geomColName) {
@@ -32363,6 +33228,11 @@ ${svg}
     } else {
       return importContent(obj, opts);
     }
+    if (Array.isArray(dataset)) {
+      return dataset.map(function(ds) {
+        return finalizeImportedDataset(ds, dataFmt, data, opts);
+      });
+    }
     return finalizeImportedDataset(dataset, dataFmt, data, opts);
   }
 
@@ -32564,12 +33434,18 @@ ${svg}
 
   cmd.importFiles = async function(catalog, opts) {
     var files = opts.files || [];
-    var dataset;
+    var dataset, datasets, target;
 
     if (opts.stdin) {
       dataset = await importFileAsync('/dev/stdin', opts);
-      catalog.addDataset(dataset);
-      return dataset;
+      datasets = normalizeImportedDatasets(dataset);
+      catalog.addDatasets(datasets);
+      if (datasets.length > 1) {
+        catalog.setDefaultTargets(datasets.map(function(ds) {
+          return {dataset: ds, layers: ds.layers};
+        }));
+      }
+      return normalizeImportedTarget(datasets);
     }
 
     if (files.length > 0 === false) {
@@ -32604,14 +33480,22 @@ ${svg}
     } else {
       dataset = await importFilesTogetherAsync(files, opts);
     }
+    datasets = normalizeImportedDatasets(dataset);
+    datasets = validateAndCleanGpkgSelection(datasets, opts);
 
     if (opts.merge_files && files.length > 1) {
       // TODO: deprecate and remove this option (use -merge-layers cmd instead)
-      dataset.layers = cmd.mergeLayers(dataset.layers);
+      datasets[0].layers = cmd.mergeLayers(datasets[0].layers);
     }
 
-    catalog.addDataset(dataset);
-    return dataset;
+    catalog.addDatasets(datasets);
+    if (datasets.length > 1) {
+      catalog.setDefaultTargets(datasets.map(function(ds) {
+        return {dataset: ds, layers: ds.layers};
+      }));
+    }
+    target = normalizeImportedTarget(datasets);
+    return target;
   };
 
   // replace any JSON data objects with filenames and cache the data
@@ -32712,7 +33596,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;
 
@@ -32815,17 +33700,20 @@ ${svg}
   // Import multiple files to a single dataset
   function importFilesTogether(files, opts) {
     var unbuiltTopology = false;
-    var datasets = files.map(function(fname) {
+    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 dataset = importFile(fname, importOpts);
+      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
-      if (dataset.arcs && dataset.arcs.size() > 0 && dataset.info.input_formats[0] != 'topojson') {
-        unbuiltTopology = true;
-      }
-      return dataset;
-    });
+      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
@@ -32843,12 +33731,15 @@ ${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 dataset = await importFileAsync(fname, importOpts);
-      if (dataset.arcs && dataset.arcs.size() > 0 && dataset.info.input_formats[0] != 'topojson') {
-        unbuiltTopology = true;
-      }
-      datasets.push(dataset);
+      var imported = normalizeImportedDatasets(await importFileAsync(fname, importOpts));
+      imported.forEach(function(dataset) {
+        if (dataset.arcs && dataset.arcs.size() > 0 && dataset.info.input_formats[0] != 'topojson') {
+          unbuiltTopology = true;
+        }
+        datasets.push(dataset);
+      });
     }
+    datasets = validateAndCleanGpkgSelection(datasets, opts);
     var combined = mergeDatasets(datasets);
     if (unbuiltTopology && !opts.no_topology) {
       cleanPathsAfterImport(combined, opts);
@@ -32857,6 +33748,60 @@ ${svg}
     return combined;
   }
 
+  // Validate the GeoPackage layers= selection across all imported datasets,
+  // remove any placeholder datasets produced by filter misses, and strip the
+  // bookkeeping metadata attached by the GeoPackage importer.
+  function validateAndCleanGpkgSelection(datasets, opts) {
+    var availableSet = new Set();
+    var importedSet = new Set();
+    var sawGpkg = false;
+    datasets.forEach(function(ds) {
+      var info = ds && ds.info;
+      if (!info || !Array.isArray(info._gpkg_available_layers)) return;
+      sawGpkg = true;
+      info._gpkg_available_layers.forEach(function(name) { availableSet.add(name); });
+      if (!info._gpkg_placeholder) {
+        (ds.layers || []).forEach(function(lyr) {
+          if (lyr && lyr.name) importedSet.add(lyr.name);
+        });
+      }
+    });
+    if (sawGpkg && Array.isArray(opts.layers) && opts.layers.length > 0) {
+      var missing = opts.layers.filter(function(name) {
+        return !importedSet.has(name);
+      });
+      if (missing.length > 0) {
+        stop$1(
+          'Missing GeoPackage layer(s): ' + missing.join(', ') + '\n' +
+          'Existing layers: ' + Array.from(availableSet).join(' ')
+        );
+      }
+    }
+    var cleaned = datasets.filter(function(ds) {
+      return !(ds && ds.info && ds.info._gpkg_placeholder);
+    });
+    cleaned.forEach(function(ds) {
+      if (ds && ds.info) {
+        delete ds.info._gpkg_available_layers;
+        delete ds.info._gpkg_placeholder;
+      }
+    });
+    return cleaned;
+  }
+
+  function normalizeImportedDatasets(datasetOrArray) {
+    return Array.isArray(datasetOrArray) ? datasetOrArray : [datasetOrArray];
+  }
+
+  function normalizeImportedTarget(datasets) {
+    if (datasets.length == 1) return datasets[0];
+    return {
+      layers: datasets.reduce(function(memo, dataset) {
+        return memo.concat(dataset.layers);
+      }, [])
+    };
+  }
+
   function getUnsupportedFileMessage(path) {
     var ext = getFileExtension(path);
     var msg = 'Unable to import ' + path;
@@ -39139,6 +40084,7 @@ ${svg}
 
   // assumes layers and arcs have been prepared for clipping
   function clipPolygons(targetShapes, clipShapes, nodes, type, optsArg) {
+    profileStart('clipPolygons');
     var arcs = nodes.arcs;
     var opts = optsArg || {};
     var clipFlags = new Uint8Array(arcs.size());
@@ -39149,59 +40095,47 @@ ${svg}
     var findPath = getPathFinder(nodes, useRoute, routeIsActive);
     var dissolvePolygon = getPolygonDissolver(nodes);
 
-    // The following cleanup step is a performance bottleneck (it often takes longer than
-    // other clipping operations) and is usually not needed. Furthermore, it only
-    // eliminates a few kinds of problems, like target polygons with abnormal winding
-    // or overlapping rings. TODO: try to optimize or remove it for all cases
-
-    // skipping shape cleanup when using the experimental fast bbox clipping option
-    // if (!opts.bbox2 && !opts.no_cleanup) {
     if (!opts.bbox2) {
-      // clean each target polygon by dissolving its rings
+      profileStart('cp.dissolveTargetRings');
       targetShapes = targetShapes.map(dissolvePolygon);
+      profileEnd('cp.dissolveTargetRings');
     }
 
-    // Originally, clip shapes were dissolved here as an optimization, using
-    // an unreliable dissolve function.
-    // Now, clip shapes are dissolved using a more reliable (but slower)
-    // function in mapshaper-clip-erase.js
-    // clipShapes = [dissolvePolygon(internal.concatShapes(clipShapes))];
-
-    // Open pathways in the clip/erase layer
-    // Need to expose clip/erase routes in both directions by setting route
-    // in both directions to visible -- this is how cut-out shapes are detected
-    // Or-ing with 0x11 makes both directions visible (so reverse paths will block)
+    profileStart('cp.openClipRoutes');
     openArcRoutes(clipShapes, arcs, clipFlags, type == 'clip', type == 'erase', true, 0x11);
+    profileEnd('cp.openClipRoutes');
+    profileStart('cp.PathIndex#1');
     var index = new PathIndex(clipShapes, arcs);
+    profileEnd('cp.PathIndex#1');
+    profileStart('cp.clipShapes');
     var clippedShapes = targetShapes.map(function(shape, i) {
       if (shape) {
         return clipPolygon(shape, type, index);
       }
       return null;
     });
+    profileEnd('cp.clipShapes');
 
-    markPathsAsUsed(clippedShapes, routeFlags); // to help us find unused paths later
-
-
-    // add clip/erase polygons that are fully contained in a target polygon
-    // need to index only non-intersecting clip shapes
-    // (Intersecting shapes have one or more arcs that have been scanned)
-
-    // first, find shapes that do not intersect the target layer
-    // (these could be inside or outside the target polygons)
+    markPathsAsUsed(clippedShapes, routeFlags);
 
+    profileStart('cp.findUndividedClip');
     var undividedClipShapes = findUndividedClipShapes(clipShapes);
+    profileEnd('cp.findUndividedClip');
 
-    closeArcRoutes(clipShapes, arcs, routeFlags, true, true); // not needed?
+    closeArcRoutes(clipShapes, arcs, routeFlags, true, true);
+    profileStart('cp.PathIndex#2');
     index = new PathIndex(undividedClipShapes, arcs);
+    profileEnd('cp.PathIndex#2');
+    profileStart('cp.findInteriorPaths');
     targetShapes.forEach(function(shape, shapeId) {
-      // find clipping paths that are internal to this target polygon
       var paths = shape ? findInteriorPaths(shape, type, index) : null;
       if (paths) {
         clippedShapes[shapeId] = (clippedShapes[shapeId] || []).concat(paths);
       }
     });
+    profileEnd('cp.findInteriorPaths');
 
+    profileEnd('clipPolygons');
     return clippedShapes;
 
     function clipPolygon(shape, type, index) {
@@ -39629,31 +40563,36 @@ ${svg}
   // @clipSrc: layer in @dataset or filename
   // @type: 'clip' or 'erase'
   function clipLayers(targetLayers, clipSrc, targetDataset, type, opts) {
+    profileStart('clipLayers');
     var usingPathClip = utils.some(targetLayers, layerHasPaths);
-    var mergedDataset, clipLyr, nodes;
+    var mergedDataset, clipLyr, nodes, result;
     opts = opts || {no_cleanup: true}; // TODO: update testing functions
     if (opts.bbox2 && usingPathClip) { // assumes target dataset has arcs
-      return clipLayersByBBox(targetLayers, targetDataset, opts);
+      result = clipLayersByBBox(targetLayers, targetDataset, opts);
+      profileEnd('clipLayers');
+      return result;
     }
+    profileStart('mergeLayersForOverlay');
     mergedDataset = mergeLayersForOverlay(targetLayers, targetDataset, clipSrc, opts);
+    profileEnd('mergeLayersForOverlay');
     clipLyr = mergedDataset.layers[mergedDataset.layers.length-1];
     if (usingPathClip) {
-      // add vertices at all line intersections
-      // (generally slower than actual clipping)
       nodes = addIntersectionCuts(mergedDataset, opts);
       targetDataset.arcs = mergedDataset.arcs;
-      // dissolve clip layer shapes (to remove overlaps and other topological issues
-      // that might confuse the clipping function)
-      // use a data-free copy of the clip lyr, so data records are not dissolved
-      // (this avoids triggering an unnecessary and expensive DBF read operation in some cases).
+      profileStart('clipDissolvePolygonLayer2');
       clipLyr = utils.defaults({data: null}, clipLyr);
       clipLyr = dissolvePolygonLayer2(clipLyr, mergedDataset, {quiet: true, silent: true});
+      profileEnd('clipDissolvePolygonLayer2');
 
     } else {
       nodes = new NodeCollection(mergedDataset.arcs);
     }
 
-    return clipLayersByLayer(targetLayers, clipLyr, nodes, type, opts);
+    profileStart('clipLayersByLayer');
+    result = clipLayersByLayer(targetLayers, clipLyr, nodes, type, opts);
+    profileEnd('clipLayersByLayer');
+    profileEnd('clipLayers');
+    return result;
   }
 
   function clipLayersByBBox(layers, dataset, opts) {
@@ -50192,7 +51131,7 @@ ${svg}
     });
   }
 
-  var version = "0.6.117";
+  var version = "0.6.119";
 
   // 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.
@@ -50890,6 +51829,7 @@ ${svg}
     LayerUtils,
     Lines,
     Logging,
+    Profile,
     Merging,
     MosaicIndex$1,
     OptionParsingUtils,