mapshaper 0.7.3 → 0.7.5

package/www/mapshaper-gui.js

@@ -1,108 +1,5 @@
 (function () {
 
-  var utils = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    get addThousandsSep () { return addThousandsSep; },
-    get addslashes () { return addslashes; },
-    get arrayToIndex () { return arrayToIndex; },
-    get clamp () { return clamp; },
-    get cleanNumericString () { return cleanNumericString; },
-    get contains () { return contains; },
-    get copyElements () { return copyElements; },
-    get countValues () { return countValues; },
-    get createBuffer () { return createBuffer; },
-    get default () { return utils; },
-    get defaults () { return defaults; },
-    get difference () { return difference; },
-    get endsWith () { return endsWith; },
-    get every () { return every; },
-    get expandoBuffer () { return expandoBuffer; },
-    get extend () { return extend; },
-    get extendBuffer () { return extendBuffer; },
-    get find () { return find; },
-    get findMedian () { return findMedian; },
-    get findQuantile () { return findQuantile; },
-    get findRankByValue () { return findRankByValue; },
-    get findStringPrefix () { return findStringPrefix; },
-    get findValueByPct () { return findValueByPct; },
-    get findValueByRank () { return findValueByRank; },
-    get forEach () { return forEach; },
-    get forEachProperty () { return forEachProperty; },
-    get format () { return format; },
-    get formatDateISO () { return formatDateISO; },
-    get formatIntlNumber () { return formatIntlNumber; },
-    get formatNumber () { return formatNumber; },
-    get formatNumberForDisplay () { return formatNumberForDisplay; },
-    get formatVersionedName () { return formatVersionedName; },
-    get formatter () { return formatter; },
-    get genericSort () { return genericSort; },
-    get getArrayBounds () { return getArrayBounds; },
-    get getGenericComparator () { return getGenericComparator; },
-    get getKeyComparator () { return getKeyComparator; },
-    get getSortedIds () { return getSortedIds; },
-    get getUniqueName () { return getUniqueName; },
-    get groupBy () { return groupBy; },
-    get htmlEscape () { return htmlEscape; },
-    get indexOf () { return indexOf; },
-    get indexOn () { return indexOn; },
-    get inherit () { return inherit; },
-    get initializeArray () { return initializeArray; },
-    get intersection () { return intersection; },
-    get isArray () { return isArray; },
-    get isArrayLike () { return isArrayLike; },
-    get isBoolean () { return isBoolean; },
-    get isDate () { return isDate; },
-    get isEven () { return isEven; },
-    get isFiniteNumber () { return isFiniteNumber; },
-    get isFunction () { return isFunction; },
-    get isInteger () { return isInteger; },
-    get isNonNegNumber () { return isNonNegNumber; },
-    get isNumber () { return isNumber; },
-    get isObject () { return isObject; },
-    get isOdd () { return isOdd; },
-    get isPromise () { return isPromise; },
-    get isString () { return isString; },
-    get isValidNumber () { return isValidNumber; },
-    get lpad () { return lpad; },
-    get ltrim () { return ltrim; },
-    get mean () { return mean; },
-    get merge () { return merge; },
-    get mergeNames () { return mergeNames; },
-    get numToStr () { return numToStr; },
-    get parseIntlNumber () { return parseIntlNumber; },
-    get parseNumber () { return parseNumber; },
-    get parsePercent () { return parsePercent; },
-    get parseString () { return parseString; },
-    get pickOne () { return pickOne; },
-    get pluck () { return pluck; },
-    get pluralSuffix () { return pluralSuffix; },
-    get promisify () { return promisify; },
-    get quicksort () { return quicksort; },
-    get quicksortPartition () { return quicksortPartition; },
-    get range () { return range; },
-    get reduceAsync () { return reduceAsync; },
-    get regexEscape () { return regexEscape; },
-    get reorderArray () { return reorderArray; },
-    get repeat () { return repeat; },
-    get repeatString () { return repeatString; },
-    get replaceArray () { return replaceArray; },
-    get rpad () { return rpad; },
-    get rtrim () { return rtrim; },
-    get shuffle () { return shuffle; },
-    get some () { return some; },
-    get sortArrayIndex () { return sortArrayIndex; },
-    get sortOn () { return sortOn; },
-    get splitLines () { return splitLines; },
-    get sum () { return sum; },
-    get toArray () { return toArray; },
-    get toBuffer () { return toBuffer; },
-    get trim () { return trim; },
-    get trimQuotes () { return trimQuotes; },
-    get uniq () { return uniq; },
-    get uniqifyNames () { return uniqifyNames; },
-    get wildcardToRegExp () { return wildcardToRegExp; }
-  });
-
   var api = window.mapshaper; // assuming mapshaper is in global scope
   var mapshaper = api,
     utils$1 = api.utils,
@@ -113,7 +10,7 @@
     UserError$1 = internal.UserError,
     message$1 = internal.message, // stop, error and message are overridden in gui-proxy.js
     stop$1 = internal.stop,
-    error$1 = internal.error;
+    error$2 = internal.error;
 
   api.enableLogging();
 
@@ -232,7 +129,7 @@
       evt = new EventData(this.type);
       evt.target = this.target;
     } else if (evt.target != this.target || evt.type != this.type) {
-      error$1("[Handler] event target/type have changed.");
+      error$2("[Handler] event target/type have changed.");
     }
     this.callback.call(this.listener, evt);
   };
@@ -481,10 +378,10 @@
       try {
         els = root.querySelectorAll(selector);
       } catch (e) {
-        error$1("Invalid selector:", selector);
+        error$2("Invalid selector:", selector);
       }
     } else {
-      error$1("This browser doesn't support CSS query selectors");
+      error$2("This browser doesn't support CSS query selectors");
     }
     return utils$1.toArray(els);
   };
@@ -522,7 +419,7 @@
   };
 
   function El(ref) {
-    if (!ref) error$1("Element() needs a reference");
+    if (!ref) error$2("Element() needs a reference");
     if (ref instanceof El) {
       return ref;
     }
@@ -543,7 +440,7 @@
     } else if (ref.tagName) {
       node = ref;
     }
-    if (!node) error$1("Unmatched element selector:", ref);
+    if (!node) error$2("Unmatched element selector:", ref);
     this.el = node;
   }
 
@@ -1087,7 +984,7 @@
       }
       var val = utils$1.clamp(arg, _min, _max);
       if (!_validator(val)) {
-        error$1("ClickText#value() invalid value:", arg);
+        error$2("ClickText#value() invalid value:", arg);
       } else {
         _value = val;
       }
@@ -1418,6 +1315,7 @@
     //
     var options = getSaveFileOptions(filename);
     var handle;
+    done = done || function() {};
     try {
       handle = await window.showSaveFilePicker(options);
       var writable = await handle.createWritable();
@@ -1519,13 +1417,36 @@
   // https://github.com/jakearchibald/idb-keyval
   var sessionId = getUniqId('session');
   var snapshotCount = 0;
+  // IDs of snapshots created (and not removed) by this tab. Tracked in memory
+  // so the pagehide handler can fire a single batched delMany() without first
+  // awaiting idb.keys() -- the page may not survive the round trip.
+  var ownSnapshotIds = new Set();
+
+  // Lifecycle constants for snapshot cleanup.
+  // HEARTBEAT_INTERVAL_MS: how often this tab refreshes its localStorage entry.
+  // STALE_THRESHOLD_MS: a session whose heartbeat is older than this is treated
+  //   as dead. Generous enough to tolerate backgrounded/throttled tabs.
+  // BROADCAST_DISCOVERY_MS: how long startup waits for live tabs to identify
+  //   themselves over BroadcastChannel before deciding what to delete.
+  var HEARTBEAT_INTERVAL_MS = 30 * 1000;
+  var STALE_THRESHOLD_MS = 5 * 60 * 1000;
+  var BROADCAST_DISCOVERY_MS = 200;
+  var SESSION_DATA_KEY = 'session_data';
+  var BROADCAST_CHANNEL_NAME = 'mapshaper-snapshots';
 
   function getUniqId(prefix) {
     return prefix + '_' + (Math.random() + 1).toString(36).substring(2,8);
   }
 
+  function getSessionFromSnapshotId(snapshotId) {
+    // Snapshot ids look like 'session_<6chars>_<NNN>'. The session id is the
+    // 'session_<6chars>' prefix.
+    var m = /^(session_[a-z0-9]+)_\d+$/.exec(snapshotId);
+    return m ? m[1] : null;
+  }
+
   function isSnapshotId(str) {
-    return /^session_/.test(str);
+    return getSessionFromSnapshotId(str) !== null;
   }
 
   function SessionSnapshots(gui) {
@@ -1543,13 +1464,20 @@
         return;
       }
       menu = El('div').addClass('nav-sub-menu save-menu').appendTo(btn.node());
+      startLifecycle();
       await initialCleanup();
 
-      window.addEventListener('beforeunload', async function() {
-        // delete snapshot data
-        // This is not ideal, because the data gets deleted even if the user
-        // cancels the page close... but there's no apparent good alternative
-        await finalCleanup();
+      // 'pagehide' is more reliable than 'unload' across modern browsers
+      // (Chrome's bfcache rules increasingly suppress 'unload'). Sync work
+      // (localStorage write, BroadcastChannel notice) always completes; the
+      // best-effort delMany() below frequently completes in Chrome/Firefox and
+      // sometimes in Safari, but is not relied upon -- the next session's
+      // startup cleanup is the safety net.
+      window.addEventListener('pagehide', function(e) {
+        if (e.persisted) return; // bfcache: tab may come back, leave entry alive
+        removeOwnSession();
+        announceLeaving();
+        attemptOwnDataDeletion();
       });
 
       btn.on('mouseenter', function() {
@@ -1573,12 +1501,6 @@
       var snapshots = await fetchSnapshotList();
 
       menu.empty();
-      addMenuLink({
-        slug: 'stash',
-        // label: 'save data snapshot',
-        label: 'create a snapshot',
-        action: saveSnapshot
-      });
 
       if (!gui.session.isEmpty()) {
         // Surface the console "history" command via the snapshot menu so users
@@ -1593,6 +1515,15 @@
         });
       }
 
+      addMenuLink({
+        slug: 'stash',
+        // label: 'save data snapshot',
+        label: 'create a snapshot',
+        action: saveSnapshot
+      });
+
+
+
       // var available = await getAvailableStorage();
       // if (available) {
       //   El('div').addClass('save-menu-entry').text(available + ' available').appendTo(menu);
@@ -1676,6 +1607,7 @@
       };
 
       await idb.set(entry.id, obj);
+      ownSnapshotIds.add(entry.id);
       await addToIndex(entry);
       renderMenu();
     }
@@ -1690,7 +1622,7 @@
   }
 
   async function fetchSnapshotList() {
-    await removeMissingSnapshots();
+    await pruneIndexAgainstKeys();
     var index = await fetchIndex();
     var snapshots = index.snapshots;
     snapshots = snapshots.filter(function(o) {return o.session == sessionId;});
@@ -1699,6 +1631,7 @@
 
   async function removeSnapshotById(id, gui) {
     await idb.del(id);
+    ownSnapshotIds.delete(id);
     return updateIndex(function(index) {
       index.snapshots = index.snapshots.filter(function(snap) {
         return snap.id != id;
@@ -1796,13 +1729,16 @@
   }
 
   async function addToIndex(obj) {
-    updateSessionData();
+    touchOwnSession();
     return updateIndex(function(index) {
       index.snapshots.push(obj);
     });
   }
 
-  async function removeMissingSnapshots() {
+  // Drop index entries whose underlying IndexedDB blob has gone missing
+  // (e.g. cleared by another tab). Cheaper than reclaimDeadSessionData; used
+  // before rendering the menu to keep stale entries out of the UI.
+  async function pruneIndexAgainstKeys() {
     var keys = await idb.keys();
     return updateIndex(function(index) {
       index.snapshots = index.snapshots.filter(function(snap) {
@@ -1811,32 +1747,65 @@
     });
   }
 
+  // Run on every fresh page load. Aggressively reclaim space by deleting any
+  // snapshot whose owning session is no longer alive.
   async function initialCleanup() {
-    // (Safari workaround) remove any lingering data from past sessions
-    if (getSessionData().length === 0) {
-      await idb.clear();
-    }
-    // remove any snapshots that are not indexed
+    touchOwnSession();
+    pruneStaleSessionData();
+    var liveSessions = await discoverLiveSessions();
+    await reclaimDeadSessionData(liveSessions);
+  }
+
+  // Delete every snapshot in IndexedDB whose session id is not in liveSessions,
+  // and keep the on-disk index consistent with the actual key set.
+  async function reclaimDeadSessionData(liveSessions) {
     var keys = await idb.keys();
-    var indexedIds = (await fetchIndex()).snapshots.map(function(snap) {return snap.id;});
+    var doomedKeys = [];
+    var doomedSessions = new Set();
     keys.forEach(function(key) {
-      if (isSnapshotId(key) && !indexedIds.includes(key)) {
-        idb.del(key);
+      var sid = getSessionFromSnapshotId(key);
+      if (sid && !liveSessions.has(sid)) {
+        doomedKeys.push(key);
+        doomedSessions.add(sid);
       }
     });
-    // remove old indexed snapshots
+
+    // Sum sizes from the index for an informative log message. We only know
+    // the size of snapshots that still have an index entry; orphaned blobs
+    // are counted but their sizes contribute 0.
+    var sizeBytes = 0;
+    if (doomedKeys.length) {
+      var index = await fetchIndex();
+      var doomedKeySet = new Set(doomedKeys);
+      index.snapshots.forEach(function(snap) {
+        if (doomedKeySet.has(snap.id) && typeof snap.size === 'number') {
+          sizeBytes += snap.size;
+        }
+      });
+      await Promise.all(doomedKeys.map(function(k) { return idb.del(k); }));
+    }
+
+    // Drop index entries pointing to deleted snapshots, and any entries whose
+    // session is dead even if the underlying key was already gone.
+    var remainingKeys = await idb.keys();
+    var keySet = new Set(remainingKeys);
     await updateIndex(function(index) {
       index.snapshots = index.snapshots.filter(function(snap) {
-        var msPerDay = 1000 * 60 * 60 * 24;
-        var daysOld = (Date.now() - snap.created) / msPerDay;
-        if (daysOld > 1) {
-          if (keys.includes(snap.id)) idb.del(snap.id);
-          return false;
-        }
-        return true;
+        if (!keySet.has(snap.id)) return false;
+        var sid = getSessionFromSnapshotId(snap.id);
+        return sid && liveSessions.has(sid);
       });
-      return index;
     });
+
+    if (doomedKeys.length) {
+      var msg = '[mapshaper] startup cleanup reclaimed ' +
+        doomedKeys.length + ' snapshot' + (doomedKeys.length === 1 ? '' : 's') +
+        ' from ' + doomedSessions.size + ' stale session' +
+        (doomedSessions.size === 1 ? '' : 's');
+      var sizeStr = sizeBytes > 0 ? formatSize(sizeBytes) : '';
+      if (sizeStr) msg += ' (' + sizeStr + ')';
+      console.log(msg);
+    }
   }
 
   async function getAvailableStorage() {
@@ -1874,52 +1843,164 @@
     return target;
   }
 
-  // Clean up snapshot data (called just before browser tab is closed)
-  async function finalCleanup() {
-    // When called on 'beforeunload', idb.clear() seems to complete
-    // before tab is unloaded in Chrome and Firefox, but not in Safari.
-    // Calling idb.del(key) to selectively delete data for the current session
-    // does not seem to complete in any browser.
-    // So we wait until the last open session is ending at this URL, and delete
-    // data for all recently open sessions.
-    //
-    var sessions = getSessionData().filter(function(item) {
-      // remove current session
-      var daysOld = (Date.now() - item.timestamp) / (1000 * 60 * 60 * 24);
-      if (item.session == sessionId) return false;
-      // also remove any lingering old sessions (ordinarily this shouldn't be needed)
-      if (daysOld > 1) return false;
-      return true;
+  // Heartbeat + BroadcastChannel state. The localStorage map and the channel
+  // together let other tabs identify themselves on demand and let crashed tabs'
+  // data be reclaimed safely.
+  //
+  // localStorage 'session_data' shape: { <sessionId>: <lastSeenMs>, ... }
+  // (The previous build stored an array; old data is overwritten on first
+  //  touchOwnSession() call. Only used for cleanup heuristics, not user data.)
+
+  var _heartbeatTimer = null;
+  var _channel = null;
+
+  function startLifecycle() {
+    touchOwnSession();
+    _heartbeatTimer = setInterval(touchOwnSession, HEARTBEAT_INTERVAL_MS);
+    if (typeof BroadcastChannel == 'function') {
+      try {
+        _channel = new BroadcastChannel(BROADCAST_CHANNEL_NAME);
+        _channel.onmessage = function(e) {
+          var msg = e.data;
+          if (!msg || msg.from === sessionId) return;
+          if (msg.type === 'whois') {
+            try {
+              _channel.postMessage({type: 'iam', from: sessionId});
+            } catch (err) {} // channel can throw if tab is being torn down
+          }
+        };
+      } catch (err) {
+        _channel = null; // sandboxed contexts may forbid BroadcastChannel
+      }
+    }
+  }
+
+  // Discover other live tabs. Returns a Set of session ids that should be
+  // considered alive (always includes our own).
+  function discoverLiveSessions() {
+    return new Promise(function(resolve) {
+      var live = new Set([sessionId]);
+      // localStorage heartbeat data is the durable signal; it survives
+      // backgrounded/throttled tabs that may not respond to BroadcastChannel
+      // promptly.
+      var data = readSessionData();
+      Object.keys(data).forEach(function(sid) {
+        if (Date.now() - data[sid] < STALE_THRESHOLD_MS) {
+          live.add(sid);
+        }
+      });
+      if (!_channel) {
+        resolve(live);
+        return;
+      }
+      // Broadcast 'whois' and add any tab that responds within the discovery
+      // window. This is fast and authoritative for foreground tabs.
+      var listener = function(e) {
+        var msg = e.data;
+        if (msg && msg.type === 'iam' && msg.from && msg.from !== sessionId) {
+          live.add(msg.from);
+        }
+      };
+      _channel.addEventListener('message', listener);
+      try {
+        _channel.postMessage({type: 'whois', from: sessionId});
+      } catch (err) {}
+      setTimeout(function() {
+        _channel.removeEventListener('message', listener);
+        resolve(live);
+      }, BROADCAST_DISCOVERY_MS);
     });
-    setSessionData(sessions);
-    if (sessions.length === 0) {
-      await idb.clear();
+  }
+
+  function announceLeaving() {
+    if (!_channel) return;
+    try {
+      _channel.postMessage({type: 'leaving', from: sessionId});
+      _channel.close();
+    } catch (err) {}
+  }
+
+  // Best-effort eager cleanup at end-of-session. Snapshots can be tens or
+  // hundreds of MB, so we don't want to rely solely on the next session's
+  // startup to reclaim space. A single delMany() transaction is cheap to
+  // launch and frequently commits before the page is fully torn down,
+  // especially in Chrome/Firefox; Safari is less reliable. Anything that
+  // doesn't complete here will be reclaimed by the next session anyway.
+  //
+  // Important: do NOT await any of this. The browser doesn't await async work
+  // in the unload path; we just want the IDB transaction to be queued before
+  // the page is killed.
+  function attemptOwnDataDeletion() {
+    if (ownSnapshotIds.size === 0) return;
+    var ids = Array.from(ownSnapshotIds);
+    ownSnapshotIds.clear();
+    // Delete the blobs in a single transaction.
+    try {
+      idb.delMany(ids).catch(function() {});
+    } catch (err) {}
+    // Drop our entries from the index in a separate (also fire-and-forget)
+    // transaction. If only one of the two completes, startup cleanup will
+    // reconcile -- reclaimDeadSessionData() handles both "key gone, index
+    // entry remains" and "index entry gone, key remains".
+    try {
+      updateIndex(function(index) {
+        index.snapshots = index.snapshots.filter(function(snap) {
+          return getSessionFromSnapshotId(snap.id) !== sessionId;
+        });
+      }).catch(function() {});
+    } catch (err) {}
+  }
+
+  function touchOwnSession() {
+    var data = readSessionData();
+    data[sessionId] = Date.now();
+    writeSessionData(data);
+  }
+
+  function removeOwnSession() {
+    var data = readSessionData();
+    if (sessionId in data) {
+      delete data[sessionId];
+      writeSessionData(data);
     }
   }
 
-  function updateSessionData() {
-    // make sure the current session is added to the list of open sessions
-    var sessions = getSessionData();
-    if (sessions.find(o => o.session == sessionId)) return;
-    var entry = {
-      session: sessionId,
-      timestamp: Date.now()
-    };
-    setSessionData(sessions.concat([entry]));
+  function pruneStaleSessionData() {
+    var data = readSessionData();
+    var now = Date.now();
+    var changed = false;
+    Object.keys(data).forEach(function(sid) {
+      if (now - data[sid] > STALE_THRESHOLD_MS) {
+        delete data[sid];
+        changed = true;
+      }
+    });
+    if (changed) writeSessionData(data);
   }
 
-  function getSessionData() {
-    var data = JSON.parse(window.localStorage.getItem('session_data'));
-    return data || [];
+  function readSessionData() {
+    try {
+      var raw = window.localStorage.getItem(SESSION_DATA_KEY);
+      var parsed = raw ? JSON.parse(raw) : null;
+      // Tolerate the legacy array shape by ignoring it (next write replaces it).
+      if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+        return parsed;
+      }
+      return {};
+    } catch (e) {
+      return {};
+    }
   }
 
-  function setSessionData(arr) {
-    window.localStorage.setItem('session_data', JSON.stringify(arr));
+  function writeSessionData(obj) {
+    try {
+      window.localStorage.setItem(SESSION_DATA_KEY, JSON.stringify(obj));
+    } catch (e) {} // localStorage can throw on quota exceeded; non-fatal
   }
 
   async function isStorageEnabled() {
     try {
-      setSessionData(getSessionData());
+      writeSessionData(readSessionData());
       await updateIndex(function() {});
       return true;
     } catch(e) {
@@ -2399,10 +2480,34 @@
         } else if (await importDataset(group, groupImportOpts)) {
           importCount++;
           gui.session.fileImported(group.filename, optStr);
+          notifyMissingShapefileParts(group);
         }
       }
     }
 
+    // Surface a passive warning if a .shp file came in without its .dbf or .prj
+    // sibling. Both files are technically optional, but their absence has very
+    // different consequences (no attribute data, no projection metadata) and
+    // users frequently load just the .shp by accident. Mapshaper generally
+    // doesn't need .shx, so we don't warn about that.
+    function notifyMissingShapefileParts(group) {
+      if (!group.shp || !gui.notify) return;
+      var missing = [];
+      if (!group.dbf) missing.push({ext: '.dbf', why: 'no attribute data'});
+      if (!group.prj) missing.push({ext: '.prj', why: 'no projection metadata'});
+      if (!missing.length) return;
+      var base = internal.getFileBase(group.shp.filename);
+      var parts = missing.map(function(m) { return m.ext; }).join(' and ');
+      var consequences = missing.map(function(m) { return m.why; }).join(', ');
+      gui.notify({
+        severity: 'warn',
+        body: base + '.shp was loaded without its ' + parts +
+              (missing.length > 1 ? ' files' : ' file') +
+              ' (' + consequences + ').',
+        dedupKey: 'shp-missing:' + base
+      });
+    }
+
     async function importDataset(group, importOpts) {
       var dataset;
       var datasets;
@@ -2943,15 +3048,25 @@
 
     function message() {
       var msg = GUI.formatMessageArgs(arguments);
-      gui.message(msg);
-      internal.logArgs(arguments);
+      if (gui.notify) {
+        gui.notify({severity: 'info', body: msg});
+      } else {
+        // Fallback for early messages before MessageControl is constructed
+        gui.message(msg);
+        internal.logArgs(arguments);
+      }
     }
 
-    // GUI warning uses the alert popup, which replaces previous popup
-    // (unlike message) -- this allows for catching and handling errors
-    // by replacing the error popup with a warning.
+    // CLI warnings used to surface as modal alerts, which interrupt the user
+    // and replace any previous popup. They now go to the Messages inbox so
+    // they can accumulate non-disruptively.
     function warn() {
-      gui.alert(GUI.formatMessageArgs(arguments));
+      var msg = GUI.formatMessageArgs(arguments);
+      if (gui.notify) {
+        gui.notify({severity: 'warn', body: msg, dedupKey: 'warn:' + msg});
+      } else {
+        gui.alert(msg);
+      }
     }
 
     internal.setLoggingFunctions(message, error, stop, warn);
@@ -2970,7 +3085,11 @@
         try {
           await utils$1.promisify(saveFilesToServer)(paths, data);
           if (files.length >= 1) {
-            gui.alert('<b>Saved</b><br>' + paths.join('<br>'));
+            if (gui.notify) {
+              gui.notify({severity: 'info', title: 'Saved', body: paths.join('\n')});
+            } else {
+              gui.alert('<b>Saved</b><br>' + paths.join('<br>'));
+            }
           }
         } catch(err) {
           msg = "<b>Direct save failed</b><br>Reason: " + err.message + ".";
@@ -3811,7 +3930,7 @@
     slider.on('change', function(e) {
       var pct = fromSliderPct(e.pct);
       text.value(pct);
-      pct = utils$1.parsePercent(text.text()); // use rounded value (for consistency w/ cli)
+      pct = internal.parsePercent(text.text()); // use rounded value (for consistency w/ cli)
       onChange(pct);
     });
     slider.on('start', function(e) {
@@ -4058,11 +4177,16 @@
       if (!_isOpen) {
         btn.addClass('active');
         _isOpen = true;
-        // use console for messages while open
+        // Route logging output to the in-app console while it's open, so a
+        // user typing CLI commands here sees the results inline -- the same
+        // way a CLI user sees output in their terminal. warn() goes to a
+        // distinct consoleWarn() rather than to the Messages inbox: warnings
+        // emitted by command pipelines should land where the user typed,
+        // not in a separate UI surface they might not notice.
         // TODO: find a solution for logging problem when switching between multiple
         // gui instances with the console open. E.g. console could close
         // when an instance loses focus.
-        internal.setLoggingFunctions(consoleMessage, consoleError, consoleStop);
+        internal.setLoggingFunctions(consoleMessage, consoleError, consoleStop, consoleWarn);
         gui.container.addClass('console-open');
         el.show();
         gui.dispatchEvent('resize');
@@ -4460,6 +4584,15 @@
       toLog(msg, 'console-error');
     }
 
+    // Routed from internal.warn() while the console is open. Distinct from
+    // consoleWarning() (which is used for hard-stop errors) so the styling
+    // can differ -- warnings shouldn't read as red "something went wrong",
+    // they're just heads-ups about how the input was interpreted.
+    function consoleWarn() {
+      var msg = GUI.formatMessageArgs(arguments);
+      toLog(msg, 'console-warn');
+    }
+
     function consoleMessage() {
       var msg = GUI.formatMessageArgs(arguments);
       if (internal.loggingEnabled()) {
@@ -4710,7 +4843,7 @@
       });
 
       internal.writeFiles = function() {
-        error$1(unsupportedMsg);
+        error$2(unsupportedMsg);
       };
       return;
     }
@@ -6825,1356 +6958,1386 @@
   // Fall back to browserify's Buffer polyfill
   var B = typeof Buffer != 'undefined' ? Buffer : require$1('buffer').Buffer;
 
-  // This module provides a way for multiple jobs to run together asynchronously
-  // while keeping job-level context variables (like "defs") separate.
-
-  var stash = {};
-
-  function stashVar(key, val) {
-    if (key in stash) {
-      error('Tried to replace a stashed variable:', key);
-    }
-    stash[key] = val;
+  // We do NOT import from mapshaper-logging here to avoid a circular dependency
+  function error$1() {
+    throw new Error(Array.prototype.slice.call(arguments).join(' '));
   }
 
-  function getStashedVar(key) {
-    if (key in stash === false) {
-      return undefined; // to support running commands in tests
-      // error('Tried to read a nonexistent variable from the stash:', key);
-    }
-    return stash[key];
+  var uniqCount = 0;
+  function getUniqueName(prefix) {
+    return (prefix || "__id_") + (++uniqCount);
   }
 
-  function clearStash() {
-    stash = {};
+  function isFunction(obj) {
+    return typeof obj == 'function';
   }
 
-  var LOGGING = false;
-  var STDOUT = false; // use stdout for status messages
-  var _error, _stop, _message, _warn;
+  function isPromise(arg) {
+    return arg ? isFunction(arg.then) : false;
+  }
 
-  var _interrupt = function() {
-    throw new NonFatalError(formatLogArgs(arguments));
-  };
+  function isObject(obj) {
+    return obj === Object(obj); // via underscore
+  }
 
-  var onceMessages = [];
+  function clamp(val, min, max) {
+    return val < min ? min : (val > max ? max : val);
+  }
 
-  setLoggingForCLI();
+  function isArray(obj) {
+    return Array.isArray(obj);
+  }
 
-  function getLoggingSetter() {
-    var e = _error, s = _stop, m = _message, w = _warn;
-    return function() {
-      setLoggingFunctions(m, e, s, w);
-    };
+  // Is obj a valid number or NaN? (test if obj is type number)
+  function isNumber(obj) {
+    return obj != null && obj.constructor == Number;
   }
 
-  function setLoggingForCLI() {
-    function stop() {
-      throw new UserError(formatLogArgs(arguments));
-    }
+  function isValidNumber(val) {
+    return isNumber(val) && !isNaN(val);
+  }
 
-    function error() {
-      var msg = utils.toArray(arguments).join(' ');
-      throw new Error(msg);
-    }
+  // Similar to isFinite() but does not coerce strings or other types
+  function isFiniteNumber(val) {
+    return isValidNumber(val) && val !== Infinity && val !== -Infinity;
+  }
 
-    function message() {
-      logArgs(arguments);
-    }
+  // This uses type conversion
+  // export function isFiniteNumber(val) {
+  //   return val > -Infinity && val < Infinity;
+  // }
 
-    // CLI warning is just a message (GUI behaves differently)
-    var warn = message;
+  function isNonNegNumber(val) {
+    return isNumber(val) && val >= 0;
+  }
 
-    setLoggingFunctions(message, error, stop, warn);
+  function isInteger(obj) {
+    return isNumber(obj) && ((obj | 0) === obj);
   }
 
-  function enableLogging() {
-    LOGGING = true;
+  function isEven(obj) {
+    return (obj % 2) === 0;
   }
 
-  function disableLogging() {
-    LOGGING = false;
+  function isOdd(obj) {
+    return (obj % 2) === 1;
   }
 
-  function loggingEnabled() {
-    return !!LOGGING;
+  function isString(obj) {
+    return obj != null && obj.toString === String.prototype.toString;
+    // TODO: replace w/ something better.
   }
 
-  // Handle an unexpected condition (internal error)
-  function error() {
-    _error.apply(null, utils.toArray(arguments));
+  function isDate(obj) {
+    return !!obj && obj.getTime === Date.prototype.getTime;
   }
 
-  // Handle an error caused by invalid input or misuse of API
-  function stop() {
-    // _stop.apply(null, utils.toArray(arguments));
-    _stop.apply(null, messageArgs(arguments));
+  function isBoolean(obj) {
+    return obj === true || obj === false;
   }
 
-  function interrupt() {
-    _interrupt.apply(null, utils.toArray(arguments));
+  function formatDateISO(d) {
+    if (!isDate(d)) return '';
+    return d.toISOString().replace(':00.000Z', 'Z');
   }
 
-  // Print a status message
-  function message() {
-    _message.apply(null, messageArgs(arguments));
+  // Convert an array-like object to an Array, or make a copy if @obj is an Array
+  function toArray(obj) {
+    var arr;
+    if (!isArrayLike(obj)) error$1("toArray() requires an array-like object");
+    try {
+      arr = Array.prototype.slice.call(obj, 0); // breaks in ie8
+    } catch(e) {
+      // support ie8
+      arr = [];
+      for (var i=0, n=obj.length; i<n; i++) {
+        arr[i] = obj[i];
+      }
+    }
+    return arr;
   }
 
-  function warn() {
-    _warn.apply(null, messageArgs(arguments));
+  // Array like: has length property, is numerically indexed and mutable.
+  // TODO: try to detect objects with length property but no indexed data elements
+  function isArrayLike(obj) {
+    if (!obj) return false;
+    if (isArray(obj)) return true;
+    if (isString(obj)) return false;
+    if (obj.length === 0 || obj.length > 0) return true;
+    return false;
   }
 
-  function warnOnce() {
-    var str = formatLogArgs(arguments);
-    if (onceMessages.includes(str)) return;
-    onceMessages.push(str);
-    _warn.apply(null, messageArgs(arguments));
+  // See https://raw.github.com/kvz/phpjs/master/functions/strings/addslashes.js
+  function addslashes(str) {
+    return (str + '').replace(/[\\"']/g, '\\$&').replace(/\u0000/g, '\\0');
   }
 
-  // A way for the GUI to replace the CLI logging functions
-  function setLoggingFunctions(message, error, stop, warn) {
-    _message = message;
-    _error = error;
-    _stop = stop;
-    _warn = warn;
+  // Escape a literal string to use in a regexp.
+  // Ref.: http://simonwillison.net/2006/Jan/20/escape/
+  function regexEscape(str) {
+    return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
   }
 
-  // get detailed error information from error stack (if available)
-  // Example stack string (Node.js):
-  /*
-  /Users/someuser/somescript.js:226
-      opacity: Math.round(weight * 5 / 5 // 0.2 0.4 0.6 etc
-                                       ^
 
-  SyntaxError: missing ) after argument list
-      at internalCompileFunction (node:internal/vm:73:18)
-      at wrapSafe (node:internal/modules/cjs/loader:1149:20)
-      at Module._compile (node:internal/modules/cjs/loader:1190:27)
-      ...
-  */
-  function getErrorDetail(e) {
-    var parts = (typeof e.stack == 'string') ? e.stack.split(/\n\s*\n/) : [];
-    if (parts.length > 1 || true) {
-      return '\nError details:\n' + parts[0];
-    }
-    return '';
+  // See https://github.com/janl/mustache.js/blob/master/mustache.js
+  var entityMap = {
+    '&': '&amp;',
+    '<': '&lt;',
+    '>': '&gt;',
+    '"': '&quot;',
+    "'": '&#39;',
+    '/': '&#x2F;'
+  };
+  function htmlEscape(s) {
+    return String(s).replace(/[&<>"'/]/g, function(s) {
+      return entityMap[s];
+    });
   }
 
-  // print a message to stdout
-  function print() {
-    STDOUT = true; // tell logArgs() to print to stdout, not stderr
-    // calling message() adds the "[command name]" prefix
-    _message(utils.toArray(arguments));
-    STDOUT = false;
-  }
 
-  function verbose() {
-    // verbose can be set globally with the -verbose command or separately for each command
-    if (useVerbose()) {
-      message.apply(null, arguments);
+  function defaults(dest) {
+    for (var i=1, n=arguments.length; i<n; i++) {
+      var src = arguments[i] || {};
+      for (var key in src) {
+        if (key in dest === false && src.hasOwnProperty(key)) {
+          dest[key] = src[key];
+        }
+      }
     }
+    return dest;
   }
 
-  function useVerbose() {
-    return getStashedVar('VERBOSE');
+  function extend(o) {
+    var dest = o || {},
+        n = arguments.length,
+        key, i, src;
+    for (i=1; i<n; i++) {
+      src = arguments[i] || {};
+      for (key in src) {
+        if (src.hasOwnProperty(key)) {
+          dest[key] = src[key];
+        }
+      }
+    }
+    return dest;
   }
 
-  function useDebug() {
-    return getStashedVar('DEBUG');
-  }
+  // Pseudoclassical inheritance
+  //
+  // Inherit from a Parent function:
+  //    inherit(Child, Parent);
+  // Call parent's constructor (inside child constructor):
+  //    this.__super__([args...]);
+  function inherit(targ, src) {
+    var f = function() {
+      if (this.__super__ == f) {
+        // add __super__ of parent to front of lookup chain
+        // so parent class constructor can call its parent using this.__super__
+        this.__super__ = src.prototype.__super__;
+        // call parent constructor function. this.__super__ now points to parent-of-parent
+        src.apply(this, arguments);
+        // remove temp __super__, expose targ.prototype.__super__ again
+        delete this.__super__;
+      }
+    };
 
-  function debug() {
-    if (useDebug()) {
-      logArgs(arguments);
-    }
+    f.prototype = src.prototype || src; // added || src to allow inheriting from objects as well as functions
+    // Extend targ prototype instead of wiping it out --
+    //   in case inherit() is called after targ.prototype = {stuff}; statement
+    targ.prototype = extend(new f(), targ.prototype); //
+    targ.prototype.constructor = targ;
+    targ.prototype.__super__ = f;
   }
 
-  function time(slug) {
-    if (useDebug()) {
-      console.time(slug);
-    }
+  function promisify(asyncFn) {
+    return function() {
+      var args = toArray(arguments);
+      return new Promise((resolve, reject) => {
+        var cb = function(err, data) {
+          if (err) reject(err);
+          else resolve(data);
+        };
+        args.push(cb);
+        asyncFn.apply(this, args);
+      });
+    };
   }
 
-  function timeEnd(slug) {
-    if (useDebug()) {
-      console.timeEnd(slug);
+   function runAsync(fn, arg) {
+      return new Promise((resolve, reject) => {
+        fn(arg, function(err, data) {
+          return err ? reject(err) : resolve(data);
+        });
+      });
     }
-  }
 
-  function printError(err) {
-    var msg;
-    if (!LOGGING) return;
-    if (utils.isString(err)) {
-      err = new UserError(err);
-    }
-    if (err.name == 'NonFatalError') {
-      console.error(messageArgs([err.message]).join(' '));
-    } else if (err.name == 'UserError') {
-      msg = err.message;
-      if (!/Error/.test(msg)) {
-        msg = "Error: " + msg;
+  // Call @iter on each member of an array (similar to Array#reduce(iter))
+  //    iter: function(memo, item, callback)
+  // Call @done when all members have been processed or if an error occurs
+  //    done: function(err, memo)
+  // @memo: Initial value
+  //
+  function reduceAsync(arr, memo, iter, done) {
+    var call = typeof setImmediate == 'undefined' ? setTimeout : setImmediate;
+    var i=0;
+    next(null, memo);
+
+    function next(err, memo) {
+      // Detach next operation from call stack to prevent overflow
+      // Don't use setTimeout(, 0) if setImmediate is available
+      // (setTimeout() can introduce a long delay if previous operation was slow,
+      //    as of Node 0.10.32 -- a bug?)
+      if (err) {
+        return done(err, null);
       }
-      console.error(messageArgs([msg]).join(' '));
-      console.error("Run mapshaper -h to view help");
-    } else {
-      // not a user error (i.e. a bug in mapshaper)
-      console.error(err);
-      // throw err;
+      call(function() {
+        if (i < arr.length === false) {
+          done(null, memo);
+        } else {
+          iter(memo, arr[i++], next);
+        }
+      }, 0);
     }
   }
 
-  function UserError(msg) {
-    var err = new Error(msg);
-    err.name = 'UserError';
-    return err;
-  }
 
-  function NonFatalError(msg) {
-    var err = new Error(msg);
-    err.name = 'NonFatalError';
-    return err;
+  // Append elements of @src array to @dest array
+  function merge(dest, src) {
+    if (!isArray(dest) || !isArray(src)) {
+      error$1("Usage: merge(destArray, srcArray);");
+    }
+    for (var i=0, n=src.length; i<n; i++) {
+      dest.push(src[i]);
+    }
+    return dest;
   }
 
-  function formatColumns(arr, alignments) {
-    var widths = arr.reduce(function(memo, line) {
-      return line.map(function(str, i) {
-        return memo ? Math.max(memo[i], str.length) : str.length;
-      });
-    }, null);
-    return arr.map(function(line) {
-      line = line.map(function(str, i) {
-        var rt = alignments && alignments[i] == 'right';
-        var pad = (rt ? str.padStart : str.padEnd).bind(str);
-        return pad(widths[i], ' ');
-      });
-      return '  ' + line.join(' ');
-    }).join('\n');
+  // Returns elements in arr and not in other
+  // (similar to underscore diff)
+  function difference(arr, other) {
+    var index = arrayToIndex(other);
+    return arr.filter(function(el) {
+      return !Object.prototype.hasOwnProperty.call(index, el);
+    });
   }
 
-  // Format an array of (preferably short) strings in columns for console logging.
-  function formatStringsAsGrid(arr, width) {
-    // TODO: variable column width
-    var longest = arr.reduce(function(len, str) {
-          return Math.max(len, str.length);
-        }, 0),
-        colWidth = longest + 2,
-        perLine = Math.floor((width || 80) / colWidth) || 1;
-    return arr.reduce(function(memo, name, i) {
-      var col = i % perLine;
-      if (i > 0 && col === 0) memo += '\n';
-      if (col < perLine - 1) { // right-pad all but rightmost column
-        name = utils.rpad(name, colWidth - 2, ' ');
-      }
-      return memo +  '  ' + name;
-    }, '');
+  // Return the intersection of two arrays
+  function intersection(a, b) {
+    return a.filter(function(el) {
+      return b.includes(el);
+    });
   }
 
-  // expose so GUI can use it
-  function formatLogArgs(args) {
-    return utils.toArray(args).join(' ');
+  function indexOf(arr, item) {
+    var nan = item !== item;
+    for (var i = 0, len = arr.length || 0; i < len; i++) {
+      if (arr[i] === item) return i;
+      if (nan && arr[i] !== arr[i]) return i;
+    }
+    return -1;
   }
 
-  function messageArgs(args) {
-    var arr = utils.toArray(args);
-    var cmd = getStashedVar('current_command');
-    if (cmd && cmd != 'help') {
-      arr.unshift('[' + cmd + ']');
+  // Test a string or array-like object for existence of substring or element
+  function contains(container, item) {
+    if (isString(container)) {
+      return container.indexOf(item) != -1;
     }
-    return arr;
+    else if (isArrayLike(container)) {
+      return indexOf(container, item) != -1;
+    }
+    error$1("Expected Array or String argument");
   }
 
-  function logArgs(args) {
-    if (!LOGGING || getStashedVar('QUIET') || !utils.isArrayLike(args)) return;
-    var msg = formatLogArgs(args);
-    if (STDOUT) console.log(msg);
-    else console.error(msg);
+  function some(arr, test) {
+    return arr.reduce(function(val, item) {
+      return val || test(item); // TODO: short-circuit?
+    }, false);
   }
 
-  function truncateString(str, maxLen) {
-    maxLen = maxLen || 80;
-    if (str.length > maxLen) {
-      str = str.substring(0, maxLen - 3).trimEnd() + '...';
-    }
-    return str;
+  function every(arr, test) {
+    return arr.reduce(function(val, item) {
+      return val && test(item);
+    }, true);
   }
 
-  var uniqCount = 0;
-  function getUniqueName(prefix) {
-    return (prefix || "__id_") + (++uniqCount);
+  function find(arr, test, ctx) {
+    var matches = arr.filter(test, ctx);
+    return matches.length === 0 ? null : matches[0];
   }
 
-  function isFunction(obj) {
-    return typeof obj == 'function';
+  function range(len, start, inc) {
+    var arr = [],
+        v = start === void 0 ? 0 : start,
+        i = inc === void 0 ? 1 : inc;
+    while(len--) {
+      arr.push(v);
+      v += i;
+    }
+    return arr;
   }
 
-  function isPromise(arg) {
-    return arg ? isFunction(arg.then) : false;
+  function repeat(times, func) {
+    var values = [],
+        val;
+    for (var i=0; i<times; i++) {
+      val = func(i);
+      if (val !== void 0) {
+        values[i] = val;
+      }
+    }
+    return values.length > 0 ? values : void 0;
   }
 
-  function isObject(obj) {
-    return obj === Object(obj); // via underscore
+  // Calc sum, skip falsy and NaN values
+  // Assumes: no other non-numeric objects in array
+  //
+  function sum(arr, info) {
+    if (!isArrayLike(arr)) error$1 ("sum() expects an array, received:", arr);
+    var tot = 0,
+        nan = 0,
+        val;
+    for (var i=0, n=arr.length; i<n; i++) {
+      val = arr[i];
+      if (val) {
+        tot += val;
+      } else if (isNaN(val)) {
+        nan++;
+      }
+    }
+    if (info) {
+      info.nan = nan;
+    }
+    return tot;
   }
 
-  function clamp(val, min, max) {
-    return val < min ? min : (val > max ? max : val);
+  // Calculate min and max values of an array, ignoring NaN values
+  function getArrayBounds(arr) {
+    var min = Infinity,
+      max = -Infinity,
+      nan = 0, val;
+    for (var i=0, len=arr.length; i<len; i++) {
+      val = arr[i];
+      if (val !== val) nan++;
+      if (val < min) min = val;
+      if (val > max) max = val;
+    }
+    return {
+      min: min,
+      max: max,
+      nan: nan
+    };
   }
 
-  function isArray(obj) {
-    return Array.isArray(obj);
-  }
+  // export function uniq(src) {
+  //   var index = {};
+  //   return src.reduce(function(memo, el) {
+  //     if (el in index === false) {
+  //       index[el] = true;
+  //       memo.push(el);
+  //     }
+  //     return memo;
+  //   }, []);
+  // }
 
-  // Is obj a valid number or NaN? (test if obj is type number)
-  function isNumber(obj) {
-    return obj != null && obj.constructor == Number;
+  function uniq(src) {
+    var index = new Set();
+    var arr = [];
+    var item;
+    for (var i=0, n=src.length; i<n; i++) {
+      item = src[i];
+      if (!index.has(item)) {
+        arr.push(item);
+        index.add(item);
+      }
+    }
+    return arr;
   }
 
-  function isValidNumber(val) {
-    return isNumber(val) && !isNaN(val);
+  function pluck(arr, key) {
+    return arr.map(function(obj) {
+      return obj[key];
+    });
   }
 
-  // Similar to isFinite() but does not coerce strings or other types
-  function isFiniteNumber(val) {
-    return isValidNumber(val) && val !== Infinity && val !== -Infinity;
+  function countValues(arr) {
+    return arr.reduce(function(memo, val) {
+      memo[val] = (val in memo) ? memo[val] + 1 : 1;
+      return memo;
+    }, {});
   }
 
-  // This uses type conversion
-  // export function isFiniteNumber(val) {
-  //   return val > -Infinity && val < Infinity;
-  // }
-
-  function isNonNegNumber(val) {
-    return isNumber(val) && val >= 0;
+  function indexOn(arr, k) {
+    return arr.reduce(function(index, o) {
+      index[o[k]] = o;
+      return index;
+    }, {});
   }
 
-  function isInteger(obj) {
-    return isNumber(obj) && ((obj | 0) === obj);
+  function groupBy(arr, k) {
+    return arr.reduce(function(index, o) {
+      var keyval = o[k];
+      if (keyval in index) {
+        index[keyval].push(o);
+      } else {
+        index[keyval] = [o];
+      }
+      return index;
+    }, {});
   }
 
-  function isEven(obj) {
-    return (obj % 2) === 0;
+  function arrayToIndex(arr, val) {
+    var init = arguments.length > 1;
+    return arr.reduce(function(index, key) {
+      index[key] = init ? val : true;
+      return index;
+    }, {});
   }
 
-  function isOdd(obj) {
-    return (obj % 2) === 1;
+  // Support for iterating over array-like objects, like typed arrays
+  function forEach(arr, func, ctx) {
+    if (!isArrayLike(arr)) {
+      throw new Error("#forEach() takes an array-like argument. " + arr);
+    }
+    for (var i=0, n=arr.length; i < n; i++) {
+      func.call(ctx, arr[i], i);
+    }
   }
 
-  function isString(obj) {
-    return obj != null && obj.toString === String.prototype.toString;
-    // TODO: replace w/ something better.
+  function forEachProperty(o, func, ctx) {
+    Object.keys(o).forEach(function(key) {
+      func.call(ctx, o[key], key);
+    });
   }
 
-  function isDate(obj) {
-    return !!obj && obj.getTime === Date.prototype.getTime;
+  function initializeArray(arr, init) {
+    for (var i=0, len=arr.length; i<len; i++) {
+      arr[i] = init;
+    }
+    return arr;
   }
 
-  function isBoolean(obj) {
-    return obj === true || obj === false;
+  function replaceArray(arr, arr2) {
+    arr.splice(0, arr.length);
+    for (var i=0, n=arr2.length; i<n; i++) {
+      arr.push(arr2[i]);
+    }
   }
 
-  function formatDateISO(d) {
-    if (!isDate(d)) return '';
-    return d.toISOString().replace(':00.000Z', 'Z');
+  function repeatString(src, n) {
+    var str = "";
+    for (var i=0; i<n; i++)
+      str += src;
+    return str;
   }
 
-  // Convert an array-like object to an Array, or make a copy if @obj is an Array
-  function toArray(obj) {
-    var arr;
-    if (!isArrayLike(obj)) error("toArray() requires an array-like object");
-    try {
-      arr = Array.prototype.slice.call(obj, 0); // breaks in ie8
-    } catch(e) {
-      // support ie8
-      arr = [];
-      for (var i=0, n=obj.length; i<n; i++) {
-        arr[i] = obj[i];
-      }
-    }
-    return arr;
+  function splitLines(str) {
+    return str.split(/\r?\n/);
   }
 
-  // Array like: has length property, is numerically indexed and mutable.
-  // TODO: try to detect objects with length property but no indexed data elements
-  function isArrayLike(obj) {
-    if (!obj) return false;
-    if (isArray(obj)) return true;
-    if (isString(obj)) return false;
-    if (obj.length === 0 || obj.length > 0) return true;
-    return false;
+  function pluralSuffix(count) {
+    return count != 1 ? 's' : '';
   }
 
-  // See https://raw.github.com/kvz/phpjs/master/functions/strings/addslashes.js
-  function addslashes(str) {
-    return (str + '').replace(/[\\"']/g, '\\$&').replace(/\u0000/g, '\\0');
+  function endsWith(str, ending) {
+      return str.indexOf(ending, str.length - ending.length) !== -1;
   }
 
-  // Escape a literal string to use in a regexp.
-  // Ref.: http://simonwillison.net/2006/Jan/20/escape/
-  function regexEscape(str) {
-    return str.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&');
+  function lpad(str, size, pad) {
+    pad = pad || ' ';
+    str = String(str);
+    return repeatString(pad, size - str.length) + str;
   }
 
+  function rpad(str, size, pad) {
+    pad = pad || ' ';
+    str = String(str);
+    return str + repeatString(pad, size - str.length);
+  }
 
-  // See https://github.com/janl/mustache.js/blob/master/mustache.js
-  var entityMap = {
-    '&': '&amp;',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    "'": '&#39;',
-    '/': '&#x2F;'
-  };
-  function htmlEscape(s) {
-    return String(s).replace(/[&<>"'/]/g, function(s) {
-      return entityMap[s];
-    });
+  function trim(str) {
+    return ltrim(rtrim(str));
   }
 
+  var ltrimRxp = /^\s+/;
+  function ltrim(str) {
+    return str.replace(ltrimRxp, '');
+  }
 
-  function defaults(dest) {
-    for (var i=1, n=arguments.length; i<n; i++) {
-      var src = arguments[i] || {};
-      for (var key in src) {
-        if (key in dest === false && src.hasOwnProperty(key)) {
-          dest[key] = src[key];
-        }
-      }
-    }
-    return dest;
+  var rtrimRxp = /\s+$/;
+  function rtrim(str) {
+    return str.replace(rtrimRxp, '');
   }
 
-  function extend(o) {
-    var dest = o || {},
-        n = arguments.length,
-        key, i, src;
-    for (i=1; i<n; i++) {
-      src = arguments[i] || {};
-      for (key in src) {
-        if (src.hasOwnProperty(key)) {
-          dest[key] = src[key];
-        }
-      }
+  function addThousandsSep(str) {
+    var fmt = '',
+        start = str[0] == '-' ? 1 : 0,
+        dec = str.indexOf('.'),
+        end = str.length,
+        ins = (dec == -1 ? end : dec) - 3;
+    while (ins > start) {
+      fmt = ',' + str.substring(ins, end) + fmt;
+      end = ins;
+      ins -= 3;
     }
-    return dest;
+    return str.substring(0, end) + fmt;
   }
 
-  // Pseudoclassical inheritance
-  //
-  // Inherit from a Parent function:
-  //    inherit(Child, Parent);
-  // Call parent's constructor (inside child constructor):
-  //    this.__super__([args...]);
-  function inherit(targ, src) {
-    var f = function() {
-      if (this.__super__ == f) {
-        // add __super__ of parent to front of lookup chain
-        // so parent class constructor can call its parent using this.__super__
-        this.__super__ = src.prototype.__super__;
-        // call parent constructor function. this.__super__ now points to parent-of-parent
-        src.apply(this, arguments);
-        // remove temp __super__, expose targ.prototype.__super__ again
-        delete this.__super__;
-      }
-    };
-
-    f.prototype = src.prototype || src; // added || src to allow inheriting from objects as well as functions
-    // Extend targ prototype instead of wiping it out --
-    //   in case inherit() is called after targ.prototype = {stuff}; statement
-    targ.prototype = extend(new f(), targ.prototype); //
-    targ.prototype.constructor = targ;
-    targ.prototype.__super__ = f;
+  function numToStr(num, decimals) {
+    return decimals >= 0 ? num.toFixed(decimals) : String(num);
   }
 
-  function promisify(asyncFn) {
-    return function() {
-      var args = toArray(arguments);
-      return new Promise((resolve, reject) => {
-        var cb = function(err, data) {
-          if (err) reject(err);
-          else resolve(data);
-        };
-        args.push(cb);
-        asyncFn.apply(this, args);
-      });
-    };
+  function formatNumber(val) {
+    return val + '';
   }
 
-   function runAsync(fn, arg) {
-      return new Promise((resolve, reject) => {
-        fn(arg, function(err, data) {
-          return err ? reject(err) : resolve(data);
-        });
-      });
-    }
-
-  // Call @iter on each member of an array (similar to Array#reduce(iter))
-  //    iter: function(memo, item, callback)
-  // Call @done when all members have been processed or if an error occurs
-  //    done: function(err, memo)
-  // @memo: Initial value
-  //
-  function reduceAsync(arr, memo, iter, done) {
-    var call = typeof setImmediate == 'undefined' ? setTimeout : setImmediate;
-    var i=0;
-    next(null, memo);
+  function formatIntlNumber(val) {
+    var str = formatNumber(val);
+    return '"' + str.replace('.', ',') + '"'; // need to quote if comma-delimited
+  }
 
-    function next(err, memo) {
-      // Detach next operation from call stack to prevent overflow
-      // Don't use setTimeout(, 0) if setImmediate is available
-      // (setTimeout() can introduce a long delay if previous operation was slow,
-      //    as of Node 0.10.32 -- a bug?)
-      if (err) {
-        return done(err, null);
+  function formatNumberForDisplay(num, decimals, nullStr, showPos) {
+    var fmt;
+    if (isNaN(num)) {
+      fmt = nullStr || '-';
+    } else {
+      fmt = numToStr(num, decimals);
+      fmt = addThousandsSep(fmt);
+      if (showPos && parseFloat(fmt) > 0) {
+        fmt = "+" + fmt;
       }
-      call(function() {
-        if (i < arr.length === false) {
-          done(null, memo);
-        } else {
-          iter(memo, arr[i++], next);
-        }
-      }, 0);
     }
+    return fmt;
   }
 
-
-  // Append elements of @src array to @dest array
-  function merge(dest, src) {
-    if (!isArray(dest) || !isArray(src)) {
-      error("Usage: merge(destArray, srcArray);");
-    }
-    for (var i=0, n=src.length; i<n; i++) {
-      dest.push(src[i]);
+  function shuffle(arr) {
+    var tmp, i, j;
+    for (i = arr.length - 1; i > 0; i--) {
+      j = Math.floor(Math.random() * (i + 1));
+      tmp = arr[i];
+      arr[i] = arr[j];
+      arr[j] = tmp;
     }
-    return dest;
   }
 
-  // Returns elements in arr and not in other
-  // (similar to underscore diff)
-  function difference(arr, other) {
-    var index = arrayToIndex(other);
-    return arr.filter(function(el) {
-      return !Object.prototype.hasOwnProperty.call(index, el);
-    });
+  function pickOne(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
   }
 
-  // Return the intersection of two arrays
-  function intersection(a, b) {
-    return a.filter(function(el) {
-      return b.includes(el);
+  // Sort an array of objects based on one or more properties.
+  // Usage: sortOn(array, key1, asc?[, key2, asc? ...])
+  //
+  function sortOn(arr) {
+    var comparators = [];
+    for (var i=1; i<arguments.length; i+=2) {
+      comparators.push(getKeyComparator(arguments[i], arguments[i+1]));
+    }
+    arr.sort(function(a, b) {
+      var cmp = 0,
+          i = 0,
+          n = comparators.length;
+      while (i < n && cmp === 0) {
+        cmp = comparators[i](a, b);
+        i++;
+      }
+      return cmp;
     });
+    return arr;
   }
 
-  function indexOf(arr, item) {
-    var nan = item !== item;
-    for (var i = 0, len = arr.length || 0; i < len; i++) {
-      if (arr[i] === item) return i;
-      if (nan && arr[i] !== arr[i]) return i;
-    }
-    return -1;
+  // Sort array of values that can be compared with < > operators (strings, numbers)
+  // null, undefined and NaN are sorted to the end of the array
+  // default order is ascending
+  //
+  function genericSort(arr, ascending) {
+    var compare = getGenericComparator(ascending);
+    Array.prototype.sort.call(arr, compare);
+    return arr;
   }
 
-  // Test a string or array-like object for existence of substring or element
-  function contains(container, item) {
-    if (isString(container)) {
-      return container.indexOf(item) != -1;
-    }
-    else if (isArrayLike(container)) {
-      return indexOf(container, item) != -1;
-    }
-    error("Expected Array or String argument");
+  function getSortedIds(arr, asc) {
+    var ids = range(arr.length);
+    sortArrayIndex(ids, arr, asc);
+    return ids;
   }
 
-  function some(arr, test) {
-    return arr.reduce(function(val, item) {
-      return val || test(item); // TODO: short-circuit?
-    }, false);
+  function sortArrayIndex(ids, arr, asc) {
+    var compare = getGenericComparator(asc);
+    ids.sort(function(i, j) {
+      // added i, j comparison to guarantee that sort is stable
+      var cmp = compare(arr[i], arr[j]);
+      return cmp > 0 || cmp === 0 && i > j ? 1 : -1;
+    });
   }
 
-  function every(arr, test) {
-    return arr.reduce(function(val, item) {
-      return val && test(item);
-    }, true);
+  function reorderArray(arr, idxs) {
+    var len = idxs.length;
+    var arr2 = [];
+    for (var i=0; i<len; i++) {
+      var idx = idxs[i];
+      if (idx < 0 || idx >= len) error$1("Out-of-bounds array idx");
+      arr2[i] = arr[idx];
+    }
+    replaceArray(arr, arr2);
   }
 
-  function find(arr, test, ctx) {
-    var matches = arr.filter(test, ctx);
-    return matches.length === 0 ? null : matches[0];
+  function getKeyComparator(key, asc) {
+    var compare = getGenericComparator(asc);
+    return function(a, b) {
+      return compare(a[key], b[key]);
+    };
   }
 
-  function range(len, start, inc) {
-    var arr = [],
-        v = start === void 0 ? 0 : start,
-        i = inc === void 0 ? 1 : inc;
-    while(len--) {
-      arr.push(v);
-      v += i;
-    }
-    return arr;
+  function getGenericComparator(asc) {
+    asc = asc !== false && asc != 'descending'; // ascending is the default
+    return function(a, b) {
+      var retn = 0;
+      if (b == null) {
+        retn = a == null ? 0 : -1;
+      } else if (a == null) {
+        retn = 1;
+      } else if (a < b) {
+        retn = asc ? -1 : 1;
+      } else if (a > b) {
+        retn = asc ? 1 : -1;
+      } else if (a !== a) {
+        retn = 1;
+      } else if (b !== b) {
+        retn = -1;
+      }
+      return retn;
+    };
   }
 
-  function repeat(times, func) {
-    var values = [],
-        val;
-    for (var i=0; i<times; i++) {
-      val = func(i);
-      if (val !== void 0) {
-        values[i] = val;
-      }
-    }
-    return values.length > 0 ? values : void 0;
+
+  // Generic in-place sort (null, NaN, undefined not handled)
+  function quicksort(arr, asc) {
+    quicksortPartition(arr, 0, arr.length-1);
+    if (asc === false) Array.prototype.reverse.call(arr); // Works with typed arrays
+    return arr;
   }
 
-  // Calc sum, skip falsy and NaN values
-  // Assumes: no other non-numeric objects in array
-  //
-  function sum(arr, info) {
-    if (!isArrayLike(arr)) error ("sum() expects an array, received:", arr);
-    var tot = 0,
-        nan = 0,
-        val;
-    for (var i=0, n=arr.length; i<n; i++) {
-      val = arr[i];
-      if (val) {
-        tot += val;
-      } else if (isNaN(val)) {
-        nan++;
+  // Moved out of quicksort() (saw >100% speedup in Chrome with deep recursion)
+  function quicksortPartition (a, lo, hi) {
+    var i = lo,
+        j = hi,
+        pivot, tmp;
+    while (i < hi) {
+      pivot = a[lo + hi >> 1]; // avoid n^2 performance on sorted arrays
+      while (i <= j) {
+        while (a[i] < pivot) i++;
+        while (a[j] > pivot) j--;
+        if (i <= j) {
+          tmp = a[i];
+          a[i] = a[j];
+          a[j] = tmp;
+          i++;
+          j--;
+        }
       }
+      if (lo < j) quicksortPartition(a, lo, j);
+      lo = i;
+      j = hi;
     }
-    if (info) {
-      info.nan = nan;
-    }
-    return tot;
-  }
-
-  // Calculate min and max values of an array, ignoring NaN values
-  function getArrayBounds(arr) {
-    var min = Infinity,
-      max = -Infinity,
-      nan = 0, val;
-    for (var i=0, len=arr.length; i<len; i++) {
-      val = arr[i];
-      if (val !== val) nan++;
-      if (val < min) min = val;
-      if (val > max) max = val;
-    }
-    return {
-      min: min,
-      max: max,
-      nan: nan
-    };
   }
 
-  // export function uniq(src) {
-  //   var index = {};
-  //   return src.reduce(function(memo, el) {
-  //     if (el in index === false) {
-  //       index[el] = true;
-  //       memo.push(el);
-  //     }
-  //     return memo;
-  //   }, []);
-  // }
 
-  function uniq(src) {
-    var index = new Set();
-    var arr = [];
-    var item;
-    for (var i=0, n=src.length; i<n; i++) {
-      item = src[i];
-      if (!index.has(item)) {
-        arr.push(item);
-        index.add(item);
-      }
+  function findRankByValue(arr, value) {
+    if (isNaN(value)) return arr.length;
+    var rank = 1;
+    for (var i=0, n=arr.length; i<n; i++) {
+      if (value > arr[i]) rank++;
     }
-    return arr;
+    return rank;
   }
 
-  function pluck(arr, key) {
-    return arr.map(function(obj) {
-      return obj[key];
-    });
+  function findValueByPct(arr, pct) {
+    var rank = Math.ceil((1-pct) * (arr.length));
+    return findValueByRank(arr, rank);
   }
 
-  function countValues(arr) {
-    return arr.reduce(function(memo, val) {
-      memo[val] = (val in memo) ? memo[val] + 1 : 1;
-      return memo;
-    }, {});
-  }
+  // See http://ndevilla.free.fr/median/median/src/wirth.c
+  // Elements of @arr are reordered
+  //
+  function findValueByRank(arr, rank) {
+    if (!arr.length || rank < 1 || rank > arr.length) error$1("[findValueByRank()] invalid input");
 
-  function indexOn(arr, k) {
-    return arr.reduce(function(index, o) {
-      index[o[k]] = o;
-      return index;
-    }, {});
+    rank = clamp(rank | 0, 1, arr.length);
+    var k = rank - 1, // conv. rank to array index
+        n = arr.length,
+        l = 0,
+        m = n - 1,
+        i, j, val, tmp;
+
+    while (l < m) {
+      val = arr[k];
+      i = l;
+      j = m;
+      do {
+        while (arr[i] < val) {i++;}
+        while (val < arr[j]) {j--;}
+        if (i <= j) {
+          tmp = arr[i];
+          arr[i] = arr[j];
+          arr[j] = tmp;
+          i++;
+          j--;
+        }
+      } while (i <= j);
+      if (j < k) l = i;
+      if (k < i) m = j;
+    }
+    return arr[k];
   }
 
-  function groupBy(arr, k) {
-    return arr.reduce(function(index, o) {
-      var keyval = o[k];
-      if (keyval in index) {
-        index[keyval].push(o);
-      } else {
-        index[keyval] = [o];
-      }
-      return index;
-    }, {});
+  function findMedian(arr) {
+    return findQuantile(arr, 0.5);
   }
 
-  function arrayToIndex(arr, val) {
-    var init = arguments.length > 1;
-    return arr.reduce(function(index, key) {
-      index[key] = init ? val : true;
-      return index;
-    }, {});
+  function findQuantile(arr, k) {
+    var n = arr.length,
+        i1 = Math.floor((n - 1) * k),
+        i2 = Math.ceil((n - 1) * k);
+    if (i1 < 0 || i2 >= n) return NaN;
+    var v1 = findValueByRank(arr, i1 + 1);
+    if (i1 == i2) return v1;
+    var v2 = findValueByRank(arr, i2 + 1);
+    // use linear interpolation
+    var w1 = i2 / (n - 1) - k;
+    var w2 = k - i1 / (n - 1);
+    var v = (v1 * w1 + v2 * w2) * (n - 1);
+    return v;
   }
 
-  // Support for iterating over array-like objects, like typed arrays
-  function forEach(arr, func, ctx) {
-    if (!isArrayLike(arr)) {
-      throw new Error("#forEach() takes an array-like argument. " + arr);
-    }
-    for (var i=0, n=arr.length; i < n; i++) {
-      func.call(ctx, arr[i], i);
+  function mean(arr) {
+    var count = 0,
+        avg = NaN,
+        val;
+    for (var i=0, n=arr.length; i<n; i++) {
+      val = arr[i];
+      if (isNaN(val)) continue;
+      avg = ++count == 1 ? val : val / count + (count - 1) / count * avg;
     }
+    return avg;
   }
 
-  function forEachProperty(o, func, ctx) {
-    Object.keys(o).forEach(function(key) {
-      func.call(ctx, o[key], key);
-    });
+
+  /*
+  A simplified version of printf formatting
+  Format codes: %[flags][width][.precision]type
+
+  supported flags:
+    +   add '+' before positive numbers
+    0   left-pad with '0'
+    '   Add thousands separator
+  width: 1 to many
+  precision: .(1 to many)
+  type:
+    s     string
+    di    integers
+    f     decimal numbers
+    xX    hexidecimal (unsigned)
+    %     literal '%'
+
+  Examples:
+    code    val    formatted
+    %+d     1      '+1'
+    %4i     32     '  32'
+    %04i    32     '0032'
+    %x      255    'ff'
+    %.2f    0.125  '0.13'
+    %'f     1000   '1,000'
+  */
+
+  // Usage: format(formatString, [values])
+  // Tip: When reusing the same format many times, use formatter() for 5x - 10x better performance
+  //
+  function format(fmt) {
+    var fn = formatter(fmt);
+    var str = fn.apply(null, Array.prototype.slice.call(arguments, 1));
+    return str;
   }
 
-  function initializeArray(arr, init) {
-    for (var i=0, len=arr.length; i<len; i++) {
-      arr[i] = init;
+  function formatValue(val, matches) {
+    var flags = matches[1];
+    var padding = matches[2];
+    var decimals = matches[3] ? parseInt(matches[3].substr(1)) : void 0;
+    var type = matches[4];
+    var isString = type == 's',
+        isHex = type == 'x' || type == 'X',
+        // isInt = type == 'd' || type == 'i',
+        // isFloat = type == 'f',
+        isNumber = !isString;
+
+    var sign = "",
+        padDigits = 0,
+        isZero = false,
+        isNeg = false;
+
+    var str, padChar, padStr;
+    if (isString) {
+      str = String(val);
+    }
+    else if (isHex) {
+      str = val.toString(16);
+      if (type == 'X')
+        str = str.toUpperCase();
+    }
+    else if (isNumber) {
+      // str = formatNumberForDisplay(val, isInt ? 0 : decimals);
+      str = numToStr(val, decimals);
+      if (str[0] == '-') {
+        isNeg = true;
+        str = str.substr(1);
+      }
+      isZero = parseFloat(str) == 0;
+      if (flags.indexOf("'") != -1 || flags.indexOf(',') != -1) {
+        str = addThousandsSep(str);
+      }
+      if (!isZero) { // BUG: sign is added when num rounds to 0
+        if (isNeg) {
+          sign = "\u2212"; // U+2212
+        } else if (flags.indexOf('+') != -1) {
+          sign = '+';
+        }
+      }
     }
-    return arr;
-  }
 
-  function replaceArray(arr, arr2) {
-    arr.splice(0, arr.length);
-    for (var i=0, n=arr2.length; i<n; i++) {
-      arr.push(arr2[i]);
+    if (padding) {
+      var strLen = str.length + sign.length;
+      var minWidth = parseInt(padding, 10);
+      if (strLen < minWidth) {
+        padDigits = minWidth - strLen;
+        padChar = flags.indexOf('0') == -1 ? ' ' : '0';
+        padStr = repeatString(padChar, padDigits);
+      }
     }
-  }
 
-  function repeatString(src, n) {
-    var str = "";
-    for (var i=0; i<n; i++)
-      str += src;
+    if (padDigits == 0) {
+      str = sign + str;
+    } else if (padChar == '0') {
+      str = sign + padStr + str;
+    } else {
+      str = padStr + sign + str;
+    }
     return str;
   }
 
-  function splitLines(str) {
-    return str.split(/\r?\n/);
-  }
-
-  function pluralSuffix(count) {
-    return count != 1 ? 's' : '';
-  }
+  // Get a function for interpolating formatted values into a string.
+  function formatter(fmt) {
+    var codeRxp = /%([',+0]*)([1-9]?)((?:\.[1-9])?)([sdifxX%])/g;
+    var literals = [],
+        formatCodes = [],
+        startIdx = 0,
+        prefix = "",
+        matches = codeRxp.exec(fmt),
+        literal;
 
-  function endsWith(str, ending) {
-      return str.indexOf(ending, str.length - ending.length) !== -1;
-  }
+    while (matches) {
+      literal = fmt.substring(startIdx, codeRxp.lastIndex - matches[0].length);
+      if (matches[0] == '%%') {
+        prefix += literal + '%';
+      } else {
+        literals.push(prefix + literal);
+        prefix = '';
+        formatCodes.push(matches);
+      }
+      startIdx = codeRxp.lastIndex;
+      matches = codeRxp.exec(fmt);
+    }
+    literals.push(prefix + fmt.substr(startIdx));
 
-  function lpad(str, size, pad) {
-    pad = pad || ' ';
-    str = String(str);
-    return repeatString(pad, size - str.length) + str;
+    return function() {
+      var str = literals[0],
+          n = arguments.length;
+      if (n != formatCodes.length) {
+        error$1("[format()] Data does not match format string; format:", fmt, "data:", arguments);
+      }
+      for (var i=0; i<n; i++) {
+        str += formatValue(arguments[i], formatCodes[i]) + literals[i+1];
+      }
+      return str;
+    };
   }
 
-  function rpad(str, size, pad) {
-    pad = pad || ' ';
-    str = String(str);
-    return str + repeatString(pad, size - str.length);
+  function wildcardToRegExp(name) {
+    var rxp = name.split('*').map(function(str) {
+      return regexEscape(str);
+    }).join('.*');
+    return new RegExp('^' + rxp + '$');
   }
 
-  function trim(str) {
-    return ltrim(rtrim(str));
+  function createBuffer(arg, arg2) {
+    if (isInteger(arg)) {
+      return B.allocUnsafe ? B.allocUnsafe(arg) : new B(arg);
+    } else {
+      // check allocUnsafe to make sure Buffer.from() will accept strings (it didn't before Node v5.10)
+      return B.from && B.allocUnsafe ? B.from(arg, arg2) : new B(arg, arg2);
+    }
   }
 
-  var ltrimRxp = /^\s+/;
-  function ltrim(str) {
-    return str.replace(ltrimRxp, '');
+  function toBuffer(src) {
+    if (src instanceof B) return src;
+    if (src instanceof ArrayBuffer) return B.from(src);
+    if (src instanceof Uint8Array) {
+      return B.from(src.buffer, src.byteOffset, src.byteLength);
+    }
+    error$1('Unexpected argument type');
   }
 
-  var rtrimRxp = /\s+$/;
-  function rtrim(str) {
-    return str.replace(rtrimRxp, '');
+  function expandoBuffer(constructor, rate) {
+    var capacity = 0,
+        k = rate >= 1 ? rate : 1.2,
+        buf;
+    return function(size) {
+      if (size > capacity) {
+        capacity = Math.ceil(size * k);
+        buf = constructor ? new constructor(capacity) : createBuffer(capacity);
+      }
+      return buf;
+    };
   }
 
-  function addThousandsSep(str) {
-    var fmt = '',
-        start = str[0] == '-' ? 1 : 0,
-        dec = str.indexOf('.'),
-        end = str.length,
-        ins = (dec == -1 ? end : dec) - 3;
-    while (ins > start) {
-      fmt = ',' + str.substring(ins, end) + fmt;
-      end = ins;
-      ins -= 3;
+  function copyElements(src, i, dest, j, n, rev) {
+    var same = src == dest || src.buffer && src.buffer == dest.buffer;
+    var inc = 1,
+        offs = 0,
+        k;
+    if (rev) {
+      if (same) error$1('copy error');
+      inc = -1;
+      offs = n - 1;
+    }
+    if (same && j > i) {
+      for (k=n-1; k>=0; k--) {
+        dest[j + k] = src[i + k];
+      }
+    } else {
+      for (k=0; k<n; k++, offs += inc) {
+        dest[k + j] = src[i + offs];
+      }
     }
-    return str.substring(0, end) + fmt;
-  }
-
-  function numToStr(num, decimals) {
-    return decimals >= 0 ? num.toFixed(decimals) : String(num);
   }
 
-  function formatNumber(val) {
-    return val + '';
+  function extendBuffer(src, newLen, copyLen) {
+    var len = Math.max(src.length, newLen);
+    var n = copyLen || src.length;
+    var dest = new src.constructor(len);
+    copyElements(src, 0, dest, 0, n);
+    return dest;
   }
 
-  function formatIntlNumber(val) {
-    var str = formatNumber(val);
-    return '"' + str.replace('.', ',') + '"'; // need to quote if comma-delimited
+  function mergeNames(name1, name2) {
+    var merged;
+    if (name1 && name2) {
+      merged = findStringPrefix(name1, name2).replace(/[-_]$/, '');
+    }
+    return merged || '';
   }
 
-  function formatNumberForDisplay(num, decimals, nullStr, showPos) {
-    var fmt;
-    if (isNaN(num)) {
-      fmt = nullStr || '-';
-    } else {
-      fmt = numToStr(num, decimals);
-      fmt = addThousandsSep(fmt);
-      if (showPos && parseFloat(fmt) > 0) {
-        fmt = "+" + fmt;
-      }
+  function findStringPrefix(a, b) {
+    var i = 0;
+    for (var n=a.length; i<n; i++) {
+      if (a[i] !== b[i]) break;
     }
-    return fmt;
+    return a.substr(0, i);
   }
 
-  function shuffle(arr) {
-    var tmp, i, j;
-    for (i = arr.length - 1; i > 0; i--) {
-      j = Math.floor(Math.random() * (i + 1));
-      tmp = arr[i];
-      arr[i] = arr[j];
-      arr[j] = tmp;
+  function formatVersionedName(name, i) {
+    var suffix = String(i);
+    if (/[0-9]$/.test(name)) {
+      suffix = '-' + suffix;
     }
+    return name + suffix;
   }
 
-  function pickOne(arr) {
-    return arr[Math.floor(Math.random() * arr.length)];
-  }
+  function uniqifyNames(names, formatter) {
+    var counts = countValues(names),
+        format = formatter || formatVersionedName,
+        names2 = [];
 
-  // Sort an array of objects based on one or more properties.
-  // Usage: sortOn(array, key1, asc?[, key2, asc? ...])
-  //
-  function sortOn(arr) {
-    var comparators = [];
-    for (var i=1; i<arguments.length; i+=2) {
-      comparators.push(getKeyComparator(arguments[i], arguments[i+1]));
-    }
-    arr.sort(function(a, b) {
-      var cmp = 0,
-          i = 0,
-          n = comparators.length;
-      while (i < n && cmp === 0) {
-        cmp = comparators[i](a, b);
+    names.forEach(function(name) {
+      var i = 0,
+          candidate = name,
+          versionedName;
+      while (
+          names2.indexOf(candidate) > -1 || // candidate name has already been used
+          candidate == name && counts[candidate] > 1 || // duplicate unversioned names
+          candidate != name && counts[candidate] > 0) { // versioned name is a preexisting name
         i++;
+        versionedName = format(name, i);
+        if (!versionedName || versionedName == candidate) {
+          throw new Error("Naming error"); // catch buggy versioning function
+        }
+        candidate = versionedName;
       }
-      return cmp;
+      names2.push(candidate);
     });
-    return arr;
+    return names2;
   }
 
-  // Sort array of values that can be compared with < > operators (strings, numbers)
-  // null, undefined and NaN are sorted to the end of the array
-  // default order is ascending
-  //
-  function genericSort(arr, ascending) {
-    var compare = getGenericComparator(ascending);
-    Array.prototype.sort.call(arr, compare);
-    return arr;
-  }
 
-  function getSortedIds(arr, asc) {
-    var ids = range(arr.length);
-    sortArrayIndex(ids, arr, asc);
-    return ids;
+  // Assume: @raw is string, undefined or null
+  function parseString(raw) {
+    return raw ? raw : "";
   }
 
-  function sortArrayIndex(ids, arr, asc) {
-    var compare = getGenericComparator(asc);
-    ids.sort(function(i, j) {
-      // added i, j comparison to guarantee that sort is stable
-      var cmp = compare(arr[i], arr[j]);
-      return cmp > 0 || cmp === 0 && i > j ? 1 : -1;
-    });
+  // Assume: @raw is string, undefined or null
+  // 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) {
+    return parseToNum(raw, cleanNumericString);
   }
 
-  function reorderArray(arr, idxs) {
-    var len = idxs.length;
-    var arr2 = [];
-    for (var i=0; i<len; i++) {
-      var idx = idxs[i];
-      if (idx < 0 || idx >= len) error("Out-of-bounds array idx");
-      arr2[i] = arr[idx];
-    }
-    replaceArray(arr, arr2);
+  function parseIntlNumber(raw) {
+    return parseToNum(raw, convertIntlNumString);
   }
 
-  function getKeyComparator(key, asc) {
-    var compare = getGenericComparator(asc);
-    return function(a, b) {
-      return compare(a[key], b[key]);
-    };
+  function parseToNum(raw, clean) {
+    var str = String(raw).trim();
+    var parsed = str ? Number(clean(str)) : NaN;
+    return isNaN(parsed) ? null : parsed;
   }
 
-  function getGenericComparator(asc) {
-    asc = asc !== false && asc != 'descending'; // ascending is the default
-    return function(a, b) {
-      var retn = 0;
-      if (b == null) {
-        retn = a == null ? 0 : -1;
-      } else if (a == null) {
-        retn = 1;
-      } else if (a < b) {
-        retn = asc ? -1 : 1;
-      } else if (a > b) {
-        retn = asc ? 1 : -1;
-      } else if (a !== a) {
-        retn = 1;
-      } else if (b !== b) {
-        retn = -1;
-      }
-      return retn;
-    };
+  // Remove comma separators from strings
+  function cleanNumericString(str) {
+    return (str.indexOf(',') > 0) ? str.replace(/,([0-9]{3})/g, '$1') : str;
   }
 
-
-  // Generic in-place sort (null, NaN, undefined not handled)
-  function quicksort(arr, asc) {
-    quicksortPartition(arr, 0, arr.length-1);
-    if (asc === false) Array.prototype.reverse.call(arr); // Works with typed arrays
-    return arr;
+  function convertIntlNumString(str) {
+    str = str.replace(/[ .]([0-9]{3})/g, '$1');
+    return str.replace(',', '.');
   }
 
-  // Moved out of quicksort() (saw >100% speedup in Chrome with deep recursion)
-  function quicksortPartition (a, lo, hi) {
-    var i = lo,
-        j = hi,
-        pivot, tmp;
-    while (i < hi) {
-      pivot = a[lo + hi >> 1]; // avoid n^2 performance on sorted arrays
-      while (i <= j) {
-        while (a[i] < pivot) i++;
-        while (a[j] > pivot) j--;
-        if (i <= j) {
-          tmp = a[i];
-          a[i] = a[j];
-          a[j] = tmp;
-          i++;
-          j--;
-        }
+  function trimQuotes(str) {
+    var len = str.length, first, last;
+    if (len >= 2) {
+      first = str.charAt(0);
+      last = str.charAt(len-1);
+      // if (first == '"' && last == '"' && !str.includes('","') ||
+      //     first == "'" && last == "'" && !str.includes("','")) {
+      // don't strip if there are unescaped quotes
+      // e.g. expressions that start and end with quotes
+      // e.g. comma-separated list of quoted values
+      if (first == '"' && last == '"' && !/[^\\]"./.test(str) ||
+          first == "'" && last == "'" && !/[^\\]'./.test(str)) {
+        str = str.substr(1, len-2);
+        // remove string escapes
+        str = str.replace(first == '"' ? /\\(?=")/g : /\\(?=')/g, '');
       }
-      if (lo < j) quicksortPartition(a, lo, j);
-      lo = i;
-      j = hi;
-    }
-  }
-
-
-  function findRankByValue(arr, value) {
-    if (isNaN(value)) return arr.length;
-    var rank = 1;
-    for (var i=0, n=arr.length; i<n; i++) {
-      if (value > arr[i]) rank++;
     }
-    return rank;
+    return str;
   }
 
-  function findValueByPct(arr, pct) {
-    var rank = Math.ceil((1-pct) * (arr.length));
-    return findValueByRank(arr, rank);
-  }
+  // Default export so consumers can do `import utils from './mapshaper-utils'`
+  // and call `utils.isObject(x)` etc. Listing the names explicitly (instead
+  // of using `import * as utils from './mapshaper-utils'`) avoids a
+  // self-import and the resulting Rollup circular-dependency warning.
+  var utils = {
+    addThousandsSep, addslashes, arrayToIndex,
+    clamp, cleanNumericString, contains, copyElements, countValues, createBuffer,
+    defaults, difference,
+    endsWith, every, expandoBuffer, extend, extendBuffer,
+    find, findMedian, findQuantile, findRankByValue, findStringPrefix,
+    findValueByPct, findValueByRank, forEach, forEachProperty, format,
+    formatDateISO, formatIntlNumber, formatNumber, formatNumberForDisplay,
+    formatVersionedName, formatter,
+    genericSort, getArrayBounds, getGenericComparator, getKeyComparator,
+    getSortedIds, getUniqueName, groupBy,
+    htmlEscape,
+    indexOf, indexOn, inherit, initializeArray, intersection,
+    isArray, isArrayLike, isBoolean, isDate, isEven, isFiniteNumber, isFunction,
+    isInteger, isNonNegNumber, isNumber, isObject, isOdd, isPromise, isString,
+    isValidNumber,
+    lpad, ltrim,
+    mean, merge, mergeNames,
+    numToStr,
+    parseIntlNumber, parseNumber, parseString, pickOne, pluck,
+    pluralSuffix, promisify,
+    quicksort, quicksortPartition,
+    range, reduceAsync, regexEscape, reorderArray, repeat, repeatString,
+    replaceArray, rpad, rtrim,
+    shuffle, some, sortArrayIndex, sortOn, splitLines, sum,
+    toArray, toBuffer, trim, trimQuotes,
+    uniq, uniqifyNames,
+    wildcardToRegExp
+  };
 
-  // See http://ndevilla.free.fr/median/median/src/wirth.c
-  // Elements of @arr are reordered
+  // This module provides a way for multiple jobs to run together asynchronously
+  // while keeping job-level context variables (like "defs") separate.
   //
-  function findValueByRank(arr, rank) {
-    if (!arr.length || rank < 1 || rank > arr.length) error("[findValueByRank()] invalid input");
+  // We deliberately do NOT import from mapshaper-logging here -- the logging
+  // module imports from this one, and avoiding the back-edge keeps the
+  // foundational dependency graph acyclic. (The single error path below is
+  // an internal-bug guard, not a user-facing message, so a plain Error is
+  // adequate.)
 
-    rank = clamp(rank | 0, 1, arr.length);
-    var k = rank - 1, // conv. rank to array index
-        n = arr.length,
-        l = 0,
-        m = n - 1,
-        i, j, val, tmp;
+  var stash = {};
 
-    while (l < m) {
-      val = arr[k];
-      i = l;
-      j = m;
-      do {
-        while (arr[i] < val) {i++;}
-        while (val < arr[j]) {j--;}
-        if (i <= j) {
-          tmp = arr[i];
-          arr[i] = arr[j];
-          arr[j] = tmp;
-          i++;
-          j--;
-        }
-      } while (i <= j);
-      if (j < k) l = i;
-      if (k < i) m = j;
+  function stashVar(key, val) {
+    if (key in stash) {
+      throw new Error('Tried to replace a stashed variable: ' + key);
     }
-    return arr[k];
+    stash[key] = val;
   }
 
-  function findMedian(arr) {
-    return findQuantile(arr, 0.5);
+  function getStashedVar(key) {
+    if (key in stash === false) {
+      return undefined; // to support running commands in tests
+      // error('Tried to read a nonexistent variable from the stash:', key);
+    }
+    return stash[key];
   }
 
-  function findQuantile(arr, k) {
-    var n = arr.length,
-        i1 = Math.floor((n - 1) * k),
-        i2 = Math.ceil((n - 1) * k);
-    if (i1 < 0 || i2 >= n) return NaN;
-    var v1 = findValueByRank(arr, i1 + 1);
-    if (i1 == i2) return v1;
-    var v2 = findValueByRank(arr, i2 + 1);
-    // use linear interpolation
-    var w1 = i2 / (n - 1) - k;
-    var w2 = k - i1 / (n - 1);
-    var v = (v1 * w1 + v2 * w2) * (n - 1);
-    return v;
+  function clearStash() {
+    stash = {};
   }
 
-  function mean(arr) {
-    var count = 0,
-        avg = NaN,
-        val;
-    for (var i=0, n=arr.length; i<n; i++) {
-      val = arr[i];
-      if (isNaN(val)) continue;
-      avg = ++count == 1 ? val : val / count + (count - 1) / count * avg;
-    }
-    return avg;
+  var LOGGING = false;
+  var STDOUT = false; // use stdout for status messages
+  var _error, _stop, _message, _warn;
+
+  var _interrupt = function() {
+    throw new NonFatalError(formatLogArgs(arguments));
+  };
+
+  var onceMessages = [];
+
+  setLoggingForCLI();
+
+  function getLoggingSetter() {
+    var e = _error, s = _stop, m = _message, w = _warn;
+    return function() {
+      setLoggingFunctions(m, e, s, w);
+    };
   }
 
+  function setLoggingForCLI() {
+    function stop() {
+      throw new UserError(formatLogArgs(arguments));
+    }
 
-  /*
-  A simplified version of printf formatting
-  Format codes: %[flags][width][.precision]type
+    function error() {
+      var msg = utils.toArray(arguments).join(' ');
+      throw new Error(msg);
+    }
 
-  supported flags:
-    +   add '+' before positive numbers
-    0   left-pad with '0'
-    '   Add thousands separator
-  width: 1 to many
-  precision: .(1 to many)
-  type:
-    s     string
-    di    integers
-    f     decimal numbers
-    xX    hexidecimal (unsigned)
-    %     literal '%'
+    function message() {
+      logArgs(arguments);
+    }
 
-  Examples:
-    code    val    formatted
-    %+d     1      '+1'
-    %4i     32     '  32'
-    %04i    32     '0032'
-    %x      255    'ff'
-    %.2f    0.125  '0.13'
-    %'f     1000   '1,000'
-  */
+    // CLI warning is just a message (GUI behaves differently)
+    var warn = message;
 
-  // Usage: format(formatString, [values])
-  // Tip: When reusing the same format many times, use formatter() for 5x - 10x better performance
-  //
-  function format(fmt) {
-    var fn = formatter(fmt);
-    var str = fn.apply(null, Array.prototype.slice.call(arguments, 1));
-    return str;
+    setLoggingFunctions(message, error, stop, warn);
   }
 
-  function formatValue(val, matches) {
-    var flags = matches[1];
-    var padding = matches[2];
-    var decimals = matches[3] ? parseInt(matches[3].substr(1)) : void 0;
-    var type = matches[4];
-    var isString = type == 's',
-        isHex = type == 'x' || type == 'X',
-        // isInt = type == 'd' || type == 'i',
-        // isFloat = type == 'f',
-        isNumber = !isString;
+  function enableLogging() {
+    LOGGING = true;
+  }
 
-    var sign = "",
-        padDigits = 0,
-        isZero = false,
-        isNeg = false;
+  function disableLogging() {
+    LOGGING = false;
+  }
 
-    var str, padChar, padStr;
-    if (isString) {
-      str = String(val);
-    }
-    else if (isHex) {
-      str = val.toString(16);
-      if (type == 'X')
-        str = str.toUpperCase();
-    }
-    else if (isNumber) {
-      // str = formatNumberForDisplay(val, isInt ? 0 : decimals);
-      str = numToStr(val, decimals);
-      if (str[0] == '-') {
-        isNeg = true;
-        str = str.substr(1);
-      }
-      isZero = parseFloat(str) == 0;
-      if (flags.indexOf("'") != -1 || flags.indexOf(',') != -1) {
-        str = addThousandsSep(str);
-      }
-      if (!isZero) { // BUG: sign is added when num rounds to 0
-        if (isNeg) {
-          sign = "\u2212"; // U+2212
-        } else if (flags.indexOf('+') != -1) {
-          sign = '+';
-        }
-      }
-    }
+  function loggingEnabled() {
+    return !!LOGGING;
+  }
 
-    if (padding) {
-      var strLen = str.length + sign.length;
-      var minWidth = parseInt(padding, 10);
-      if (strLen < minWidth) {
-        padDigits = minWidth - strLen;
-        padChar = flags.indexOf('0') == -1 ? ' ' : '0';
-        padStr = repeatString(padChar, padDigits);
-      }
-    }
+  // Handle an unexpected condition (internal error)
+  function error() {
+    _error.apply(null, utils.toArray(arguments));
+  }
 
-    if (padDigits == 0) {
-      str = sign + str;
-    } else if (padChar == '0') {
-      str = sign + padStr + str;
-    } else {
-      str = padStr + sign + str;
-    }
-    return str;
+  // Handle an error caused by invalid input or misuse of API
+  function stop() {
+    // _stop.apply(null, utils.toArray(arguments));
+    _stop.apply(null, messageArgs(arguments));
   }
 
-  // Get a function for interpolating formatted values into a string.
-  function formatter(fmt) {
-    var codeRxp = /%([',+0]*)([1-9]?)((?:\.[1-9])?)([sdifxX%])/g;
-    var literals = [],
-        formatCodes = [],
-        startIdx = 0,
-        prefix = "",
-        matches = codeRxp.exec(fmt),
-        literal;
+  function interrupt() {
+    _interrupt.apply(null, utils.toArray(arguments));
+  }
 
-    while (matches) {
-      literal = fmt.substring(startIdx, codeRxp.lastIndex - matches[0].length);
-      if (matches[0] == '%%') {
-        prefix += literal + '%';
-      } else {
-        literals.push(prefix + literal);
-        prefix = '';
-        formatCodes.push(matches);
-      }
-      startIdx = codeRxp.lastIndex;
-      matches = codeRxp.exec(fmt);
-    }
-    literals.push(prefix + fmt.substr(startIdx));
+  // Print a status message
+  function message() {
+    _message.apply(null, messageArgs(arguments));
+  }
 
-    return function() {
-      var str = literals[0],
-          n = arguments.length;
-      if (n != formatCodes.length) {
-        error("[format()] Data does not match format string; format:", fmt, "data:", arguments);
-      }
-      for (var i=0; i<n; i++) {
-        str += formatValue(arguments[i], formatCodes[i]) + literals[i+1];
-      }
-      return str;
-    };
+  function warn() {
+    _warn.apply(null, messageArgs(arguments));
   }
 
-  function wildcardToRegExp(name) {
-    var rxp = name.split('*').map(function(str) {
-      return regexEscape(str);
-    }).join('.*');
-    return new RegExp('^' + rxp + '$');
+  function warnOnce() {
+    var str = formatLogArgs(arguments);
+    if (onceMessages.includes(str)) return;
+    onceMessages.push(str);
+    _warn.apply(null, messageArgs(arguments));
   }
 
-  function createBuffer(arg, arg2) {
-    if (isInteger(arg)) {
-      return B.allocUnsafe ? B.allocUnsafe(arg) : new B(arg);
-    } else {
-      // check allocUnsafe to make sure Buffer.from() will accept strings (it didn't before Node v5.10)
-      return B.from && B.allocUnsafe ? B.from(arg, arg2) : new B(arg, arg2);
-    }
+  // A way for the GUI to replace the CLI logging functions
+  function setLoggingFunctions(message, error, stop, warn) {
+    _message = message;
+    _error = error;
+    _stop = stop;
+    _warn = warn;
   }
 
-  function toBuffer(src) {
-    if (src instanceof B) return src;
-    if (src instanceof ArrayBuffer) return B.from(src);
-    if (src instanceof Uint8Array) {
-      return B.from(src.buffer, src.byteOffset, src.byteLength);
+  // get detailed error information from error stack (if available)
+  // Example stack string (Node.js):
+  /*
+  /Users/someuser/somescript.js:226
+      opacity: Math.round(weight * 5 / 5 // 0.2 0.4 0.6 etc
+                                       ^
+
+  SyntaxError: missing ) after argument list
+      at internalCompileFunction (node:internal/vm:73:18)
+      at wrapSafe (node:internal/modules/cjs/loader:1149:20)
+      at Module._compile (node:internal/modules/cjs/loader:1190:27)
+      ...
+  */
+  function getErrorDetail(e) {
+    var parts = (typeof e.stack == 'string') ? e.stack.split(/\n\s*\n/) : [];
+    if (parts.length > 1 || true) {
+      return '\nError details:\n' + parts[0];
     }
-    error('Unexpected argument type');
+    return '';
   }
 
-  function expandoBuffer(constructor, rate) {
-    var capacity = 0,
-        k = rate >= 1 ? rate : 1.2,
-        buf;
-    return function(size) {
-      if (size > capacity) {
-        capacity = Math.ceil(size * k);
-        buf = constructor ? new constructor(capacity) : createBuffer(capacity);
-      }
-      return buf;
-    };
+  // print a message to stdout
+  function print() {
+    STDOUT = true; // tell logArgs() to print to stdout, not stderr
+    // calling message() adds the "[command name]" prefix
+    _message(utils.toArray(arguments));
+    STDOUT = false;
   }
 
-  function copyElements(src, i, dest, j, n, rev) {
-    var same = src == dest || src.buffer && src.buffer == dest.buffer;
-    var inc = 1,
-        offs = 0,
-        k;
-    if (rev) {
-      if (same) error('copy error');
-      inc = -1;
-      offs = n - 1;
-    }
-    if (same && j > i) {
-      for (k=n-1; k>=0; k--) {
-        dest[j + k] = src[i + k];
-      }
-    } else {
-      for (k=0; k<n; k++, offs += inc) {
-        dest[k + j] = src[i + offs];
-      }
+  function verbose() {
+    // verbose can be set globally with the -verbose command or separately for each command
+    if (useVerbose()) {
+      message.apply(null, arguments);
     }
   }
 
-  function extendBuffer(src, newLen, copyLen) {
-    var len = Math.max(src.length, newLen);
-    var n = copyLen || src.length;
-    var dest = new src.constructor(len);
-    copyElements(src, 0, dest, 0, n);
-    return dest;
+  function useVerbose() {
+    return getStashedVar('VERBOSE');
   }
 
-  function mergeNames(name1, name2) {
-    var merged;
-    if (name1 && name2) {
-      merged = findStringPrefix(name1, name2).replace(/[-_]$/, '');
-    }
-    return merged || '';
+  function useDebug() {
+    return getStashedVar('DEBUG');
   }
 
-  function findStringPrefix(a, b) {
-    var i = 0;
-    for (var n=a.length; i<n; i++) {
-      if (a[i] !== b[i]) break;
+  function debug() {
+    if (useDebug()) {
+      logArgs(arguments);
     }
-    return a.substr(0, i);
   }
 
-  function parsePercent(o) {
-    var str = String(o);
-    var isPct = str.indexOf('%') > 0;
-    var pct;
-    if (isPct) {
-      pct = Number(str.replace('%', '')) / 100;
-    } else {
-      pct = Number(str);
-    }
-    if (!(pct >= 0 && pct <= 1)) {
-      stop(format("Invalid percentage: %s", str));
+  function time(slug) {
+    if (useDebug()) {
+      console.time(slug);
     }
-    return pct;
   }
 
-  function formatVersionedName(name, i) {
-    var suffix = String(i);
-    if (/[0-9]$/.test(name)) {
-      suffix = '-' + suffix;
+  function timeEnd(slug) {
+    if (useDebug()) {
+      console.timeEnd(slug);
     }
-    return name + suffix;
   }
 
-  function uniqifyNames(names, formatter) {
-    var counts = countValues(names),
-        format = formatter || formatVersionedName,
-        names2 = [];
-
-    names.forEach(function(name) {
-      var i = 0,
-          candidate = name,
-          versionedName;
-      while (
-          names2.indexOf(candidate) > -1 || // candidate name has already been used
-          candidate == name && counts[candidate] > 1 || // duplicate unversioned names
-          candidate != name && counts[candidate] > 0) { // versioned name is a preexisting name
-        i++;
-        versionedName = format(name, i);
-        if (!versionedName || versionedName == candidate) {
-          throw new Error("Naming error"); // catch buggy versioning function
-        }
-        candidate = versionedName;
+  function printError(err) {
+    var msg;
+    if (!LOGGING) return;
+    if (utils.isString(err)) {
+      err = new UserError(err);
+    }
+    if (err.name == 'NonFatalError') {
+      console.error(messageArgs([err.message]).join(' '));
+    } else if (err.name == 'UserError') {
+      msg = err.message;
+      if (!/Error/.test(msg)) {
+        msg = "Error: " + msg;
       }
-      names2.push(candidate);
-    });
-    return names2;
+      console.error(messageArgs([msg]).join(' '));
+      console.error("Run mapshaper -h to view help");
+    } else {
+      // not a user error (i.e. a bug in mapshaper)
+      console.error(err);
+      // throw err;
+    }
   }
 
+  function UserError(msg) {
+    var err = new Error(msg);
+    err.name = 'UserError';
+    return err;
+  }
 
-  // Assume: @raw is string, undefined or null
-  function parseString(raw) {
-    return raw ? raw : "";
+  function NonFatalError(msg) {
+    var err = new Error(msg);
+    err.name = 'NonFatalError';
+    return err;
   }
 
-  // Assume: @raw is string, undefined or null
-  // 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) {
-    return parseToNum(raw, cleanNumericString);
+  function formatColumns(arr, alignments) {
+    var widths = arr.reduce(function(memo, line) {
+      return line.map(function(str, i) {
+        return memo ? Math.max(memo[i], str.length) : str.length;
+      });
+    }, null);
+    return arr.map(function(line) {
+      line = line.map(function(str, i) {
+        var rt = alignments && alignments[i] == 'right';
+        var pad = (rt ? str.padStart : str.padEnd).bind(str);
+        return pad(widths[i], ' ');
+      });
+      return '  ' + line.join(' ');
+    }).join('\n');
   }
 
-  function parseIntlNumber(raw) {
-    return parseToNum(raw, convertIntlNumString);
+  // Format an array of (preferably short) strings in columns for console logging.
+  function formatStringsAsGrid(arr, width) {
+    // TODO: variable column width
+    var longest = arr.reduce(function(len, str) {
+          return Math.max(len, str.length);
+        }, 0),
+        colWidth = longest + 2,
+        perLine = Math.floor((width || 80) / colWidth) || 1;
+    return arr.reduce(function(memo, name, i) {
+      var col = i % perLine;
+      if (i > 0 && col === 0) memo += '\n';
+      if (col < perLine - 1) { // right-pad all but rightmost column
+        name = utils.rpad(name, colWidth - 2, ' ');
+      }
+      return memo +  '  ' + name;
+    }, '');
   }
 
-  function parseToNum(raw, clean) {
-    var str = String(raw).trim();
-    var parsed = str ? Number(clean(str)) : NaN;
-    return isNaN(parsed) ? null : parsed;
+  // expose so GUI can use it
+  function formatLogArgs(args) {
+    return utils.toArray(args).join(' ');
   }
 
-  // Remove comma separators from strings
-  function cleanNumericString(str) {
-    return (str.indexOf(',') > 0) ? str.replace(/,([0-9]{3})/g, '$1') : str;
+  function messageArgs(args) {
+    var arr = utils.toArray(args);
+    var cmd = getStashedVar('current_command');
+    if (cmd && cmd != 'help') {
+      arr.unshift('[' + cmd + ']');
+    }
+    return arr;
   }
 
-  function convertIntlNumString(str) {
-    str = str.replace(/[ .]([0-9]{3})/g, '$1');
-    return str.replace(',', '.');
+  function logArgs(args) {
+    if (!LOGGING || getStashedVar('QUIET') || !utils.isArrayLike(args)) return;
+    var msg = formatLogArgs(args);
+    if (STDOUT) console.log(msg);
+    else console.error(msg);
   }
 
-  function trimQuotes(str) {
-    var len = str.length, first, last;
-    if (len >= 2) {
-      first = str.charAt(0);
-      last = str.charAt(len-1);
-      // if (first == '"' && last == '"' && !str.includes('","') ||
-      //     first == "'" && last == "'" && !str.includes("','")) {
-      // don't strip if there are unescaped quotes
-      // e.g. expressions that start and end with quotes
-      // e.g. comma-separated list of quoted values
-      if (first == '"' && last == '"' && !/[^\\]"./.test(str) ||
-          first == "'" && last == "'" && !/[^\\]'./.test(str)) {
-        str = str.substr(1, len-2);
-        // remove string escapes
-        str = str.replace(first == '"' ? /\\(?=")/g : /\\(?=')/g, '');
-      }
+  function truncateString(str, maxLen) {
+    maxLen = maxLen || 80;
+    if (str.length > maxLen) {
+      str = str.substring(0, maxLen - 3).trimEnd() + '...';
     }
     return str;
   }
@@ -8415,7 +8578,7 @@
     } else if (geoType == 'polygon') {
       test = polygonTest;
     } else {
-      error$1("Unexpected geometry type:", geoType);
+      error$2("Unexpected geometry type:", geoType);
     }
     return test;
 
@@ -11091,7 +11254,7 @@
     hit.on('drag', function(e) {
       if (!labelSelected(e) || activeId == -1) return;
       if (e.id != activeId) {
-        error$1("Mismatched hit ids:", e.id, activeId);
+        error$2("Mismatched hit ids:", e.id, activeId);
       }
       var scale = ext.getSymbolScale() || 1;
       var symNode, textNode;
@@ -13467,9 +13630,12 @@
     //   is noticeably slower during animations with multiple canvases.
     // Highlights are drawn on a separate canvas while hovering, because this
     //   is generally faster than redrawing all of the shapes.
+    // Fast-nav forces the same path: _mainCanv has a CSS transform but stale
+    //   pixels, so painting on it would visually go through that transform a
+    //   second time and detach the highlight from its feature.
     this.drawOverlayLayers = function(layers, action) {
       var canv;
-      if (action == 'hover') {
+      if (action == 'hover' || _fastActive) {
         canv = _overlayCanv;
         _overlayCanv.prep(_ext);
       } else {
@@ -14649,7 +14815,7 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
           ]
         });
       } else {
-        error$1('unsupported map style:', style);
+        error$2('unsupported map style:', style);
       }
     }
 
@@ -14876,6 +15042,200 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
     };
   }
 
+  // Passive "Messages" inbox: a non-blocking alternative to modal alerts for
+  // status messages and warnings. Backed by a header button (the envelope icon)
+  // in #mode-buttons and a popup-dialog panel.
+  //
+  // Public API (attached to the gui instance):
+  //   gui.notify({severity, body, title?, dedupKey?})   add an entry
+  //   gui.notify(message)                                shorthand: info severity
+  //
+  // severity is one of 'info' | 'warn' | 'error' (default 'info').
+  // If dedupKey is given and an entry with the same key already exists, the
+  // existing entry's count is incremented and its timestamp updated instead of
+  // adding a new row -- handy for repeated CLI warnings.
+
+
+  var SEVERITIES = {info: true, warn: true, error: true};
+  var PULSE_DURATION_MS = 1900; // matches the CSS animation total runtime
+
+  function MessageControl(gui) {
+    var btn = gui.container.findChild('.messages-btn');
+    var badge = btn.findChild('.messages-badge');
+    var panel = gui.container.findChild('.messages-panel');
+    var listEl = panel.findChild('.messages-list');
+    var emptyEl = panel.findChild('.messages-empty');
+    var clearBtn = new SimpleButton(panel.findChild('.messages-clear-btn'));
+    var closeBtn = new SimpleButton(panel.findChild('.close2-btn'));
+    var entries = [];
+    var nextId = 1;
+    var pulseTimer = null;
+    var rendered = false;
+
+    // Start fully hidden until the first notification arrives, so the icon
+    // doesn't take up header space when there's nothing to show.
+    btn.addClass('hidden');
+    gui.addMode('messages', turnOn, turnOff, btn);
+
+    closeBtn.on('click', function() {
+      gui.clearMode();
+    });
+
+    clearBtn.on('click', function() {
+      if (entries.length === 0) return;
+      entries = [];
+      // Close the panel so the now-disabled envelope isn't holding open a
+      // panel the user can no longer dismiss with a header click.
+      gui.clearMode();
+      renderList();
+      updateBadge();
+    });
+
+    // Public API
+    gui.notify = function(opts) {
+      if (typeof opts == 'string') {
+        opts = {body: opts};
+      }
+      opts = opts || {};
+      var severity = SEVERITIES[opts.severity] ? opts.severity : 'info';
+      var body = opts.body == null ? '' : String(opts.body);
+      var title = opts.title || null;
+      if (!body && !title) return;
+
+      if (opts.dedupKey) {
+        for (var i = 0; i < entries.length; i++) {
+          if (entries[i].dedupKey === opts.dedupKey) {
+            entries[i].count = (entries[i].count || 1) + 1;
+            entries[i].time = new Date();
+            // Promote severity if a later occurrence is more severe.
+            if (severityRank(severity) > severityRank(entries[i].severity)) {
+              entries[i].severity = severity;
+            }
+            renderList();
+            pulseBadge();
+            return;
+          }
+        }
+      }
+
+      entries.unshift({
+        id: nextId++,
+        severity: severity,
+        title: title,
+        body: body,
+        count: 1,
+        time: new Date(),
+        dedupKey: opts.dedupKey || null
+      });
+      renderList();
+      updateBadge();
+      pulseBadge();
+
+      // Mirror to the JS console so power users still see a record even if they
+      // never open the panel. Use the matching console method per severity.
+      var rec = (title ? title + ': ' : '') + body;
+      if (severity === 'error') console.error(rec);
+      else if (severity === 'warn') console.warn(rec);
+      else if (typeof internal !== 'undefined' && internal.logArgs) {
+        internal.logArgs([rec]);
+      } else {
+        console.log(rec);
+      }
+    };
+
+    function severityRank(s) {
+      return s === 'error' ? 2 : s === 'warn' ? 1 : 0;
+    }
+
+    function turnOn() {
+      if (!rendered) renderList();
+      panel.show();
+    }
+
+    function turnOff() {
+      panel.hide();
+    }
+
+    function updateBadge() {
+      var n = entries.length;
+      var hasWarn = false;
+      var hasError = false;
+      for (var i = 0; i < entries.length; i++) {
+        if (entries[i].severity === 'error') hasError = true;
+        else if (entries[i].severity === 'warn') hasWarn = true;
+      }
+      badge.text(n > 99 ? '99+' : String(n));
+      badge.classed('hidden', n === 0);
+      badge.classed('warn', hasWarn && !hasError);
+      badge.classed('error', hasError);
+      btn.classed('hidden', n === 0);
+    }
+
+    function pulseBadge() {
+      btn.removeClass('pulse');
+      // Force reflow so removing+adding the class restarts the CSS animation.
+      void btn.node().offsetWidth;
+      btn.addClass('pulse');
+      if (pulseTimer) clearTimeout(pulseTimer);
+      pulseTimer = setTimeout(function() {
+        btn.removeClass('pulse');
+        pulseTimer = null;
+      }, PULSE_DURATION_MS);
+    }
+
+    function renderList() {
+      rendered = true;
+      listEl.empty();
+      if (entries.length === 0) {
+        emptyEl.show();
+        return;
+      }
+      emptyEl.hide();
+      for (var i = 0; i < entries.length; i++) {
+        listEl.node().appendChild(renderItem(entries[i]).node());
+      }
+    }
+
+    function renderItem(entry) {
+      var item = El('div').addClass('message-item').addClass('severity-' + entry.severity);
+      if (entry.title) {
+        El('span').addClass('message-title').text(entry.title).appendTo(item);
+      }
+      var bodyText = entry.body || '';
+      if (entry.count > 1) {
+        bodyText += '  (\u00d7' + entry.count + ')';
+      }
+      El('div').addClass('message-body').text(bodyText).appendTo(item);
+      El('span').addClass('message-time').text(formatTime(entry.time)).appendTo(item);
+      var dismiss = El('span').addClass('message-dismiss').attr('title', 'Dismiss').text('\u00d7').appendTo(item);
+      var entryId = entry.id;
+      dismiss.on('click', function(e) {
+        // Prevent the click from also triggering any panel-level handlers.
+        if (e && e.stopPropagation) e.stopPropagation();
+        entries = entries.filter(function(x) { return x.id !== entryId; });
+        // If we just dismissed the last entry, close the panel for the same
+        // reason as Clear all: the envelope will go disabled and the user
+        // wouldn't be able to dismiss the panel by clicking the header again.
+        if (entries.length === 0) gui.clearMode();
+        renderList();
+        updateBadge();
+      });
+      return item;
+    }
+
+    function formatTime(d) {
+      if (!(d instanceof Date)) return '';
+      var hh = String(d.getHours()).padStart(2, '0');
+      var mm = String(d.getMinutes()).padStart(2, '0');
+      return hh + ':' + mm;
+    }
+
+    return {
+      notify: gui.notify,
+      count: function() { return entries.length; }
+    };
+  }
+
   // import { ProjectOptions } from './gui-project-control';
 
 
@@ -14897,6 +15257,7 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
     gui.keyboard = new KeyboardEvents(gui);
     gui.buttons = new SidebarButtons(gui);
     gui.display = new DisplayOptions(gui);
+    gui.messages = new MessageControl(gui);
     gui.basemap = new Basemap(gui);
     gui.session = new SessionHistory(gui);
     gui.contextMenu = new ContextMenu();
@@ -14988,6 +15349,25 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
   // This is the entry point for bundling mapshaper's web UI
 
 
+  // Refresh detection for mapshaper-gui: if the previous incarnation of this
+  // tab set the 'navigating away' marker on pagehide, then this page load is a
+  // reload (not a fresh tab). Tell the server to cancel any pending /close,
+  // otherwise the server's grace window can race past while the new page is
+  // idle and terminate the process. sessionStorage is per-tab and survives a
+  // refresh, but is gone after a real close -- exactly the signal we need.
+  // This runs before onload to fire as early as possible in the page lifecycle.
+  if (typeof window !== 'undefined' &&
+      window.location.hostname === 'localhost' &&
+      window.sessionStorage &&
+      window.sessionStorage.getItem('mapshaper_navigating_away')) {
+    window.sessionStorage.removeItem('mapshaper_navigating_away');
+    if (navigator.sendBeacon) {
+      navigator.sendBeacon('/cancel-close');
+    } else {
+      try { fetch('/cancel-close', {method: 'GET', keepalive: true}); } catch (err) {}
+    }
+  }
+
   onload(function() {
     if (!GUI.browserIsSupported()) {
       El("#mshp-not-supported").show();
@@ -15031,10 +15411,9 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
         importOpts = getImportOpts(manifest),
         gui = new GuiInstance('body');
 
-    // TODO: re-enable the "blurb"
-    // if (manifest.blurb) {
-    //   El('#splash-screen-blurb').text(manifest.blurb);
-    // }
+    if (!importOpts.files?.length) {
+      El('body').removeClass('mapshaper-preload');
+    }
 
     new AlertControl(gui);
     new IntersectionControl(gui);
@@ -15056,12 +15435,23 @@ GUI and setting the size and crop of SVG output.</p><div><input type="text" clas
       }
     });
 
-    window.addEventListener('unload', function(e) {
-      if (window.location.hostname == 'localhost') {
-        // send termination signal for mapshaper-gui
-        var req = new XMLHttpRequest();
-        req.open('GET', '/close');
-        req.send();
+    // Send termination signal to mapshaper-gui when the tab is closed.
+    // Use 'pagehide' rather than 'unload' (the latter is increasingly suppressed
+    // by Chrome/Edge for bfcache reasons), and use sendBeacon / keepalive fetch
+    // because async XHR in the unload path is not guaranteed to be sent.
+    // The sessionStorage marker is the refresh-vs-close signal: if a new page
+    // loads in the same tab, it'll see the marker and send /cancel-close to
+    // abort the pending exit (see the top of this file).
+    window.addEventListener('pagehide', function(e) {
+      if (window.location.hostname != 'localhost') return;
+      if (e.persisted) return; // page is being cached, not actually closed
+      try { window.sessionStorage.setItem('mapshaper_navigating_away', '1'); } catch (err) {}
+      if (navigator.sendBeacon) {
+        navigator.sendBeacon('/close');
+      } else {
+        try {
+          fetch('/close', {method: 'GET', keepalive: true});
+        } catch (err) {}
       }
     });