mapshaper 0.7.5 → 0.7.7

package/mapshaper.js

@@ -4629,6 +4629,32 @@
     return inputs && inputs[0] || '';
   }
 
+  // Return layers in @dataset that were *not* selected by the current target
+  // set but still match a command-specific geometry predicate.
+  //
+  // Used for command side-effect messaging, e.g.:
+  //   - -proj (shared dataset reprojection)
+  //   - -simplify (shared arc simplification)
+  //
+  // @targetLayers should be the layer selection that triggered the command.
+  // If all layers are targeted (or target selection is missing), returns [].
+  // @filterFn optional predicate (lyr -> bool) for command-specific relevance.
+  function getImplicitlyTargetedLayers(dataset, targetLayers, filterFn) {
+    if (!targetLayers || targetLayers.length === 0 || targetLayers.length >= dataset.layers.length) {
+      return [];
+    }
+    var targeted = new Set(targetLayers);
+    return dataset.layers.filter(function(lyr) {
+      return !targeted.has(lyr) && (!filterFn || filterFn(lyr));
+    });
+  }
+
+  function getImplicitlyTargetedLayerNames(dataset, targetLayers, filterFn) {
+    return getImplicitlyTargetedLayers(dataset, targetLayers, filterFn).map(function(lyr) {
+      return lyr.name || '[unnamed]';
+    });
+  }
+
   // Divide a collection of features with mixed types into layers of a single type
   // (Used for importing TopoJSON and GeoJSON features)
   function divideFeaturesByType(shapes, properties, types) {
@@ -4769,6 +4795,8 @@
     filterPathLayerByArcIds: filterPathLayerByArcIds,
     getArcPresenceTest2: getArcPresenceTest2,
     getFeatureCount: getFeatureCount,
+    getImplicitlyTargetedLayerNames: getImplicitlyTargetedLayerNames,
+    getImplicitlyTargetedLayers: getImplicitlyTargetedLayers,
     getLayerBounds: getLayerBounds,
     getLayerDataTable: getLayerDataTable,
     getLayerSourceFile: getLayerSourceFile,
@@ -18415,7 +18443,7 @@
   function exportSVG(dataset, opts) {
     var namespace = 'xmlns="http://www.w3.org/2000/svg"';
     var defs = [];
-    var frame, svg, layers;
+    var frame, svg, layers, metadataJSON;
     var style = '';
 
     // kludge for map keys
@@ -18439,6 +18467,9 @@
     frame = getFrameData(dataset, opts);
     fitDatasetToFrame(dataset, frame);
     setCoordinatePrecision(dataset, opts.precision || 0.01);
+    if (opts.metadata) {
+      metadataJSON = JSON.stringify(getGeospatialMetadata(dataset, frame));
+    }
 
     // error if one or more svg_data fields are not present in any layers
     if (opts.svg_data) validateSvgDataFields(dataset.layers, opts.svg_data);
@@ -18458,6 +18489,10 @@
       return stringify(obj);
     }).join('\n');
 
+    if (metadataJSON) {
+      svg = getMetadataBlock(metadataJSON, [0, 0, frame.width, frame.height]) + svg;
+    }
+
     if (defs.length > 0) {
       svg = '<defs>\n' + utils.pluck(defs, 'svg').join('') + '</defs>\n' + svg;
     }
@@ -18485,6 +18520,57 @@ ${svg}
     }];
   }
 
+  function getMetadataBlock(metadataJSON, viewBox) {
+    var x = 0;
+    var y = 0;
+    var width = viewBox && viewBox[2] || 0;
+    var height = viewBox && viewBox[3] || 0;
+    return '<metadata>' + metadataJSON + '</metadata>\n' +
+      '<g id="mapshaper-metadata">\n' +
+      '<rect x="' + x + '" y="' + y + '" width="' + width + '" height="' + height + '" opacity="0"/>\n' +
+      '<text opacity="0" font-size="0.1">' + metadataJSON + '</text>\n' +
+      '</g>\n';
+  }
+
+  function getGeospatialMetadata(dataset, frame) {
+    return {
+      crs: getSVGMetadataCRS(dataset),
+      bbox: frame.bbox || null
+    };
+  }
+
+  function getSVGMetadataCRS(dataset) {
+    var crs = getDatasetCRS(dataset);
+    var info = getDatasetCrsInfo(dataset);
+    var proj4 = null;
+    if (crs) {
+      proj4 = crsToProj4(crs);
+    }
+    if (proj4) return proj4;
+    return getAuthorityCodeString(info) || null;
+  }
+
+  function getAuthorityCodeString(info) {
+    var authority = null;
+    if (info && info.crs_string) {
+      authority = parseAuthorityCodeString(info.crs_string);
+    }
+    if (!authority && info && info.wkt1) {
+      authority = parseAuthorityCodeFromWkt(info.wkt1);
+    }
+    if (!authority && info && info.geopackage_crs) {
+      authority = parseGeoPackageAuthority(info.geopackage_crs);
+    }
+    return authority ? authority.authority + ':' + authority.code : null;
+  }
+
+  function parseGeoPackageAuthority(o) {
+    if (!o) return null;
+    var authority = o.organization || o.authority || null;
+    var code = o.organization_coordsys_id || o.code || null;
+    return authority && code != null ? {authority: String(authority).toUpperCase(), code: String(code)} : null;
+  }
+
   function exportFurnitureLayerForSVG(lyr, frame, opts) {
     var layerObj = getEmptyLayerForSVG(lyr, opts);
     layerObj.children = renderFurnitureLayer(lyr, frame);
@@ -19446,7 +19532,9 @@ ${svg}
 
   function exportDbfFile(lyr, dataset, opts) {
     var data = lyr.data,
-        buf;
+        buf,
+        files,
+        encoding;
     // create empty data table if missing a table or table is being cut out
     if (!data || opts.cut_table || opts.drop_table) {
       data = new DataTable(lyr.shapes ? lyr.shapes.length : 0);
@@ -19460,14 +19548,34 @@ ${svg}
     } else {
       buf = Dbf.exportRecords(data.getRecords(), opts.encoding, opts.field_order);
     }
+    encoding = getDbfExportEncoding(data, opts);
     if (utils.isInteger(opts.ldid)) {
       new Uint8Array(buf)[29] = opts.ldid; // set language driver id
     }
-    // TODO: also export .cpg page
-    return [{
+    files = [{
       content: buf,
       filename: lyr.name + '.dbf'
     }];
+    if (opts.export_cpg && encoding) {
+      files.push({
+        content: formatCpgEncoding(encoding),
+        filename: lyr.name + '.cpg'
+      });
+    }
+    return files;
+  }
+
+  function getDbfExportEncoding(data, opts) {
+    if (data && data.getDbfEncoding) {
+      return data.getDbfEncoding(opts);
+    }
+    return opts.encoding || 'utf8';
+  }
+
+  function formatCpgEncoding(encoding) {
+    // Canonical spelling for the default.
+    if (/^utf-?8$/i.test(String(encoding))) return 'UTF-8';
+    return String(encoding);
   }
 
   var decoder;
@@ -22232,8 +22340,9 @@ ${svg}
   function exportShapefile(dataset, opts) {
     return dataset.layers.reduce(function(files, lyr) {
       var prj = exportPrjFile(lyr, dataset);
+      var dbfOpts = utils.defaults({export_cpg: true}, opts);
       files = files.concat(exportShpAndShxFiles(lyr, dataset));
-      files = files.concat(exportDbfFile(lyr, dataset, opts));
+      files = files.concat(exportDbfFile(lyr, dataset, dbfOpts));
       if (prj) files.push(prj);
       return files;
     }, []);
@@ -27966,6 +28075,10 @@ ${svg}
         old_alias: 'json-subtree',
         describe: '[JSON] path to JSON input data; separator is /'
       })
+      .option('ndjson', {
+        type: 'flag',
+        describe: '[JSON/GeoJSON] input is newline-delimited JSON objects'
+      })
       .option('single-part', {
         type: 'flag',
         // describe: '[GeoJSON] split multi-part features into single-part features'
@@ -28058,10 +28171,6 @@ ${svg}
         describe: '[TopoJSON] export coordinates without quantization',
         type: 'flag'
       })
-      .option('metadata', {
-        // describe: '[TopoJSON] Add a metadata object containing CRS information',
-        type: 'flag'
-      })
       .option('no-point-quantization', {
         // describe: '[TopoJSON] export point coordinates without quantization',
         type: 'flag'
@@ -28104,6 +28213,10 @@ ${svg}
         describe: '[GeoJSON/JSON] output newline-delimited features or records',
         type: 'flag'
       })
+      .option('metadata', {
+        describe: '[SVG/TopoJSON] include metadata in output',
+        type: 'flag'
+      })
       .option('width', {
         describe: '[SVG/TopoJSON] pixel width of output (SVG default is 800)',
         type: 'number'
@@ -28166,10 +28279,7 @@ ${svg}
       .option('final', {
         type: 'flag' // for testing
       })
-      .option('metadata', {
-        // describe: '[TopoJSON] add a metadata object',
-        type: 'flag'
-      });
+      ;
 
     parser.section('Editing commands');
 
@@ -30251,6 +30361,7 @@ ${svg}
     };
 
     this.getFields = getFieldNames;
+    this.getEncoding = getEncoding;
 
     // TODO: switch to streaming output under Node.js
     this.getBuffer = function() {
@@ -30570,6 +30681,19 @@ ${svg}
       return Dbf.exportRecords(getTable().getRecords(), opts.encoding, opts.field_order);
     };
 
+    // Return the text encoding that exportAsDbf() will use for the current
+    // options. If we're exporting the untouched original DBF bytes, use the
+    // reader's detected/declared encoding; otherwise we regenerate with either
+    // opts.encoding or the writer default (utf8).
+    this.getDbfEncoding = function(optsArg) {
+      var opts = optsArg || {};
+      var useOriginal = !!reader && !altered && !opts.field_order && !opts.encoding;
+      if (useOriginal) {
+        return reader.getEncoding();
+      }
+      return opts.encoding || 'utf8';
+    };
+
     this.getReadOnlyRecordAt = function(i) {
       return reader ? reader.readRow(i) : table.getReadOnlyRecordAt(i);
     };
@@ -31409,7 +31533,7 @@ ${svg}
     (srcCollection.features || srcCollection.geometries || []).forEach(importer.parseObject);
     dataset = importer.done();
     importCRS(dataset, srcObj); // TODO: remove this
-    warnIfProjectedCoords(dataset, srcObj);
+    warnIfProjectedCoords(dataset, srcObj, opts);
     return dataset;
   }
 
@@ -31417,12 +31541,13 @@ ${svg}
   // `crs` member). If the imported file makes no CRS claim but its coordinates
   // are clearly outside lat-long range, warn the user: silent fallthrough here
   // usually surfaces later as cryptic -proj errors or grossly wrong output.
-  function warnIfProjectedCoords(dataset, jsonObj) {
+  function warnIfProjectedCoords(dataset, jsonObj, opts) {
+    if (!opts.warn_projected_coords) return;
     if (jsonObj && jsonObj.crs) return; // user has explicitly declared a CRS
     var bounds = getRoughDatasetBounds(dataset);
     if (!bounds || !bounds.hasBounds()) return;
     if (probablyDecimalDegreeBounds(bounds)) return;
-    warn('Imported GeoJSON has coordinates outside the lat-long range &mdash; ' +
+    warn('Imported GeoJSON has coordinates outside the lat-long range -- ' +
       ' importing as projected geometry with unknown CRS. Commands ' +
       'like -proj that require a CRS will not work until you set a source ' +
       'CRS, e.g. -proj init=EPSG:3857.');
@@ -32413,7 +32538,13 @@ ${svg}
     var str = readFirstChars(reader, 1000);
     var type = identifyJSONString(str, opts);
     var dataset, retn;
-    if (type == 'geojson') { // consider only for larger files
+    if (opts.ndjson) {
+      // NDJSON can represent either newline-delimited GeoJSON features/geometries
+      // or plain JSON records. Defer type detection until after line parsing.
+      retn = {
+        content: reader.toString('utf8')
+      };
+    } else if (type == 'geojson') { // consider only for larger files
       dataset = importGeoJSONFile(reader, opts);
       retn = {
         dataset: dataset,
@@ -32465,6 +32596,12 @@ ${svg}
     }
 
     if (content) {
+      if (opts.ndjson) {
+        var nd = importNDJSON(content, opts);
+        retn.dataset = nd.dataset;
+        retn.format = nd.format;
+        return retn;
+      }
       if (utils.isString(content)) {
         try {
           content = JSON.parse(content); // ~3sec for 100MB string
@@ -32485,7 +32622,7 @@ ${svg}
       if (fmt == 'topojson') {
         retn.dataset = importTopoJSON(content, opts);
       } else if (fmt == 'geojson') {
-        retn.dataset = importGeoJSON(content, opts);
+        retn.dataset = importGeoJSON(content, getGeoJSONImportOpts(opts));
       } else if (fmt == 'json') {
         retn.dataset = importJSONTable(content);
       } else {
@@ -32497,6 +32634,60 @@ ${svg}
     return retn;
   }
 
+  function getGeoJSONImportOpts(opts) {
+    return Object.assign({}, opts, {
+      warn_projected_coords: true
+    });
+  }
+
+  function importNDJSON(content, opts) {
+    var lines = utils.isString(content) ? utils.splitLines(content) : [];
+    var objects = [];
+    var firstGeo = null;
+    for (var i = 0; i < lines.length; i++) {
+      var raw = lines[i].trim();
+      if (!raw) continue;
+      var obj;
+      try {
+        obj = JSON.parse(raw);
+      } catch (e) {
+        stop$1('NDJSON parsing error on line ' + (i + 1) + ': ' + e.message);
+      }
+      objects.push(obj);
+      if (firstGeo === null) {
+        firstGeo = isGeoJSONObject(obj);
+      } else if (firstGeo !== isGeoJSONObject(obj)) {
+        stop$1('NDJSON input mixes GeoJSON and non-GeoJSON objects');
+      }
+    }
+    if (objects.length === 0) {
+      stop$1('NDJSON input does not contain any JSON objects');
+    }
+    if (!firstGeo) {
+      return {dataset: importJSONTable(objects), format: 'json'};
+    }
+    var parser = new GeoJSONParser(getGeoJSONImportOpts(opts));
+    objects.forEach(function(obj) {
+      if (obj && obj.type == 'FeatureCollection') {
+        (obj.features || []).forEach(parser.parseObject);
+      } else if (obj && obj.type == 'GeometryCollection') {
+        (obj.geometries || []).forEach(parser.parseObject);
+      } else {
+        parser.parseObject(obj);
+      }
+    });
+    return {dataset: parser.done(), format: 'geojson'};
+  }
+
+  function isGeoJSONObject(obj) {
+    if (!obj || typeof obj != 'object') return false;
+    var type = obj.type;
+    return type == 'Feature' || type == 'FeatureCollection' ||
+      type == 'GeometryCollection' || type == 'Point' || type == 'MultiPoint' ||
+      type == 'LineString' || type == 'MultiLineString' ||
+      type == 'Polygon' || type == 'MultiPolygon';
+  }
+
   // path: path from top-level to the target object
   function selectFromObject(o, path) {
     var arrayRxp = /(.*)\[([0-9]+)\]$/; // array bracket notation w/ index
@@ -33087,6 +33278,7 @@ ${svg}
     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 geometadata = parseSVGGeometadata(root, str);
     var groups = getTopLevelLayerGroups(root);
     var layerData = [];
     var datasets = [];
@@ -33103,7 +33295,11 @@ ${svg}
       });
     });
 
-    flipYCoordinates(layerData);
+    if (geometadata && geometadata.bbox && geometadata.viewBox) {
+      remapCoordinatesFromSVGToMap(layerData, geometadata.viewBox, geometadata.bbox);
+    } else {
+      flipYCoordinates(layerData);
+    }
 
     layerData.forEach(function(layer) {
       datasets.push(importLayerFeatures(layer.name, layer.features, opts));
@@ -33113,9 +33309,237 @@ ${svg}
       return {layers: [], info: {}};
     }
     if (datasets.length === 1) {
-      return datasets[0];
+      return applySVGGeometadata(datasets[0], geometadata);
     }
-    return mergeDatasets(datasets);
+    return applySVGGeometadata(mergeDatasets(datasets), geometadata);
+  }
+
+  function applySVGGeometadata(dataset, geometadata) {
+    if (geometadata && geometadata.crs) {
+      setDatasetCrsInfo(dataset, getCrsInfo(geometadata.crs));
+    }
+    return dataset;
+  }
+
+  function parseSVGGeometadata(root, svgText) {
+    var json = findMetadataJSONString(root, svgText);
+    var obj;
+    var metadataViewport = getMetadataViewportRect(root);
+    if (!json) return null;
+    obj = parseMetadataJSONObject(json);
+    if (!obj) return null;
+    return {
+      crs: normalizeMetadataCRS(obj.crs),
+      bbox: normalizeMetadataBBox(obj.bbox),
+      viewBox: metadataViewport || parseSVGViewBox(root && root.getAttribute && root.getAttribute('viewBox'))
+    };
+  }
+
+  function findMetadataJSONString(root, svgText) {
+    var text = getMetadataTagText(root) || getHiddenMetadataText(root);
+    if (!text && svgText) {
+      text = extractHiddenMetadataFromSource(svgText);
+    }
+    return normalizeMetadataJSONText(text);
+  }
+
+  function getMetadataTagText(root) {
+    var nodes = getElementChildren(root);
+    for (var i = 0; i < nodes.length; i++) {
+      if (getTagName(nodes[i]) == 'metadata') {
+        return nodes[i].textContent || '';
+      }
+    }
+    return null;
+  }
+
+  function getHiddenMetadataText(root) {
+    var node = getMetadataGroupNode(root);
+    if (node) {
+      return node.textContent || '';
+    }
+    return null;
+  }
+
+  function getMetadataGroupNode(root) {
+    var nodes = getElementChildren(root);
+    var i, node;
+    for (i = 0; i < nodes.length; i++) {
+      node = nodes[i];
+      if (getTagName(node) == 'g' && node.getAttribute && node.getAttribute('id') == 'mapshaper-metadata') {
+        return node;
+      }
+    }
+    return null;
+  }
+
+  function getMetadataViewportRect(root) {
+    var node = getMetadataGroupNode(root);
+    var children, i, rect;
+    if (!node) return null;
+    children = getElementChildren(node);
+    for (i = 0; i < children.length; i++) {
+      if (getTagName(children[i]) == 'rect') {
+        rect = parseMetadataRectNode(children[i]);
+        if (rect) return rect;
+      }
+    }
+    return null;
+  }
+
+  function parseMetadataRectNode(node) {
+    var x = parseNumber(node.getAttribute('x')) || 0;
+    var y = parseNumber(node.getAttribute('y')) || 0;
+    var width = parseNumber(node.getAttribute('width'));
+    var height = parseNumber(node.getAttribute('height'));
+    var pts, i, p;
+    var xmin = Infinity, ymin = Infinity, xmax = -Infinity, ymax = -Infinity;
+    if (!isFiniteNumber(width) || !isFiniteNumber(height) || width === 0 || height === 0) {
+      return null;
+    }
+    pts = [
+      [x, y],
+      [x + width, y],
+      [x, y + height],
+      [x + width, y + height]
+    ];
+    for (i = 0; i < pts.length; i++) {
+      p = applyNodeTransformChain(node, pts[i]);
+      xmin = Math.min(xmin, p[0]);
+      ymin = Math.min(ymin, p[1]);
+      xmax = Math.max(xmax, p[0]);
+      ymax = Math.max(ymax, p[1]);
+    }
+    if (!isFiniteNumber(xmin) || !isFiniteNumber(ymin) || !isFiniteNumber(xmax) || !isFiniteNumber(ymax)) {
+      return null;
+    }
+    return [xmin, ymin, xmax - xmin, ymax - ymin];
+  }
+
+  function applyNodeTransformChain(node, point) {
+    var chain = [];
+    var p = [point[0], point[1]];
+    var i;
+    while (node && node.nodeType == 1) {
+      chain.unshift(node);
+      node = node.parentNode;
+    }
+    for (i = 0; i < chain.length; i++) {
+      p = applyTransformString(chain[i].getAttribute && chain[i].getAttribute('transform'), p);
+    }
+    return p;
+  }
+
+  function applyTransformString(str, point) {
+    var re = /([a-z]+)\s*\(([^)]*)\)/ig;
+    var m = null;
+    var p = [point[0], point[1]];
+    while ((m = re.exec(String(str || '')))) {
+      p = applyTransformCommand(m[1].toLowerCase(), parseTransformNumbers(m[2]), p);
+    }
+    return p;
+  }
+
+  function parseTransformNumbers(str) {
+    return String(str || '')
+      .trim()
+      .split(/[\s,]+/)
+      .filter(Boolean)
+      .map(Number)
+      .filter(function(v) { return isFiniteNumber(v); });
+  }
+
+  function applyTransformCommand(cmd, nums, point) {
+    var x = point[0], y = point[1];
+    var sx, sy;
+    if (cmd == 'translate') {
+      return [x + (nums[0] || 0), y + (nums.length > 1 ? nums[1] : 0)];
+    }
+    if (cmd == 'scale') {
+      sx = nums.length > 0 ? nums[0] : 1;
+      sy = nums.length > 1 ? nums[1] : sx;
+      return [x * sx, y * sy];
+    }
+    if (cmd == 'matrix' && nums.length >= 6) {
+      return [
+        nums[0] * x + nums[2] * y + nums[4],
+        nums[1] * x + nums[3] * y + nums[5]
+      ];
+    }
+    return point;
+  }
+
+  function extractHiddenMetadataFromSource(str) {
+    var m = String(str || '').match(/<g[^>]*\bid\s*=\s*["']mapshaper-metadata["'][^>]*>([\s\S]*?)<\/g>/i);
+    if (!m) return null;
+    return stripMarkupTags(m[1]);
+  }
+
+  function stripMarkupTags(str) {
+    return String(str || '').replace(/<[^>]*>/g, '');
+  }
+
+  function normalizeMetadataJSONText(str) {
+    if (!str) return null;
+    return decodeHTMLEntities(stripMarkupTags(String(str))).trim();
+  }
+
+  function decodeHTMLEntities(str) {
+    return String(str || '')
+      .replace(/&#34;|&#x22;/gi, '"')
+      .replace(/&#39;|&#x27;/gi, "'")
+      .replace(/&#38;|&#x26;/gi, '&')
+      .replace(/&#60;|&#x3c;/gi, '<')
+      .replace(/&#62;|&#x3e;/gi, '>')
+      .replace(/&quot;/g, '"')
+      .replace(/&apos;/g, "'")
+      .replace(/&amp;/g, '&')
+      .replace(/&lt;/g, '<')
+      .replace(/&gt;/g, '>');
+  }
+
+  function parseMetadataJSONObject(text) {
+    try {
+      return JSON.parse(text);
+    } catch (e) {
+      return null;
+    }
+  }
+
+  function normalizeMetadataCRS(crs) {
+    return typeof crs == 'string' && crs.trim() ? crs.trim() : null;
+  }
+
+  function normalizeMetadataBBox(bbox) {
+    if (!Array.isArray(bbox) || bbox.length != 4) return null;
+    var out = bbox.map(function(v) { return Number(v); });
+    return out.every(isFiniteNumber) ? out : null;
+  }
+
+  function parseSVGViewBox(str) {
+    var parts = String(str || '').trim().split(/[\s,]+/).map(Number);
+    if (parts.length != 4 || !parts.every(isFiniteNumber) || parts[2] === 0 || parts[3] === 0) {
+      return null;
+    }
+    return parts;
+  }
+
+  function remapCoordinatesFromSVGToMap(layerData, viewBox, bbox) {
+    var vx = viewBox[0], vy = viewBox[1], vw = viewBox[2], vh = viewBox[3];
+    var minX = bbox[0], minY = bbox[1], maxX = bbox[2], maxY = bbox[3];
+    var scaleX = (maxX - minX) / vw;
+    var scaleY = (maxY - minY) / vh;
+
+    layerData.forEach(function(layer) {
+      layer.features.forEach(function(feature) {
+        forEachGeometryCoordinate(feature && feature.geometry, function(coord) {
+          var sx = coord[0];
+          var sy = coord[1];
+          coord[0] = minX + (sx - vx) * scaleX;
+          coord[1] = maxY - (sy - vy) * scaleY;
+        });
+      });
+    });
   }
 
   function importLayerFeatures(layerName, features, opts) {
@@ -33143,6 +33567,7 @@ ${svg}
     childNodes.forEach(function(node) {
       var tag = getTagName(node);
       if (tag == 'defs') return;
+      if (tag == 'g' && node.getAttribute && node.getAttribute('id') == 'mapshaper-metadata') return;
       if (tag == 'g') {
         groups.push({
           node: node,
@@ -41193,7 +41618,7 @@ ${svg}
   // @type: 'clip' or 'erase'
   function clipLayers(targetLayers, clipSrc, targetDataset, type, opts) {
     profileStart('clipLayers');
-    opts = opts || {no_fcleanup: true}; // TODO: update testing functions
+    opts = opts || {no_cleanup: true}; // TODO: update testing functions
     var usingPathClip = utils.some(targetLayers, layerHasPaths);
     var mergedDataset, clipLyr, nodes, result;
     var clipDataset = normalizeOverlaySource(clipSrc, targetDataset, opts);
@@ -43429,20 +43854,24 @@ ${svg}
       }
     }
 
-    printJoinMessage({
-      matches: matchCount,
-      n: n,
-      joins: countJoins(joinCounts),
-      m: srcRecords.length,
-      skipped: skipCount,
-      collisions: collisionCount,
-      collisionFields: collisionFields,
-      destKey: destKey,
-      srcKey: srcKey,
-      unmatchedTargetKeys: takeSampleKeys(unmatchedTargetKeys),
-      unusedSourceKeys: takeSampleKeys(unusedSourceKeys),
-      opts: opts
-    });
+    // Opt-in summary logging. Some commands (e.g. -divide) reuse this join
+    // helper internally and don't want user-facing join diagnostics.
+    if (opts.show_join_message) {
+      printJoinMessage({
+        matches: matchCount,
+        n: n,
+        joins: countJoins(joinCounts),
+        m: srcRecords.length,
+        skipped: skipCount,
+        collisions: collisionCount,
+        collisionFields: collisionFields,
+        destKey: destKey,
+        srcKey: srcKey,
+        unmatchedTargetKeys: takeSampleKeys(unmatchedTargetKeys),
+        unusedSourceKeys: takeSampleKeys(unusedSourceKeys),
+        opts: opts
+      });
+    }
 
     if (opts.unjoined) {
       retn.unjoined = {
@@ -46804,7 +47233,7 @@ ${svg}
   // Works for lcc, aea, tmerc, etc.
   // TODO: add more projections
   //
-  function expandProjDefn(str, dataset) {
+  function expandProjDefn(str, dataset, targetLayers) {
     var mproj = require$1('mproj');
     var proj4, params, bbox, isConic2SP, isCentered, decimals;
     if (str in mproj.internal.pj_list === false) {
@@ -46815,7 +47244,7 @@ ${svg}
     isCentered = ['tmerc', 'etmerc'].includes(str);
     proj4 = '+proj=' + str;
     if (isConic2SP || isCentered) {
-      bbox = getBBox(dataset); // TODO: support projected datasets
+      bbox = getBBox(dataset, targetLayers); // TODO: support projected datasets
       decimals = getBoundsPrecisionForDisplay(bbox);
       params = isCentered ? getCenterParams(bbox, decimals) : getConicParams(bbox, decimals);
       proj4 += ' ' + params;
@@ -46824,11 +47253,16 @@ ${svg}
     return proj4;
   }
 
-  function getBBox(dataset) {
+  function getBBox(dataset, targetLayers) {
+    var source = targetLayers && targetLayers.length > 0 ? {
+      arcs: dataset.arcs,
+      layers: targetLayers,
+      info: dataset.info
+    } : dataset;
     if (!isLatLngCRS(getDatasetCRS(dataset))) {
       stop$1('Expected unprojected data');
     }
-    return getDatasetBounds(dataset).toArray();
+    return getDatasetBounds(source).toArray();
   }
 
   // See: Savric & Jenny, "Automating the selection of standard parallels for conic map projections"
@@ -46854,8 +47288,9 @@ ${svg}
     getConicParams: getConicParams
   });
 
-  cmd.proj = function(dataset, catalog, opts) {
+  cmd.proj = function(dataset, catalog, opts, targetLayers) {
     var srcInfo, destInfo, destStr;
+    var implicitlyProjectedNames = getImplicitlyTargetedLayerNames(dataset, targetLayers, layerHasGeometry);
     if (opts.init) {
       srcInfo = fetchCrsInfo(opts.init, catalog);
       if (!srcInfo.crs) stop$1("Unknown projection source:", opts.init);
@@ -46864,11 +47299,17 @@ ${svg}
     if (opts.match) {
       destInfo = fetchCrsInfo(opts.match, catalog);
     } else if (opts.crs) {
-      destStr = expandProjDefn(opts.crs, dataset);
+      destStr = expandProjDefn(opts.crs, dataset, targetLayers);
       destInfo = getCrsInfo(destStr);
     }
     if (destInfo) {
-      projCmd(dataset, destInfo, opts);
+      var didProject = projCmd(dataset, destInfo, opts);
+      if (didProject && implicitlyProjectedNames.length > 0) {
+        message(
+          'Also projected non-target layer' + utils.pluralSuffix(implicitlyProjectedNames.length) +
+          ' from the same dataset: ' + implicitlyProjectedNames.join(', ')
+        );
+      }
     }
   };
 
@@ -46886,7 +47327,7 @@ ${svg}
     if (!datasetHasGeometry(dataset)) {
       // still set the crs of datasets that are missing geometry
       setDatasetCrsInfo(dataset, destInfo);
-      return;
+      return false;
     }
 
     var srcInfo = getDatasetCrsInfo(dataset);
@@ -46896,7 +47337,7 @@ ${svg}
 
     if (crsAreEqual(srcInfo.crs, destInfo.crs)) {
       message("Source and destination CRS are the same");
-      return;
+      return false;
     }
 
     if (dataset.arcs) {
@@ -46922,9 +47363,9 @@ ${svg}
       // replace original layers with modified layers
       utils.extend(lyr, target.layers[i]);
     });
+    return true;
   }
 
-
   // name: a layer identifier, .prj file or projection defn
   // Converts layer ids and .prj files to CRS defn
   // Returns projection defn
@@ -48059,17 +48500,62 @@ ${svg}
     });
   }
 
+  function parseWKTPoint(val) {
+    if (!utils.isString(val)) return null;
+    // Support 2D POINT WKT, case-insensitive, with optional Z/M tokens.
+    // Examples:
+    //   POINT (1 2)
+    //   point(1 2)
+    //   POINT Z (1 2 3)
+    //   POINT M (1 2 3)
+    //   POINT ZM (1 2 3 4)
+    var m = /^\s*POINT(?:\s+Z(?:M)?|\s+M)?\s*\(\s*([^\s,]+)\s+([^\s,]+)(?:\s+[^)]*)?\)\s*$/i.exec(val);
+    if (!m) return null;
+    var x = coordinateFromValue(m[1]);
+    var y = coordinateFromValue(m[2]);
+    if (isNaN(x) || isNaN(y)) return null;
+    return [x, y];
+  }
+
+  function findWKTField(records, fields) {
+    var sampleSize = Math.min(records.length, 50);
+    return utils.find(fields, function(name) {
+      var seen = 0;
+      var matches = 0;
+      for (var i = 0; i < sampleSize; i++) {
+        var rec = records[i];
+        if (!rec) continue;
+        var val = rec[name];
+        if (!utils.isString(val) || val.trim() === '') continue;
+        seen++;
+        if (parseWKTPoint(val)) matches++;
+      }
+      // Require at least one non-empty sample and majority parseable as POINT.
+      return seen > 0 && matches / seen >= 0.6;
+    });
+  }
+
   function pointsFromDataTableAuto(data) {
     var fields = data ? data.getFields() : [];
+    var records = data ? data.getRecords() : [];
     var opts = {
       x: findXField(fields),
       y: findYField(fields)
     };
+    if (!opts.x || !opts.y) {
+      opts.wkt = findWKTField(records, fields);
+    }
     return pointsFromDataTable(data, opts);
   }
 
   function pointsFromDataTable(data, opts) {
     if (!data) stop$1("Layer is missing a data table");
+    if (opts.wkt && data.fieldExists(opts.wkt)) {
+      return data.getRecords().map(function(rec) {
+        var p = parseWKTPoint(rec[opts.wkt]);
+        return p ? [p] : null;
+      });
+    }
     if (!opts.x || !opts.y || !data.fieldExists(opts.x) || !data.fieldExists(opts.y)) {
       stop$1("Missing x,y data fields");
     }
@@ -48087,8 +48573,10 @@ ${svg}
   var Points = /*#__PURE__*/Object.freeze({
     __proto__: null,
     coordinateFromValue: coordinateFromValue,
+    findWKTField: findWKTField,
     findXField: findXField,
     findYField: findYField,
+    parseWKTPoint: parseWKTPoint,
     pointsFromPolygons: pointsFromPolygons
   });
 
@@ -48477,6 +48965,9 @@ ${svg}
   }
 
   cmd.join = function(targetLyr, targetDataset, src, opts) {
+    // Opt in to the post-join summary emitted by joinTableToLayer().
+    // Other commands can reuse the helper without showing this message.
+    opts = Object.assign({}, opts, {show_join_message: true});
     var srcType, targetType, retn;
     if (!src || !src.dataset) {
       stop$1("Missing a joinable data source");
@@ -51094,8 +51585,9 @@ ${svg}
     replaceInArray: replaceInArray
   });
 
-  cmd.simplify = function(dataset, opts) {
+  cmd.simplify = function(dataset, opts, targetLayers) {
     var arcs = dataset.arcs;
+    var implicitlySimplifiedNames = getImplicitlyTargetedLayerNames(dataset, targetLayers, layerHasPaths);
     if (!arcs || arcs.size() === 0) return; // removed in v0.4.125: stop("Missing path data");
     opts = getStandardSimplifyOpts(dataset, opts); // standardize options
     simplifyPaths(arcs, opts);
@@ -51114,6 +51606,12 @@ ${svg}
     }
 
     finalizeSimplification(dataset, opts);
+    if (implicitlySimplifiedNames.length > 0) {
+      message(
+        'Also simplified non-target layer' + utils.pluralSuffix(implicitlySimplifiedNames.length) +
+        ' from the same dataset: ' + implicitlySimplifiedNames.join(', ')
+      );
+    }
   };
 
   function finalizeSimplification(dataset, opts) {
@@ -52807,7 +53305,7 @@ ${svg}
         await initProjLibrary(opts);
         job.resumeCommand();
         targets.forEach(function(targ) {
-          cmd.proj(targ.dataset, job.catalog, opts);
+          cmd.proj(targ.dataset, job.catalog, opts, targ.layers);
         });
 
       } else if (name == 'rectangle') {
@@ -52850,7 +53348,7 @@ ${svg}
         if (opts.variable) {
           cmd.variableSimplify(targetLayers, targetDataset, opts);
         } else {
-          cmd.simplify(targetDataset, opts);
+          cmd.simplify(targetDataset, opts, targetLayers);
         }
 
       } else if (name == 'slice') {
@@ -52976,7 +53474,7 @@ ${svg}
     });
   }
 
-  var version = "0.7.5";
+  var version = "0.7.7";
 
   // 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.