mapshaper 0.5.88 → 0.5.92

package/www/mapshaper-gui.js

@@ -233,6 +233,30 @@
     return parsed[0].options;
   };
 
+  // Convert an options object to a command line options string
+  // (used by gui-import-control.js)
+  // TODO: handle options with irregular string <-> object conversion
+  GUI.formatCommandOptions = function(o) {
+    var arr = [];
+    Object.keys(o).forEach(function(key) {
+      var name = key.replace(/_/g, '-');
+      var val = o[key];
+      var str;
+      // TODO: quote values that contain spaces
+      if (Array.isArray(val)) {
+        str = name + '=' + val.join(',');
+      } else if (val === true) {
+        str = name;
+      } else if (val === false) {
+        return;
+      } else {
+        str = name + '=' + val;
+      }
+      arr.push(str);
+    });
+    return arr.join(' ');
+  };
+
   // @file: Zip file
   // @cb: function(err, <files>)
   //
@@ -1107,20 +1131,19 @@
 
   function ImportControl(gui, opts) {
     var model = gui.model;
+    var initialImport = true;
     var importCount = 0;
     var importTotal = 0;
     var overQuickView = false;
-    var useQuickView = opts.quick_view; // may be set by mapshaper-gui
     var queuedFiles = [];
     var manifestFiles = opts.files || [];
-    var cachedFiles = {};
     var catalog;
 
     if (opts.catalog) {
       catalog = new CatalogControl(gui, opts.catalog, downloadFiles);
     }
 
-    new SimpleButton('#import-buttons .submit-btn').on('click', onSubmit);
+    new SimpleButton('#import-buttons .submit-btn').on('click', importQueuedFiles);
     new SimpleButton('#import-buttons .cancel-btn').on('click', gui.clearMode);
     new DropControl(gui, 'body', receiveFiles);
     new FileChooser('#file-selection-btn', receiveFiles);
@@ -1128,7 +1151,7 @@
     new FileChooser('#add-file-btn', receiveFiles);
     initDropArea('#import-quick-drop', true);
     initDropArea('#import-drop');
-    gui.keyboard.onMenuSubmit(El('#import-options'), onSubmit);
+    gui.keyboard.onMenuSubmit(El('#import-options'), importQueuedFiles);
 
     gui.addMode('import', turnOn, turnOff);
     gui.enterMode('import');
@@ -1140,6 +1163,10 @@
       }
     });
 
+    function useQuickView() {
+      return initialImport && (opts.quick_view || overQuickView);
+    }
+
     function initDropArea(el, isQuick) {
       var area = El(el)
         .on('dragleave', onout)
@@ -1157,15 +1184,19 @@
       }
     }
 
-    function findMatchingShp(filename) {
-      // use case-insensitive matching
-      var base = internal.getPathBase(filename).toLowerCase();
-      return model.getDatasets().filter(function(d) {
-        var fname = d.info.input_files && d.info.input_files[0] || "";
-        var ext = internal.getFileExtension(fname).toLowerCase();
-        var base2 = internal.getPathBase(fname).toLowerCase();
-        return base == base2 && ext == 'shp';
-      });
+    async function importQueuedFiles() {
+      gui.container.removeClass('queued-files');
+      gui.container.removeClass('splash-screen');
+      var files = queuedFiles;
+      try {
+        if (files.length > 0) {
+          queuedFiles = [];
+          await importFiles(files);
+        }
+      } catch(e) {
+        console.error(e);
+      }
+      gui.clearMode();
     }
 
     function turnOn() {
@@ -1186,13 +1217,8 @@
         importCount = 0;
       }
       gui.clearProgressMessage();
-      useQuickView = false; // unset 'quick view' mode, if on
-      close();
-    }
-
-    function close() {
+      initialImport = false; // unset 'quick view' mode, if on
       clearQueuedFiles();
-      cachedFiles = {};
     }
 
     function onImportComplete() {
@@ -1206,6 +1232,7 @@
         }
       }
       model.updated({select: true});
+
     }
 
     function clearQueuedFiles() {
@@ -1226,34 +1253,6 @@
       }, []);
     }
 
-    // When a Shapefile component is at the head of the queue, move the entire
-    // Shapefile to the front of the queue, sorted in reverse alphabetical order,
-    // (a kludge), so .shp is read before .dbf and .prj
-    // (If a .dbf file is imported before a .shp, it becomes a separate dataset)
-    // TODO: import Shapefile parts without relying on this kludge
-    function sortQueue(queue) {
-      var nextFile = queue[0];
-      var basename, parts;
-      if (!isShapefilePart(nextFile.name)) {
-        return queue;
-      }
-      basename = internal.getFileBase(nextFile.name).toLowerCase();
-      parts = [];
-      queue = queue.filter(function(file) {
-        if (internal.getFileBase(file.name).toLowerCase() == basename) {
-          parts.push(file);
-          return false;
-        }
-        return true;
-      });
-      parts.sort(function(a, b) {
-        // Sorting on LC filename so Shapefiles with mixed-case
-        // extensions are sorted correctly
-        return a.name.toLowerCase() < b.name.toLowerCase() ? 1 : -1;
-      });
-      return parts.concat(queue);
-    }
-
     function showQueuedFiles() {
       var list = gui.container.findChild('.dropped-file-list').empty();
       queuedFiles.forEach(function(f) {
@@ -1261,16 +1260,14 @@
       });
     }
 
-    function receiveFiles(files) {
-      var prevSize = queuedFiles.length;
-      useQuickView = useQuickView || overQuickView;
-      files = handleZipFiles(utils.toArray(files));
-      addFilesToQueue(files);
+    async function receiveFiles(files) {
+      // TODO: show importing message here?
+      var expanded = await expandFiles(files);
+      addFilesToQueue(expanded);
       if (queuedFiles.length === 0) return;
       gui.enterMode('import');
-
-      if (useQuickView) {
-        onSubmit();
+      if (useQuickView()) {
+        importQueuedFiles();
       } else {
         gui.container.addClass('queued-files');
         El('#path-import-options').classed('hidden', !filesMayContainPaths(queuedFiles));
@@ -1278,25 +1275,51 @@
       }
     }
 
-    function filesMayContainPaths(files) {
-      return utils.some(files, function(f) {
-          var type = internal.guessInputFileType(f.name);
-          return type == 'shp' || type == 'json' || internal.isZipFile(f.name);
-      });
+    async function expandFiles(files) {
+      var files2 = [], expanded;
+      for (var f of files) {
+        if (internal.isZipFile(f.name)) {
+          expanded = await readZipFile(f);
+          files2 = files2.concat(expanded);
+        } else {
+          files2.push(f);
+        }
+      }
+      return files2;
     }
 
-    function onSubmit() {
-      gui.container.removeClass('queued-files');
-      gui.container.removeClass('splash-screen');
-      procNextQueuedFile();
+    async function importFiles(files) {
+      var fileData = await readFiles(files);
+      var importOpts = readImportOpts();
+      var groups = groupFilesForImport(fileData, importOpts);
+      for (var group of groups) {
+        if (group.size > 4e7) {
+          gui.showProgressMessage('Importing');
+          await wait(35);
+        }
+        importDataset(group, importOpts);
+      }
     }
 
-    function addDataset(dataset) {
-      if (!datasetIsEmpty(dataset)) {
-        model.addDataset(dataset);
-        importCount++;
+    function importDataset(group, importOpts) {
+      var optStr = GUI.formatCommandOptions(importOpts);
+      var dataset = internal.importContent(group, importOpts);
+      if (datasetIsEmpty(dataset)) return;
+      if (group.layername) {
+        dataset.layers.forEach(lyr => lyr.name = group.layername);
       }
-      procNextQueuedFile();
+      // save import options for use by repair control, etc.
+      dataset.info.import_options = importOpts;
+      model.addDataset(dataset);
+      importCount++;
+      gui.session.fileImported(group.filename, optStr);
+    }
+
+    function filesMayContainPaths(files) {
+      return utils.some(files, function(f) {
+          var type = internal.guessInputFileType(f.name);
+          return type == 'shp' || type == 'json' || internal.isZipFile(f.name);
+      });
     }
 
     function datasetIsEmpty(dataset) {
@@ -1305,41 +1328,27 @@
       });
     }
 
-    function procNextQueuedFile() {
-      if (queuedFiles.length === 0) {
-        gui.clearMode();
-      } else {
-        queuedFiles = sortQueue(queuedFiles);
-        readFile(queuedFiles.shift());
-      }
-    }
 
     // TODO: support .cpg
     function isShapefilePart(name) {
       return /\.(shp|shx|dbf|prj)$/i.test(name);
     }
 
-
     function readImportOpts() {
-      if (useQuickView) return {};
-      var freeform = El('#import-options .advanced-options').node().value,
-          opts = GUI.parseFreeformOptions(freeform, 'i');
-      opts.no_repair = !El("#repair-intersections-opt").node().checked;
-      opts.snap = !!El("#snap-points-opt").node().checked;
-      return opts;
-    }
-
-    // for CLI output
-    function readImportOptsAsString() {
-      if (useQuickView) return '';
-      var freeform = El('#import-options .advanced-options').node().value;
-      var opts = readImportOpts();
-      if (opts.snap) freeform = 'snap ' + freeform;
-      return freeform.trim();
+      var importOpts;
+      if (useQuickView()) {
+        importOpts = {}; // default opts using quickview
+      } else {
+        var freeform = El('#import-options .advanced-options').node().value;
+        importOpts = GUI.parseFreeformOptions(freeform, 'i');
+        importOpts.no_repair = !El("#repair-intersections-opt").node().checked;
+        importOpts.snap = !!El("#snap-points-opt").node().checked;
+      }
+      return importOpts;
     }
 
     // @file a File object
-    function readFile(file) {
+    async function readContentFileAsync(file, cb) {
       var name = file.name,
           reader = new FileReader(),
           useBinary = internal.isSupportedBinaryInputType(name) ||
@@ -1349,9 +1358,9 @@
 
       reader.addEventListener('loadend', function(e) {
         if (!reader.result) {
-          handleImportError("Web browser was unable to load the file.", name);
+          cb(new Error());
         } else {
-          importFileContent(name, reader.result);
+          cb(null, reader.result);
         }
       });
       if (useBinary) {
@@ -1362,91 +1371,6 @@
       }
     }
 
-    function importFileContent(fileName, content) {
-      var fileType = internal.guessInputType(fileName, content),
-          importOpts = readImportOpts(),
-          matches = findMatchingShp(fileName),
-          dataset, lyr;
-
-      // Add dbf data to a previously imported .shp file with a matching name
-      // (.shp should have been queued before .dbf)
-      if (fileType == 'dbf' && matches.length > 0) {
-        // find an imported .shp layer that is missing attribute data
-        // (if multiple matches, try to use the most recently imported one)
-        dataset = matches.reduce(function(memo, d) {
-          if (!d.layers[0].data) {
-            memo = d;
-          }
-          return memo;
-        }, null);
-        if (dataset) {
-          lyr = dataset.layers[0];
-          lyr.data = new internal.ShapefileTable(content, importOpts.encoding);
-          if (lyr.shapes && lyr.data.size() != lyr.shapes.length) {
-            stop("Different number of records in .shp and .dbf files");
-          }
-          if (!lyr.geometry_type) {
-            // kludge: trigger display of table cells if .shp has null geometry
-            // TODO: test case if lyr is not the current active layer
-            model.updated({});
-          }
-          procNextQueuedFile();
-          return;
-        }
-      }
-
-      if (fileType == 'shx') {
-        // save .shx for use when importing .shp
-        // (queue should be sorted so that .shx is processed before .shp)
-        cachedFiles[fileName.toLowerCase()] = {filename: fileName, content: content};
-        procNextQueuedFile();
-        return;
-      }
-
-      // Add .prj file to previously imported .shp file
-      if (fileType == 'prj') {
-        matches.forEach(function(d) {
-          if (!d.info.prj) {
-            d.info.prj = content;
-          }
-        });
-        procNextQueuedFile();
-        return;
-      }
-
-      importNewDataset(fileType, fileName, content, importOpts);
-    }
-
-    function importNewDataset(fileType, fileName, content, importOpts) {
-      var size = content.byteLength || content.length, // ArrayBuffer or string
-          delay = 0;
-
-      // show importing message if file is large
-      if (size > 4e7) {
-        gui.showProgressMessage('Importing');
-        delay = 35;
-      }
-      setTimeout(function() {
-        var dataset;
-        var input = {};
-        try {
-          input[fileType] = {filename: fileName, content: content};
-          if (fileType == 'shp') {
-            // shx file should already be cached, if it was added together with the shp
-            input.shx = cachedFiles[fileName.replace(/shp$/i, 'shx').toLowerCase()] || null;
-          }
-          dataset = internal.importContent(input, importOpts);
-          // save import options for use by repair control, etc.
-          dataset.info.import_options = importOpts;
-          gui.session.fileImported(fileName, readImportOptsAsString());
-          addDataset(dataset);
-
-        } catch(e) {
-          handleImportError(e, fileName);
-        }
-      }, delay);
-    }
-
     function handleImportError(e, fileName) {
       var msg = utils.isString(e) ? e : e.message;
       if (fileName) {
@@ -1457,34 +1381,6 @@
       console.error(e);
     }
 
-    function handleZipFiles(files) {
-      return files.filter(function(file) {
-        var isZip = internal.isZipFile(file.name);
-        if (isZip) {
-          importZipFile(file);
-        }
-        return !isZip;
-      });
-    }
-
-    function importZipFile(file) {
-      // gui.showProgressMessage('Importing');
-      setTimeout(function() {
-        GUI.readZipFile(file, function(err, files) {
-          if (err) {
-            handleImportError(err, file.name);
-          } else {
-            // don't try to import .txt files from zip files
-            // (these would be parsed as dsv and throw errows)
-            files = files.filter(function(f) {
-              return !/\.txt$/i.test(f.name);
-            });
-            receiveFiles(files);
-          }
-        });
-      }, 35);
-    }
-
     function prepFilesForDownload(names) {
       var items = names.map(function(name) {
         var isUrl = /:\/\//.test(name);
@@ -1530,37 +1426,107 @@
       });
     }
 
-    function downloadNextFile_v1(memo, item, next) {
-      var req = new XMLHttpRequest();
-      var blob;
-      req.responseType = 'blob';
-      req.addEventListener('load', function(e) {
-        if (req.status == 200) {
-          blob = req.response;
-        }
-      });
-      req.addEventListener('progress', function(e) {
-        if (!e.lengthComputable) return;
-        var pct = e.loaded / e.total;
-        if (catalog) catalog.progress(pct);
+    function wait(ms) {
+      return new Promise(resolve => setTimeout(resolve, ms));
+    }
+
+    function runAsync(fn, arg) {
+      return new Promise((resolve, reject) => {
+        fn(arg, function(err, data) {
+          return err ? reject(err) : resolve(data);
+        });
       });
-      req.addEventListener('loadend', function() {
-        var err;
-        if (req.status == 404) {
-          err = "Not&nbsp;found:&nbsp;" + item.name;
-        } else if (!blob) {
-          // Errors like DNS lookup failure, no CORS headers, no network connection
-          // all are status 0 - it seems impossible to show a more specific message
-          // actual reason is displayed on the console
-          err = "Error&nbsp;loading&nbsp;" + item.name + ". Possible causes include: wrong URL, no network connection, server not configured for cross-domain sharing (CORS).";
+    }
+
+    async function readZipFile(file) {
+      var files;
+      await wait(35); // pause a beat so status message can display
+      try {
+        files = await runAsync(GUI.readZipFile, file);
+        // don't try to import .txt files from zip files
+        // (these would be parsed as dsv and throw errows)
+        files = files.filter(function(f) {
+          return !/\.txt$/i.test(f.name);
+        });
+      } catch(e) {
+        handleImportError(e, file.name);
+        files = [];
+      }
+      return files;
+    }
+
+    async function readFileData(file) {
+      try {
+        var content = await runAsync(readContentFileAsync, file);
+        return {
+          content: content,
+          size: content.byteLength || content.length, // ArrayBuffer or string
+          name: file.name,
+          basename: internal.getFileBase(file.name).toLowerCase(),
+          type: internal.guessInputType(file.name, content)
+        };
+      } catch (e) {
+        handleImportError("Web browser was unable to load the file.", file.name);
+      }
+      return null;
+    }
+
+    async function readFiles(files) {
+      var data = [], d;
+      for (var file of files) {
+        d = await readFileData(file);
+        if (d) data.push(d);
+      }
+      return data;
+    }
+
+    function groupFilesForImport(data, importOpts) {
+      var names = importOpts.name ? [importOpts.name] : null;
+      if (initialImport && opts.name) { // name from mapshaper-gui --name option
+        names = opts.name.split(',');
+      }
+
+      function key(basename, type) {
+        return basename + '.' + type;
+      }
+      function hasShp(basename) {
+        var shpKey = key(basename, 'shp');
+        return data.some(d => key(d.basename, d.type) == shpKey);
+      }
+      data.forEach(d => {
+        if (d.type == 'shp' || !isShapefilePart(d.name)) {
+          d.group = key(d.basename, d.type);
+          d.filename = d.name;
+        } else if (hasShp(d.basename)) {
+          d.group = key(d.basename, 'shp');
+        } else if (d.type == 'dbf') {
+          d.filename = d.name;
+          d.group = key(d.basename, 'dbf');
         } else {
-          blob.name = item.basename;
-          memo.push(blob);
+          // shapefile part without a .shp file
+          d.group = null;
         }
-        next(err, memo);
       });
-      req.open('GET', item.url);
-      req.send();
+      var index = {};
+      var groups = [];
+      data.forEach(d => {
+        if (!d.group) return;
+        var g = index[d.group];
+        if (!g) {
+          g = {};
+          g.layername = names ? names[groups.length] || names[names.length - 1] : null;
+          groups.push(g);
+          index[d.group] = g;
+        }
+        g.size = (g.size || 0) + d.size; // accumulate size
+        g[d.type] = {
+          filename: d.name,
+          content: d.content
+        };
+        // kludge: stash import name for session history
+        if (d.filename) g.filename = d.filename;
+      });
+      return groups;
     }
   }
 
@@ -2222,6 +2188,13 @@
     // expose this function, so other components can run commands (e.g. box tool)
     this.runMapshaperCommands = runMapshaperCommands;
 
+    this.runInitialCommands = function(str) {
+      str = str.trim();
+      if (!str) return;
+      turnOn();
+      submit(str);
+    };
+
     consoleMessage(PROMPT);
     gui.keyboard.on('keydown', onKeyDown);
     window.addEventListener('beforeunload', saveHistory); // save history if console is open on refresh
@@ -3584,7 +3557,7 @@
 
   // import { cloneShape } from '../paths/mapshaper-shape-utils';
   // import { copyRecord } from '../datatable/mapshaper-data-utils';
-  var snapVerticesToPoint$1 = internal.snapVerticesToPoint;
+  var snapVerticesToPoint = internal.snapVerticesToPoint;
   var cloneShape = internal.cloneShape;
   var copyRecord = internal.copyRecord;
 
@@ -3693,7 +3666,7 @@
       var arcs = target.dataset.arcs;
       var p = internal.getVertexCoords(ids[0], arcs);
       return function() {
-        snapVerticesToPoint$1(ids, p, arcs, true);
+        snapVerticesToPoint(ids, p, arcs, true);
       };
     };
 
@@ -4133,13 +4106,38 @@
     return self;
   }
 
-  function getShapeHitTest(displayLayer, ext) {
+  function absArcId(arcId) {
+    return arcId >= 0 ? arcId : ~arcId;
+  }
+
+  function calcArcBounds(xx, yy, start, len) {
+    var i = start | 0,
+        n = isNaN(len) ? xx.length - i : len + i,
+        x, y, xmin, ymin, xmax, ymax;
+    if (n > 0) {
+      xmin = xmax = xx[i];
+      ymin = ymax = yy[i];
+    }
+    for (i++; i<n; i++) {
+      x = xx[i];
+      y = yy[i];
+      if (x < xmin) xmin = x;
+      if (x > xmax) xmax = x;
+      if (y < ymin) ymin = y;
+      if (y > ymax) ymax = y;
+    }
+    return [xmin, ymin, xmax, ymax];
+  }
+
+  function getShapeHitTest(displayLayer, ext, interactionMode) {
     var geoType = displayLayer.layer.geometry_type;
     var test;
     if (geoType == 'point' && displayLayer.style.type == 'styled') {
       test = getGraduatedCircleTest(getRadiusFunction(displayLayer.style));
     } else if (geoType == 'point') {
       test = pointTest;
+    } else if (interactionMode == 'vertices') {
+      test = vertexTest;
     } else if (geoType == 'polyline') {
       test = polylineTest;
     } else if (geoType == 'polygon') {
@@ -4165,14 +4163,14 @@
     }
 
     function polygonTest(x, y) {
-      var maxDist = getZoomAdjustedHitBuffer(5, 1),
+      var maxDist = getZoomAdjustedHitBuffer(10, 1),
           cands = findHitCandidates(x, y, maxDist),
           hits = [],
           cand, hitId;
       for (var i=0; i<cands.length; i++) {
         cand = cands[i];
         if (geom.testPointInPolygon(x, y, cand.shape, displayLayer.arcs)) {
-          hits.push(cand.id);
+          hits.push(cand);
         }
       }
       if (cands.length > 0 && hits.length === 0) {
@@ -4180,7 +4178,9 @@
         sortByDistance(x, y, cands, displayLayer.arcs);
         hits = pickNearestCandidates(cands, 0, maxDist);
       }
-      return hits;
+      return {
+        ids: utils.pluck(hits, 'id')
+      };
     }
 
     function pickNearestCandidates(sorted, bufDist, maxDist) {
@@ -4195,22 +4195,41 @@
         } else if (cand.dist - minDist > bufDist) {
           break;
         }
-        hits.push(cand.id);
+        hits.push(cand);
       }
       return hits;
     }
 
+     function vertexTest(x, y) {
+      var maxDist = getZoomAdjustedHitBuffer(15, 2),
+          bufDist = getZoomAdjustedHitBuffer(0.05), // tiny threshold for hitting almost-identical lines
+          cands = findHitCandidates(x, y, maxDist);
+      sortByDistance(x, y, cands, displayLayer.arcs);
+      cands = pickNearestCandidates(cands, bufDist, maxDist);
+      var arcs = cands.map(function(cand) { return absArcId(cand.info.arcId); });
+      return {
+        arcs: utils.uniq(arcs),
+        ids: utils.pluck(cands, 'id')
+      };
+    }
+
     function polylineTest(x, y) {
       var maxDist = getZoomAdjustedHitBuffer(15, 2),
           bufDist = getZoomAdjustedHitBuffer(0.05), // tiny threshold for hitting almost-identical lines
           cands = findHitCandidates(x, y, maxDist);
       sortByDistance(x, y, cands, displayLayer.arcs);
-      return pickNearestCandidates(cands, bufDist, maxDist);
+      cands = pickNearestCandidates(cands, bufDist, maxDist);
+      return {
+        ids: utils.pluck(cands, 'id')
+      };
     }
 
     function sortByDistance(x, y, cands, arcs) {
+      var cand;
       for (var i=0; i<cands.length; i++) {
-        cands[i].dist = geom.getPointToShapeDistance(x, y, cands[i].shape, arcs);
+        cand = cands[i];
+        cand.info = geom.getPointToShapeInfo(x, y, cands[i].shape, arcs);
+        cand.dist = cand.info.distance;
       }
       utils.sortOn(cands, 'dist');
     }
@@ -4238,7 +4257,9 @@
         }
       });
       // console.log(hitThreshold, bullseye);
-      return utils.uniq(hits); // multipoint features can register multiple hits
+      return {
+        ids: utils.uniq(hits) // multipoint features can register multiple hits
+      };
     }
 
     function getRadiusFunction(style) {
@@ -4292,7 +4313,9 @@
             hits.push(id);
           }
         });
-        return hits;
+        return {
+          ids: hits
+        };
       };
     }
 
@@ -4429,20 +4452,18 @@
 
   }
 
-  function getPointerHitTest(mapLayer, ext) {
+  function getPointerHitTest(mapLayer, ext, interactionMode) {
     var shapeTest, svgTest, targetLayer;
     if (!mapLayer || !internal.layerHasGeometry(mapLayer.layer)) {
-      return null;
+      return function() {return {ids: []};};
     }
-    shapeTest = getShapeHitTest(mapLayer, ext);
+    shapeTest = getShapeHitTest(mapLayer, ext, interactionMode);
     svgTest = getSvgHitTest(mapLayer);
 
     // e: pointer event
     return function(e) {
       var p = ext.translatePixelCoords(e.x, e.y);
-      var data = {
-        ids: shapeTest(p[0], p[1]) || []
-      };
+      var data = shapeTest(p[0], p[1]) || {ids:[]};
       var svgData = svgTest(e); // null or a data object
       if (svgData) { // mouse is over an SVG symbol
         utils.extend(data, svgData);
@@ -4502,22 +4523,25 @@
     }, !!'capture'); // preempt the layer control's arrow key handler
 
     self.setLayer = function(mapLayer) {
-      hitTest = getPointerHitTest(mapLayer, ext);
-      if (!hitTest) {
-        hitTest = function() {return {ids: []};};
-      }
       targetLayer = mapLayer;
+      updateHitTest();
     };
 
+    function updateHitTest() {
+      hitTest = getPointerHitTest(targetLayer, ext, interactionMode);
+    }
+
     function turnOn(mode) {
       interactionMode = mode;
       active = true;
+      updateHitTest();
     }
 
     function turnOff() {
       if (active) {
         updateSelectionState(null); // no hit data, no event
         active = false;
+        hitTest = null;
       }
     }
 
@@ -4561,6 +4585,20 @@
       }
     };
 
+    self.setHoverVertex = function(p) {
+      var p2 = storedData.hit_coordinates;
+      if (!active || !p) return;
+      if (p2 && p2[0] == p[0] && p2[1] == p[1]) return;
+      storedData.hit_coordinates = p;
+      triggerHitEvent('change');
+    };
+
+    self.clearVertexOverlay = function() {
+      if (!storedData.hit_coordinates) return;
+      delete storedData.hit_coordinates;
+      triggerHitEvent('change');
+    };
+
     self.clearSelection = function() {
       updateSelectionState(null);
     };
@@ -5901,50 +5939,108 @@
     rec[key] = isString ? String(newVal) : newVal;
   }
 
-  var snapVerticesToPoint = internal.snapVerticesToPoint;
-
-  function getDisplayCoordsById(id, layer, ext) {
-    var coords = getPointCoordsById(id, layer);
-    return ext.translateCoords(coords[0], coords[1]);
-  }
+  function initLabelDragging(gui, ext, hit) {
+    var downEvt;
+    var activeId;
+    var activeRecord;
 
-  function getPointCoordsById(id, layer) {
-    var coords = layer && layer.geometry_type == 'point' && layer.shapes[id];
-    if (!coords || coords.length != 1) {
-      return null;
+    function active(e) {
+      return e.id > -1 && gui.interaction.getMode() == 'labels';
     }
-    return coords[0];
-  }
 
-  function translateDeltaDisplayCoords(dx, dy, ext) {
-    var a = ext.translatePixelCoords(0, 0);
-    var b = ext.translatePixelCoords(dx, dy);
-    return [b[0] - a[0], b[1] - a[1]];
-  }
+    hit.on('dragstart', function(e) {
+      if (!active(e)) return;
+      var textNode = getTextTarget3(e);
+      var table = hit.getTargetDataTable();
+      if (!textNode || !table) return false;
+      activeId = e.id;
+      activeRecord = getLabelRecordById(activeId);
+      downEvt = e;
+      gui.dispatchEvent('label_dragstart', {FID: activeId});
+    });
 
+    hit.on('drag', function(e) {
+      if (!active(e)) return;
+      if (e.id != activeId) {
+        error("Mismatched hit ids:", e.id, activeId);
+      }
+      var scale = ext.getSymbolScale() || 1;
+      var textNode;
+      applyDelta(activeRecord, 'dx', e.dx / scale);
+      applyDelta(activeRecord, 'dy', e.dy / scale);
+      textNode = getTextTarget3(e);
+      if (!isMultilineLabel(textNode)) {
+        // update anchor position of single-line labels based on label position
+        // relative to anchor point, for better placement when eventual display font is
+        // different from mapshaper's font.
+        autoUpdateTextAnchor(textNode, activeRecord, getDisplayCoordsById(activeId, hit.getHitTarget().layer, ext));
+      }
+      // updateSymbol(targetTextNode, activeRecord);
+      updateSymbol2(textNode, activeRecord, activeId);
+    });
 
-  function InteractiveEditor(gui, ext, hit) {
-    // var targetTextNode; // text node currently being dragged
-    var dragging = false;
-    var activeRecord;
-    var activeId = -1;
-    var self = new EventDispatcher();
-    var activeVertexIds = null; // for vertex dragging
+    hit.on('dragend', function(e) {
+      if (!active(e)) return;
+      gui.dispatchEvent('label_dragend', {FID: e.id});
+      activeId = -1;
+      activeRecord = null;
+      downEvt = null;
+    });
 
-    initDragging();
+    function getDisplayCoordsById(id, layer, ext) {
+      var coords = getPointCoordsById(id, layer);
+      return ext.translateCoords(coords[0], coords[1]);
+    }
 
-    return self;
+    function getPointCoordsById(id, layer) {
+      var coords = layer && layer.geometry_type == 'point' && layer.shapes[id];
+      if (!coords || coords.length != 1) {
+        return null;
+      }
+      return coords[0];
+    }
 
-    function labelEditingEnabled() {
-      return gui.interaction && gui.interaction.getMode() == 'labels' ? true : false;
+    function getTextTarget3(e) {
+      if (e.id > -1 === false || !e.container) return null;
+      return getSymbolNodeById(e.id, e.container);
     }
 
-    function locationEditingEnabled() {
-      return gui.interaction && gui.interaction.getMode() == 'location' ? true : false;
+    function getSymbolNodeById(id, parent) {
+      // TODO: optimize selector
+      var sel = '[data-id="' + id + '"]';
+      return parent.querySelector(sel);
+    }
+
+    function getTextTarget2(e) {
+      var el = e && e.targetSymbol || null;
+      if (el && el.tagName == 'tspan') {
+        el = el.parentNode;
+      }
+      return el && el.tagName == 'text' ? el : null;
     }
 
-    function vertexEditingEnabled() {
-      return gui.interaction && gui.interaction.getMode() == 'vertices' ? true : false;
+    function getTextTarget(e) {
+      var el = e.target;
+      if (el.tagName == 'tspan') {
+        el = el.parentNode;
+      }
+      return el.tagName == 'text' ? el : null;
+    }
+
+    function getLabelRecordById(id) {
+      var table = hit.getTargetDataTable();
+      if (id >= 0 === false || !table) return null;
+      // add dx and dy properties, if not available
+      if (!table.fieldExists('dx')) {
+        table.addField('dx', 0);
+      }
+      if (!table.fieldExists('dy')) {
+        table.addField('dy', 0);
+      }
+      if (!table.fieldExists('text-anchor')) {
+        table.addField('text-anchor', '');
+      }
+      return table.getRecordAt(id);
     }
 
     // update symbol by setting attributes
@@ -5971,249 +6067,167 @@
       gui.dispatchEvent('popup-needs-refresh');
       return node2;
     }
+  }
 
-    function initDragging() {
-      var downEvt;
-      var eventPriority = 1;
-
-      // inspector and label editing aren't fully synced - stop editing if inspector opens
-      // gui.on('inspector_on', function() {
-      //   stopEditing();
-      // });
-
-      gui.on('interaction_mode_change', function(e) {
-        if (e.mode != 'labels') {
-          stopDragging();
-        }
-        gui.undo.clear(); // TODO: put this elsewhere?
-      });
-
-      // down event on svg
-      // a: off text
-      //    -> stop editing
-      // b: on text
-      //    1: not editing -> nop
-      //    2: on selected text -> start dragging
-      //    3: on other text -> stop dragging, select new text
-
-      hit.on('dragstart', function(e) {
-        if (e.id >= 0 === false) return;
-        if (labelEditingEnabled() && onLabelDragStart(e)) {
-          triggerGlobalEvent('label_dragstart', e);
-          startDragging();
-        } else if (locationEditingEnabled()) {
-          triggerGlobalEvent('symbol_dragstart', e);
-          startDragging();
-        } else if (vertexEditingEnabled()) {
-          onVertexDragStart(e);
-          triggerGlobalEvent('vertex_dragstart', e);
-          startDragging();
-        }
-      });
-
-      hit.on('drag', function(e) {
-        if (labelEditingEnabled()) {
-          onLabelDrag(e);
-        } else if (locationEditingEnabled()) {
-          onLocationDrag(e);
-        } else if (vertexEditingEnabled()) {
-          onVertexDrag(e);
-        }
-      });
-
-      hit.on('dragend', function(e) {
-        if (locationEditingEnabled()) {
-          triggerGlobalEvent('symbol_dragend', e);
-          stopDragging();
-        } else if (labelEditingEnabled()) {
-          triggerGlobalEvent('label_dragend', e);
-          stopDragging();
-        } else if (vertexEditingEnabled()) {
-          // kludge to get dataset to recalculate internal bounding boxes
-          hit.getHitTarget().arcs.transformPoints(function() {});
-          triggerGlobalEvent('vertex_dragend', e);
-          stopDragging();
-        }
-      });
-
-      hit.on('click', function(e) {
-        if (labelEditingEnabled()) {
-          var target = hit.getHitTarget();
-          onLabelClick(e);
-        }
-      });
+  function initPointDragging(gui, ext, hit) {
 
-      // TODO: highlight hit vertex in path edit mode
-      if (false) hit.on('hover', function(e) {
-        if (vertexEditingEnabled() && !dragging) {
-          onVertexHover(e);
-        }
-      }, null, 100);
+    function active(e) {
+      return e.id > -1 && gui.interaction.getMode() == 'location';
+    }
 
-      function onVertexHover(e) {
-        // hovering in vertex edit mode: find vertex insertion point
-        var target = hit.getHitTarget();
-        var shp = target.layer.shapes[e.id];
-        var p = ext.translatePixelCoords(e.x, e.y);
-        var o = internal.findInsertionPoint(p, shp, target.arcs, ext.getPixelSize());
-      }
+    hit.on('dragstart', function(e) {
+      if (!active(e)) return;
+      gui.dispatchEvent('symbol_dragstart', {FID: e.id});
+    });
 
+    hit.on('drag', function(e) {
+      if (!active(e)) return;
+      var lyr = hit.getHitTarget().layer;
+      var p = getPointCoordsById(e.id, lyr);
+      if (!p) return;
+      var diff = translateDeltaDisplayCoords(e.dx, e.dy, ext);
+      p[0] += diff[0];
+      p[1] += diff[1];
+      gui.dispatchEvent('map-needs-refresh');
+      gui.dispatchEvent('symbol_drag', {FID: e.id});
+    });
 
-      function getVertexEventData(e) {
-        return {
-          FID: activeId,
-          vertexIds: activeVertexIds
-        };
-      }
+    hit.on('dragend', function(e) {
+      if (!active(e)) return;
+      gui.dispatchEvent('symbol_dragend', {FID: e.id});
+    });
 
-      function onLocationDrag(e) {
-        var lyr = hit.getHitTarget().layer;
-        var p = getPointCoordsById(e.id, lyr);
-        if (!p) return;
-        var diff = translateDeltaDisplayCoords(e.dx, e.dy, ext);
-        p[0] += diff[0];
-        p[1] += diff[1];
-        triggerRedraw();
-        triggerGlobalEvent('symbol_drag', e);
-      }
+    function translateDeltaDisplayCoords(dx, dy, ext) {
+      var a = ext.translatePixelCoords(0, 0);
+      var b = ext.translatePixelCoords(dx, dy);
+      return [b[0] - a[0], b[1] - a[1]];
+    }
 
-      function onVertexDragStart(e) {
-        var target = hit.getHitTarget();
-        var shp = target.layer.shapes[e.id];
-        var p = ext.translatePixelCoords(e.x, e.y);
-        activeVertexIds = internal.findNearestVertices(p, shp, target.arcs);
-        activeId = e.id;
+    function getPointCoordsById(id, layer) {
+      var coords = layer && layer.geometry_type == 'point' && layer.shapes[id];
+      if (!coords || coords.length != 1) {
+        return null;
       }
+      return coords[0];
+    }
+  }
 
-      function onVertexDrag(e) {
-        var target = hit.getHitTarget();
-        if (!activeVertexIds) return; // ignore error condition
-        var p = ext.translatePixelCoords(e.x, e.y);
-        if (gui.keyboard.shiftIsPressed()) {
-          internal.snapPointToArcEndpoint(p, activeVertexIds, target.arcs);
-        }
-        snapVerticesToPoint(activeVertexIds, p, target.arcs);
-        triggerRedraw();
-      }
+  function initVertexDragging(gui, ext, hit) {
+    var activeShapeId = -1;
+    var draggedVertexIds = null;
+    var selectedVertexIds = null;
 
-      function onLabelClick(e) {
-        var textNode = getTextTarget3(e);
-        var rec = getLabelRecordById(e.id);
-        if (textNode && rec && isMultilineLabel(textNode)) {
-          toggleTextAlign(textNode, rec);
-          updateSymbol2(textNode, rec, e.id);
-          // e.stopPropagation(); // prevent pin/unpin on popup
-        }
-      }
+    function active(e) {
+      return e.id > -1 && gui.interaction.getMode() == 'vertices';
+    }
 
-      function triggerRedraw() {
-        gui.dispatchEvent('map-needs-refresh');
-      }
+    function fire(type) {
+      gui.dispatchEvent(type, {
+        FID: activeShapeId,
+        vertex_ids: draggedVertexIds
+      });
+    }
 
-      function triggerGlobalEvent(type, e) {
-        if (e.id >= 0 === false) return;
-        var o = {
-          FID: e.id,
-          layer_name: hit.getHitTarget().layer.name,
-          vertex_ids: activeVertexIds
-        };
-        // fire event to signal external editor that symbol coords have changed
-        gui.dispatchEvent(type, o);
-      }
+    function setHoverVertex(id) {
+      var target = hit.getHitTarget();
+      hit.setHoverVertex(target.arcs.getVertex2(id));
+    }
 
-      function getLabelRecordById(id) {
-        var table = hit.getTargetDataTable();
-        if (id >= 0 === false || !table) return null;
-        // add dx and dy properties, if not available
-        if (!table.fieldExists('dx')) {
-          table.addField('dx', 0);
-        }
-        if (!table.fieldExists('dy')) {
-          table.addField('dy', 0);
-        }
-        if (!table.fieldExists('text-anchor')) {
-          table.addField('text-anchor', '');
-        }
-        return table.getRecordAt(id);
-      }
+    function clearHoverVertex() {
+      hit.clearVertexOverlay();
+      // gui.state.vertex_overlay = null;
+    }
 
-      function onLabelDragStart(e) {
-        var textNode = getTextTarget3(e);
-        var table = hit.getTargetDataTable();
-        if (!textNode || !table) return false;
-        activeId = e.id;
-        activeRecord = getLabelRecordById(activeId);
-        downEvt = e;
-        return true;
+    function findDraggableVertices(e) {
+      var target = hit.getHitTarget();
+      var shp = target.layer.shapes[e.id];
+      var p = ext.translatePixelCoords(e.x, e.y);
+      var nearestIds = internal.findNearestVertices(p, shp, target.arcs);
+      var p2 = target.arcs.getVertex2(nearestIds[0]);
+      var dist = geom.distance2D(p[0], p[1], p2[0], p2[1]);
+      var pixelDist = dist / ext.getPixelSize();
+      if (pixelDist > 5) {
+        draggedVertexIds = null;
+        return null;
       }
+      return nearestIds;
+    }
 
-      function onLabelDrag(e) {
-        var scale = ext.getSymbolScale() || 1;
-        var textNode;
-        if (!dragging) return;
-        if (e.id != activeId) {
-          error("Mismatched hit ids:", e.id, activeId);
-        }
-        applyDelta(activeRecord, 'dx', e.dx / scale);
-        applyDelta(activeRecord, 'dy', e.dy / scale);
-        textNode = getTextTarget3(e);
-        if (!isMultilineLabel(textNode)) {
-          // update anchor position of single-line labels based on label position
-          // relative to anchor point, for better placement when eventual display font is
-          // different from mapshaper's font.
-          autoUpdateTextAnchor(textNode, activeRecord, getDisplayCoordsById(activeId, hit.getHitTarget().layer, ext));
-        }
-        // updateSymbol(targetTextNode, activeRecord);
-        updateSymbol2(textNode, activeRecord, activeId);
-      }
+    hit.on('dragstart', function(e) {
+      if (!active(e)) return;
+      draggedVertexIds = findDraggableVertices(e);
+      if (!draggedVertexIds) return;
+      setHoverVertex(draggedVertexIds[0]);
+      activeShapeId = e.id;
+      fire('vertex_dragstart');
+    });
 
-      function getSymbolNodeById(id, parent) {
-        // TODO: optimize selector
-        var sel = '[data-id="' + id + '"]';
-        return parent.querySelector(sel);
+    hit.on('drag', function(e) {
+      if (!active(e) || !draggedVertexIds) return;
+      var target = hit.getHitTarget();
+      var p = ext.translatePixelCoords(e.x, e.y);
+      if (gui.keyboard.shiftIsPressed()) {
+        internal.snapPointToArcEndpoint(p, draggedVertexIds, target.arcs);
       }
+      internal.snapVerticesToPoint(draggedVertexIds, p, target.arcs);
+      setHoverVertex(draggedVertexIds[0]);
+      // redrawing the whole map updates the data layer as well as the overlay layer
+      // gui.dispatchEvent('map-needs-refresh');
+    });
 
-      function getTextTarget3(e) {
-        if (e.id > -1 === false || !e.container) return null;
-        return getSymbolNodeById(e.id, e.container);
-      }
+    hit.on('dragend', function(e) {
+      if (!active(e) || !draggedVertexIds) return;
+      // kludge to get dataset to recalculate internal bounding boxes
+      hit.getHitTarget().arcs.transformPoints(function() {});
+      clearHoverVertex();
+      fire('vertex_dragend');
+      draggedVertexIds = null;
+      activeShapeId = -1;
+      // redraw data layer
+      gui.dispatchEvent('map-needs-refresh');
+    });
 
-      function getTextTarget2(e) {
-        var el = e && e.targetSymbol || null;
-        if (el && el.tagName == 'tspan') {
-          el = el.parentNode;
-        }
-        return el && el.tagName == 'text' ? el : null;
-      }
+    // select clicked vertices
+    hit.on('click', function(e) {
+      if (!active(e)) return;
+      var vertices = findDraggableVertices(e); // same selection criteria as for dragging
+      // TODO
+    });
 
-      function getTextTarget(e) {
-        var el = e.target;
-        if (el.tagName == 'tspan') {
-          el = el.parentNode;
-        }
-        return el.tagName == 'text' ? el : null;
+    // highlight hit vertex in path edit mode
+    hit.on('hover', function(e) {
+      if (!active(e) || draggedVertexIds) return; // no hover effect while dragging
+      var vertexIds = findDraggableVertices(e);
+      if (vertexIds) {
+        setHoverVertex(vertexIds[0]);
+        return;
       }
-    }
+      var target = hit.getHitTarget();
+      var shp = target.layer.shapes[e.id];
+      var p = ext.translatePixelCoords(e.x, e.y);
+      var o = internal.findInsertionPoint(p, shp, target.arcs, ext.getPixelSize());
+      console.log('*', o, p);
+      clearHoverVertex();
+    }, null, 100);
 
-    function startDragging() {
-      dragging = true;
-    }
+  }
 
-    function stopDragging() {
-      dragging = false;
-      activeId = -1;
-      activeRecord = null;
-      activeVertexIds = null;
-    }
+  function initInteractiveEditing(gui, ext, hit) {
+    initLabelDragging(gui, ext, hit);
+    initPointDragging(gui, ext, hit);
+    initVertexDragging(gui, ext, hit);
 
-    function isClickEvent(up, down) {
-      var elapsed = Math.abs(down.timeStamp - up.timeStamp);
-      var dx = up.screenX - down.screenX;
-      var dy = up.screenY - down.screenY;
-      var dist = Math.sqrt(dx * dx + dy * dy);
-      return dist <= 4 && elapsed < 300;
-    }
+    gui.on('interaction_mode_change', function(e) {
+      gui.undo.clear(); // TODO: put this elsewhere?
+    });
 
+    // function isClickEvent(up, down) {
+    //   var elapsed = Math.abs(down.timeStamp - up.timeStamp);
+    //   var dx = up.screenX - down.screenX;
+    //   var dy = up.screenY - down.screenY;
+    //   var dist = Math.sqrt(dx * dx + dy * dy);
+    //   return dist <= 4 && elapsed < 300;
+    // }
   }
 
   var darkStroke = "#334",
@@ -6384,8 +6398,14 @@
     var geomType = lyr.geometry_type;
     var topId = o.id; // pinned id (if pinned) or hover id
     var topIdx = -1;
-    var styler = function(o, i) {
-      utils.extend(o, i === topIdx ? topStyle: baseStyle);
+    var styler = function(style, i) {
+      utils.extend(style, i === topIdx ? topStyle: baseStyle);
+      // kludge to show vertices when editing path shapes
+      if (o.mode == 'vertices') {
+        style.vertices = true;
+        style.vertex_overlay = o.hit_coordinates || null;
+        style.fillColor = null;
+      }
     };
     var baseStyle = getDefaultStyle(lyr, selectionStyles[geomType]);
     var topStyle;
@@ -6856,19 +6876,25 @@
     _self.drawVertices = function(shapes, arcs, style, filter) {
       var iter = new internal.ShapeIter(arcs);
       var t = getScaledTransform(_ext);
-      var radius = (style.strokeWidth * 0.9 || 2.2) * GUI.getPixelRatio() * getScaledLineScale(_ext);
+      var radius = (style.strokeWidth > 2 ? style.strokeWidth * 0.9 : 2) * GUI.getPixelRatio() * getScaledLineScale(_ext);
       var color = style.strokeColor || 'black';
-      var shp;
+      var radius2 = radius * 2;
       _ctx.beginPath();
       _ctx.fillStyle = color;
       for (var i=0; i<shapes.length; i++) {
-        shp = shapes[i];
+        var shp = shapes[i];
         if (!shp || filter && !filter(shp)) continue;
-        iter.init(shp);
-        while (iter.hasNext()) {
-          drawCircle(iter.x * t.mx + t.bx, iter.y * t.my + t.by, radius, _ctx);
+        for (var j=0; j<shp.length; j++) {
+          iter.init(shp[j]);
+          while (iter.hasNext()) {
+            drawCircle(iter.x * t.mx + t.bx, iter.y * t.my + t.by, radius, _ctx);
+          }
         }
       }
+      if (style.vertex_overlay) {
+        var p = style.vertex_overlay;
+        drawCircle(p[0] * t.mx + t.bx, p[1] * t.my + t.by, radius2, _ctx);
+      }
       _ctx.fill();
       _ctx.closePath();
     };
@@ -7921,7 +7947,7 @@
         _visibleLayers = [], // cached visible map layers
         _fullBounds = null,
         _intersectionLyr, _activeLyr, _overlayLyr,
-        _inspector, _stack, _editor,
+        _inspector, _stack,
         _dynamicCRS;
 
     if (gui.options.showMouseCoordinates) {
@@ -8104,7 +8130,9 @@
         });
       }
 
-      _editor = new InteractiveEditor(gui, _ext, _hit);
+      if (gui.interaction) {
+        initInteractiveEditing(gui, _ext, _hit);
+      }
 
       _ext.on('change', function(e) {
         if (e.reset) return; // don't need to redraw map here if extent has been reset
@@ -8124,10 +8152,6 @@
     function updateOverlayLayer(e) {
       var style = getOverlayStyle(_activeLyr.layer, e);
       if (style) {
-        // kludge to show vertices when editing path shapes
-        if (gui.state.interaction_mode == 'vertices') {
-          style.vertices = true;
-        }
         _overlayLyr = utils.defaults({
           layer: filterLayerByIds(_activeLyr.layer, style.ids),
           style: style
@@ -8431,14 +8455,14 @@
     startEditing();
   });
 
-  function getImportOpts() {
+  function getManifest() {
+    return window.mapshaper.manifest || {}; // kludge -- bin/mapshaper-gui sets this
+  }
+
+  function getImportOpts(manifest) {
     var vars = GUI.getUrlVars();
     var opts = {};
-    var manifest = window.mapshaper.manifest || {}; // kludge -- bin/mapshaper-gui sets this
-    if (Array.isArray(manifest)) {
-      // old-style manifest: an array of filenames
-      opts.files = manifest;
-    } else if (manifest.files) {
+    if (manifest.files) {
       opts.files = manifest.files.concat();
     } else {
       opts.files = [];
@@ -8452,14 +8476,24 @@
     opts.display_all = vars['display-all'] || vars.a || !!manifest.display_all;
     opts.quick_view = vars['quick-view'] || vars.q || !!manifest.quick_view;
     opts.target = vars.target || manifest.target || null;
+    opts.name = vars.name || manifest.name || null;
     return opts;
   }
 
+  function getInitialConsoleCommands() {
+    return getManifest().commands || '';
+  }
+
   var startEditing = function() {
     var dataLoaded = false,
-        importOpts = getImportOpts(),
+        manifest = getManifest(),
+        importOpts = getImportOpts(manifest),
         gui = new GuiInstance('body');
 
+    if (manifest.blurb) {
+      El('#splash-screen-blurb').text(manifest.blurb);
+    }
+
     new AlertControl(gui);
     new RepairControl(gui);
     new SimplifyControl(gui);
@@ -8496,6 +8530,8 @@
           gui.map.setLayerPinning(o, true);
         });
       }
+      gui.console.runInitialCommands(getInitialConsoleCommands());
+
     });
   };