mapshaper 0.6.101 → 0.6.103

package/www/mapshaper.js

@@ -67,6 +67,7 @@
     get formatIntlNumber () { return formatIntlNumber; },
     get formatNumberForDisplay () { return formatNumberForDisplay; },
     get shuffle () { return shuffle; },
+    get pickOne () { return pickOne; },
     get sortOn () { return sortOn; },
     get genericSort () { return genericSort; },
     get getSortedIds () { return getSortedIds; },
@@ -133,8 +134,24 @@
     clearStash: clearStash
   });
 
+  // Several dependencies are loaded via require()
+  var f;
+  if (typeof require == 'function') {
+    // Node.js context: native require() function
+    f = require;
+  } else if (typeof window == 'object' && window.modules) {
+    // running in web GUI
+    f = function(name) {
+      return window.modules[name];
+    };
+  } else {
+    // stub to avoid runtime error in a handful of tests
+    f = function() {};
+  }
+  var require$1 = f;
+
   // Fall back to browserify's Buffer polyfill
-  var B$3 = typeof Buffer != 'undefined' ? Buffer : require('buffer').Buffer;
+  var B$3 = typeof Buffer != 'undefined' ? Buffer : require$1('buffer').Buffer;
 
   var uniqCount = 0;
   function getUniqueName(prefix) {
@@ -267,6 +284,7 @@
     });
   }
 
+
   function defaults(dest) {
     for (var i=1, n=arguments.length; i<n; i++) {
       var src = arguments[i] || {};
@@ -683,6 +701,10 @@
     }
   }
 
+  function pickOne(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+  }
+
   // Sort an array of objects based on one or more properties.
   // Usage: sortOn(array, key1, asc?[, key2, asc? ...])
   //
@@ -1755,12 +1777,29 @@
     return count;
   }
 
+  // export function getPointBounds(shapes) {
+  //   var bounds = new Bounds();
+  //   forEachPoint(shapes, function(p) {
+  //     bounds.mergePoint(p[0], p[1]);
+  //   });
+  //   return bounds;
+  // }
+
   function getPointBounds$1(shapes) {
-    var bounds = new Bounds();
-    forEachPoint(shapes, function(p) {
-      bounds.mergePoint(p[0], p[1]);
-    });
-    return bounds;
+    new Bounds();
+    var shp, x, y, xmin = Infinity, ymin = Infinity, xmax = -Infinity, ymax = -Infinity;
+    for (var i=0, n=shapes.length; i<n; i++) {
+      shp = shapes[i];
+      for (var j=0, m=shp ? shp.length : 0; j<m; j++) {
+        x = shp[j][0];
+        y = shp[j][1];
+        if (x > xmax) xmax = x;
+        if (x < xmin) xmin = x;
+        if (y > ymax) ymax = y;
+        if (y < ymin) ymin = y;
+      }
+    }
+    return shp ? new Bounds(xmin, ymin, xmax, ymax) : new Bounds();
   }
 
   function getPointFeatureBounds(shape, bounds) {
@@ -3714,20 +3753,6 @@
     findMaxPartCount: findMaxPartCount
   });
 
-  // Several dependencies are loaded via require() ... this module returns a
-  // stub function when require() does not exist as a global function,
-  // to avoid runtime errors (this should only happen in some tests when single
-  // modules are imported)
-  var f;
-  if (typeof require == 'function') {
-    f = require;
-  } else {
-    f = function() {
-      // console.error('Unable to load module', name);
-    };
-  }
-  var require$1 = f;
-
   var iconv = require$1('iconv-lite');
 
   // import iconv from 'iconv-lite';
@@ -9614,11 +9639,10 @@
   });
 
   // aliases for shorter compressed code (most minifers don't do this)
-  var u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;
+  var u8 = Uint8Array, u16 = Uint16Array, i32 = Int32Array;
   // fixed length extra bits
   var fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);
   // fixed distance extra bits
-  // see fleb note
   var fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);
   // code length index map
   var clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
@@ -9629,26 +9653,26 @@
           b[i] = start += 1 << eb[i - 1];
       }
       // numbers here are at max 18 bits
-      var r = new u32(b[30]);
+      var r = new i32(b[30]);
       for (var i = 1; i < 30; ++i) {
           for (var j = b[i]; j < b[i + 1]; ++j) {
               r[j] = ((j - b[i]) << 5) | i;
           }
       }
-      return [b, r];
+      return { b: b, r: r };
   };
-  var _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];
+  var _a = freb(fleb, 2), fl = _a.b, revfl = _a.r;
   // we can ignore the fact that the other numbers are wrong; they never happen anyway
   fl[28] = 258, revfl[258] = 28;
-  var _b = freb(fdeb, 0), fd = _b[0], revfd = _b[1];
+  var _b = freb(fdeb, 0), fd = _b.b, revfd = _b.r;
   // map of value to reverse (assuming 16 bits)
   var rev = new u16(32768);
   for (var i = 0; i < 32768; ++i) {
       // reverse table algorithm from SO
-      var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);
-      x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);
-      x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);
-      rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;
+      var x = ((i & 0xAAAA) >> 1) | ((i & 0x5555) << 1);
+      x = ((x & 0xCCCC) >> 2) | ((x & 0x3333) << 2);
+      x = ((x & 0xF0F0) >> 4) | ((x & 0x0F0F) << 4);
+      rev[i] = (((x & 0xFF00) >> 8) | ((x & 0x00FF) << 8)) >> 1;
   }
   // create huffman tree from u8 "map": index -> code length for code index
   // mb (max bits) must be at most 15
@@ -9666,7 +9690,7 @@
       }
       // u16 "map": index -> minimum code for bit length = index
       var le = new u16(mb);
-      for (i = 0; i < mb; ++i) {
+      for (i = 1; i < mb; ++i) {
           le[i] = (le[i - 1] + l[i - 1]) << 1;
       }
       var co;
@@ -9687,7 +9711,7 @@
                   // m is end value
                   for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {
                       // every 16 bit value starting with the code yields the same result
-                      co[rev[v] >>> rvb] = sv;
+                      co[rev[v] >> rvb] = sv;
                   }
               }
           }
@@ -9696,7 +9720,7 @@
           co = new u16(s);
           for (i = 0; i < s; ++i) {
               if (cd[i]) {
-                  co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);
+                  co[i] = rev[le[cd[i] - 1]++] >> (15 - cd[i]);
               }
           }
       }
@@ -9749,9 +9773,7 @@
       if (e == null || e > v.length)
           e = v.length;
       // can't use .constructor in case user-supplied
-      var n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);
-      n.set(v.subarray(s, e));
-      return n;
+      return new u8(v.subarray(s, e));
   };
   // error codes
   var ec = [
@@ -9781,19 +9803,18 @@
       return e;
   };
   // expands raw DEFLATE data
-  var inflt = function (dat, buf, st) {
-      // source length
-      var sl = dat.length;
-      if (!sl || (st && st.f && !st.l))
+  var inflt = function (dat, st, buf, dict) {
+      // source length       dict length
+      var sl = dat.length, dl = dict ? dict.length : 0;
+      if (!sl || st.f && !st.l)
           return buf || new u8(0);
+      var noBuf = !buf;
       // have to estimate size
-      var noBuf = !buf || st;
+      var resize = noBuf || st.i != 2;
       // no state
-      var noSt = !st || st.i;
-      if (!st)
-          st = {};
+      var noSt = st.i;
       // Assumes roughly 33% compression ratio average
-      if (!buf)
+      if (noBuf)
           buf = new u8(sl * 3);
       // ensure buffer can fit at least l elements
       var cbuf = function (l) {
@@ -9826,7 +9847,7 @@
                       break;
                   }
                   // ensure size
-                  if (noBuf)
+                  if (resize)
                       cbuf(bt + l);
                   // Copy over uncompressed data
                   buf.set(dat.subarray(s, t), bt);
@@ -9859,7 +9880,7 @@
                       // bits read
                       pos += r & 15;
                       // symbol
-                      var s = r >>> 4;
+                      var s = r >> 4;
                       // code length to copy
                       if (s < 16) {
                           ldt[i++] = s;
@@ -9895,14 +9916,14 @@
               }
           }
           // Make sure the buffer can hold this + the largest possible addition
-          // Maximum chunk size (practically, theoretically infinite) is 2^17;
-          if (noBuf)
+          // Maximum chunk size (practically, theoretically infinite) is 2^17
+          if (resize)
               cbuf(bt + 131072);
           var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
           var lpos = pos;
           for (;; lpos = pos) {
               // bits read, code
-              var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;
+              var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
               pos += c & 15;
               if (pos > tbts) {
                   if (noSt)
@@ -9927,52 +9948,55 @@
                       pos += b;
                   }
                   // dist
-                  var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;
+                  var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
                   if (!d)
                       err(3);
                   pos += d & 15;
                   var dt = fd[dsym];
                   if (dsym > 3) {
                       var b = fdeb[dsym];
-                      dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;
+                      dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
                   }
                   if (pos > tbts) {
                       if (noSt)
                           err(0);
                       break;
                   }
-                  if (noBuf)
+                  if (resize)
                       cbuf(bt + 131072);
                   var end = bt + add;
-                  for (; bt < end; bt += 4) {
-                      buf[bt] = buf[bt - dt];
-                      buf[bt + 1] = buf[bt + 1 - dt];
-                      buf[bt + 2] = buf[bt + 2 - dt];
-                      buf[bt + 3] = buf[bt + 3 - dt];
+                  if (bt < dt) {
+                      var shift = dl - dt, dend = Math.min(dt, end);
+                      if (shift + bt < 0)
+                          err(3);
+                      for (; bt < dend; ++bt)
+                          buf[bt] = dict[shift + bt];
                   }
-                  bt = end;
+                  for (; bt < end; ++bt)
+                      buf[bt] = buf[bt - dt];
               }
           }
           st.l = lm, st.p = lpos, st.b = bt, st.f = final;
           if (lm)
               final = 1, st.m = lbt, st.d = dm, st.n = dbt;
       } while (!final);
-      return bt == buf.length ? buf : slc(buf, 0, bt);
+      // don't reallocate for streams or user buffers
+      return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
   };
   // starting at p, write the minimum number of bits that can hold v to d
   var wbits = function (d, p, v) {
       v <<= p & 7;
       var o = (p / 8) | 0;
       d[o] |= v;
-      d[o + 1] |= v >>> 8;
+      d[o + 1] |= v >> 8;
   };
   // starting at p, write the minimum number of bits (>8) that can hold v to d
   var wbits16 = function (d, p, v) {
       v <<= p & 7;
       var o = (p / 8) | 0;
       d[o] |= v;
-      d[o + 1] |= v >>> 8;
-      d[o + 2] |= v >>> 16;
+      d[o + 1] |= v >> 8;
+      d[o + 2] |= v >> 16;
   };
   // creates code lengths from a frequency table
   var hTree = function (d, mb) {
@@ -9985,11 +10009,11 @@
       var s = t.length;
       var t2 = t.slice();
       if (!s)
-          return [et, 0];
+          return { t: et, l: 0 };
       if (s == 1) {
           var v = new u8(t[0].s + 1);
           v[t[0].s] = 1;
-          return [v, 1];
+          return { t: v, l: 1 };
       }
       t.sort(function (a, b) { return a.f - b.f; });
       // after i2 reaches last ind, will be stopped
@@ -10033,7 +10057,7 @@
               else
                   break;
           }
-          dt >>>= lft;
+          dt >>= lft;
           while (dt > 0) {
               var i2_2 = t2[i].s;
               if (tr[i2_2] < mb)
@@ -10050,7 +10074,7 @@
           }
           mbt = mb;
       }
-      return [new u8(tr), mbt];
+      return { t: new u8(tr), l: mbt };
   };
   // get the max length and assign length codes
   var ln = function (n, l, d) {
@@ -10093,7 +10117,7 @@
               cln = c[i];
           }
       }
-      return [cl.subarray(0, cli), s];
+      return { c: cl.subarray(0, cli), n: s };
   };
   // calculate the length of output from tree, code lengths
   var clen = function (cf, cl) {
@@ -10109,7 +10133,7 @@
       var s = dat.length;
       var o = shft(pos + 2);
       out[o] = s & 255;
-      out[o + 1] = s >>> 8;
+      out[o + 1] = s >> 8;
       out[o + 2] = out[o] ^ 255;
       out[o + 3] = out[o + 1] ^ 255;
       for (var i = 0; i < s; ++i)
@@ -10120,23 +10144,23 @@
   var wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {
       wbits(out, p++, final);
       ++lf[256];
-      var _a = hTree(lf, 15), dlt = _a[0], mlb = _a[1];
-      var _b = hTree(df, 15), ddt = _b[0], mdb = _b[1];
-      var _c = lc(dlt), lclt = _c[0], nlc = _c[1];
-      var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];
+      var _a = hTree(lf, 15), dlt = _a.t, mlb = _a.l;
+      var _b = hTree(df, 15), ddt = _b.t, mdb = _b.l;
+      var _c = lc(dlt), lclt = _c.c, nlc = _c.n;
+      var _d = lc(ddt), lcdt = _d.c, ndc = _d.n;
       var lcfreq = new u16(19);
       for (var i = 0; i < lclt.length; ++i)
-          lcfreq[lclt[i] & 31]++;
+          ++lcfreq[lclt[i] & 31];
       for (var i = 0; i < lcdt.length; ++i)
-          lcfreq[lcdt[i] & 31]++;
-      var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];
+          ++lcfreq[lcdt[i] & 31];
+      var _e = hTree(lcfreq, 7), lct = _e.t, mlcb = _e.l;
       var nlcc = 19;
       for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)
           ;
       var flen = (bl + 5) << 3;
       var ftlen = clen(lf, flt) + clen(df, fdt) + eb;
-      var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);
-      if (flen <= ftlen && flen <= dtlen)
+      var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + 2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18];
+      if (bs >= 0 && flen <= ftlen && flen <= dtlen)
           return wfblk(out, p, dat.subarray(bs, bs + bl));
       var lm, ll, dm, dl;
       wbits(out, p, 1 + (dtlen < ftlen)), p += 2;
@@ -10157,7 +10181,7 @@
                   var len = clct[i] & 31;
                   wbits(out, p, llm[len]), p += lct[len];
                   if (len > 15)
-                      wbits(out, p, (clct[i] >>> 5) & 127), p += clct[i] >>> 12;
+                      wbits(out, p, (clct[i] >> 5) & 127), p += clct[i] >> 12;
               }
           }
       }
@@ -10165,63 +10189,55 @@
           lm = flm, ll = flt, dm = fdm, dl = fdt;
       }
       for (var i = 0; i < li; ++i) {
-          if (syms[i] > 255) {
-              var len = (syms[i] >>> 18) & 31;
+          var sym = syms[i];
+          if (sym > 255) {
+              var len = (sym >> 18) & 31;
               wbits16(out, p, lm[len + 257]), p += ll[len + 257];
               if (len > 7)
-                  wbits(out, p, (syms[i] >>> 23) & 31), p += fleb[len];
-              var dst = syms[i] & 31;
+                  wbits(out, p, (sym >> 23) & 31), p += fleb[len];
+              var dst = sym & 31;
               wbits16(out, p, dm[dst]), p += dl[dst];
               if (dst > 3)
-                  wbits16(out, p, (syms[i] >>> 5) & 8191), p += fdeb[dst];
+                  wbits16(out, p, (sym >> 5) & 8191), p += fdeb[dst];
           }
           else {
-              wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];
+              wbits16(out, p, lm[sym]), p += ll[sym];
           }
       }
       wbits16(out, p, lm[256]);
       return p + ll[256];
   };
   // deflate options (nice << 13) | chain
-  var deo = /*#__PURE__*/ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
+  var deo = /*#__PURE__*/ new i32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);
   // empty
   var et = /*#__PURE__*/ new u8(0);
   // compresses data into a raw DEFLATE buffer
-  var dflt = function (dat, lvl, plvl, pre, post, lst) {
-      var s = dat.length;
+  var dflt = function (dat, lvl, plvl, pre, post, st) {
+      var s = st.z || dat.length;
       var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);
       // writing to this writes to the output buffer
       var w = o.subarray(pre, o.length - post);
-      var pos = 0;
-      if (!lvl || s < 8) {
-          for (var i = 0; i <= s; i += 65535) {
-              // end
-              var e = i + 65535;
-              if (e >= s) {
-                  // write final block
-                  w[pos >> 3] = lst;
-              }
-              pos = wfblk(w, pos + 1, dat.subarray(i, e));
-          }
-      }
-      else {
+      var lst = st.l;
+      var pos = (st.r || 0) & 7;
+      if (lvl) {
+          if (pos)
+              w[0] = st.r >> 3;
           var opt = deo[lvl - 1];
-          var n = opt >>> 13, c = opt & 8191;
+          var n = opt >> 13, c = opt & 8191;
           var msk_1 = (1 << plvl) - 1;
           //    prev 2-byte val map    curr 2-byte val map
-          var prev = new u16(32768), head = new u16(msk_1 + 1);
+          var prev = st.p || new u16(32768), head = st.h || new u16(msk_1 + 1);
           var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;
           var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };
           // 24576 is an arbitrary number of maximum symbols per block
           // 424 buffer for last block
-          var syms = new u32(25000);
+          var syms = new i32(25000);
           // length/literal freq   distance freq
           var lf = new u16(288), df = new u16(32);
-          //  l/lcnt  exbits  index  l/lind  waitdx  bitpos
-          var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;
-          for (; i < s; ++i) {
+          //  l/lcnt  exbits  index          l/lind  waitdx          blkpos
+          var lc_1 = 0, eb = 0, i = st.i || 0, li = 0, wi = st.w || 0, bs = 0;
+          for (; i + 2 < s; ++i) {
               // hash value
-              // deopt when i > s - 3 - at end, deopt acceptable
               var hv = hsh(i);
               // index mod 32768    previous index mod
               var imod = i & 32767, pimod = head[hv];
@@ -10232,7 +10248,7 @@
               if (wi <= i) {
                   // bytes remaining
                   var rem = s - i;
-                  if ((lc_1 > 7000 || li > 24576) && rem > 423) {
+                  if ((lc_1 > 7000 || li > 24576) && (rem > 423 || !lst)) {
                       pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);
                       li = lc_1 = eb = 0, bs = i;
                       for (var j = 0; j < 286; ++j)
@@ -10241,7 +10257,7 @@
                           df[j] = 0;
                   }
                   //  len    dist   chain
-                  var l = 2, d = 0, ch_1 = c, dif = (imod - pimod) & 32767;
+                  var l = 2, d = 0, ch_1 = c, dif = imod - pimod & 32767;
                   if (rem > 2 && hv == hsh(i - dif)) {
                       var maxn = Math.min(n, rem) - 1;
                       var maxd = Math.min(32767, i);
@@ -10264,9 +10280,9 @@
                                   var mmd = Math.min(dif, nl - 2);
                                   var md = 0;
                                   for (var j = 0; j < mmd; ++j) {
-                                      var ti = (i - dif + j + 32768) & 32767;
+                                      var ti = i - dif + j & 32767;
                                       var pti = prev[ti];
-                                      var cd = (ti - pti + 32768) & 32767;
+                                      var cd = ti - pti & 32767;
                                       if (cd > md)
                                           md = cd, pimod = ti;
                                   }
@@ -10274,12 +10290,12 @@
                           }
                           // check the previous match
                           imod = pimod, pimod = prev[imod];
-                          dif += (imod - pimod + 32768) & 32767;
+                          dif += imod - pimod & 32767;
                       }
                   }
                   // d will be nonzero only when a match was found
                   if (d) {
-                      // store both dist and len data in one Uint32
+                      // store both dist and len data in one int32
                       // Make sure this is recognized as a len/dist with 28th bit (2^28)
                       syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];
                       var lin = revfl[l] & 31, din = revfd[d] & 31;
@@ -10295,10 +10311,30 @@
                   }
               }
           }
+          for (i = Math.max(i, wi); i < s; ++i) {
+              syms[li++] = dat[i];
+              ++lf[dat[i]];
+          }
           pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);
-          // this is the easiest way to avoid needing to maintain state
-          if (!lst && pos & 7)
-              pos = wfblk(w, pos + 1, et);
+          if (!lst) {
+              st.r = (pos & 7) | w[(pos / 8) | 0] << 3;
+              // shft(pos) now 1 less if pos & 7 != 0
+              pos -= 7;
+              st.h = head, st.p = prev, st.i = i, st.w = wi;
+          }
+      }
+      else {
+          for (var i = st.w || 0; i < s + lst; i += 65535) {
+              // end
+              var e = i + 65535;
+              if (e >= s) {
+                  // write final block
+                  w[(pos / 8) | 0] = lst;
+                  e = s;
+              }
+              pos = wfblk(w, pos + 1, dat.subarray(i, e));
+          }
+          st.i = s;
       }
       return slc(o, 0, pre + shft(pos) + post);
   };
@@ -10329,7 +10365,18 @@
   };
   // deflate with opts
   var dopt = function (dat, opt, pre, post, st) {
-      return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : (12 + opt.mem), pre, post, !st);
+      if (!st) {
+          st = { l: 1 };
+          if (opt.dictionary) {
+              var dict = opt.dictionary.subarray(-32768);
+              var newDat = new u8(dict.length + dat.length);
+              newDat.set(dict);
+              newDat.set(dat, dict.length);
+              dat = newDat;
+              st.w = dict.length;
+          }
+      }
+      return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? (st.l ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : 20) : (12 + opt.mem), pre, post, st);
   };
   // Walmart object spread
   var mrg = function (a, b) {
@@ -10374,7 +10421,7 @@
           else
               td[k] = v;
       }
-      return [fnStr, td];
+      return fnStr;
   };
   var ch = [];
   // clone bufs
@@ -10389,27 +10436,29 @@
   };
   // use a worker to execute code
   var wrkr = function (fns, init, id, cb) {
-      var _a;
       if (!ch[id]) {
           var fnStr = '', td_1 = {}, m = fns.length - 1;
           for (var i = 0; i < m; ++i)
-              _a = wcln(fns[i], fnStr, td_1), fnStr = _a[0], td_1 = _a[1];
-          ch[id] = wcln(fns[m], fnStr, td_1);
+              fnStr = wcln(fns[i], fnStr, td_1);
+          ch[id] = { c: wcln(fns[m], fnStr, td_1), e: td_1 };
       }
-      var td = mrg({}, ch[id][1]);
-      return wk(ch[id][0] + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);
+      var td = mrg({}, ch[id].e);
+      return wk(ch[id].c + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);
   };
   // base async inflate fn
-  var bInflt = function () { return [u8, u16, u32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gu8]; };
-  var bDflt = function () { return [u8, u16, u32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };
+  var bInflt = function () { return [u8, u16, i32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gopt]; };
+  var bDflt = function () { return [u8, u16, i32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };
   // gzip extra
   var gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };
   // gunzip extra
   var guze = function () { return [gzs, gzl]; };
   // post buf
   var pbf = function (msg) { return postMessage(msg, [msg.buffer]); };
-  // get u8
-  var gu8 = function (o) { return o && o.size && new u8(o.size); };
+  // get opts
+  var gopt = function (o) { return o && {
+      out: o.size && new u8(o.size),
+      dictionary: o.dictionary
+  }; };
   // async helper
   var cbify = function (dat, opts, fns, init, id, cb) {
       var w = wrkr(fns, init, id, function (err, dat) {
@@ -10449,7 +10498,7 @@
       var flg = d[3];
       var st = 10;
       if (flg & 4)
-          st += d[10] | (d[11] << 8) + 2;
+          st += (d[10] | d[11] << 8) + 2;
       for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])
           ;
       return st + (flg & 2);
@@ -10457,10 +10506,10 @@
   // gzip length
   var gzl = function (d) {
       var l = d.length;
-      return ((d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16) | (d[l - 1] << 24)) >>> 0;
+      return (d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16 | d[l - 1] << 24) >>> 0;
   };
   // gzip header length
-  var gzhl = function (o) { return 10 + ((o.filename && (o.filename.length + 1)) || 0); };
+  var gzhl = function (o) { return 10 + (o.filename ? o.filename.length + 1 : 0); };
   function deflate(data, opts, cb) {
       if (!cb)
           cb = opts, opts = {};
@@ -10486,16 +10535,16 @@
           err(7);
       return cbify(data, opts, [
           bInflt
-      ], function (ev) { return pbf(inflateSync(ev.data[0], gu8(ev.data[1]))); }, 1, cb);
+      ], function (ev) { return pbf(inflateSync(ev.data[0], gopt(ev.data[1]))); }, 1, cb);
   }
   /**
    * Expands DEFLATE data with no wrapper
    * @param data The data to decompress
-   * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.
+   * @param opts The decompression options
    * @returns The decompressed version of the data
    */
-  function inflateSync(data, out) {
-      return inflt(data, out);
+  function inflateSync(data, opts) {
+      return inflt(data, { i: 2 }, opts && opts.out, opts && opts.dictionary);
   }
   function gzip(data, opts, cb) {
       if (!cb)
@@ -10531,16 +10580,19 @@
           bInflt,
           guze,
           function () { return [gunzipSync$1]; }
-      ], function (ev) { return pbf(gunzipSync$1(ev.data[0])); }, 3, cb);
+      ], function (ev) { return pbf(gunzipSync$1(ev.data[0], ev.data[1])); }, 3, cb);
   }
   /**
    * Expands GZIP data
    * @param data The data to decompress
-   * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.
+   * @param opts The decompression options
    * @returns The decompressed version of the data
    */
-  function gunzipSync$1(data, out) {
-      return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));
+  function gunzipSync$1(data, opts) {
+      var st = gzs(data);
+      if (st + 8 > data.length)
+          err(6, 'invalid gzip data');
+      return inflt(data.subarray(st, -8), { i: 2 }, opts && opts.out || new u8(gzl(data)), opts && opts.dictionary);
   }
   // flatten a directory structure
   var fltn = function (d, p, t, o) {
@@ -10573,7 +10625,7 @@
           var c = d[i++];
           var eb = (c > 127) + (c > 223) + (c > 239);
           if (i + eb > d.length)
-              return [r, slc(d, i - 1)];
+              return { s: r, r: slc(d, i - 1) };
           if (!eb)
               r += String.fromCharCode(c);
           else if (eb == 3) {
@@ -10639,13 +10691,14 @@
               r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));
           return r;
       }
-      else if (td)
+      else if (td) {
           return td.decode(dat);
+      }
       else {
-          var _a = dutf8(dat), out = _a[0], ext = _a[1];
-          if (ext.length)
+          var _a = dutf8(dat), s = _a.s, r = _a.r;
+          if (r.length)
               err(8);
-          return out;
+          return s;
       }
   }
   // skip local zip header
@@ -10688,7 +10741,7 @@
       var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;
       if (y < 0 || y > 119)
           err(10);
-      wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >>> 1)), b += 4;
+      wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >> 1)), b += 4;
       if (c != -1) {
           wbytes(d, b, f.crc);
           wbytes(d, b + 4, c < 0 ? -c - 2 : c);
@@ -10928,9 +10981,10 @@
                       cbl(null, slc(data, b, b + sc));
                   else if (c_1 == 8) {
                       var infl = data.subarray(b, b + sc);
-                      if (sc < 320000) {
+                      // Synchronously decompress under 512KB, or barely-compressed data
+                      if (su < 524288 || sc > 0.8 * su) {
                           try {
-                              cbl(null, inflateSync(infl, new u8(su)));
+                              cbl(null, inflateSync(infl, { out: new u8(su) }));
                           }
                           catch (e) {
                               cbl(e, null);
@@ -10993,7 +11047,7 @@
               if (!c_2)
                   files[fn] = slc(data, b, b + sc);
               else if (c_2 == 8)
-                  files[fn] = inflateSync(data.subarray(b, b + sc), new u8(su));
+                  files[fn] = inflateSync(data.subarray(b, b + sc), { out: new u8(su) });
               else
                   err(14, 'unknown compression type ' + c_2);
           }
@@ -13762,7 +13816,7 @@
             convertIntervalParam(opt[1], crs)];
   }
 
-  // Accepts a single value or a list of four values. List order is l,b,t,r
+  // Accepts a single value or a list of four values. List order is l,b,r,t
   function convertFourSides(opt, crs, bounds) {
     var arr = opt.includes(',') ? opt.split(',') : opt.split(' ');
     if (arr.length == 1) {
@@ -13776,7 +13830,7 @@
         tmp = parseFloat(param) / 100 || 0;
         return tmp * (i == 1 || i == 3 ? bounds.height() : bounds.width());
       }
-      return convertIntervalParam(opt, crs);
+      return convertIntervalParam(param, crs);
     });
   }
 
@@ -18486,18 +18540,30 @@
     type: 'frame'
   }
   */
+
+
   function getFrameData(dataset, exportOpts) {
     var frameLyr = findFrameLayerInDataset(dataset);
-    var frameData;
+    var data;
     if (frameLyr) {
-      frameData = getFrameLayerData(frameLyr, dataset.arcs);
+      data = getFrameLayerData(frameLyr, dataset.arcs);
     } else {
-      frameData = calcFrameData(dataset, exportOpts);
+      data = calcFrameData(dataset, exportOpts);
     }
-    frameData.crs = getDatasetCRS(dataset);
-    return frameData;
+    data.invert_y = !!exportOpts.invert_y;
+    data.crs = getDatasetCRS(dataset);
+    return data;
   }
 
+  function fitDatasetToFrame(dataset, frame) {
+    var bounds = new Bounds(frame.bbox);
+    var bounds2 = frame.bbox2 ? new Bounds(frame.bbox2) : new Bounds(0, 0, frame.width, frame.height);
+    bounds.fillOut(bounds2.width() / bounds2.height());
+    var fwd = bounds.getTransform(bounds2, frame.invert_y);
+    transformPoints(dataset, function(x, y) {
+      return fwd.transform(x, y);
+    });
+  }
 
   function getFrameLayerData(lyr, arcs) {
     var bounds = getLayerBounds(lyr, arcs);
@@ -18515,17 +18581,17 @@
 
 
   function calcFrameData(dataset, opts) {
-    var bounds;
-    var outputBbox = opts.svg_bbox || opts.output_bbox || null;
-    if (outputBbox) {
-      bounds = new Bounds(outputBbox);
+    var inputBounds, outputBounds;
+    if (opts.svg_bbox) {
+      inputBounds = new Bounds(opts.svg_bbox);
       opts = Object.assign({margin: 0}, opts); // prevent default pixel margin around content
     } else {
-      bounds = getDatasetBounds(dataset);
+      inputBounds = getDatasetBounds(dataset);
     }
-    var outputBounds = calcOutputSizeInPixels(bounds, opts);
+    // side effect: inputBounds may be expanded to add margins
+    outputBounds = calcOutputBounds(inputBounds, opts);
     return {
-      bbox: bounds.toArray(),
+      bbox: inputBounds.toArray(),
       bbox2: outputBounds.toArray(),
       width: Math.round(outputBounds.width()),
       height: Math.round(outputBounds.height()) || 1,
@@ -18533,7 +18599,7 @@
     };
   }
 
-  // Used by mapshaper-frame and mapshaper-pixel-transform. TODO: refactor
+  // Used by mapshaper-frame  TODO: refactor
   function getFrameSize(bounds, opts) {
     var aspectRatio = bounds.width() / bounds.height();
     var height, width;
@@ -18602,9 +18668,9 @@
 
 
   // bounds: Bounds object containing bounds of content in geographic coordinates
-  // returns Bounds object containing bounds of pixel output
+  // returns Bounds object containing output bounds
   // side effect: bounds param is modified to match the output frame
-  function calcOutputSizeInPixels(bounds, opts) {
+  function calcOutputBounds(bounds, opts) {
     var padX = 0,
         padY = 0,
         offX = 0,
@@ -18617,65 +18683,59 @@
         // TODO: add option to tweak alignment of content when both width and height are given
         wx = 0.5, // how padding is distributed horizontally (0: left aligned, 0.5: centered, 1: right aligned)
         wy = 0.5, // vertical padding distribution
-        widthPx, heightPx, size, kx, ky;
+        width2, height2, size2, kx, ky;
 
     if (opts.fit_bbox) {
       // scale + shift content to fit within a bbox
       offX = opts.fit_bbox[0];
       offY = opts.fit_bbox[1];
-      widthPx = opts.fit_bbox[2] - offX;
-      heightPx = opts.fit_bbox[3] - offY;
-      if (width / height > widthPx / heightPx) {
-        // data is wider than fit box...
-        // scale the data to fit widthwise
-        heightPx = 0;
-      } else {
-        widthPx = 0; // fit the data to the height
-      }
+      width2 = opts.fit_bbox[2] - offX;
+      height2 = opts.fit_bbox[3] - offY;
       marginX = marginY = 0; // TODO: support margins
 
     } else if (opts.svg_scale > 0) {
       // alternative to using a fixed width (e.g. when generating multiple files
       // at a consistent geographic scale)
-      widthPx = width / opts.svg_scale + marginX;
-      heightPx = 0;
+      width2 = width / opts.svg_scale + marginX;
+      height2 = 0;
     } else if (+opts.pixels) {
-      size = getFrameSize(bounds, opts);
-      widthPx = size[0];
-      heightPx = size[1];
+      size2 = getFrameSize(bounds, opts);
+      width2 = size2[0];
+      height2 = size2[1];
     } else {
-      heightPx = opts.height || 0;
-      widthPx = opts.width || (heightPx > 0 ? 0 : 800); // 800 is default width
+      height2 = opts.height || 0;
+      width2 = opts.width || (height2 > 0 ? 0 : 800); // 800 is default width
     }
 
-    if (heightPx > 0) {
+    if (height2 > 0) {
       // vertical meters per pixel to fit height param
-      ky = (height || width || 1) / (heightPx - marginY);
+      ky = (height || width || 1) / (height2 - marginY);
     }
-    if (widthPx > 0) {
+    if (width2 > 0) {
       // horizontal meters per pixel to fit width param
-      kx = (width || height || 1) / (widthPx - marginX);
+      kx = (width || height || 1) / (width2 - marginX);
     }
 
-    if (!widthPx) { // heightPx and ky are defined, set width to match
+    if (!width2) { // height2 and ky are defined, set width to match
       kx = ky;
-      widthPx = width > 0 ? marginX + width / kx : heightPx; // export square graphic if content has 0 width (reconsider this?)
-    } else if (!heightPx) { // widthPx and kx are set, set height to match
+      width2 = width > 0 ? marginX + width / kx : height2; // export square graphic if content has 0 width (reconsider this?)
+    } else if (!height2) { // width2 and kx are set, set height to match
       ky = kx;
-      heightPx = height > 0 ? marginY + height / ky : widthPx;
+      height2 = height > 0 ? marginY + height / ky : width2;
       // limit height if max_height is defined
-      if (opts.max_height > 0 && heightPx > opts.max_height) {
-        ky = kx * heightPx / opts.max_height;
-        heightPx = opts.max_height;
+      if (opts.max_height > 0 && height2 > opts.max_height) {
+        ky = kx * height2 / opts.max_height;
+        height2 = opts.max_height;
       }
     }
 
+    // add padding, if needed
     if (kx > ky) { // content is wide -- need to pad vertically
       ky = kx;
-      padY = ky * (heightPx - marginY) - height;
+      padY = ky * (height2 - marginY) - height;
     } else if (ky > kx) { // content is tall -- need to pad horizontally
       kx = ky;
-      padX = kx * (widthPx - marginX) - width;
+      padX = kx * (width2 - marginX) - width;
     }
 
     bounds.padBounds(
@@ -18684,14 +18744,14 @@
       margins[2] * kx + padX * (1 - wx),
       margins[3] * ky + padY * (1 - wy));
 
-    if (!(widthPx > 0 && heightPx > 0)) {
+    if (!(width2 > 0 && height2 > 0)) {
       error("Missing valid height and width parameters");
     }
     if (!(kx === ky && kx > 0)) {
       error("Missing valid margin parameters");
     }
 
-    return new Bounds(offX, offY, widthPx + offX, heightPx + offY);
+    return new Bounds(offX, offY, width2 + offX, height2 + offY);
   }
 
   function parseMarginOption(opt) {
@@ -18702,13 +18762,14 @@
     if (margins.length == 3) margins.push(margins[2]);
     return margins.map(function(str) {
       var px = parseFloat(str);
-      return isNaN(px) ? 1 : px; // 1 is default
+      return isNaN(px) ? 0 : px; // 0 is default
     });
   }
 
-  var FrameData = /*#__PURE__*/Object.freeze({
+  var FrameUtils = /*#__PURE__*/Object.freeze({
     __proto__: null,
     getFrameData: getFrameData,
+    fitDatasetToFrame: fitDatasetToFrame,
     getFrameLayerData: getFrameLayerData,
     calcFrameData: calcFrameData,
     getFrameSize: getFrameSize,
@@ -18719,7 +18780,7 @@
     findFrame: findFrame,
     getFrameLayerBounds: getFrameLayerBounds,
     getMapFrameMetersPerPixel: getMapFrameMetersPerPixel,
-    calcOutputSizeInPixels: calcOutputSizeInPixels,
+    calcOutputBounds: calcOutputBounds,
     parseMarginOption: parseMarginOption
   });
 
@@ -20152,27 +20213,6 @@
     renderFurnitureLayer: renderFurnitureLayer
   });
 
-  function transformDatasetToPixels(dataset, opts) {
-    var frame = getFrameData(dataset, opts);
-    fitDatasetToFrame(dataset, frame, opts);
-    return [frame.width, frame.height];
-  }
-
-  function fitDatasetToFrame(dataset, frame, opts) {
-    var bounds = new Bounds(frame.bbox);
-    var bounds2 = frame.bbox2 ? new Bounds(frame.bbox2) : new Bounds(0, 0, frame.width, frame.height);
-    var fwd = bounds.getTransform(bounds2, opts.invert_y);
-    transformPoints(dataset, function(x, y) {
-      return fwd.transform(x, y);
-    });
-  }
-
-  var PixelTransform = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    transformDatasetToPixels: transformDatasetToPixels,
-    fitDatasetToFrame: fitDatasetToFrame
-  });
-
   function stringify(obj) {
     var svg, joinStr;
     if (!obj || !obj.tag) return '';
@@ -20460,10 +20500,11 @@
       dataset = copyDataset(dataset); // Modify a copy of the dataset
     }
 
-    // invert_y setting for screen coordinates and geojson polygon generation
-    utils.extend(opts, {invert_y: true});
+    // use invert_y: 0 setting for screen coordinates and geojson polygon generation
+    // use 1px default margin so typical strokes don't get cut off on the sides
+    opts = Object.assign({invert_y: true, margin: "1"}, opts);
     frame = getFrameData(dataset, opts);
-    fitDatasetToFrame(dataset, frame, opts);
+    fitDatasetToFrame(dataset, frame);
     setCoordinatePrecision(dataset, opts.precision || 0.0001);
 
     // error if one or more svg_data fields are not present in any layers
@@ -20705,7 +20746,7 @@ ${svg}
   // import { isKmzFile } from '../io/mapshaper-file-types';
 
   function exportKML(dataset, opts) {
-    var toKML = require("@placemarkio/tokml").toKML;
+    var toKML = require$1("@placemarkio/tokml").toKML;
     var geojsonOpts = Object.assign({combine_layers: true, geojson_type: 'FeatureCollection'}, opts);
     var geojson = exportDatasetAsGeoJSON(dataset, geojsonOpts);
     var kml = toKML(geojson);
@@ -22099,10 +22140,14 @@ ${svg}
     }
 
     if (opts.width > 0 || opts.height > 0) {
+      // these options create a TopoJSON with pixel coordinates, including
+      // origin (0,0) in the top left corner of the viewport, generally for
+      // direct conversion to SVG (many online examples using d3 are like this)
+      //
       opts = utils.defaults({invert_y: true}, opts);
-      transformDatasetToPixels(dataset, opts);
+      fitDatasetToFrame(dataset, getFrameData(dataset, opts));
     } else if (opts.fit_bbox) {
-      transformDatasetToPixels(dataset, {fit_bbox: opts.fit_bbox});
+      fitDatasetToFrame(dataset, getFrameData(dataset, {fit_bbox: opts.fit_bbox}));
     }
 
     if (opts.precision && opts.no_quantization) {
@@ -24311,7 +24356,7 @@ ${svg}
           describe: 'aspect ratio as a number or range (e.g. 2 0.8,1.6 ,2)'
         },
         offsetOpt = {
-          describe: 'padding as distance or pct of h/w (single value or list)',
+          describe: 'offset distance or pct of h/w (single value or l,b,r,t list)',
           type: 'distance'
         };
 
@@ -25324,6 +25369,14 @@ ${svg}
         describe: '(polygon-polygon join) use max overlap to join one polygon',
         type: 'flag'
       })
+      .option('min-overlap-pct', {
+        describe: '(polygon-polygon join) min overlap as pct of target polygon',
+        type: 'percent'
+      })
+      .option('min-overlap-area', {
+        describe: '(polygon-polygon join) minimum area of overlap',
+        type: 'area'
+      })
       // .option('nearest-point', {
       //   describe: '(point-point join)',
       //   type: 'flag'
@@ -25762,6 +25815,10 @@ ${svg}
     parser.command('style')
       .oldAlias('svg-style')
       .describe('set SVG style properties using JS or literal values')
+      .option('clear', {
+        describe: 'remove all style properties from a layer',
+        type: 'flag'
+      })
       .option('where', whereOpt)
       .option('class', {
         describe: 'name of CSS class or classes (space-separated)'
@@ -33402,18 +33459,22 @@ ${svg}
   function getCategoricalClassifier(classValues, nullVal, opts) {
     // categories: strings to match in the data
     var categories = opts.categories;
+    // index categories for better performance on datasets with many categories
+    var index = categories.reduce((memo, key, i) => {
+      memo[key] = i;
+      return memo;
+    }, {});
     var classToValue = getDiscreteValueGetter(classValues, nullVal, opts.other);
     return function(val) {
-      var i = categories.indexOf(val);
-      var idx = -1;
-      if (i >= 0) {
-        idx = i;
-      } else if (val) {
-        idx = -2; // field contains an 'other' value
+      var i;
+      if (val in index) {
+        i = index[val];
+      } else if (val || val === 0) {
+        i = -2; // -2 indicates an 'other' value
       } else {
-        idx = -1; // field is empty (null value)
+        i = -1; // field is empty (null value)
       }
-      return classToValue(idx);
+      return classToValue(i);
     };
   }
 
@@ -34282,7 +34343,6 @@ ${svg}
     addCategoricalScheme('Tableau20',
       '4c78a89ecae9f58518ffbf7954a24b88d27ab79a20f2cf5b43989483bcb6e45756ff9d9879706ebab0acd67195fcbfd2b279a2d6a5c99e765fd8b5a5');
     index.all = [].concat(index.sequential, index.rainbow, index.diverging, index.categorical);
-
   }
 
   function standardName(name) {
@@ -34296,8 +34356,15 @@ ${svg}
     return null;
   }
 
-  function addSchemesFromD3(type, names) {
-    index[type] = index[type].concat(names.split(','));
+  function addSchemesFromD3(type, namesStr) {
+    var names = namesStr.split(',');
+    index[type] = index[type].concat(names);
+    if (type == 'categorical') {
+      // copy categorical colors for simplicity
+      names.forEach(name => {
+        ramps[name] = d3Scales['scheme' + name];
+      });
+    }
   }
 
   function addCategoricalScheme(name, str) {
@@ -34351,16 +34418,14 @@ ${svg}
     initSchemes();
     var names = index[type];
     if (!names) error('Unknown color scheme type:', type);
-    var i = Math.floor(Math.random() * names.length);
-    return names[i];
+    return utils.pickOne(names);
   }
 
-  function getRandomColors(n) {
+  function pickRandomCategoricalScheme(n) {
     initSchemes();
-    var colors = getCategoricalColorScheme('Tableau20', 20);
-    utils.shuffle(colors);
-    colors = wrapColors(colors, n);
-    return colors.slice(0, n);
+    var minSize = Math.min(n, 20); // use largest available if n is too large
+    var schemes = index.categorical.filter(name => ramps[name].length >= minSize);
+    return utils.pickOne(schemes) || 'Tableau20';
   }
 
   function getCategoricalColorScheme(name, n) {
@@ -34469,10 +34534,11 @@ ${svg}
 
     if (colorArg == 'random') {
       if (categorical) {
-        return getRandomColors(n);
+        colorScheme = pickRandomCategoricalScheme(n);
+      } else {
+        colorScheme = pickRandomColorScheme('sequential');
       }
-      colorScheme = pickRandomColorScheme('sequential');
-      message('Randomly selected color ramp:', colorScheme);
+      message('Randomly selected color scheme:', colorScheme);
     } else if (isColorSchemeName(colorArg)) {
       colorScheme = colorArg;
     } else if (colorArg && !parseColor(colorArg)) {
@@ -36725,7 +36791,7 @@ ${svg}
 
   // Join data from @src table to records in @destLyr layer.
   // @join function
-  //    Receives index of record in the dest table
+  //    Receives index of one record in the dest table
   //    Returns array of matching records in src table, or null if no matches
   //
   function joinTableToLayer(destLyr, src, join, opts) {
@@ -36751,7 +36817,7 @@ ${svg}
         collisionFields = [],
         skipCount = 0,
         retn = {},
-        srcRec, srcId, destRec, joins, count, filter, calc, i, j, n, m;
+        srcRec, srcId, destRec, joinIds, count, filter, calc, i, j, n, m;
 
     // support for duplication of destination records for many-to-one joins
     var duplicateRecords, destShapes;
@@ -36773,14 +36839,14 @@ ${svg}
     n = destRecords.length;
     for (i=0; i<n; i++) {
       destRec = destRecords[i];
-      joins = join(i);
-      if (joins && filter) {
-        skipCount += joins.length;
-        joins = filter(joins, destRec);
-        skipCount -= joins.length;
-      }
-      for (j=0, count=0, m=joins ? joins.length : 0; j<m; j++) {
-        srcId = joins[j];
+      joinIds = join(i);
+      if (joinIds && filter) {
+        skipCount += joinIds.length;
+        joinIds = filter(joinIds, destRec);
+        skipCount -= joinIds.length;
+      }
+      for (j=0, count=0, m=joinIds ? joinIds.length : 0; j<m; j++) {
+        srcId = joinIds[j];
         srcRec = srcRecords[srcId];
         // duplication mode: many-to-one joins add new features to the target layer.
         if (count > 0 && useDuplication) {
@@ -36806,7 +36872,7 @@ ${svg}
         count++;
       }
       if (calc) {
-        calc(joins, destRec);
+        calc(joinIds, destRec);
       }
       if (count > 0) {
         matchCount++;
@@ -39353,7 +39419,7 @@ ${svg}
     // TODO: consider projections that may or may not be aligned,
     // depending on parameters
     if (inList(P, 'cassini,gnom,bertin1953,chamb,ob_tran,tpeqd,healpix,rhealpix,' +
-      'ocea,omerc,tmerc,etmerc')) {
+      'ocea,omerc,tmerc,etmerc,nicol')) {
       return false;
     }
     if (isAzimuthal(P)) {
@@ -39928,7 +39994,7 @@ ${svg}
   }
 
   function isCircleClippedProjection(P) {
-    return inList(P, 'stere,sterea,ups,ortho,gnom,laea,nsper,tpers,geos');
+    return inList(P, 'stere,sterea,ups,ortho,gnom,laea,nsper,tpers,geos,nicol');
   }
 
   function getPerspectiveClipAngle(P) {
@@ -39953,6 +40019,7 @@ ${svg}
       laea: 179,
       //ortho: 89.9, // projection errors betwen lat +/-35 to 55
       ortho: 89.85, // TODO: investigate
+      nicol: 89.85,
       stere: 142,
       sterea: 142,
       ups: 10.5 // TODO: should be 6.5 deg at north pole
@@ -40765,11 +40832,14 @@ ${svg}
     };
     // make a mosaic from merged shapes of both layers
     var mosaicIndex = new MosaicIndex(mergedLyr, nodes, {flat: false});
-
     var joinOpts = utils.extend({}, opts);
-    var joinFunction = getPolygonToPolygonFunction(targetLyr, sourceLyr, mosaicIndex, opts);
-    var retn = joinTableToLayer(targetLyr, sourceLyr.data, joinFunction, joinOpts);
+    if (joinOpts.min_overlap_area) {
+      // convert area arg to square meters (typically)
+      joinOpts.min_overlap_area = convertAreaParam(joinOpts.min_overlap_area, getDatasetCRS(targetDataset));
+    }
 
+    var joinFunction = getPolygonToPolygonFunction(targetLyr, sourceLyr, mosaicIndex, joinOpts);
+    var retn = joinTableToLayer(targetLyr, sourceLyr.data, joinFunction, joinOpts);
     if (opts.interpolate) {
       if (opts.duplication) stop('duplication and interpolate options cannot be used together');
       interpolateFieldsByArea(targetLyr, sourceLyr, mosaicIndex, opts);
@@ -40783,6 +40853,22 @@ ${svg}
     var sourceFields = opts.interpolate;
     var sourceRecords = sourceLyr.data.getRecords();
 
+    // Use different interpolation methods for qualitative and quantitative data
+    // Assumes string and boolean fields are qualitative and numeric fields are
+    //   quantitative (TODO: somehow recognize numeric index data as qualitative)
+    var quantitativeFields = [];
+    var qualitativeFields = [];
+    sourceFields.forEach(function(field) {
+      var type = getColumnType(field, sourceRecords);
+      if (type == 'number') {
+        quantitativeFields.push(field);
+      } else if (type == 'string' || type == 'boolean') {
+        qualitativeFields.push(field);
+      } else {
+        message(`"${field}" field appears to contain ${type}-type data. No interpolation method is available.`);
+      }
+    });
+
     // for each destination polygon, calculate interpolated values,
     // using the data calculated in previous steps
     destLyr.data.getRecords().forEach(function(destRec, destId) {
@@ -40791,9 +40877,13 @@ ${svg}
       for (i=0; i<tileIds.length; i++) {
         tileRecords.push(mosaicRecords[tileIds[i]]);
       }
-      for (i=0; i<sourceFields.length; i++) {
+      for (i=0; i<quantitativeFields.length; i++) {
         field = sourceFields[i];
-        destRec[field] = getInterpolatedValue(field, tileRecords, sourceRecords);
+        destRec[field] = getInterpolatedNumber(field, tileRecords, sourceRecords);
+      }
+      for (i=0; i<qualitativeFields.length; i++) {
+        field = sourceFields[i];
+        destRec[field] = getInterpolatedCategory(field, tileRecords, sourceRecords);
       }
     });
   }
@@ -40846,7 +40936,7 @@ ${svg}
   //   return value;
   // }
 
-  function getInterpolatedValue(field, tileRecords, sourceRecords) {
+  function getInterpolatedNumber(field, tileRecords, sourceRecords) {
     var value = 0, tileRec, sourceRec, sourceId;
     for (var i=0; i<tileRecords.length; i++) {
       tileRec = tileRecords[i];
@@ -40860,6 +40950,31 @@ ${svg}
     return value;
   }
 
+  function getInterpolatedCategory(field, tileRecords, sourceRecords) {
+    var value, tileRec, sourceRec, sourceId, idx;
+    var areas = [];
+    var values = [];
+    for (var i=0; i<tileRecords.length; i++) {
+      tileRec = tileRecords[i];
+      if (!tileRec.sourceIds) continue;
+      for (var j=0; j<tileRec.sourceIds.length; j++) {
+        sourceId = tileRec.sourceIds[j];
+        sourceRec = sourceRecords[sourceId];
+        value = sourceRec[field];
+        idx = values.indexOf(value);
+        if (idx == -1) {
+          values.push(value);
+          areas.push(tileRec.area);
+        } else {
+          areas[idx] += tileRec.area;
+        }
+      }
+    }
+    var maxArea = Math.max.apply(null, areas);
+    var maxIdx = areas.indexOf(maxArea);
+    return maxIdx == -1 ? null : values[maxIdx];
+  }
+
 
   function getIdConversionFunction(offset, length) {
     return function (mergedIds) {
@@ -40872,17 +40987,50 @@ ${svg}
     };
   }
 
-  function getMaxOverlapFunction(destLyr, srcLyr, mosaicIndex) {
-    var arcs = mosaicIndex.nodes.arcs;
+  function getMinPctFunction(minPct, destLyr, mosaicIndex) {
+    mosaicIndex.nodes.arcs;
     var destLen = destLyr.shapes.length;
 
-    function getTotalArea(tileIds) {
-      var area = 0;
-      for (var i=0; i<tileIds.length; i++) {
-        area += geom.getShapeArea(mosaicIndex.mosaic[tileIds[i]], arcs);
-      }
-      return area;
+    return function(destId, srcIds) {
+      var destTileIds = mosaicIndex.getTileIdsByShapeId(destId);
+      var destArea = getAreaOfTiles(destTileIds, mosaicIndex);
+      return srcIds.filter(function(srcId, i) {
+        var srcTileIds = mosaicIndex.getTileIdsByShapeId(srcId + destLen);
+        var sharedIds = utils.intersection(destTileIds, srcTileIds);
+        var overlapArea = getAreaOfTiles(sharedIds, mosaicIndex);
+        var overlapPct = overlapArea / destArea || 0;
+        return overlapPct >= minPct;
+      });
+    };
+  }
+
+  function getMinAreaFunction(minArea, destLyr, mosaicIndex) {
+    mosaicIndex.nodes.arcs;
+    var destLen = destLyr.shapes.length;
+
+    return function(destId, srcIds) {
+      var destTileIds = mosaicIndex.getTileIdsByShapeId(destId);
+
+      return srcIds.filter(function(srcId, i) {
+        var srcTileIds = mosaicIndex.getTileIdsByShapeId(srcId + destLen);
+        var sharedIds = utils.intersection(destTileIds, srcTileIds);
+        var overlapArea = getAreaOfTiles(sharedIds, mosaicIndex);
+        return overlapArea >= minArea;
+      });
+    };
+  }
+
+  function getAreaOfTiles(tileIds, mosaicIndex) {
+    var arcs = mosaicIndex.nodes.arcs;
+    var area = 0;
+    for (var i=0; i<tileIds.length; i++) {
+      area += geom.getShapeArea(mosaicIndex.mosaic[tileIds[i]], arcs);
     }
+    return area;
+  }
+
+  function getMaxOverlapFunction(destLyr, mosaicIndex) {
+    var destLen = destLyr.shapes.length;
 
     return function(destId, srcIds) {
       var destTileIds = mosaicIndex.getTileIdsByShapeId(destId);
@@ -40891,7 +41039,7 @@ ${svg}
       srcIds.forEach(function(srcId, i) {
         var srcTileIds = mosaicIndex.getTileIdsByShapeId(srcId + destLen);
         var sharedIds = utils.intersection(destTileIds, srcTileIds);
-        var area = getTotalArea(sharedIds);
+        var area = getAreaOfTiles(sharedIds, mosaicIndex);
         if (area >= maxArea) {
           maxId = srcId;
           maxArea = area;
@@ -40904,14 +41052,21 @@ ${svg}
 
 
   // Returned function converts a target layer feature id to multiple source feature ids
-  // TODO: option to join the source polygon with the greatest overlapping area
   // TODO: option to ignore source polygon with small overlaps
   //       (as a percentage of the area of one or the other polygon?)
   function getPolygonToPolygonFunction(targetLyr, srcLyr, mosaicIndex, opts) {
     var mergedToSourceIds = getIdConversionFunction(targetLyr.shapes.length, srcLyr.shapes.length);
     var selectMaxOverlap;
+    var minAreaFilter;
+    var minPctFilter;
     if (opts.largest_overlap) {
-      selectMaxOverlap = getMaxOverlapFunction(targetLyr, srcLyr, mosaicIndex);
+      selectMaxOverlap = getMaxOverlapFunction(targetLyr, mosaicIndex);
+    }
+    if (opts.min_overlap_pct) {
+      minPctFilter = getMinPctFunction(opts.min_overlap_pct, targetLyr, mosaicIndex);
+    }
+    if (opts.min_overlap_area) {
+      minAreaFilter = getMinAreaFunction(opts.min_overlap_area, targetLyr, mosaicIndex);
     }
 
     return function(targId) {
@@ -40926,6 +41081,12 @@ ${svg}
       if (sourceIds.length > 1 && opts.largest_overlap) {
         sourceIds = selectMaxOverlap(targId, sourceIds);
       }
+      if (minAreaFilter) {
+        sourceIds = minAreaFilter(targId, sourceIds);
+      }
+      if (minPctFilter) {
+        sourceIds = minPctFilter(targId, sourceIds);
+      }
       return sourceIds;
     };
   }
@@ -44443,7 +44604,7 @@ ${svg}
   };
 
   cmd.svgStyle = function(lyr, dataset, opts) {
-    var filter;
+    var filterFn;
     if (getFeatureCount(lyr) === 0) {
       return;
     }
@@ -44451,7 +44612,10 @@ ${svg}
       initDataTable(lyr);
     }
     if (opts.where) {
-      filter = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+      filterFn = compileFeatureExpression(opts.where, lyr, dataset.arcs);
+    }
+    if (opts.clear) {
+      lyr.data.getFields().filter(isSupportedSvgStyleProperty).forEach(lyr.data.deleteField, lyr.data);
     }
     Object.keys(opts).forEach(function(optName) {
       var svgName = optName.replace('_', '-'); // undo cli parser name conversion
@@ -44461,7 +44625,7 @@ ${svg}
       var strVal = opts[optName].trim();
       var accessor = getSymbolPropertyAccessor(strVal, svgName, lyr);
       getLayerDataTable(lyr).getRecords().forEach(function(rec, i) {
-        if (filter && !filter(i)) {
+        if (filterFn && !filterFn(i)) {
           // make sure field exists if record is excluded by filter
           if (svgName in rec === false) {
             rec[svgName] = undefined;
@@ -45905,7 +46069,7 @@ ${svg}
     });
   }
 
-  var version = "0.6.101";
+  var version = "0.6.103";
 
   // Parse command line args into commands and run them
   // Function takes an optional Node-style callback. A Promise is returned if no callback is given.
@@ -46598,7 +46762,7 @@ ${svg}
     FileTypes,
     FilterGeom,
     Frame,
-    FrameData,
+    FrameUtils,
     Furniture,
     Geodesic,
     GeojsonExport,
@@ -46633,7 +46797,7 @@ ${svg}
     PathImport,
     PathRepair,
     PathUtils,
-    PixelTransform,
+    // PixelTransform,
     PointPolygonJoin,
     Points,
     PointToGrid,