mapshaper 0.6.115 → 0.6.117

package/www/mapshaper.js

@@ -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;
   }
 
@@ -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);
   }
 
@@ -5248,7 +5248,7 @@
   }
 
   function toLngLat(xy, P) {
-    return projectPoint(xy, P, parseCrsString('wgs84'));
+    return projectPoint(xy, P, parseCrsString$1('wgs84'));
   }
 
   function projectPoint(xy, crsFrom, crsTo) {
@@ -5335,11 +5335,11 @@
   function getCrsInfo(str) {
     return {
       crs_string: str,
-      crs: parseCrsString(str)
+      crs: parseCrsString$1(str)
     };
   }
 
-  function parseCrsString(str) {
+  function parseCrsString$1(str) {
     var defn = getProjDefn(str);  // defn is a string or a Proj object
     var P;
     if (!utils.isString(defn)) {
@@ -5374,15 +5374,15 @@
   function getDatasetCrsInfo(dataset) {
     var info = copyCrsProperties(dataset.info || {});
     if (!info.crs && info.wkt1) {
-      info.crs = parseCrsString(wkt1ToProj(info.wkt1));
+      info.crs = parseCrsString$1(wkt1ToProj(info.wkt1));
     } else if (!info.crs && info.crs_string) {
-      info.crs = parseCrsString(info.crs_string);
+      info.crs = parseCrsString$1(info.crs_string);
     }
     if (!info.crs) {
       if (probablyDecimalDegreeBounds(getDatasetBounds(dataset))) {
         // use wgs84 for probable latlong datasets with unknown datums
         info.crs_string = 'wgs84';
-        info.crs = parseCrsString(info.crs_string);
+        info.crs = parseCrsString$1(info.crs_string);
       }
     }
     return info;
@@ -5473,7 +5473,7 @@
 
   // Convert contents of a .prj file to a projection object
   function parsePrj(str) {
-    return parseCrsString(wkt1ToProj(str));
+    return parseCrsString$1(wkt1ToProj(str));
   }
 
   var Projections = /*#__PURE__*/Object.freeze({
@@ -5499,7 +5499,7 @@
     isWGS84: isWGS84,
     isWebMercator: isWebMercator,
     looksLikeProj4String: looksLikeProj4String,
-    parseCrsString: parseCrsString,
+    parseCrsString: parseCrsString$1,
     parsePrj: parsePrj,
     printProjections: printProjections,
     projectPoint: projectPoint,
@@ -11611,7 +11611,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 +11634,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 +11655,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 +11731,8 @@
     looksLikeContentFile: looksLikeContentFile,
     looksLikeImportableFile: looksLikeImportableFile,
     stringLooksLikeJSON: stringLooksLikeJSON,
-    stringLooksLikeKML: stringLooksLikeKML
+    stringLooksLikeKML: stringLooksLikeKML,
+    stringLooksLikeSVG: stringLooksLikeSVG
   });
 
   // input: A file path or a buffer
@@ -24493,22 +24500,28 @@ ${svg}
   }
 
   async function exportLayerToGeoPackage(lyr, dataset, gpkg, opts) {
-    var features, fields, columns;
+    var features, fields, columns, tableName, targetSrs;
     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);
-    var tableName = getTableName(lyr.name);
+    tableName = getTableName(lyr.name);
     columns = fields.map(function(field) {
       return {
         name: field.name,
         dataType: field.type
       };
     });
-    await gpkg.createFeatureTableFromProperties(tableName, columns);
+    targetSrs = getExportSrs(dataset);
+    await ensureSrsExists(gpkg, targetSrs);
+    // createFeatureTableFromProperties() hardcodes EPSG:4326
+    await gpkg.createFeatureTable(tableName, null, columns, undefined, targetSrs.srs_id);
     var featureDao = gpkg.getFeatureDao(tableName);
-    var srs = normalizeSrsForInsert(featureDao && featureDao.srs);
+    // addGeoJSONFeatureToGeoPackageWithFeatureDaoAndSrs() assumes source
+    // 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];
       var normalized = normalizeFeature(feat, fields);
@@ -24607,6 +24620,143 @@ ${svg}
     return removeUndefinedValues(output);
   }
 
+  function getExportSrs(dataset) {
+    var info = dataset.info || {};
+    var gpkgCrs = normalizeSrsForInsert(info.geopackage_crs);
+    if (gpkgCrs) {
+      if (!gpkgCrs.definition && info.wkt1) {
+        gpkgCrs.definition = info.wkt1;
+      }
+      return gpkgCrs;
+    }
+    var parsed = parseCrsString(info.crs_string);
+    if (parsed) {
+      if (info.wkt1) parsed.definition = info.wkt1;
+      return parsed;
+    }
+    var fromWkt = parseWktAuthority(info.wkt1);
+    if (fromWkt) {
+      fromWkt.definition = info.wkt1;
+      return fromWkt;
+    }
+    if (info.wkt1) {
+      return buildCustomSrsFromWkt(info.wkt1);
+    }
+    return {
+      srs_id: 4326,
+      organization: 'EPSG',
+      organization_coordsys_id: 4326
+    };
+  }
+
+  function parseCrsString(str) {
+    if (!str || typeof str != 'string') return null;
+    var match = str.match(/^([a-z]+):(\d+)$/i);
+    if (!match) return null;
+    var org = match[1].toUpperCase();
+    var code = +match[2];
+    if (!code) return null;
+    return {
+      srs_id: code,
+      organization: org,
+      organization_coordsys_id: code
+    };
+  }
+
+  function parseWktAuthority(wkt) {
+    if (!wkt || typeof wkt != 'string') return null;
+    var rootAuthority = findTopLevelWktAuthority(wkt);
+    if (!rootAuthority) return null;
+    var org = String(rootAuthority[1]).toUpperCase();
+    var code = +rootAuthority[2];
+    if (!code) return null;
+    return {
+      srs_id: code,
+      organization: org,
+      organization_coordsys_id: code
+    };
+  }
+
+  function findTopLevelWktAuthority(wkt) {
+    var depth = 0;
+    var inQuote = false;
+    for (var i = 0; i < wkt.length; i++) {
+      var c = wkt.charAt(i);
+      if (c == '"') {
+        inQuote = !inQuote;
+        continue;
+      }
+      if (inQuote) continue;
+      if (c == '[') {
+        depth++;
+        continue;
+      }
+      if (c == ']') {
+        depth--;
+        continue;
+      }
+      if (depth != 1) continue;
+      if (wkt.slice(i, i + 10).toUpperCase() == 'AUTHORITY[') {
+        return wkt.slice(i).match(/^AUTHORITY\["([^"]+)","(\d+)"\]/i);
+      }
+    }
+    return null;
+  }
+
+  function buildCustomSrsFromWkt(wkt) {
+    var srsId = getCustomSrsId(wkt);
+    return {
+      srs_id: srsId,
+      srs_name: getWktName(wkt) || 'CUSTOM_CRS',
+      organization: 'NONE',
+      organization_coordsys_id: srsId,
+      definition: wkt,
+      description: 'Custom projection'
+    };
+  }
+
+  function getWktName(wkt) {
+    var match = wkt && String(wkt).match(/^(?:PROJCS|GEOGCS)\["([^"]+)"/i);
+    return match ? match[1] : null;
+  }
+
+  function getCustomSrsId(wkt) {
+    var str = String(wkt || '');
+    var hash = 2166136261; // FNV-1a
+    for (var i = 0; i < str.length; i++) {
+      hash ^= str.charCodeAt(i);
+      hash = (hash * 16777619) >>> 0;
+    }
+    return 100000 + (hash % 900000);
+  }
+
+  async function ensureSrsExists(gpkg, srs) {
+    if (!srs || !srs.srs_id) return;
+    var existing = gpkg.getSrs(srs.srs_id);
+    if (existing) return;
+    if (!srs.definition) {
+      stop$1('Unable to export GeoPackage with missing CRS definition for SRS ' + srs.srs_id);
+    }
+    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.definition = srs.definition;
+    spatialReferenceSystem.description = srs.description || null;
+    gpkg.createSpatialReferenceSystem(spatialReferenceSystem);
+  }
+
+  function getSourceSrsWithoutReprojection(tableSrs, fallbackSrs) {
+    var target = normalizeSrsForInsert(tableSrs) || normalizeSrsForInsert(fallbackSrs);
+    return {
+      srs_id: target.srs_id,
+      organization: 'EPSG',
+      organization_coordsys_id: 4326
+    };
+  }
+
   function normalizeValue(value, type) {
     if (value === null || value === undefined) return null;
     if (type == 'TEXT' && typeof value != 'string') {
@@ -24664,14 +24814,14 @@ ${svg}
   }
 
   function normalizeSrsForInsert(srs) {
-    if (!srs) {
-      return {
-        srs_id: 4326,
-        organization: 'EPSG',
-        organization_coordsys_id: 4326
-      };
-    }
+    if (!srs) return null;
     var normalized = Object.assign({}, srs);
+    if (normalized.srs_id == null && normalized.id != null) {
+      normalized.srs_id = normalized.id;
+    }
+    if (normalized.organization_coordsys_id == null && normalized.code != null) {
+      normalized.organization_coordsys_id = normalized.code;
+    }
     if (normalized.srs_id == null && normalized.srsId != null) {
       normalized.srs_id = normalized.srsId;
     }
@@ -24685,6 +24835,7 @@ ${svg}
     if (!normalized.organization) {
       normalized.organization = 'EPSG';
     }
+    normalized.organization = String(normalized.organization).toUpperCase();
     if (normalized.organization_coordsys_id == null) {
       normalized.organization_coordsys_id = normalized.srs_id || 4326;
     }
@@ -31313,17 +31464,26 @@ ${svg}
     var gpkg;
     var datasets;
     var source;
+    var tmpPath = null;
 
     if (!geopackage || !geopackage.GeoPackageAPI) {
       stop$1('GeoPackage library is not loaded');
     }
 
-    source = utils.isString(content) ? content : new Uint8Array(content);
+    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);
     try {
       datasets = readFeatureTableDatasets(gpkg, opts);
     } finally {
       gpkg.close();
+      removeTempGeoPackageFile(tmpPath);
     }
 
     if (datasets.length === 0) {
@@ -31338,6 +31498,24 @@ ${svg}
     return mergeDatasets(datasets);
   }
 
+  function writeGeoPackageTempFile(content) {
+    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.writeFileSync(tmpPath, Buffer.from(new Uint8Array(content)));
+    return tmpPath;
+  }
+
+  function removeTempGeoPackageFile(filepath) {
+    if (!filepath) return;
+    var fs = require$1('fs');
+    if (fs.existsSync(filepath)) {
+      fs.unlinkSync(filepath);
+    }
+  }
+
   // load lookup tables for epsg codes if needed (for browser)
   async function initProjLib(datasets) {
     for (const dataset of datasets) {
@@ -31449,6 +31627,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:
@@ -31491,6 +32335,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) {
@@ -31690,7 +32539,7 @@ ${svg}
     if (o.crs_string) {
       // load external files (e.g. epsg definitions) if needed in GUI
       await initProjLibrary({crs: o.crs_string});
-      o.crs = parseCrsString(o.crs_string);
+      o.crs = parseCrsString$1(o.crs_string);
     } else if (o.prj) {
       o.crs = parsePrj(o.prj);
     }
@@ -35072,7 +35921,7 @@ ${svg}
   // Make a single geodetic circle
   function getCircleGeoJSON(center, radius, vertices, opts) {
     var n = 360;
-    var geod = getGeodeticSegmentFunction(parseCrsString('wgs84')); // ?
+    var geod = getGeodeticSegmentFunction(parseCrsString$1('wgs84')); // ?
     if (opts.inset) {
       radius -= opts.inset;
     }
@@ -43702,23 +44551,23 @@ ${svg}
   };
 
   function createUnprojectedPolygon(opts) {
-    var crs = parseCrsString('wgs84');
+    var crs = parseCrsString$1('wgs84');
     return getPolygonDataset$1(crs, crs, opts);
   }
 
   function createProjectedPolygon(dest, opts) {
-    var src = parseCrsString('wgs84');
+    var src = parseCrsString$1('wgs84');
     return getPolygonDataset$1(src, dest, opts);
   }
 
   function createUnprojectedGraticule(opts) {
-    var src = parseCrsString('wgs84');
+    var src = parseCrsString$1('wgs84');
     var graticule = importGeoJSON(createGraticule(src, false, opts));
     return graticule;
   }
 
   function createProjectedGraticule(dest, opts) {
-    var src = parseCrsString('wgs84');
+    var src = parseCrsString$1('wgs84');
     var outline = getOutlineDataset(src, dest, {});
     var graticule = importGeoJSON(createGraticule(dest, !!outline, opts));
     projectDataset(graticule, src, dest, {no_clip: false}); // TODO: densify?
@@ -46752,7 +47601,7 @@ ${svg}
       stop$1('Missing required radius parameter.');
     }
     var cp = opts.center || [0, 0];
-    var radius = opts.radius || getCircleRadiusFromAngle(parseCrsString('wgs84'), opts.radius_angle);
+    var radius = opts.radius || getCircleRadiusFromAngle(parseCrsString$1('wgs84'), opts.radius_angle);
     return getCircleGeoJSON(cp, radius, null, {geometry_type : opts.geometry || 'polygon'});
   }
 
@@ -49343,7 +50192,7 @@ ${svg}
     });
   }
 
-  var version = "0.6.115";
+  var version = "0.6.117";
 
   // 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.