mapshaper 0.6.116 → 0.6.118

package/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; },
@@ -53,7 +53,7 @@
     get isBoolean () { return isBoolean; },
     get isDate () { return isDate; },
     get isEven () { return isEven; },
-    get isFiniteNumber () { return isFiniteNumber; },
+    get isFiniteNumber () { return isFiniteNumber$1; },
     get isFunction () { return isFunction; },
     get isInteger () { return isInteger; },
     get isNonNegNumber () { return isNonNegNumber; },
@@ -70,7 +70,7 @@
     get mergeNames () { return mergeNames; },
     get numToStr () { return numToStr; },
     get parseIntlNumber () { return parseIntlNumber; },
-    get parseNumber () { return parseNumber; },
+    get parseNumber () { return parseNumber$1; },
     get parsePercent () { return parsePercent; },
     get parseString () { return parseString; },
     get pickOne () { return pickOne; },
@@ -188,7 +188,7 @@
   }
 
   // Similar to isFinite() but does not coerce strings or other types
-  function isFiniteNumber(val) {
+  function isFiniteNumber$1(val) {
     return isValidNumber(val) && val !== Infinity && val !== -Infinity;
   }
 
@@ -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];
   }
@@ -1182,7 +1182,7 @@
   // Use null instead of NaN for unparsable values
   // (in part because if NaN is used, empty strings get converted to "NaN"
   // when re-exported).
-  function parseNumber(raw) {
+  function parseNumber$1(raw) {
     return parseToNum(raw, cleanNumericString);
   }
 
@@ -6399,41 +6399,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 +6456,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 +6472,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 +6595,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 +6616,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 +6680,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 +6697,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 +6711,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 +6754,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);
@@ -11611,7 +11669,7 @@
   function guessInputFileType(file) {
     var ext = getFileExtension(file || '').toLowerCase(),
         type = null;
-    if (ext == 'dbf' || ext == 'shp' || ext == 'kml' || ext == 'fgb' || ext == 'gpkg') {
+    if (ext == 'dbf' || ext == 'shp' || ext == 'kml' || ext == 'svg' || ext == 'fgb' || ext == 'gpkg') {
       type = ext;
     } else if (isAuxiliaryInputFileType(ext)) {
       type = ext;
@@ -11634,7 +11692,8 @@
     var type = null;
     if (utils.isString(content)) {
       type = stringLooksLikeJSON(content) && 'json' ||
-        stringLooksLikeKML(content) && 'kml' || 'text';
+        stringLooksLikeKML(content) && 'kml' ||
+        stringLooksLikeSVG(content) && 'svg' || 'text';
     } else if (utils.isObject(content) && content.type || utils.isArray(content)) {
       type = 'json';
     }
@@ -11654,6 +11713,11 @@
     return str.includes('<kml ') && str.includes('xmlns="http://www.opengis.net/kml/');
   }
 
+  function stringLooksLikeSVG(str) {
+    str = String(str);
+    return str.includes('<svg ') && str.includes('xmlns="http://www.w3.org/2000/svg"');
+  }
+
   function couldBeDsvFile(name) {
     var ext = getFileExtension(name).toLowerCase();
     return /csv|tsv|txt$/.test(ext);
@@ -11725,7 +11789,8 @@
     looksLikeContentFile: looksLikeContentFile,
     looksLikeImportableFile: looksLikeImportableFile,
     stringLooksLikeJSON: stringLooksLikeJSON,
-    stringLooksLikeKML: stringLooksLikeKML
+    stringLooksLikeKML: stringLooksLikeKML,
+    stringLooksLikeSVG: stringLooksLikeSVG
   });
 
   // input: A file path or a buffer
@@ -18717,13 +18782,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);
   }
@@ -18732,7 +18797,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();
@@ -24493,12 +24558,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 {
@@ -24515,8 +24578,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(
@@ -24526,8 +24592,9 @@ ${svg}
         );
       } catch (e) {
         throw Error('GeoPackage insert failed at layer "' + tableName +
-          '", feature ' + i + ': ' + e.message);
+          '", feature ' + featureIndex + ': ' + e.message);
       }
+      featureIndex++;
     }
   }
 
@@ -24554,9 +24621,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;
@@ -24570,11 +24639,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';
@@ -24593,10 +24730,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) ?
@@ -24615,11 +24748,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);
@@ -24635,13 +24765,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);
@@ -24733,9 +24933,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);
@@ -24744,7 +24945,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
     };
@@ -24821,18 +25024,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;
   }
 
@@ -26862,6 +27068,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)'
@@ -31456,24 +31666,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);
@@ -31482,13 +31703,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) {
@@ -31497,10 +31777,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');
@@ -31519,13 +31829,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 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 convertOrgToProj4(crs) {
+  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;
@@ -31553,14 +32057,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',
@@ -31576,8 +32091,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) {
@@ -31620,6 +32134,672 @@ ${svg}
     return obj;
   }
 
+  var INHERITED_STYLE_KEYS = [
+    'fill', 'fill-opacity',
+    'stroke', 'stroke-width', 'stroke-opacity', 'stroke-dasharray',
+    'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit',
+    'opacity', 'vector-effect',
+    'font-family', 'font-size', 'font-style', 'font-stretch', 'font-weight',
+    'text-anchor', 'dominant-baseline', 'letter-spacing', 'line-height'
+  ];
+
+  var INHERITED_STYLE_INDEX = INHERITED_STYLE_KEYS.reduce(function(memo, key) {
+    memo[key] = true;
+    return memo;
+  }, {});
+
+  var LAYER_SUFFIX = {
+    polygon: 'polygons',
+    polyline: 'lines',
+    point: 'points'
+  };
+
+  function importSVG(str, optsArg) {
+    var opts = optsArg || {};
+    var Parser = typeof DOMParser == 'undefined' ? require$1('@xmldom/xmldom').DOMParser : DOMParser;
+    var doc = new Parser().parseFromString(str, 'text/xml');
+    var root = doc && doc.documentElement;
+    var groups = getTopLevelLayerGroups(root);
+    var layerData = [];
+    var datasets = [];
+
+    groups.forEach(function(group) {
+      var features = [];
+      collectFeatures(group.node, {}, features, {
+        forcePolylinePaths: layerHasOpenPaths(group.node)
+      });
+      if (features.length === 0) return;
+      layerData.push({
+        name: group.name,
+        features: features
+      });
+    });
+
+    flipYCoordinates(layerData);
+
+    layerData.forEach(function(layer) {
+      datasets.push(importLayerFeatures(layer.name, layer.features, opts));
+    });
+
+    if (datasets.length === 0) {
+      return {layers: [], info: {}};
+    }
+    if (datasets.length === 1) {
+      return datasets[0];
+    }
+    return mergeDatasets(datasets);
+  }
+
+  function importLayerFeatures(layerName, features, opts) {
+    var dataset = importGeoJSON({
+      type: 'FeatureCollection',
+      features: features
+    }, opts);
+    if (dataset.layers.length === 1) {
+      dataset.layers[0].name = layerName;
+    } else {
+      dataset.layers.forEach(function(lyr) {
+        var suffix = LAYER_SUFFIX[lyr.geometry_type] || 'features';
+        lyr.name = layerName + '_' + suffix;
+      });
+    }
+    return dataset;
+  }
+
+  function getTopLevelLayerGroups(root) {
+    var groups = [];
+    var childNodes = getElementChildren(root);
+    var defaultNode = null;
+    var layerCount = 0;
+
+    childNodes.forEach(function(node) {
+      var tag = getTagName(node);
+      if (tag == 'defs') return;
+      if (tag == 'g') {
+        groups.push({
+          node: node,
+          name: node.getAttribute('id') || getDefaultLayerName(++layerCount)
+        });
+      } else if (tag == 'path' || tag == 'circle' || tag == 'text') {
+        if (!defaultNode) {
+          defaultNode = {
+            tagName: 'g',
+            childNodes: [],
+            attributes: []
+          };
+          groups.push({
+            node: defaultNode,
+            name: getDefaultLayerName(++layerCount)
+          });
+        }
+        defaultNode.childNodes.push(node);
+      }
+    });
+
+    if (groups.length === 0 && root) {
+      groups.push({
+        node: root,
+        name: getDefaultLayerName(1)
+      });
+    }
+    return groups;
+  }
+
+  function getDefaultLayerName(i) {
+    return 'layer' + i;
+  }
+
+  function collectFeatures(node, inheritedStyles, features, layerOpts) {
+    var tag = getTagName(node);
+    var nodeStyles = getNodeStyles(node);
+    var inherited = extendProps(inheritedStyles, nodeStyles);
+
+    if (tag == 'defs') return;
+    if (tag == 'g' || tag == 'svg') {
+      getElementChildren(node).forEach(function(child) {
+        collectFeatures(child, inherited, features, layerOpts);
+      });
+      return;
+    }
+    if (tag == 'path') {
+      collectPathFeature(node, inherited, features, layerOpts);
+    } else if (tag == 'circle') {
+      collectCircleFeature(node, inherited, features);
+    } else if (tag == 'text') {
+      collectTextFeature(node, inherited, features);
+    }
+  }
+
+  function collectPathFeature(node, inherited, features, layerOpts) {
+    var d = node.getAttribute('d');
+    var geom = parsePathGeometry(d, layerOpts && layerOpts.forcePolylinePaths);
+    var props;
+    if (!geom) return;
+    props = getFeatureProperties(node, inherited, {d: true});
+    features.push({
+      type: 'Feature',
+      geometry: geom,
+      properties: props
+    });
+  }
+
+  function collectCircleFeature(node, inherited, features) {
+    var x = parseNumber(node.getAttribute('cx'));
+    var y = parseNumber(node.getAttribute('cy'));
+    var props;
+    if (!isFiniteNumber(x) || !isFiniteNumber(y)) return;
+    props = getFeatureProperties(node, inherited, {cx: true, cy: true});
+    addNumericProperty(props, 'r', node.getAttribute('r'));
+    features.push({
+      type: 'Feature',
+      geometry: {
+        type: 'Point',
+        coordinates: [x, y]
+      },
+      properties: props
+    });
+  }
+
+  function collectTextFeature(node, inherited, features) {
+    var baseX = parseNumber(node.getAttribute('x')) || 0;
+    var baseY = parseNumber(node.getAttribute('y')) || 0;
+    var translate = parseTranslate(node.getAttribute('transform'));
+    var hasTranslate = nodeHasTranslate(node.getAttribute('transform'));
+    var x = hasTranslate ? translate[0] : baseX;
+    var y = hasTranslate ? translate[1] : baseY;
+    var text = (node.textContent || '').trim();
+    var props = getFeatureProperties(node, inherited, {x: true, y: true, transform: true});
+
+    props['label-text'] = text;
+    if (hasTranslate && node.getAttribute('x') !== null) {
+      props.dx = baseX;
+    }
+    if (hasTranslate && node.getAttribute('y') !== null) {
+      props.dy = baseY;
+    }
+    features.push({
+      type: 'Feature',
+      geometry: {
+        type: 'Point',
+        coordinates: [x, y]
+      },
+      properties: props
+    });
+  }
+
+  function getFeatureProperties(node, inherited, excluded) {
+    var props = extendProps({}, inherited);
+    var attrs = node.attributes || [];
+    var styleMap = parseStyleString(node.getAttribute && node.getAttribute('style'));
+
+    Object.keys(styleMap).forEach(function(name) {
+      if (name == 'fill-rule') return;
+      props[name] = styleMap[name];
+    });
+    for (var i = 0; i < attrs.length; i++) {
+      var attr = attrs[i];
+      var key = attr && attr.name;
+      var val = attr && attr.value;
+      if (!key || key == 'style' || (excluded && excluded[key])) continue;
+      if (key == 'id' || key == 'class' || key.indexOf('data-') === 0 || INHERITED_STYLE_INDEX[key]) {
+        props[key] = val;
+      }
+    }
+    return props;
+  }
+
+  function getNodeStyles(node) {
+    var styles = {};
+    var attrs = node.attributes || [];
+    var styleMap = parseStyleString(node.getAttribute && node.getAttribute('style'));
+    var i, attr, key;
+
+    Object.keys(styleMap).forEach(function(name) {
+      if (INHERITED_STYLE_INDEX[name]) {
+        styles[name] = styleMap[name];
+      }
+    });
+
+    for (i = 0; i < attrs.length; i++) {
+      attr = attrs[i];
+      key = attr && attr.name;
+      if (key && INHERITED_STYLE_INDEX[key]) {
+        styles[key] = attr.value;
+      }
+    }
+    return styles;
+  }
+
+  function parseStyleString(style) {
+    var out = {};
+    var parts, i, part, idx, key, val;
+    if (!style) return out;
+    parts = String(style).split(';');
+    for (i = 0; i < parts.length; i++) {
+      part = parts[i].trim();
+      if (!part) continue;
+      idx = part.indexOf(':');
+      if (idx == -1) continue;
+      key = part.substr(0, idx).trim();
+      val = part.substr(idx + 1).trim();
+      if (!key) continue;
+      out[key] = val;
+    }
+    return out;
+  }
+
+  function parsePathGeometry(d, forcePolylinePaths) {
+    var subpaths = parsePathData(d);
+    var lines = [];
+    var rings = [];
+    var parts = [];
+    var polygonGeom, polylineGeom;
+
+    subpaths.forEach(function(path) {
+      var coords = path.coords;
+      if (coords.length < 2) return;
+      if (forcePolylinePaths) {
+        lines.push(path.closed || pointsEqual(coords[0], coords[coords.length - 1]) ? closeRing(coords) : coords);
+        return;
+      }
+      if (path.closed || pointsEqual(coords[0], coords[coords.length - 1])) {
+        if (coords.length >= 3) {
+          rings.push(closeRing(coords));
+        }
+      } else {
+        lines.push(coords);
+      }
+    });
+
+    if (rings.length > 0) {
+      polygonGeom = buildPolygonGeometry(rings);
+      if (polygonGeom) parts.push(polygonGeom);
+    }
+    if (lines.length > 0) {
+      polylineGeom = lines.length == 1 ? {
+        type: 'LineString',
+        coordinates: lines[0]
+      } : {
+        type: 'MultiLineString',
+        coordinates: lines
+      };
+      parts.push(polylineGeom);
+    }
+    if (parts.length === 0) return null;
+    if (parts.length === 1) return parts[0];
+    return {
+      type: 'GeometryCollection',
+      geometries: parts
+    };
+  }
+
+  function buildPolygonGeometry(rings) {
+    var ringData = rings.map(function(coords, i) {
+      return {
+        id: i,
+        coords: coords,
+        area: Math.abs(getRingArea(coords)),
+        containers: [],
+        depth: 0,
+        parent: null
+      };
+    });
+
+    ringData.forEach(function(ring, i) {
+      var point = getRingSamplePoint(ring.coords);
+      ringData.forEach(function(other, j) {
+        if (i == j) return;
+        if (pointInRing(point, other.coords)) {
+          ring.containers.push(other.id);
+        }
+      });
+      ring.depth = ring.containers.length;
+    });
+
+    ringData.forEach(function(ring) {
+      var parentDepth = ring.depth - 1;
+      if (parentDepth < 0) return;
+      ring.containers.forEach(function(parentId) {
+        var candidate = ringData[parentId];
+        if (candidate.depth != parentDepth) return;
+        if (!ring.parent || candidate.area < ring.parent.area) {
+          ring.parent = candidate;
+        }
+      });
+    });
+
+    var polygons = [];
+    ringData.forEach(function(ring) {
+      if (ring.depth % 2 !== 0) return;
+      polygons.push([ring.coords]);
+    });
+
+    ringData.forEach(function(ring) {
+      var polygon;
+      if (ring.depth % 2 !== 1 || !ring.parent) return;
+      polygon = polygons.find(function(coords) {
+        return coords[0] === ring.parent.coords;
+      });
+      if (polygon) {
+        polygon.push(ring.coords);
+      }
+    });
+
+    if (polygons.length === 0) return null;
+    if (polygons.length == 1) {
+      return {
+        type: 'Polygon',
+        coordinates: polygons[0]
+      };
+    }
+    return {
+      type: 'MultiPolygon',
+      coordinates: polygons.map(function(coords) {
+        return [coords[0]].concat(coords.slice(1));
+      })
+    };
+  }
+
+  function parsePathData(d) {
+    var tokens = tokenizePath(d || '');
+    var paths = [];
+    var cmd = null;
+    var i = 0;
+    var currX = 0;
+    var currY = 0;
+    var startX = 0;
+    var startY = 0;
+    var path = null;
+
+    function startPath(x, y) {
+      if (path && path.coords.length > 0) {
+        paths.push(path);
+      }
+      path = {
+        coords: [[x, y]],
+        closed: false
+      };
+      currX = x;
+      currY = y;
+      startX = x;
+      startY = y;
+    }
+
+    function addPoint(x, y) {
+      if (!path) {
+        startPath(x, y);
+        return;
+      }
+      path.coords.push([x, y]);
+      currX = x;
+      currY = y;
+    }
+
+    while (i < tokens.length) {
+      if (isPathCommand(tokens[i])) {
+        cmd = tokens[i++];
+        if (cmd == 'Z' || cmd == 'z') {
+          if (path) {
+            path.closed = true;
+            currX = startX;
+            currY = startY;
+          }
+        }
+        continue;
+      }
+      if (!cmd) {
+        i++;
+        continue;
+      }
+
+      if (cmd == 'M' || cmd == 'm') {
+        if (!hasPair(tokens, i)) break;
+        var moveX = Number(tokens[i++]);
+        var moveY = Number(tokens[i++]);
+        if (cmd == 'm') {
+          moveX += currX;
+          moveY += currY;
+        }
+        startPath(moveX, moveY);
+        cmd = cmd == 'm' ? 'l' : 'L';
+        continue;
+      }
+
+      if (cmd == 'L' || cmd == 'l') {
+        if (!hasPair(tokens, i)) break;
+        var lineX = Number(tokens[i++]);
+        var lineY = Number(tokens[i++]);
+        if (cmd == 'l') {
+          lineX += currX;
+          lineY += currY;
+        }
+        addPoint(lineX, lineY);
+        continue;
+      }
+
+      if (cmd == 'H' || cmd == 'h') {
+        var x = Number(tokens[i++]);
+        if (cmd == 'h') x += currX;
+        addPoint(x, currY);
+        continue;
+      }
+
+      if (cmd == 'V' || cmd == 'v') {
+        var y = Number(tokens[i++]);
+        if (cmd == 'v') y += currY;
+        addPoint(currX, y);
+        continue;
+      }
+
+      // Unsupported command -- skip following numeric tokens until next command.
+      while (i < tokens.length && !isPathCommand(tokens[i])) {
+        i++;
+      }
+    }
+
+    if (path && path.coords.length > 0) {
+      paths.push(path);
+    }
+    return paths;
+  }
+
+  function layerHasOpenPaths(node) {
+    var hasOpenPath = false;
+
+    function scan(el) {
+      var tag = getTagName(el);
+      if (!tag || tag == 'defs' || hasOpenPath) return;
+      if (tag == 'path') {
+        hasOpenPath = pathContainsOpenSubpath(el.getAttribute('d'));
+        return;
+      }
+      getElementChildren(el).forEach(scan);
+    }
+
+    scan(node);
+    return hasOpenPath;
+  }
+
+  function pathContainsOpenSubpath(d) {
+    var subpaths = parsePathData(d);
+    for (var i = 0; i < subpaths.length; i++) {
+      var coords = subpaths[i].coords;
+      if (coords.length < 2) continue;
+      if (!subpaths[i].closed && !pointsEqual(coords[0], coords[coords.length - 1])) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  function flipYCoordinates(layerData) {
+    var range = getYRange(layerData);
+    if (!range) return;
+    layerData.forEach(function(layer) {
+      layer.features.forEach(function(feature) {
+        if (feature && feature.geometry) {
+          flipGeometryY(feature.geometry, range);
+        }
+      });
+    });
+  }
+
+  function getYRange(layerData) {
+    var minY = Infinity;
+    var maxY = -Infinity;
+    layerData.forEach(function(layer) {
+      layer.features.forEach(function(feature) {
+        forEachGeometryCoordinate(feature && feature.geometry, function(coord) {
+          if (coord[1] < minY) minY = coord[1];
+          if (coord[1] > maxY) maxY = coord[1];
+        });
+      });
+    });
+    if (!isFinite(minY) || !isFinite(maxY)) return null;
+    return {min: minY, max: maxY};
+  }
+
+  function flipGeometryY(geom, range) {
+    forEachGeometryCoordinate(geom, function(coord) {
+      coord[1] = range.min + range.max - coord[1];
+    });
+  }
+
+  function forEachGeometryCoordinate(geom, cb) {
+    if (!geom || !geom.type) return;
+    if (geom.type == 'Point') {
+      cb(geom.coordinates);
+    } else if (geom.type == 'LineString' || geom.type == 'MultiPoint') {
+      geom.coordinates.forEach(cb);
+    } else if (geom.type == 'Polygon' || geom.type == 'MultiLineString') {
+      geom.coordinates.forEach(function(path) {
+        path.forEach(cb);
+      });
+    } else if (geom.type == 'MultiPolygon') {
+      geom.coordinates.forEach(function(poly) {
+        poly.forEach(function(ring) {
+          ring.forEach(cb);
+        });
+      });
+    } else if (geom.type == 'GeometryCollection') {
+      (geom.geometries || []).forEach(function(child) {
+        forEachGeometryCoordinate(child, cb);
+      });
+    }
+  }
+
+  function tokenizePath(d) {
+    var rxp = /[a-zA-Z]|-?(?:\d+\.?\d*|\.\d+)(?:e[-+]?\d+)?/ig;
+    return String(d).match(rxp) || [];
+  }
+
+  function parseTranslate(str) {
+    var match = String(str || '').match(/translate\(\s*([^\s,()]+)(?:[\s,]+([^\s,()]+))?/i);
+    var x = 0;
+    var y = 0;
+    if (match) {
+      x = parseNumber(match[1]) || 0;
+      y = parseNumber(match[2]) || 0;
+    }
+    return [x, y];
+  }
+
+  function nodeHasTranslate(str) {
+    return /translate\(/i.test(String(str || ''));
+  }
+
+  function closeRing(coords) {
+    var ring = coords.map(function(p) { return [p[0], p[1]]; });
+    if (!pointsEqual(ring[0], ring[ring.length - 1])) {
+      ring.push([ring[0][0], ring[0][1]]);
+    }
+    return ring;
+  }
+
+  function getRingSamplePoint(ring) {
+    return ring[0];
+  }
+
+  function getRingArea(ring) {
+    var area = 0;
+    for (var i = 0, n = ring.length - 1; i < n; i++) {
+      area += ring[i][0] * ring[i + 1][1] - ring[i + 1][0] * ring[i][1];
+    }
+    return area / 2;
+  }
+
+  function pointInRing(point, ring) {
+    var x = point[0];
+    var y = point[1];
+    var inside = false;
+    var i, j, xi, yi, xj, yj, intersects;
+    for (i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+      xi = ring[i][0];
+      yi = ring[i][1];
+      xj = ring[j][0];
+      yj = ring[j][1];
+      intersects = ((yi > y) != (yj > y)) &&
+        (x < (xj - xi) * (y - yi) / ((yj - yi) || 1e-30) + xi);
+      if (intersects) inside = !inside;
+    }
+    return inside;
+  }
+
+  function addNumericProperty(props, key, strVal) {
+    var num = parseNumber(strVal);
+    if (isFiniteNumber(num)) {
+      props[key] = num;
+    }
+  }
+
+  function parseNumber(str) {
+    var num = Number(str);
+    return isFiniteNumber(num) ? num : null;
+  }
+
+  function hasPair(tokens, i) {
+    return i + 1 < tokens.length && !isPathCommand(tokens[i]) && !isPathCommand(tokens[i + 1]);
+  }
+
+  function isPathCommand(token) {
+    return /^[a-z]$/i.test(token);
+  }
+
+  function pointsEqual(a, b) {
+    return a && b && a[0] == b[0] && a[1] == b[1];
+  }
+
+  function isFiniteNumber(val) {
+    return typeof val == 'number' && isFinite(val);
+  }
+
+  function getTagName(node) {
+    return node && node.tagName ? String(node.tagName).toLowerCase() : '';
+  }
+
+  function getElementChildren(node) {
+    var out = [];
+    var childNodes = node && node.childNodes ? node.childNodes : [];
+    for (var i = 0; i < childNodes.length; i++) {
+      if (childNodes[i] && childNodes[i].nodeType == 1) {
+        out.push(childNodes[i]);
+      }
+    }
+    return out;
+  }
+
+  function extendProps(dest, src) {
+    var out = {};
+    var key;
+    if (dest) {
+      for (key in dest) out[key] = dest[key];
+    }
+    if (src) {
+      for (key in src) out[key] = src[key];
+    }
+    return out;
+  }
+
   // Parse content of one or more input files and return a dataset
   // @obj: file data, indexed by file type
   // File data objects have two properties:
@@ -31662,6 +32842,11 @@ ${svg}
       data = obj.kml;
       dataset = importKML(data.content, opts);
 
+    } else if (obj.svg) {
+      dataFmt = 'svg';
+      data = obj.svg;
+      dataset = importSVG(data.content, opts);
+
     } else if (obj.fgb) {
       stop$1("FlatGeobuf import requires async import path");
     } else if (obj.gpkg) {
@@ -31685,6 +32870,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);
   }
 
@@ -31886,12 +33076,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) {
@@ -31926,14 +33122,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
@@ -32034,7 +33238,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;
 
@@ -32137,17 +33342,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
@@ -32165,12 +33373,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);
@@ -32179,6 +33390,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;
@@ -49514,7 +50779,7 @@ ${svg}
     });
   }
 
-  var version = "0.6.116";
+  var version = "0.6.118";
 
   // 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.