vega 0.2.5 → 0.2.7

data/vendor/assets/javascripts/vega.js

@@ -2,89 +2,7 @@
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
   (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vega = {}));
-}(this, (function (exports) { 'use strict';
-
-  var name = "vega";
-  var version$1 = "5.21.0";
-  var description = "The Vega visualization grammar.";
-  var keywords$1 = [
-  	"vega",
-  	"visualization",
-  	"interaction",
-  	"dataflow",
-  	"library",
-  	"data",
-  	"d3"
-  ];
-  var license = "BSD-3-Clause";
-  var author = "UW Interactive Data Lab (http://idl.cs.washington.edu)";
-  var main = "build/vega-node.js";
-  var module = "build/vega.module.js";
-  var unpkg = "build/vega.min.js";
-  var jsdelivr = "build/vega.min.js";
-  var types = "index.d.ts";
-  var repository = "vega/vega";
-  var scripts = {
-  	bundle: "rollup -c --config-bundle",
-  	prebuild: "rimraf build && rimraf build-es5",
-  	build: "rollup -c --config-core --config-bundle --config-ie",
-  	postbuild: "node schema-copy",
-  	pretest: "yarn build --config-test",
-  	test: "TZ=America/Los_Angeles tape 'test/**/*-test.js'",
-  	prepublishOnly: "yarn test && yarn build",
-  	postpublish: "./schema-deploy.sh"
-  };
-  var dependencies = {
-  	"vega-crossfilter": "~4.0.5",
-  	"vega-dataflow": "~5.7.4",
-  	"vega-encode": "~4.8.3",
-  	"vega-event-selector": "~3.0.0",
-  	"vega-expression": "~5.0.0",
-  	"vega-force": "~4.0.7",
-  	"vega-format": "~1.0.4",
-  	"vega-functions": "~5.12.1",
-  	"vega-geo": "~4.3.8",
-  	"vega-hierarchy": "~4.0.9",
-  	"vega-label": "~1.1.0",
-  	"vega-loader": "~4.4.1",
-  	"vega-parser": "~6.1.4",
-  	"vega-projection": "~1.4.5",
-  	"vega-regression": "~1.0.9",
-  	"vega-runtime": "~6.1.3",
-  	"vega-scale": "~7.1.1",
-  	"vega-scenegraph": "~4.9.4",
-  	"vega-statistics": "~1.7.10",
-  	"vega-time": "~2.0.4",
-  	"vega-transforms": "~4.9.4",
-  	"vega-typings": "~0.22.0",
-  	"vega-util": "~1.17.0",
-  	"vega-view": "~5.10.1",
-  	"vega-view-transforms": "~4.5.8",
-  	"vega-voronoi": "~4.1.5",
-  	"vega-wordcloud": "~4.1.3"
-  };
-  var devDependencies = {
-  	"vega-schema": "*"
-  };
-  var gitHead = "774165e29850b66ec8b79ba52a7955f1ab936ea6";
-  var pkg = {
-  	name: name,
-  	version: version$1,
-  	description: description,
-  	keywords: keywords$1,
-  	license: license,
-  	author: author,
-  	main: main,
-  	module: module,
-  	unpkg: unpkg,
-  	jsdelivr: jsdelivr,
-  	types: types,
-  	repository: repository,
-  	scripts: scripts,
-  	dependencies: dependencies,
-  	devDependencies: devDependencies,
-  	gitHead: gitHead
-  };
+})(this, (function (exports) { 'use strict';
 
   function accessor(fn, fields, name) {
     fn.fields = fields || [];
@@ -211,7 +129,8 @@
   const Info = 3;
   const Debug = 4;
 
-  function logger(_, method, handler = log$1$1) {
+  function logger(_, method) {
+    let handler = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : log$1$1;
     let level = _ || None$2;
     return {
       level(_) {
@@ -254,7 +173,11 @@
 
   const isLegalKey = key => key !== '__proto__';
 
-  function mergeConfig(...configs) {
+  function mergeConfig() {
+    for (var _len = arguments.length, configs = new Array(_len), _key = 0; _key < _len; _key++) {
+      configs[_key] = arguments[_key];
+    }
+
     return configs.reduce((out, source) => {
       for (const key in source) {
         if (key === 'signals') {
@@ -437,12 +360,12 @@
     return get.length === 0 ? null : accessor(gen(get, ord), Object.keys(fmap));
   }
 
-  const ascending$3 = (u, v) => (u < v || u == null) && v != null ? -1 : (u > v || v == null) && u != null ? 1 : (v = v instanceof Date ? +v : v, u = u instanceof Date ? +u : u) !== u && v === v ? -1 : v !== v && u === u ? 1 : 0;
+  const ascending$2 = (u, v) => (u < v || u == null) && v != null ? -1 : (u > v || v == null) && u != null ? 1 : (v = v instanceof Date ? +v : v, u = u instanceof Date ? +u : u) !== u && v === v ? -1 : v !== v && u === u ? 1 : 0;
 
   const comparator = (fields, orders) => fields.length === 1 ? compare1(fields[0], orders[0]) : compareN(fields, orders, fields.length);
 
   const compare1 = (field, order) => function (a, b) {
-    return ascending$3(field(a), field(b)) * order;
+    return ascending$2(field(a), field(b)) * order;
   };
 
   const compareN = (fields, orders, n) => {
@@ -455,7 +378,7 @@
 
       while (c === 0 && ++i < n) {
         f = fields[i];
-        c = ascending$3(f(a), f(b));
+        c = ascending$2(f(a), f(b));
       }
 
       return c * orders[i];
@@ -1416,47 +1339,58 @@
     return arcs;
   }
 
-  function ascending$2 (a, b) {
-    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
+  function ascending$1(a, b) {
+    return a == null || b == null ? NaN : a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
   }
 
-  function bisector$1 (f) {
+  function bisector(f) {
     let delta = f;
-    let compare = f;
+    let compare1 = f;
+    let compare2 = f;
 
-    if (f.length === 1) {
+    if (f.length !== 2) {
       delta = (d, x) => f(d) - x;
 
-      compare = ascendingComparator$1(f);
+      compare1 = ascending$1;
+
+      compare2 = (d, x) => ascending$1(f(d), x);
     }
 
-    function left(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
+    function left(a, x) {
+      let lo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      let hi = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : a.length;
 
-      while (lo < hi) {
-        const mid = lo + hi >>> 1;
-        if (compare(a[mid], x) < 0) lo = mid + 1;else hi = mid;
+      if (lo < hi) {
+        if (compare1(x, x) !== 0) return hi;
+
+        do {
+          const mid = lo + hi >>> 1;
+          if (compare2(a[mid], x) < 0) lo = mid + 1;else hi = mid;
+        } while (lo < hi);
       }
 
       return lo;
     }
 
-    function right(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
+    function right(a, x) {
+      let lo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      let hi = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : a.length;
 
-      while (lo < hi) {
-        const mid = lo + hi >>> 1;
-        if (compare(a[mid], x) > 0) hi = mid;else lo = mid + 1;
+      if (lo < hi) {
+        if (compare1(x, x) !== 0) return hi;
+
+        do {
+          const mid = lo + hi >>> 1;
+          if (compare2(a[mid], x) <= 0) lo = mid + 1;else hi = mid;
+        } while (lo < hi);
       }
 
       return lo;
     }
 
-    function center(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
+    function center(a, x) {
+      let lo = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+      let hi = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : a.length;
       const i = left(a, x, lo, hi - 1);
       return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
     }
@@ -1468,11 +1402,7 @@
     };
   }
 
-  function ascendingComparator$1(f) {
-    return (d, x) => ascending$2(f(d), x);
-  }
-
-  function number$6 (x) {
+  function number$6(x) {
     return x === null ? NaN : +x;
   }
   function* numbers$2(values, valueof) {
@@ -1493,10 +1423,10 @@
     }
   }
 
-  const ascendingBisect = bisector$1(ascending$2);
+  const ascendingBisect = bisector(ascending$1);
   const bisectRight$1 = ascendingBisect.right;
   const bisectLeft$1 = ascendingBisect.left;
-  bisector$1(number$6).center;
+  bisector(number$6).center;
   var bisect$1 = bisectRight$1;
 
   function variance(values, valueof) {
@@ -1588,14 +1518,136 @@
 
   }
 
-  function permute (source, keys) {
+  class InternMap extends Map {
+    constructor(entries) {
+      let key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : keyof;
+      super();
+      Object.defineProperties(this, {
+        _intern: {
+          value: new Map()
+        },
+        _key: {
+          value: key
+        }
+      });
+      if (entries != null) for (const [key, value] of entries) this.set(key, value);
+    }
+
+    get(key) {
+      return super.get(intern_get(this, key));
+    }
+
+    has(key) {
+      return super.has(intern_get(this, key));
+    }
+
+    set(key, value) {
+      return super.set(intern_set(this, key), value);
+    }
+
+    delete(key) {
+      return super.delete(intern_delete(this, key));
+    }
+
+  }
+  class InternSet extends Set {
+    constructor(values) {
+      let key = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : keyof;
+      super();
+      Object.defineProperties(this, {
+        _intern: {
+          value: new Map()
+        },
+        _key: {
+          value: key
+        }
+      });
+      if (values != null) for (const value of values) this.add(value);
+    }
+
+    has(value) {
+      return super.has(intern_get(this, value));
+    }
+
+    add(value) {
+      return super.add(intern_set(this, value));
+    }
+
+    delete(value) {
+      return super.delete(intern_delete(this, value));
+    }
+
+  }
+
+  function intern_get(_ref, value) {
+    let {
+      _intern,
+      _key
+    } = _ref;
+
+    const key = _key(value);
+
+    return _intern.has(key) ? _intern.get(key) : value;
+  }
+
+  function intern_set(_ref2, value) {
+    let {
+      _intern,
+      _key
+    } = _ref2;
+
+    const key = _key(value);
+
+    if (_intern.has(key)) return _intern.get(key);
+
+    _intern.set(key, value);
+
+    return value;
+  }
+
+  function intern_delete(_ref3, value) {
+    let {
+      _intern,
+      _key
+    } = _ref3;
+
+    const key = _key(value);
+
+    if (_intern.has(key)) {
+      value = _intern.get(key);
+
+      _intern.delete(key);
+    }
+
+    return value;
+  }
+
+  function keyof(value) {
+    return value !== null && typeof value === "object" ? value.valueOf() : value;
+  }
+
+  function permute(source, keys) {
     return Array.from(keys, key => source[key]);
   }
 
+  function compareDefined() {
+    let compare = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ascending$1;
+    if (compare === ascending$1) return ascendingDefined;
+    if (typeof compare !== "function") throw new TypeError("compare is not a function");
+    return (a, b) => {
+      const x = compare(a, b);
+      if (x || x === 0) return x;
+      return (compare(b, b) === 0) - (compare(a, a) === 0);
+    };
+  }
+  function ascendingDefined(a, b) {
+    return (a == null || !(a >= a)) - (b == null || !(b >= b)) || (a < b ? -1 : a > b ? 1 : 0);
+  }
+
   var e10 = Math.sqrt(50),
       e5 = Math.sqrt(10),
       e2 = Math.sqrt(2);
-  function ticks (start, stop, count) {
+  function ticks(start, stop, count) {
     var reverse,
         i = -1,
         n,
@@ -1688,7 +1740,12 @@
 
   // ISC license, Copyright 2018 Vladimir Agafonkin.
 
-  function quickselect(array, k, left = 0, right = array.length - 1, compare = ascending$2) {
+  function quickselect(array, k) {
+    let left = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    let right = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : array.length - 1;
+    let compare = arguments.length > 4 ? arguments[4] : undefined;
+    compare = compare === undefined ? ascendingDefined : compareDefined(compare);
+
     while (right > left) {
       if (right - left > 600) {
         const n = right - left + 1;
@@ -1741,7 +1798,8 @@
         value1 = min$2(values.subarray(i0 + 1));
     return value0 + (value1 - value0) * (i - i0);
   }
-  function quantileSorted(values, p, valueof = number$6) {
+  function quantileSorted(values, p) {
+    let valueof = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : number$6;
     if (!(n = values.length)) return;
     if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
     if (p >= 1) return +valueof(values[n - 1], n - 1, values);
@@ -1776,7 +1834,7 @@
     if (count) return sum / count;
   }
 
-  function median (values, valueof) {
+  function median(values, valueof) {
     return quantile$1(values, 0.5, valueof);
   }
 
@@ -1790,7 +1848,7 @@
     return Array.from(flatten(arrays));
   }
 
-  function range$1$1 (start, stop, step) {
+  function range$3(start, stop, step) {
     start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
     var i = -1,
         n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
@@ -1803,7 +1861,7 @@
     return range;
   }
 
-  function sum(values, valueof) {
+  function sum$1(values, valueof) {
     let sum = 0;
 
     if (valueof === undefined) {
@@ -1825,6 +1883,46 @@
     return sum;
   }
 
+  function intersection(values) {
+    for (var _len = arguments.length, others = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      others[_key - 1] = arguments[_key];
+    }
+
+    values = new InternSet(values);
+    others = others.map(set$4);
+
+    out: for (const value of values) {
+      for (const other of others) {
+        if (!other.has(value)) {
+          values.delete(value);
+          continue out;
+        }
+      }
+    }
+
+    return values;
+  }
+
+  function set$4(values) {
+    return values instanceof InternSet ? values : new InternSet(values);
+  }
+
+  function union() {
+    const set = new InternSet();
+
+    for (var _len = arguments.length, others = new Array(_len), _key = 0; _key < _len; _key++) {
+      others[_key] = arguments[_key];
+    }
+
+    for (const other of others) {
+      for (const o of other) {
+        set.add(o);
+      }
+    }
+
+    return set;
+  }
+
   function formatDecimal (x) {
     return Math.abs(x = Math.round(x)) >= 1e21 ? x.toLocaleString("en").replace(/,/g, "") : x.toString(10);
   } // Computes the decimal coefficient and exponent of the specified number x with
@@ -2427,7 +2525,10 @@
 
     function tickInterval(start, stop, count) {
       const target = Math.abs(stop - start) / count;
-      const i = bisector$1(([,, step]) => step).right(tickIntervals, target);
+      const i = bisector(_ref => {
+        let [,, step] = _ref;
+        return step;
+      }).right(tickIntervals, target);
       if (i === tickIntervals.length) return year.every(tickStep(start / durationYear$1, stop / durationYear$1, count));
       if (i === 0) return utcMillisecond.every(Math.max(tickStep(start, stop, count), 1));
       const [t, step] = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
@@ -2463,13 +2564,13 @@
       if (has$1(UNITS, unit)) {
         m[unit] = 1;
       } else {
-        error(`Invalid time unit: ${unit}.`);
+        error("Invalid time unit: ".concat(unit, "."));
       }
     });
     const numTypes = (m[WEEK] || m[DAY] ? 1 : 0) + (m[QUARTER] || m[MONTH] || m[DATE] ? 1 : 0) + (m[DAYOFYEAR] ? 1 : 0);
 
     if (numTypes > 1) {
-      error(`Incompatible time units: ${units}`);
+      error("Incompatible time units: ".concat(units));
     } // ensure proper sort order
 
 
@@ -2489,9 +2590,9 @@
     [MINUTES]: '00:%M',
     [SECONDS]: ':%S',
     [MILLISECONDS]: '.%L',
-    [`${YEAR}-${MONTH}`]: '%Y-%m ',
-    [`${YEAR}-${MONTH}-${DATE}`]: '%Y-%m-%d ',
-    [`${HOURS}-${MINUTES}`]: '%H:%M'
+    ["".concat(YEAR, "-").concat(MONTH)]: '%Y-%m ',
+    ["".concat(YEAR, "-").concat(MONTH, "-").concat(DATE)]: '%Y-%m-%d ',
+    ["".concat(HOURS, "-").concat(MINUTES)]: '%H:%M'
   };
 
   function timeUnitSpecifier(units, specifiers) {
@@ -2754,7 +2855,7 @@
     const ext = opt.extent,
           max = opt.maxbins || 40,
           target = Math.abs(span(ext)) / max;
-    let i = bisector$1(i => i[2]).right(intervals, target),
+    let i = bisector(i => i[2]).right(intervals, target),
         units,
         step;
 
@@ -3637,7 +3738,7 @@
     spec = spec || {};
 
     if (!isObject(spec)) {
-      error(`Invalid time multi-format specifier: ${spec}`);
+      error("Invalid time multi-format specifier: ".concat(spec));
     }
 
     const second = interval(SECONDS),
@@ -4034,12 +4135,12 @@
     const reader = formats$1(schema.type || 'json');
     if (!reader) error('Unknown data format type: ' + schema.type);
     data = reader(data, schema);
-    if (schema.parse) parse$5(data, schema.parse, timeParser, utcParser);
+    if (schema.parse) parse$6(data, schema.parse, timeParser, utcParser);
     if (has$1(data, 'columns')) delete data.columns;
     return data;
   }
 
-  function parse$5(data, types, timeParser, utcParser) {
+  function parse$6(data, types, timeParser, utcParser) {
     if (!data.length) return; // early exit for empty data
 
     const locale = timeFormatDefaultLocale();
@@ -4601,7 +4702,7 @@
      *   this flag determines if the operator registers itself as a listener on
      *   any upstream operators included in the parameters.
      * @param {boolean} [initonly=false] - A flag indicating if this operator
-     *   should calculate an update only upon its initiatal evaluation, then
+     *   should calculate an update only upon its initial evaluation, then
      *   deregister dependencies and suppress all future update invocations.
      * @return {Operator[]} - An array of upstream dependencies.
      */
@@ -5002,7 +5103,7 @@
     return s;
   }
 
-  function parse$4(data, format) {
+  function parse$5(data, format) {
     const locale = this.locale();
     return read(data, format, locale.timeParse, locale.utcParse);
   }
@@ -5829,7 +5930,7 @@
 
     df._input = {};
     df._pulse = null;
-    df.debug(`Pulse ${stamp}: ${count} operators`);
+    df.debug("Pulse ".concat(stamp, ": ").concat(count, " operators"));
 
     if (error) {
       df._postrun = [];
@@ -6323,7 +6424,7 @@
     changeset,
     // DATA LOADING
     ingest,
-    parse: parse$4,
+    parse: parse$5,
     preload,
     request,
     // EVENT HANDLING
@@ -6441,7 +6542,7 @@
     const values = Float64Array.from(numbers$1(array, f)); // don't depend on return value from typed array sort call
     // protects against undefined sort results in Safari (vega/vega-lite#4964)
 
-    values.sort(ascending$2);
+    values.sort(ascending$1);
     return p.map(_ => quantileSorted(values, _));
   }
 
@@ -6541,7 +6642,7 @@
       mu[j] = a / n;
     }
 
-    mu.sort(ascending$2);
+    mu.sort(ascending$1);
     return [quantile$1(mu, alpha / 2), quantile$1(mu, 1 - alpha / 2)];
   } // Dot density binning for dot plot construction.
   // Based on Leland Wilkinson, Dot Plots, The American Statistician, 1999.
@@ -7494,7 +7595,7 @@
   }
 
   const maxiters = 2,
-        epsilon$5 = 1e-12; // Adapted from science.js by Jason Davies
+        epsilon$6 = 1e-12; // Adapted from science.js by Jason Davies
   // Source: https://github.com/jasondavies/science.js/blob/master/src/stats/loess.js
   // License: https://github.com/jasondavies/science.js/blob/master/LICENSE
 
@@ -7546,13 +7647,13 @@
       }
 
       const medianResidual = median(residuals);
-      if (Math.abs(medianResidual) < epsilon$5) break;
+      if (Math.abs(medianResidual) < epsilon$6) break;
 
       for (let i = 0, arg, w; i < n; ++i) {
         arg = residuals[i] / (6 * medianResidual); // default to epsilon (rather than zero) for large deviations
         // keeping weights tiny but non-zero prevents singularites
 
-        robustWeights[i] = arg >= 1 ? epsilon$5 : (w = 1 - arg * arg) * w;
+        robustWeights[i] = arg >= 1 ? epsilon$6 : (w = 1 - arg * arg) * w;
       }
     }
 
@@ -8963,7 +9064,7 @@
    * @return {object} - The output distribution object.
    */
 
-  function parse$3(def, data) {
+  function parse$4(def, data) {
     const func = def[FUNCTION];
 
     if (!has$1(Distributions, func)) {
@@ -8978,7 +9079,7 @@
         d.data((def.from || data()).map(def[name]));
       } // if distribution mixture, recurse to parse each definition
       else if (name === DISTRIBUTIONS) {
-        d[name](def[name].map(_ => parse$3(_, data)));
+        d[name](def[name].map(_ => parse$4(_, data)));
       } // otherwise, simply set the parameter
       else if (typeof d[name] === FUNCTION) {
         d[name](def[name]);
@@ -9130,7 +9231,7 @@
       const out = pulse.fork(pulse.NO_SOURCE | pulse.NO_FIELDS);
 
       if (!this.value || pulse.changed() || _.modified()) {
-        const dist = parse$3(_.distribution, source$1(pulse)),
+        const dist = parse$4(_.distribution, source$1(pulse)),
               minsteps = _.steps || _.minsteps || 25,
               maxsteps = _.steps || _.maxsteps || 200;
         let method = _.method || 'pdf';
@@ -9353,8 +9454,8 @@
 
       if (!Number.isFinite(min) || !Number.isFinite(max)) {
         let name = accessorName(field);
-        if (name) name = ` for field "${name}"`;
-        pulse.dataflow.warn(`Infinite extent${name}: [${min}, ${max}]`);
+        if (name) name = " for field \"".concat(name, "\"");
+        pulse.dataflow.warn("Infinite extent".concat(name, ": [").concat(min, ", ").concat(max, "]"));
         min = max = undefined;
       }
 
@@ -10665,7 +10766,7 @@
         list.push(k);
       }
     });
-    list.sort(ascending$3);
+    list.sort(ascending$2);
     return limit ? list.slice(0, limit) : list;
   }
   /**
@@ -10882,7 +10983,7 @@
             names = (_.groupby || []).map(accessorName),
             values = [],
             step = _.step || 0.01,
-            p = _.probs || range$1$1(step / 2, 1 - EPSILON$2, step),
+            p = _.probs || range$3(step / 2, 1 - EPSILON$2, step),
             n = p.length;
       groups.forEach(g => {
         const q = quantiles(g, p);
@@ -11116,7 +11217,7 @@
       const out = pulse.materialize().fork(pulse.MOD),
             as = _.as || 'data';
       out.rem = this.value ? pulse.rem.concat(this.value) : pulse.rem;
-      this.value = range$1$1(_.start, _.stop, _.step || 1).map(v => {
+      this.value = range$3(_.start, _.stop, _.step || 1).map(v => {
         const t = {};
         t[as] = v;
         return ingest$1(t);
@@ -11216,7 +11317,7 @@
           max = floor.stop || -Infinity,
           flag = pulse.ADD;
 
-      if (_.modified() || pulse.modified(accessorFields(field))) {
+      if (_.modified() || pulse.changed(pulse.REM) || pulse.modified(accessorFields(field))) {
         pulse = pulse.reflow(true);
         flag = pulse.SOURCE;
         min = Infinity;
@@ -11751,7 +11852,7 @@
           data = list.data(cmp),
           // use cmp for stable sort
     n = data.length,
-          b = range ? bisector$1(sort) : null,
+          b = range ? bisector(sort) : null,
           w = {
       i0: 0,
       i1: 0,
@@ -11835,8 +11936,8 @@
 
   const pi$3 = Math.PI,
         tau$3 = 2 * pi$3,
-        epsilon$4 = 1e-6,
-        tauEpsilon = tau$3 - epsilon$4;
+        epsilon$5 = 1e-6,
+        tauEpsilon = tau$3 - epsilon$5;
 
   function Path$1() {
     this._x0 = this._y0 = // start of current subpath
@@ -11884,10 +11985,10 @@
       if (this._x1 === null) {
         this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
       } // Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
-      else if (!(l01_2 > epsilon$4)) ; // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
+      else if (!(l01_2 > epsilon$5)) ; // Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
       // Equivalently, is (x1,y1) coincident with (x2,y2)?
       // Or, is the radius zero? Line to (x1,y1).
-      else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$4) || !r) {
+      else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon$5) || !r) {
         this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
       } // Otherwise, draw an arc!
       else {
@@ -11901,7 +12002,7 @@
             t01 = l / l01,
             t21 = l / l21; // If the start tangent is not coincident with (x0,y0), line to.
 
-        if (Math.abs(t01 - 1) > epsilon$4) {
+        if (Math.abs(t01 - 1) > epsilon$5) {
           this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
         }
 
@@ -11922,7 +12023,7 @@
       if (this._x1 === null) {
         this._ += "M" + x0 + "," + y0;
       } // Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).
-      else if (Math.abs(this._x1 - x0) > epsilon$4 || Math.abs(this._y1 - y0) > epsilon$4) {
+      else if (Math.abs(this._x1 - x0) > epsilon$5 || Math.abs(this._y1 - y0) > epsilon$5) {
         this._ += "L" + x0 + "," + y0;
       } // Is this arc empty? We’re done.
 
@@ -11934,7 +12035,7 @@
       if (da > tauEpsilon) {
         this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0);
       } // Is this arc non-empty? Draw an arc!
-      else if (da > epsilon$4) {
+      else if (da > epsilon$5) {
         this._ += "A" + r + "," + r + ",0," + +(da >= pi$3) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1));
       }
     },
@@ -11952,17 +12053,17 @@
     };
   }
 
-  var abs$2 = Math.abs;
-  var atan2$1 = Math.atan2;
-  var cos$2 = Math.cos;
-  var max$1 = Math.max;
-  var min$1 = Math.min;
-  var sin$2 = Math.sin;
-  var sqrt$3 = Math.sqrt;
-  var epsilon$3 = 1e-12;
-  var pi$2 = Math.PI;
-  var halfPi$2 = pi$2 / 2;
-  var tau$2 = 2 * pi$2;
+  const abs$2 = Math.abs;
+  const atan2$1 = Math.atan2;
+  const cos$2 = Math.cos;
+  const max$1 = Math.max;
+  const min$1 = Math.min;
+  const sin$2 = Math.sin;
+  const sqrt$3 = Math.sqrt;
+  const epsilon$4 = 1e-12;
+  const pi$2 = Math.PI;
+  const halfPi$2 = pi$2 / 2;
+  const tau$2 = 2 * pi$2;
   function acos$1(x) {
     return x > 1 ? 0 : x < -1 ? pi$2 : Math.acos(x);
   }
@@ -11996,7 +12097,7 @@
         x32 = x3 - x2,
         y32 = y3 - y2,
         t = y32 * x10 - x32 * y10;
-    if (t * t < epsilon$3) return;
+    if (t * t < epsilon$4) return;
     t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
     return [x0 + t * x10, y0 + t * y10];
   } // Compute perpendicular offset line of length rc.
@@ -12065,12 +12166,12 @@
 
       if (r1 < r0) r = r1, r1 = r0, r0 = r; // Is it a point?
 
-      if (!(r1 > epsilon$3)) context.moveTo(0, 0); // Or is it a circle or annulus?
-      else if (da > tau$2 - epsilon$3) {
+      if (!(r1 > epsilon$4)) context.moveTo(0, 0); // Or is it a circle or annulus?
+      else if (da > tau$2 - epsilon$4) {
         context.moveTo(r1 * cos$2(a0), r1 * sin$2(a0));
         context.arc(0, 0, r1, a0, a1, !cw);
 
-        if (r0 > epsilon$3) {
+        if (r0 > epsilon$4) {
           context.moveTo(r0 * cos$2(a1), r0 * sin$2(a1));
           context.arc(0, 0, r0, a1, a0, cw);
         }
@@ -12083,18 +12184,18 @@
             da0 = da,
             da1 = da,
             ap = padAngle.apply(this, arguments) / 2,
-            rp = ap > epsilon$3 && (padRadius ? +padRadius.apply(this, arguments) : sqrt$3(r0 * r0 + r1 * r1)),
+            rp = ap > epsilon$4 && (padRadius ? +padRadius.apply(this, arguments) : sqrt$3(r0 * r0 + r1 * r1)),
             rc = min$1(abs$2(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),
             rc0 = rc,
             rc1 = rc,
             t0,
             t1; // Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.
 
-        if (rp > epsilon$3) {
+        if (rp > epsilon$4) {
           var p0 = asin$2(rp / r0 * sin$2(ap)),
               p1 = asin$2(rp / r1 * sin$2(ap));
-          if ((da0 -= p0 * 2) > epsilon$3) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;else da0 = 0, a00 = a10 = (a0 + a1) / 2;
-          if ((da1 -= p1 * 2) > epsilon$3) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;else da1 = 0, a01 = a11 = (a0 + a1) / 2;
+          if ((da0 -= p0 * 2) > epsilon$4) p0 *= cw ? 1 : -1, a00 += p0, a10 -= p0;else da0 = 0, a00 = a10 = (a0 + a1) / 2;
+          if ((da1 -= p1 * 2) > epsilon$4) p1 *= cw ? 1 : -1, a01 += p1, a11 -= p1;else da1 = 0, a01 = a11 = (a0 + a1) / 2;
         }
 
         var x01 = r1 * cos$2(a01),
@@ -12102,7 +12203,7 @@
             x10 = r0 * cos$2(a10),
             y10 = r0 * sin$2(a10); // Apply rounded corners?
 
-        if (rc > epsilon$3) {
+        if (rc > epsilon$4) {
           var x11 = r1 * cos$2(a11),
               y11 = r1 * sin$2(a11),
               x00 = r0 * cos$2(a00),
@@ -12122,8 +12223,8 @@
         } // Is the sector collapsed to a line?
 
 
-        if (!(da1 > epsilon$3)) context.moveTo(x01, y01); // Does the sector’s outer ring have rounded corners?
-        else if (rc1 > epsilon$3) {
+        if (!(da1 > epsilon$4)) context.moveTo(x01, y01); // Does the sector’s outer ring have rounded corners?
+        else if (rc1 > epsilon$4) {
           t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
           t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
           context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01); // Have the corners merged?
@@ -12138,8 +12239,8 @@
         else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw); // Is there no inner ring, and it’s a circular sector?
         // Or perhaps it’s an annular sector collapsed due to padding?
 
-        if (!(r0 > epsilon$3) || !(da0 > epsilon$3)) context.lineTo(x10, y10); // Does the sector’s inner ring (or point) have rounded corners?
-        else if (rc0 > epsilon$3) {
+        if (!(r0 > epsilon$4) || !(da0 > epsilon$4)) context.lineTo(x10, y10); // Does the sector’s inner ring (or point) have rounded corners?
+        else if (rc0 > epsilon$4) {
           t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
           t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
           context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01); // Have the corners merged?
@@ -12232,7 +12333,7 @@
 
         case 1:
           this._point = 2;
-        // proceed
+        // falls through
 
         default:
           this._context.lineTo(x, y);
@@ -12408,20 +12509,21 @@
   }
 
   var circle$1 = {
-    draw: function (context, size) {
-      var r = Math.sqrt(size / pi$2);
+    draw(context, size) {
+      const r = sqrt$3(size / pi$2);
       context.moveTo(r, 0);
       context.arc(0, 0, r, 0, tau$2);
     }
+
   };
 
-  function symbol$2 (type, size) {
-    var context = null;
+  function Symbol$1(type, size) {
+    let context = null;
     type = typeof type === "function" ? type : constant$3(type || circle$1);
     size = typeof size === "function" ? size : constant$3(size === undefined ? 64 : +size);
 
     function symbol() {
-      var buffer;
+      let buffer;
       if (!context) context = buffer = path$3();
       type.apply(this, arguments).draw(context, +size.apply(this, arguments));
       if (buffer) return context = null, buffer + "" || null;
@@ -12465,7 +12567,7 @@
       switch (this._point) {
         case 3:
           point$5(this, this._x1, this._y1);
-        // proceed
+        // falls through
 
         case 2:
           this._context.lineTo(this._x1, this._y1);
@@ -12494,7 +12596,7 @@
 
           this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6);
 
-        // proceed
+        // falls through
 
         default:
           point$5(this, x, y);
@@ -12626,7 +12728,7 @@
 
         case 3:
           this._point = 4;
-        // proceed
+        // falls through
 
         default:
           point$5(this, x, y);
@@ -12744,7 +12846,7 @@
 
         case 2:
           this._point = 3;
-        // proceed
+        // falls through
 
         default:
           point$4(this, x, y);
@@ -12887,7 +12989,7 @@
 
         case 3:
           this._point = 4;
-        // proceed
+        // falls through
 
         default:
           point$4(this, x, y);
@@ -12916,14 +13018,14 @@
         x2 = that._x2,
         y2 = that._y2;
 
-    if (that._l01_a > epsilon$3) {
+    if (that._l01_a > epsilon$4) {
       var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,
           n = 3 * that._l01_a * (that._l01_a + that._l12_a);
       x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;
       y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;
     }
 
-    if (that._l23_a > epsilon$3) {
+    if (that._l23_a > epsilon$4) {
       var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,
           m = 3 * that._l23_a * (that._l23_a + that._l12_a);
       x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;
@@ -12985,7 +13087,7 @@
 
         case 2:
           this._point = 3;
-        // proceed
+        // falls through
 
         default:
           point$3(this, x, y);
@@ -13146,7 +13248,7 @@
 
         case 3:
           this._point = 4;
-        // proceed
+        // falls through
 
         default:
           point$3(this, x, y);
@@ -13431,7 +13533,7 @@
 
         case 1:
           this._point = 2;
-        // proceed
+        // falls through
 
         default:
           {
@@ -13520,31 +13622,29 @@
 
   const implicit = Symbol("implicit");
   function ordinal() {
-    var index = new Map(),
+    var index = new InternMap(),
         domain = [],
         range = [],
         unknown = implicit;
 
     function scale(d) {
-      var key = d + "",
-          i = index.get(key);
+      let i = index.get(d);
 
-      if (!i) {
+      if (i === undefined) {
         if (unknown !== implicit) return unknown;
-        index.set(key, i = domain.push(d));
+        index.set(d, i = domain.push(d) - 1);
       }
 
-      return range[(i - 1) % range.length];
+      return range[i % range.length];
     }
 
     scale.domain = function (_) {
       if (!arguments.length) return domain.slice();
-      domain = [], index = new Map();
+      domain = [], index = new InternMap();
 
       for (const value of _) {
-        const key = value + "";
-        if (index.has(key)) continue;
-        index.set(key, domain.push(value));
+        if (index.has(value)) continue;
+        index.set(value, domain.push(value) - 1);
       }
 
       return scale;
@@ -14027,13 +14127,13 @@
   }));
 
   var A = -0.14861,
-      B = +1.78277,
+      B$1 = +1.78277,
       C$1 = -0.29227,
-      D = -0.90649,
+      D$1 = -0.90649,
       E = +1.97294,
-      ED = E * D,
-      EB = E * B,
-      BC_DA = B * C$1 - D * A;
+      ED = E * D$1,
+      EB = E * B$1,
+      BC_DA = B$1 * C$1 - D$1 * A;
 
   function cubehelixConvert(o) {
     if (o instanceof Cubehelix) return new Cubehelix(o.h, o.s, o.l, o.opacity);
@@ -14043,7 +14143,7 @@
         b = o.b / 255,
         l = (BC_DA * b + ED * r - EB * g) / (BC_DA + ED - EB),
         bl = b - l,
-        k = (E * (g - l) - C$1 * bl) / D,
+        k = (E * (g - l) - C$1 * bl) / D$1,
         s = Math.sqrt(k * k + bl * bl) / (E * l * (1 - l)),
         // NaN if l=0 or l=1
     h = s ? Math.atan2(k, bl) * degrees$2 - 120 : NaN;
@@ -14074,7 +14174,7 @@
           a = isNaN(this.s) ? 0 : this.s * l * (1 - l),
           cosh = Math.cos(h),
           sinh = Math.sin(h);
-      return new Rgb(255 * (l + a * (A * cosh + B * sinh)), 255 * (l + a * (C$1 * cosh + D * sinh)), 255 * (l + a * (E * cosh)), this.opacity);
+      return new Rgb(255 * (l + a * (A * cosh + B$1 * sinh)), 255 * (l + a * (C$1 * cosh + D$1 * sinh)), 255 * (l + a * (E * cosh)), this.opacity);
     }
   }));
 
@@ -14701,7 +14801,7 @@
     return x;
   }
 
-  function normalize(a, b) {
+  function normalize$1(a, b) {
     return (b -= a = +a) ? function (x) {
       return (x - a) / b;
     } : constants(isNaN(b) ? NaN : 0.5);
@@ -14722,7 +14822,7 @@
         d1 = domain[1],
         r0 = range[0],
         r1 = range[1];
-    if (d1 < d0) d0 = normalize(d1, d0), r0 = interpolate(r1, r0);else d0 = normalize(d0, d1), r0 = interpolate(r0, r1);
+    if (d1 < d0) d0 = normalize$1(d1, d0), r0 = interpolate(r1, r0);else d0 = normalize$1(d0, d1), r0 = interpolate(r0, r1);
     return function (x) {
       return r0(d0(x));
     };
@@ -14740,7 +14840,7 @@
     }
 
     while (++i < j) {
-      d[i] = normalize(domain[i], domain[i + 1]);
+      d[i] = normalize$1(domain[i], domain[i + 1]);
       r[i] = interpolate(range[i], range[i + 1]);
     }
 
@@ -14977,29 +15077,23 @@
   }
 
   function powp(base) {
-    return base === 10 ? pow10 : base === Math.E ? Math.exp : function (x) {
-      return Math.pow(base, x);
-    };
+    return base === 10 ? pow10 : base === Math.E ? Math.exp : x => Math.pow(base, x);
   }
 
   function logp(base) {
-    return base === Math.E ? Math.log : base === 10 && Math.log10 || base === 2 && Math.log2 || (base = Math.log(base), function (x) {
-      return Math.log(x) / base;
-    });
+    return base === Math.E ? Math.log : base === 10 && Math.log10 || base === 2 && Math.log2 || (base = Math.log(base), x => Math.log(x) / base);
   }
 
   function reflect(f) {
-    return function (x) {
-      return -f(-x);
-    };
+    return (x, k) => -f(-x, k);
   }
 
   function loggish(transform) {
-    var scale = transform(transformLog, transformExp),
-        domain = scale.domain,
-        base = 10,
-        logs,
-        pows;
+    const scale = transform(transformLog, transformExp);
+    const domain = scale.domain;
+    let base = 10;
+    let logs;
+    let pows;
 
     function rescale() {
       logs = logp(base), pows = powp(base);
@@ -15022,32 +15116,31 @@
       return arguments.length ? (domain(_), rescale()) : domain();
     };
 
-    scale.ticks = function (count) {
-      var d = domain(),
-          u = d[0],
-          v = d[d.length - 1],
-          r;
-      if (r = v < u) i = u, u = v, v = i;
-      var i = logs(u),
-          j = logs(v),
-          p,
-          k,
-          t,
-          n = count == null ? 10 : +count,
-          z = [];
+    scale.ticks = count => {
+      const d = domain();
+      let u = d[0];
+      let v = d[d.length - 1];
+      const r = v < u;
+      if (r) [u, v] = [v, u];
+      let i = logs(u);
+      let j = logs(v);
+      let k;
+      let t;
+      const n = count == null ? 10 : +count;
+      let z = [];
 
       if (!(base % 1) && j - i < n) {
         i = Math.floor(i), j = Math.ceil(j);
         if (u > 0) for (; i <= j; ++i) {
-          for (k = 1, p = pows(i); k < base; ++k) {
-            t = p * k;
+          for (k = 1; k < base; ++k) {
+            t = i < 0 ? k / pows(-i) : k * pows(i);
             if (t < u) continue;
             if (t > v) break;
             z.push(t);
           }
         } else for (; i <= j; ++i) {
-          for (k = base - 1, p = pows(i); k >= 1; --k) {
-            t = p * k;
+          for (k = base - 1; k >= 1; --k) {
+            t = i > 0 ? k / pows(-i) : k * pows(i);
             if (t < u) continue;
             if (t > v) break;
             z.push(t);
@@ -15061,39 +15154,38 @@
       return r ? z.reverse() : z;
     };
 
-    scale.tickFormat = function (count, specifier) {
-      if (specifier == null) specifier = base === 10 ? ".0e" : ",";
-      if (typeof specifier !== "function") specifier = format$3(specifier);
-      if (count === Infinity) return specifier;
+    scale.tickFormat = (count, specifier) => {
       if (count == null) count = 10;
-      var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?
+      if (specifier == null) specifier = base === 10 ? "s" : ",";
 
-      return function (d) {
-        var i = d / pows(Math.round(logs(d)));
+      if (typeof specifier !== "function") {
+        if (!(base % 1) && (specifier = formatSpecifier(specifier)).precision == null) specifier.trim = true;
+        specifier = format$3(specifier);
+      }
+
+      if (count === Infinity) return specifier;
+      const k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?
+
+      return d => {
+        let i = d / pows(Math.round(logs(d)));
         if (i * base < base - 0.5) i *= base;
         return i <= k ? specifier(d) : "";
       };
     };
 
-    scale.nice = function () {
+    scale.nice = () => {
       return domain(nice(domain(), {
-        floor: function (x) {
-          return pows(Math.floor(logs(x)));
-        },
-        ceil: function (x) {
-          return pows(Math.ceil(logs(x)));
-        }
+        floor: x => pows(Math.floor(logs(x))),
+        ceil: x => pows(Math.ceil(logs(x)))
       }));
     };
 
     return scale;
   }
   function log$2() {
-    var scale = loggish(transformer$3()).domain([1, 10]);
+    const scale = loggish(transformer$3()).domain([1, 10]);
 
-    scale.copy = function () {
-      return copy$2(scale, log$2()).base(scale.base());
-    };
+    scale.copy = () => copy$2(scale, log$2()).base(scale.base());
 
     initRange.apply(scale, arguments);
     return scale;
@@ -15204,7 +15296,7 @@
 
       for (let d of _) if (d != null && !isNaN(d = +d)) domain.push(d);
 
-      domain.sort(ascending$2);
+      domain.sort(ascending$1);
       return rescale();
     };
 
@@ -15662,7 +15754,7 @@
         bandwidth = Math.round(bandwidth);
       }
 
-      const values = range$1$1(n).map(i => start + step * i);
+      const values = range$3(n).map(i => start + step * i);
       return ordinalRange(reverse ? values.reverse() : values);
     }
 
@@ -15897,17 +15989,17 @@
 
   scale$4(Sequential, sequential, [Continuous, Interpolating]); // backwards compat
 
-  scale$4(`${Sequential}-${Linear}`, sequential, [Continuous, Interpolating]);
-  scale$4(`${Sequential}-${Log}`, sequentialLog, [Continuous, Interpolating, Log]);
-  scale$4(`${Sequential}-${Pow}`, sequentialPow, [Continuous, Interpolating]);
-  scale$4(`${Sequential}-${Sqrt}`, sequentialSqrt, [Continuous, Interpolating]);
-  scale$4(`${Sequential}-${Symlog}`, sequentialSymlog, [Continuous, Interpolating]); // diverging scales
+  scale$4("".concat(Sequential, "-").concat(Linear), sequential, [Continuous, Interpolating]);
+  scale$4("".concat(Sequential, "-").concat(Log), sequentialLog, [Continuous, Interpolating, Log]);
+  scale$4("".concat(Sequential, "-").concat(Pow), sequentialPow, [Continuous, Interpolating]);
+  scale$4("".concat(Sequential, "-").concat(Sqrt), sequentialSqrt, [Continuous, Interpolating]);
+  scale$4("".concat(Sequential, "-").concat(Symlog), sequentialSymlog, [Continuous, Interpolating]); // diverging scales
 
-  scale$4(`${Diverging}-${Linear}`, diverging, [Continuous, Interpolating]);
-  scale$4(`${Diverging}-${Log}`, divergingLog, [Continuous, Interpolating, Log]);
-  scale$4(`${Diverging}-${Pow}`, divergingPow, [Continuous, Interpolating]);
-  scale$4(`${Diverging}-${Sqrt}`, divergingSqrt, [Continuous, Interpolating]);
-  scale$4(`${Diverging}-${Symlog}`, divergingSymlog, [Continuous, Interpolating]); // discretizing scales
+  scale$4("".concat(Diverging, "-").concat(Linear), diverging, [Continuous, Interpolating]);
+  scale$4("".concat(Diverging, "-").concat(Log), divergingLog, [Continuous, Interpolating, Log]);
+  scale$4("".concat(Diverging, "-").concat(Pow), divergingPow, [Continuous, Interpolating]);
+  scale$4("".concat(Diverging, "-").concat(Sqrt), divergingSqrt, [Continuous, Interpolating]);
+  scale$4("".concat(Diverging, "-").concat(Symlog), divergingSymlog, [Continuous, Interpolating]); // discretizing scales
 
   scale$4(Quantile, quantile, [Discretizing, Quantile]);
   scale$4(Quantize, quantize$1, Discretizing);
@@ -16110,7 +16202,7 @@
 
   const defaultFormatter = value => isArray(value) ? value.map(v => String(v)) : String(value);
 
-  const ascending$1 = (a, b) => a[1] - b[1];
+  const ascending = (a, b) => a[1] - b[1];
 
   const descending = (a, b) => b[1] - a[1];
   /**
@@ -16161,7 +16253,7 @@
     let range = scale.range(),
         lo = range[0],
         hi = peek$1(range),
-        cmp = ascending$1;
+        cmp = ascending;
 
     if (lo > hi) {
       range = hi;
@@ -16363,17 +16455,17 @@
     if (isDiscretizing(scale.type)) {
       const v = labelValues(scale).slice(1).map(fmt),
             n = v.length;
-      return `${n} boundar${n === 1 ? 'y' : 'ies'}: ${v.join(', ')}`;
+      return "".concat(n, " boundar").concat(n === 1 ? 'y' : 'ies', ": ").concat(v.join(', '));
     } // if scale domain is discrete, list values
     else if (isDiscrete(scale.type)) {
       const d = scale.domain(),
             n = d.length,
             v = n > max ? d.slice(0, max - 2).map(fmt).join(', ') + ', ending with ' + d.slice(-1).map(fmt) : d.map(fmt).join(', ');
-      return `${n} value${n === 1 ? '' : 's'}: ${v}`;
+      return "".concat(n, " value").concat(n === 1 ? '' : 's', ": ").concat(v);
     } // if scale domain is continuous, describe value range
     else {
       const d = scale.domain();
-      return `values from ${fmt(d[0])} to ${fmt(peek$1(d))}`;
+      return "values from ".concat(fmt(d[0]), " to ").concat(fmt(peek$1(d)));
     }
   }
 
@@ -16525,59 +16617,83 @@
     }
 
     return curve;
-  } // Path parsing and rendering code adapted from fabric.js -- Thanks!
-
+  }
 
-  const cmdlen = {
+  const paramCounts = {
     m: 2,
     l: 2,
     h: 1,
     v: 1,
+    z: 0,
     c: 6,
     s: 4,
     q: 4,
     t: 2,
     a: 7
-  },
-        regexp = [/([MLHVCSQTAZmlhvcsqtaz])/g, /###/, /(\.\d+)(\.\d)/g, /(\d)([-+])/g, /\s|,|###/];
+  };
+  const commandPattern = /[mlhvzcsqta]([^mlhvzcsqta]+|$)/gi;
+  const numberPattern = /^[+-]?(([0-9]*\.[0-9]+)|([0-9]+\.)|([0-9]+))([eE][+-]?[0-9]+)?/;
+  const spacePattern = /^((\s+,?\s*)|(,\s*))/;
+  const flagPattern = /^[01]/;
 
-  function pathParse(pathstr) {
-    const result = [];
-    let curr, chunks, parsed, param, cmd, len, i, j, n, m; // First, break path into command sequence
+  function parse$3(path) {
+    const commands = [];
+    const matches = path.match(commandPattern) || [];
+    matches.forEach(str => {
+      let cmd = str[0];
+      const type = cmd.toLowerCase(); // parse parameters
 
-    const path = pathstr.slice().replace(regexp[0], '###$1').split(regexp[1]).slice(1); // Next, parse each command in turn
+      const paramCount = paramCounts[type];
+      const params = parseParams(type, paramCount, str.slice(1).trim());
+      const count = params.length; // error checking based on parameter count
 
-    for (i = 0, n = path.length; i < n; ++i) {
-      curr = path[i];
-      chunks = curr.slice(1).trim().replace(regexp[2], '$1###$2').replace(regexp[3], '$1###$2').split(regexp[4]);
-      cmd = curr.charAt(0);
-      parsed = [cmd];
+      if (count < paramCount || count && count % paramCount !== 0) {
+        throw Error('Invalid SVG path, incorrect parameter count');
+      } // register the command
 
-      for (j = 0, m = chunks.length; j < m; ++j) {
-        if ((param = +chunks[j]) === param) {
-          // not NaN
-          parsed.push(param);
-        }
+
+      commands.push([cmd, ...params.slice(0, paramCount)]); // exit now if we're done, also handles zero-param 'z'
+
+      if (count === paramCount) {
+        return;
+      } // handle implicit line-to
+
+
+      if (type === 'm') {
+        cmd = cmd === 'M' ? 'L' : 'l';
+      } // repeat command when given extended param list
+
+
+      for (let i = paramCount; i < count; i += paramCount) {
+        commands.push([cmd, ...params.slice(i, i + paramCount)]);
       }
+    });
+    return commands;
+  }
 
-      len = cmdlen[cmd.toLowerCase()];
+  function parseParams(type, paramCount, segment) {
+    const params = [];
 
-      if (parsed.length - 1 > len) {
-        const m = parsed.length;
-        j = 1;
-        result.push([cmd].concat(parsed.slice(j, j += len))); // handle implicit lineTo (#2803)
+    for (let index = 0; paramCount && index < segment.length;) {
+      for (let i = 0; i < paramCount; ++i) {
+        const pattern = type === 'a' && (i === 3 || i === 4) ? flagPattern : numberPattern;
+        const match = segment.slice(index).match(pattern);
 
-        cmd = cmd === 'M' ? 'L' : cmd === 'm' ? 'l' : cmd;
+        if (match === null) {
+          throw Error('Invalid SVG path, incorrect parameter type');
+        }
 
-        for (; j < m; j += len) {
-          result.push([cmd].concat(parsed.slice(j, j + len)));
+        index += match[0].length;
+        params.push(+match[0]);
+        const ws = segment.slice(index).match(spacePattern);
+
+        if (ws !== null) {
+          index += ws[0].length;
         }
-      } else {
-        result.push(parsed);
       }
     }
 
-    return result;
+    return params;
   }
 
   const DegToRad = Math.PI / 180;
@@ -16724,7 +16840,9 @@
     tempX,
         tempY,
         tempControlX,
-        tempControlY;
+        tempControlY,
+        anchorX = 0,
+        anchorY = 0;
     if (l == null) l = 0;
     if (t == null) t = 0;
     if (sX == null) sX = 1;
@@ -16782,6 +16900,8 @@
           // moveTo, relative
           x += current[1];
           y += current[2];
+          anchorX = x;
+          anchorY = y;
           context.moveTo(x + l, y + t);
           break;
 
@@ -16789,6 +16909,8 @@
           // moveTo, absolute
           x = current[1];
           y = current[2];
+          anchorX = x;
+          anchorY = y;
           context.moveTo(x + l, y + t);
           break;
 
@@ -16931,6 +17053,8 @@
 
         case 'z':
         case 'Z':
+          x = anchorX;
+          y = anchorY;
           context.closePath();
           break;
       }
@@ -17096,7 +17220,7 @@
 
   function customSymbol(path) {
     if (!has$1(custom, path)) {
-      const parsed = pathParse(path);
+      const parsed = parse$3(path);
       custom[path] = {
         draw: function (context, size) {
           pathRender(context, parsed, 0, 0, Math.sqrt(size) / 2);
@@ -17389,7 +17513,7 @@
         areahShape = area$2$1().y(y$2).x1(x$2).x0(xw).defined(def),
         lineShape = line$2$1().x(x$2).y(y$2).defined(def),
         rectShape = vg_rect().x(x$2).y(y$2).width(w).height(h).cornerRadius(tl, tr, br, bl),
-        symbolShape = symbol$2().type(type).size(sz),
+        symbolShape = Symbol$1().type(type).size(sz),
         trailShape = vg_trail().x(x$2).y(y$2).defined(def).size(ts);
 
   function hasCornerRadius(item) {
@@ -18712,7 +18836,7 @@
         cache = item.pathCache;
 
     if (!cache || cache.path !== path) {
-      (item.pathCache = cache = pathParse(path)).path = path;
+      (item.pathCache = cache = parse$3(path)).path = path;
     }
 
     if (a && context.rotate && context.translate) {
@@ -18853,7 +18977,7 @@
   }
 
   function _measureWidth(text, currentFont) {
-    const key = `(${currentFont}) ${text}`;
+    const key = "(".concat(currentFont, ") ").concat(text);
     let width = widthCache.get(key);
 
     if (width === undefined) {
@@ -20230,11 +20354,11 @@
     },
     'title-text': {
       desc: 'title',
-      caption: item => `Title text '${titleCaption(item)}'`
+      caption: item => "Title text '".concat(titleCaption(item), "'")
     },
     'title-subtitle': {
       desc: 'subtitle',
-      caption: item => `Subtitle text '${titleCaption(item)}'`
+      caption: item => "Subtitle text '".concat(titleCaption(item), "'")
     }
   }; // aria properties generated for mark item encoding channels
 
@@ -20256,7 +20380,7 @@
       const type = item.mark.marktype;
       emit(ARIA_LABEL, item.description);
       emit(ARIA_ROLE, item.ariaRole || (type === 'group' ? GRAPHICS_OBJECT : GRAPHICS_SYMBOL));
-      emit(ARIA_ROLEDESCRIPTION, item.ariaRoleDescription || `${type} mark`);
+      emit(ARIA_ROLEDESCRIPTION, item.ariaRoleDescription || "".concat(type, " mark"));
     }
   }
 
@@ -20269,7 +20393,7 @@
   function ariaMark(mark) {
     const type = mark.marktype;
     const recurse = type === 'group' || type === 'text' || mark.items.some(_ => _.description != null && _.aria !== false);
-    return bundle(recurse ? GRAPHICS_OBJECT : GRAPHICS_SYMBOL, `${type} mark container`, mark.description);
+    return bundle(recurse ? GRAPHICS_OBJECT : GRAPHICS_SYMBOL, "".concat(type, " mark container"), mark.description);
   }
 
   function ariaGuide(mark, opt) {
@@ -20296,19 +20420,19 @@
           locale = ctx.dataflow.locale(),
           type = scale.type,
           xy = orient === 'left' || orient === 'right' ? 'Y' : 'X';
-    return `${xy}-axis` + (title ? ` titled '${title}'` : '') + ` for a ${isDiscrete(type) ? 'discrete' : type} scale` + ` with ${domainCaption(locale, scale, item)}`;
+    return "".concat(xy, "-axis") + (title ? " titled '".concat(title, "'") : '') + " for a ".concat(isDiscrete(type) ? 'discrete' : type, " scale") + " with ".concat(domainCaption(locale, scale, item));
   }
 
   function legendCaption(item) {
     const datum = item.datum,
           title = datum.title ? extractTitle(item) : null,
-          type = `${datum.type || ''} legend`.trim(),
+          type = "".concat(datum.type || '', " legend").trim(),
           scales = datum.scales,
           props = Object.keys(scales),
           ctx = item.context,
           scale = ctx.scales[scales[props[0]]].value,
           locale = ctx.dataflow.locale();
-    return capitalize(type) + (title ? ` titled '${title}'` : '') + ` for ${channelCaption(props)}` + ` with ${domainCaption(locale, scale, item)}`;
+    return capitalize(type) + (title ? " titled '".concat(title, "'") : '') + " for ".concat(channelCaption(props)) + " with ".concat(domainCaption(locale, scale, item));
   }
 
   function extractTitle(item) {
@@ -20341,21 +20465,25 @@
           clear = () => outer = inner = '',
           push = tag => {
       if (outer) {
-        buf += `${outer}>${inner}`;
+        buf += "".concat(outer, ">").concat(inner);
         clear();
       }
 
       stack.push(tag);
     },
           attr = (name, value) => {
-      if (value != null) outer += ` ${name}="${attrText(value)}"`;
+      if (value != null) outer += " ".concat(name, "=\"").concat(attrText(value), "\"");
       return m;
     },
           m = {
-      open(tag, ...attrs) {
+      open(tag) {
         push(tag);
         outer = '<' + tag;
 
+        for (var _len = arguments.length, attrs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+          attrs[_key - 1] = arguments[_key];
+        }
+
         for (const set of attrs) {
           for (const key in set) attr(key, set[key]);
         }
@@ -20367,9 +20495,9 @@
         const tag = stack.pop();
 
         if (outer) {
-          buf += outer + (inner ? `>${inner}</${tag}>` : '/>');
+          buf += outer + (inner ? ">".concat(inner, "</").concat(tag, ">") : '/>');
         } else {
-          buf += `</${tag}>`;
+          buf += "</".concat(tag, ">");
         }
 
         clear();
@@ -20410,7 +20538,7 @@
     return m.close();
   }
 
-  const styles = {
+  const stylesAttr = {
     fill: 'fill',
     fillOpacity: 'fill-opacity',
     stroke: 'stroke',
@@ -20421,7 +20549,9 @@
     strokeDash: 'stroke-dasharray',
     strokeDashOffset: 'stroke-dashoffset',
     strokeMiterLimit: 'stroke-miterlimit',
-    opacity: 'opacity',
+    opacity: 'opacity'
+  };
+  const stylesCss = {
     blend: 'mix-blend-mode'
   }; // ensure miter limit default is consistent with canvas (#2498)
 
@@ -20513,10 +20643,10 @@
         setAttributes(this._svg, {
           width: this._width * this._scale,
           height: this._height * this._scale,
-          viewBox: `0 0 ${this._width} ${this._height}`
+          viewBox: "0 0 ".concat(this._width, " ").concat(this._height)
         });
 
-        this._root.setAttribute('transform', `translate(${this._origin})`);
+        this._root.setAttribute('transform', "translate(".concat(this._origin, ")"));
       }
 
       this._dirty = [];
@@ -20599,7 +20729,7 @@
      * @param {Item} item - The mark item.
      */
     isDirty(item) {
-      return this._dirtyAll || !item._svg || item.dirty === this._dirtyID;
+      return this._dirtyAll || !item._svg || !item._svg.ownerSVGElement || item.dirty === this._dirtyID;
     },
 
     /**
@@ -20676,13 +20806,14 @@
      * @param {SVGElement} prev - The previous sibling in the SVG tree.
      */
     mark(el, scene, prev) {
-      if (!this.isDirty(scene)) return scene._svg;
+      if (!this.isDirty(scene)) {
+        return scene._svg;
+      }
+
       const svg = this._svg,
             mdef = Marks[scene.marktype],
             events = scene.interactive === false ? 'none' : null,
             isGroup = mdef.tag === 'g';
-      let sibling = null,
-          i = 0;
       const parent = bind$1(scene, el, prev, 'g', svg);
       parent.setAttribute('class', cssClass(scene)); // apply aria attributes to parent container element
 
@@ -20695,6 +20826,8 @@
       }
 
       setAttribute(parent, 'clip-path', scene.clip ? clip$1$1(this, scene, scene.group) : null);
+      let sibling = null,
+          i = 0;
 
       const process = item => {
         const dirty = this.isDirty(item),
@@ -20751,10 +20884,10 @@
     style(el, item) {
       if (item == null) return;
 
-      for (const prop in styles) {
+      for (const prop in stylesAttr) {
         let value = prop === 'font' ? fontFamily(item) : item[prop];
         if (value === values[prop]) continue;
-        const name = styles[prop];
+        const name = stylesAttr[prop];
 
         if (value == null) {
           el.removeAttribute(name);
@@ -20768,6 +20901,10 @@
 
         values[prop] = value;
       }
+
+      for (const prop in stylesCss) {
+        setStyle(el, stylesCss[prop], item[prop]);
+      }
     },
 
     /**
@@ -20839,7 +20976,7 @@
       setAttributes(pt, {
         width: 1,
         height: 1,
-        fill: `url(${href()}#${grad.id})`
+        fill: "url(".concat(href(), "#").concat(grad.id, ")")
       });
       el = domChild(el, index++, 'radialGradient', svgns);
       setAttributes(el, {
@@ -20897,6 +21034,8 @@
 
 
   function recurse(renderer, el, group) {
+    // child 'g' element is second to last among children (path, g, path)
+    // other children here are foreground and background path elements
     el = el.lastChild.previousSibling;
     let prev,
         idx = 0;
@@ -21141,7 +21280,7 @@
         class: 'marks',
         width: this._width * this._scale,
         height: this._height * this._scale,
-        viewBox: `0 0 ${this._width} ${this._height}`
+        viewBox: "0 0 ".concat(this._width, " ").concat(this._height)
       })); // background, if defined
 
       const bg = this._bgcolor;
@@ -21393,6 +21532,7 @@
   }); // Helper function for attr for style presentation attributes
 
   function style(s, item, scene, tag, defs) {
+    let styleList;
     if (item == null) return s;
 
     if (tag === 'bgrect' && scene.interactive === false) {
@@ -21409,7 +21549,7 @@
     }
 
     if (tag === 'image' && item.smooth === false) {
-      s.style = 'image-rendering: optimizeSpeed; image-rendering: pixelated;';
+      styleList = ['image-rendering: optimizeSpeed;', 'image-rendering: pixelated;'];
     }
 
     if (tag === 'text') {
@@ -21420,9 +21560,9 @@
       s['font-weight'] = item.fontWeight;
     }
 
-    for (const prop in styles) {
+    for (const prop in stylesAttr) {
       let value = item[prop];
-      const name = styles[prop];
+      const name = stylesAttr[prop];
       if (value === 'transparent' && (name === 'fill' || name === 'stroke')) ;else if (value != null) {
         if (isGradient(value)) {
           value = gradientRef(value, defs.gradient, '');
@@ -21432,6 +21572,19 @@
       }
     }
 
+    for (const prop in stylesCss) {
+      const value = item[prop];
+
+      if (value != null) {
+        styleList = styleList || [];
+        styleList.push("".concat(stylesCss[prop], ": ").concat(value, ";"));
+      }
+    }
+
+    if (styleList) {
+      s.style = styleList.join(' ');
+    }
+
     return s;
   }
 
@@ -21561,7 +21714,7 @@
   }
 
   function pathEqual(a, b) {
-    return sceneEqual(pathParse(a), pathParse(b));
+    return sceneEqual(parse$3(a), parse$3(b));
   }
 
   function objectEqual(a, b) {
@@ -23336,7 +23489,7 @@
           ellipsis = values[items.length];
           items.push(ingest$1({
             index: items.length,
-            label: `\u2026${values.length - items.length} entries`,
+            label: "\u2026".concat(values.length - items.length, " entries"),
             value: ellipsis,
             offset: offset,
             size: size(ellipsis, _)
@@ -23581,8 +23734,8 @@
           values = data.map(field),
           n = values.length,
           a = start,
-          k = (stop - start) / sum(values),
-          index = range$1$1(n),
+          k = (stop - start) / sum$1(values),
+          index = range$3(n),
           i,
           t,
           v;
@@ -23768,7 +23921,7 @@
       if (!step) error('Scale bins parameter missing step property.');
       if (start < lo) start = step * Math.ceil(lo / step);
       if (stop > hi) stop = step * Math.floor(hi / step);
-      bins = range$1$1(start, stop + step / 2, step);
+      bins = range$3(start, stop + step / 2, step);
     }
 
     if (bins) {
@@ -23810,7 +23963,7 @@
         if (scale.interpolator) {
           return scale.interpolator(range);
         } else {
-          error(`Scale type ${type} does not support interpolating color schemes.`);
+          error("Scale type ".concat(type, " does not support interpolating color schemes."));
         }
       }
     } // given a range array for an interpolating scale, convert to interpolator
@@ -23853,7 +24006,7 @@
     } else {
       name = _.scheme.toLowerCase();
       scheme$1 = scheme(name);
-      if (!scheme$1) error(`Unrecognized scheme name: ${_.scheme}`);
+      if (!scheme$1) error("Unrecognized scheme name: ".concat(_.scheme));
     } // determine size for potential discrete range
 
 
@@ -24072,7 +24225,7 @@
     stack: Stack
   });
 
-  var epsilon$2 = 1e-6;
+  var epsilon$3 = 1e-6;
   var epsilon2 = 1e-12;
   var pi$1 = Math.PI;
   var halfPi$1 = pi$1 / 2;
@@ -24312,7 +24465,7 @@
       boundsStream$2.point = boundsPoint$1;
       boundsStream$2.lineStart = boundsLineStart;
       boundsStream$2.lineEnd = boundsLineEnd;
-      if (areaRingSum$1 < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);else if (deltaSum > epsilon$2) phi1 = 90;else if (deltaSum < -epsilon$2) phi0 = -90;
+      if (areaRingSum$1 < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);else if (deltaSum > epsilon$3) phi1 = 90;else if (deltaSum < -epsilon$3) phi0 = -90;
       range$2[0] = lambda0, range$2[1] = lambda1;
     },
     sphere: function () {
@@ -24408,7 +24561,7 @@
   function boundsRingEnd() {
     boundsRingPoint(lambda00$1, phi00$1);
     areaStream$1.lineEnd();
-    if (abs$1(deltaSum) > epsilon$2) lambda0 = -(lambda1 = 180);
+    if (abs$1(deltaSum) > epsilon$3) lambda0 = -(lambda1 = 180);
     range$2[0] = lambda0, range$2[1] = lambda1;
     p0 = null;
   } // Finds the left-right distance between two longitudes.
@@ -24583,7 +24736,7 @@
     if (m < epsilon2) {
       x = X1$1, y = Y1$1, z = Z1$1; // If the feature has zero length, fall back to arithmetic mean of point vectors.
 
-      if (W1 < epsilon$2) x = X0$1, y = Y0$1, z = Z0$1;
+      if (W1 < epsilon$3) x = X0$1, y = Y0$1, z = Z0$1;
       m = hypot(x, y, z); // If the feature still has an undefined ccentroid, then return.
 
       if (m < epsilon2) return [NaN, NaN];
@@ -24692,7 +24845,7 @@
     point = cartesian(point), point[0] -= cosRadius;
     cartesianNormalizeInPlace(point);
     var radius = acos(-point[1]);
-    return ((-point[2] < 0 ? -radius : radius) + tau$1 - epsilon$2) % tau$1;
+    return ((-point[2] < 0 ? -radius : radius) + tau$1 - epsilon$3) % tau$1;
   }
 
   function clipBuffer () {
@@ -24719,7 +24872,7 @@
   }
 
   function pointEqual (a, b) {
-    return abs$1(a[0] - b[0]) < epsilon$2 && abs$1(a[1] - b[1]) < epsilon$2;
+    return abs$1(a[0] - b[0]) < epsilon$3 && abs$1(a[1] - b[1]) < epsilon$3;
   }
 
   function Intersection(point, points, other, entry) {
@@ -24760,7 +24913,7 @@
         } // handle degenerate cases by moving the point
 
 
-        p1[0] += 2 * epsilon$2;
+        p1[0] += 2 * epsilon$3;
       }
 
       subject.push(x = new Intersection(p0, segment, null, true));
@@ -24841,7 +24994,7 @@
   }
 
   function longitude(point) {
-    if (abs$1(point[0]) <= pi$1) return point[0];else return sign(point[0]) * ((abs$1(point[0]) + pi$1) % tau$1 - pi$1);
+    return abs$1(point[0]) <= pi$1 ? point[0] : sign(point[0]) * ((abs$1(point[0]) + pi$1) % tau$1 - pi$1);
   }
 
   function polygonContains (polygon, point) {
@@ -24852,7 +25005,7 @@
         angle = 0,
         winding = 0;
     var sum = new Adder();
-    if (sinPhi === 1) phi = halfPi$1 + epsilon$2;else if (sinPhi === -1) phi = -halfPi$1 - epsilon$2;
+    if (sinPhi === 1) phi = halfPi$1 + epsilon$3;else if (sinPhi === -1) phi = -halfPi$1 - epsilon$3;
 
     for (var i = 0, n = polygon.length; i < n; ++i) {
       if (!(m = (ring = polygon[i]).length)) continue;
@@ -24903,7 +25056,7 @@
     // same side as the South pole.
 
 
-    return (angle < -epsilon$2 || angle < epsilon$2 && sum < -epsilon2) ^ winding & 1;
+    return (angle < -epsilon$3 || angle < epsilon$3 && sum < -epsilon2) ^ winding & 1;
   }
 
   function clip$1 (pointVisible, clipLine, interpolate, start) {
@@ -25030,7 +25183,7 @@
 
 
   function compareIntersection(a, b) {
-    return ((a = a.x)[0] < 0 ? a[1] - halfPi$1 - epsilon$2 : halfPi$1 - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi$1 - epsilon$2 : halfPi$1 - b[1]);
+    return ((a = a.x)[0] < 0 ? a[1] - halfPi$1 - epsilon$3 : halfPi$1 - a[1]) - ((b = b.x)[0] < 0 ? b[1] - halfPi$1 - epsilon$3 : halfPi$1 - b[1]);
   }
 
   var clipAntimeridian = clip$1(function () {
@@ -25054,7 +25207,7 @@
         var sign1 = lambda1 > 0 ? pi$1 : -pi$1,
             delta = abs$1(lambda1 - lambda0);
 
-        if (abs$1(delta - pi$1) < epsilon$2) {
+        if (abs$1(delta - pi$1) < epsilon$3) {
           // line crosses a pole
           stream.point(lambda0, phi0 = (phi0 + phi1) / 2 > 0 ? halfPi$1 : -halfPi$1);
           stream.point(sign0, phi0);
@@ -25065,9 +25218,9 @@
           clean = 0;
         } else if (sign0 !== sign1 && delta >= pi$1) {
           // line crosses antimeridian
-          if (abs$1(lambda0 - sign0) < epsilon$2) lambda0 -= sign0 * epsilon$2; // handle degeneracies
+          if (abs$1(lambda0 - sign0) < epsilon$3) lambda0 -= sign0 * epsilon$3; // handle degeneracies
 
-          if (abs$1(lambda1 - sign1) < epsilon$2) lambda1 -= sign1 * epsilon$2;
+          if (abs$1(lambda1 - sign1) < epsilon$3) lambda1 -= sign1 * epsilon$3;
           phi0 = clipAntimeridianIntersect(lambda0, phi0, lambda1, phi1);
           stream.point(sign0, phi0);
           stream.lineEnd();
@@ -25093,7 +25246,7 @@
     var cosPhi0,
         cosPhi1,
         sinLambda0Lambda1 = sin$1(lambda0 - lambda1);
-    return abs$1(sinLambda0Lambda1) > epsilon$2 ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1) - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
+    return abs$1(sinLambda0Lambda1) > epsilon$3 ? atan((sin$1(phi0) * (cosPhi1 = cos$1(phi1)) * sin$1(lambda1) - sin$1(phi1) * (cosPhi0 = cos$1(phi0)) * sin$1(lambda0)) / (cosPhi0 * cosPhi1 * sinLambda0Lambda1)) : (phi0 + phi1) / 2;
   }
 
   function clipAntimeridianInterpolate(from, to, direction, stream) {
@@ -25110,7 +25263,7 @@
       stream.point(-pi$1, -phi);
       stream.point(-pi$1, 0);
       stream.point(-pi$1, phi);
-    } else if (abs$1(from[0] - to[0]) > epsilon$2) {
+    } else if (abs$1(from[0] - to[0]) > epsilon$3) {
       var lambda = from[0] < to[0] ? pi$1 : -pi$1;
       phi = direction * lambda / 2;
       stream.point(-lambda, phi);
@@ -25125,7 +25278,7 @@
     var cr = cos$1(radius),
         delta = 6 * radians,
         smallRadius = cr > 0,
-        notHemisphere = abs$1(cr) > epsilon$2; // TODO optimise for this common case
+        notHemisphere = abs$1(cr) > epsilon$3; // TODO optimise for this common case
 
     function interpolate(from, to, direction, stream) {
       circleStream(stream, radius, delta, direction, from, to);
@@ -25258,11 +25411,11 @@
           z;
       if (lambda1 < lambda0) z = lambda0, lambda0 = lambda1, lambda1 = z;
       var delta = lambda1 - lambda0,
-          polar = abs$1(delta - pi$1) < epsilon$2,
-          meridian = polar || delta < epsilon$2;
+          polar = abs$1(delta - pi$1) < epsilon$3,
+          meridian = polar || delta < epsilon$3;
       if (!polar && phi1 < phi0) z = phi0, phi0 = phi1, phi1 = z; // Check that the first point is between a and b.
 
-      if (meridian ? polar ? phi0 + phi1 > 0 ^ q[1] < (abs$1(q[0] - lambda0) < epsilon$2 ? phi0 : phi1) : phi0 <= q[1] && q[1] <= phi1 : delta > pi$1 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
+      if (meridian ? polar ? phi0 + phi1 > 0 ^ q[1] < (abs$1(q[0] - lambda0) < epsilon$3 ? phi0 : phi1) : phi0 <= q[1] && q[1] <= phi1 : delta > pi$1 ^ (lambda0 <= q[0] && q[0] <= lambda1)) {
         var q1 = cartesianScale(u, (-w + t) / uu);
         cartesianAddInPlace(q1, A);
         return [q, spherical(q1)];
@@ -25370,7 +25523,7 @@
     }
 
     function corner(p, direction) {
-      return abs$1(p[0] - x0) < epsilon$2 ? direction > 0 ? 0 : 3 : abs$1(p[0] - x1) < epsilon$2 ? direction > 0 ? 2 : 1 : abs$1(p[1] - y0) < epsilon$2 ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon
+      return abs$1(p[0] - x0) < epsilon$3 ? direction > 0 ? 0 : 3 : abs$1(p[0] - x1) < epsilon$3 ? direction > 0 ? 2 : 1 : abs$1(p[1] - y0) < epsilon$3 ? direction > 0 ? 1 : 0 : direction > 0 ? 3 : 2; // abs(p[1] - y1) < epsilon
     }
 
     function compareIntersection(a, b) {
@@ -25522,7 +25675,7 @@
   }
 
   function graticuleX(y0, y1, dy) {
-    var y = range$1$1(y0, y1 - epsilon$2, dy).concat(y1);
+    var y = range$3(y0, y1 - epsilon$3, dy).concat(y1);
     return function (x) {
       return y.map(function (y) {
         return [x, y];
@@ -25531,7 +25684,7 @@
   }
 
   function graticuleY(x0, x1, dx) {
-    var x = range$1$1(x0, x1 - epsilon$2, dx).concat(x1);
+    var x = range$3(x0, x1 - epsilon$3, dx).concat(x1);
     return function (y) {
       return x.map(function (x) {
         return [x, y];
@@ -25566,10 +25719,10 @@
     }
 
     function lines() {
-      return range$1$1(ceil(X0 / DX) * DX, X1, DX).map(X).concat(range$1$1(ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(range$1$1(ceil(x0 / dx) * dx, x1, dx).filter(function (x) {
-        return abs$1(x % DX) > epsilon$2;
-      }).map(x)).concat(range$1$1(ceil(y0 / dy) * dy, y1, dy).filter(function (y) {
-        return abs$1(y % DY) > epsilon$2;
+      return range$3(ceil(X0 / DX) * DX, X1, DX).map(X).concat(range$3(ceil(Y0 / DY) * DY, Y1, DY).map(Y)).concat(range$3(ceil(x0 / dx) * dx, x1, dx).filter(function (x) {
+        return abs$1(x % DX) > epsilon$3;
+      }).map(x)).concat(range$3(ceil(y0 / dy) * dy, y1, dy).filter(function (y) {
+        return abs$1(y % DY) > epsilon$3;
       }).map(y));
     }
 
@@ -25639,7 +25792,7 @@
       return graticule;
     };
 
-    return graticule.extentMajor([[-180, -90 + epsilon$2], [180, 90 - epsilon$2]]).extentMinor([[-180, -80 - epsilon$2], [180, 80 + epsilon$2]]);
+    return graticule.extentMajor([[-180, -90 + epsilon$3], [180, 90 - epsilon$3]]).extentMinor([[-180, -80 - epsilon$3], [180, 80 + epsilon$3]]);
   }
 
   var identity = (x => x);
@@ -26125,7 +26278,7 @@
             c = c0 + c1,
             m = sqrt$1(a * a + b * b + c * c),
             phi2 = asin$1(c /= m),
-            lambda2 = abs$1(abs$1(c) - 1) < epsilon$2 || abs$1(lambda0 - lambda1) < epsilon$2 ? (lambda0 + lambda1) / 2 : atan2(b, a),
+            lambda2 = abs$1(abs$1(c) - 1) < epsilon$3 || abs$1(lambda0 - lambda1) < epsilon$3 ? (lambda0 + lambda1) / 2 : atan2(b, a),
             p = project(lambda2, phi2),
             x2 = p[0],
             y2 = p[1],
@@ -26432,7 +26585,7 @@
     var sy0 = sin$1(y0),
         n = (sy0 + sin$1(y1)) / 2; // Are the parallels symmetrical around the Equator?
 
-    if (abs$1(n) < epsilon$2) return cylindricalEqualAreaRaw(y0);
+    if (abs$1(n) < epsilon$3) return cylindricalEqualAreaRaw(y0);
     var c = 1 + sy0 * (2 * n - sy0),
         r0 = sqrt$1(c) / n;
 
@@ -26555,8 +26708,8 @@
           x = +_[0],
           y = +_[1];
       lower48Point = lower48.translate(_).clipExtent([[x - 0.455 * k, y - 0.238 * k], [x + 0.455 * k, y + 0.238 * k]]).stream(pointStream);
-      alaskaPoint = alaska.translate([x - 0.307 * k, y + 0.201 * k]).clipExtent([[x - 0.425 * k + epsilon$2, y + 0.120 * k + epsilon$2], [x - 0.214 * k - epsilon$2, y + 0.234 * k - epsilon$2]]).stream(pointStream);
-      hawaiiPoint = hawaii.translate([x - 0.205 * k, y + 0.212 * k]).clipExtent([[x - 0.214 * k + epsilon$2, y + 0.166 * k + epsilon$2], [x - 0.115 * k - epsilon$2, y + 0.234 * k - epsilon$2]]).stream(pointStream);
+      alaskaPoint = alaska.translate([x - 0.307 * k, y + 0.201 * k]).clipExtent([[x - 0.425 * k + epsilon$3, y + 0.120 * k + epsilon$3], [x - 0.214 * k - epsilon$3, y + 0.234 * k - epsilon$3]]).stream(pointStream);
+      hawaiiPoint = hawaii.translate([x - 0.205 * k, y + 0.212 * k]).clipExtent([[x - 0.214 * k + epsilon$3, y + 0.166 * k + epsilon$3], [x - 0.115 * k - epsilon$3, y + 0.234 * k - epsilon$3]]).stream(pointStream);
       return reset();
     };
 
@@ -26682,9 +26835,9 @@
 
     function project(x, y) {
       if (f > 0) {
-        if (y < -halfPi$1 + epsilon$2) y = -halfPi$1 + epsilon$2;
+        if (y < -halfPi$1 + epsilon$3) y = -halfPi$1 + epsilon$3;
       } else {
-        if (y > halfPi$1 - epsilon$2) y = halfPi$1 - epsilon$2;
+        if (y > halfPi$1 - epsilon$3) y = halfPi$1 - epsilon$3;
       }
 
       var r = f / pow$1(tany(y), n);
@@ -26717,7 +26870,7 @@
     var cy0 = cos$1(y0),
         n = y0 === y1 ? sin$1(y0) : (cy0 - cos$1(y1)) / (y1 - y0),
         g = cy0 / n + y0;
-    if (abs$1(n) < epsilon$2) return equirectangularRaw;
+    if (abs$1(n) < epsilon$3) return equirectangularRaw;
 
     function project(x, y) {
       var gy = g - y,
@@ -26907,7 +27060,7 @@
       var phi2 = phi * phi,
           phi4 = phi2 * phi2;
       phi -= delta = (phi * (1.007226 + phi2 * (0.015085 + phi4 * (-0.044475 + 0.028874 * phi2 - 0.005916 * phi4))) - y) / (1.007226 + phi2 * (0.015085 * 3 + phi4 * (-0.044475 * 7 + 0.028874 * 9 * phi2 - 0.005916 * 11 * phi4)));
-    } while (abs$1(delta) > epsilon$2 && --i > 0);
+    } while (abs$1(delta) > epsilon$3 && --i > 0);
 
     return [x / (0.8707 + (phi2 = phi * phi) * (-0.131979 + phi2 * (-0.013791 + phi2 * phi2 * phi2 * (0.003971 - 0.001529 * phi2)))), phi];
   };
@@ -26921,7 +27074,7 @@
   }
   orthographicRaw.invert = azimuthalInvert(asin$1);
   function geoOrthographic () {
-    return projection$1(orthographicRaw).scale(249.5).clipAngle(90 + epsilon$2);
+    return projection$1(orthographicRaw).scale(249.5).clipAngle(90 + epsilon$3);
   }
 
   function stereographicRaw(x, y) {
@@ -26963,7 +27116,7 @@
   var abs = Math.abs;
   var cos = Math.cos;
   var sin = Math.sin;
-  var epsilon$1 = 1e-6;
+  var epsilon$2 = 1e-6;
   var pi = Math.PI;
   var halfPi = pi / 2;
   var sqrt2 = sqrt(2);
@@ -26979,7 +27132,7 @@
         i = 30,
         delta;
 
-    do phi -= delta = (phi + sin(phi) - cpsinPhi) / (1 + cos(phi)); while (abs(delta) > epsilon$1 && --i > 0);
+    do phi -= delta = (phi + sin(phi) - cpsinPhi) / (1 + cos(phi)); while (abs(delta) > epsilon$2 && --i > 0);
 
     return phi / 2;
   }
@@ -27318,7 +27471,7 @@
           stop = ex[1],
           span = stop - start,
           step = nice ? tickStep(start, stop, k) : span / (k + 1);
-      return range$1$1(start + step, stop, step);
+      return range$3(start + step, stop, step);
     };
   }
   /**
@@ -27546,7 +27699,7 @@
       // density in points per square pixel or probability density
 
 
-      const s = counts ? Math.pow(2, -2 * k) : 1 / sum(values);
+      const s = counts ? Math.pow(2, -2 * k) : 1 / sum$1(values);
 
       for (let i = 0, sz = n * m; i < sz; ++i) values[i] *= s;
 
@@ -29382,7 +29535,7 @@
         e;
 
     while (t) {
-      if ((e = clockNow - t._time) >= 0) t._call.call(null, e);
+      if ((e = clockNow - t._time) >= 0) t._call.call(undefined, e);
       t = t._next;
     }
 
@@ -30926,7 +31079,8 @@
   var preroot = {
     depth: -1
   },
-      ambiguous = {};
+      ambiguous = {},
+      imputed = {};
 
   function defaultId(d) {
     return d.id;
@@ -30938,11 +31092,14 @@
 
   function stratify () {
     var id = defaultId,
-        parentId = defaultParentId;
+        parentId = defaultParentId,
+        path;
 
     function stratify(data) {
       var nodes = Array.from(data),
-          n = nodes.length,
+          currentId = id,
+          currentParentId = parentId,
+          n,
           d,
           i,
           root,
@@ -30952,15 +31109,34 @@
           nodeKey,
           nodeByKey = new Map();
 
-      for (i = 0; i < n; ++i) {
+      if (path != null) {
+        const I = nodes.map((d, i) => normalize(path(d, i, data)));
+        const P = I.map(parentof);
+        const S = new Set(I).add("");
+
+        for (const i of P) {
+          if (!S.has(i)) {
+            S.add(i);
+            I.push(i);
+            P.push(parentof(i));
+            nodes.push(imputed);
+          }
+        }
+
+        currentId = (_, i) => I[i];
+
+        currentParentId = (_, i) => P[i];
+      }
+
+      for (i = 0, n = nodes.length; i < n; ++i) {
         d = nodes[i], node = nodes[i] = new Node$1(d);
 
-        if ((nodeId = id(d, i, data)) != null && (nodeId += "")) {
+        if ((nodeId = currentId(d, i, data)) != null && (nodeId += "")) {
           nodeKey = node.id = nodeId;
           nodeByKey.set(nodeKey, nodeByKey.has(nodeKey) ? ambiguous : node);
         }
 
-        if ((nodeId = parentId(d, i, data)) != null && (nodeId += "")) {
+        if ((nodeId = currentParentId(d, i, data)) != null && (nodeId += "")) {
           node.parent = nodeId;
         }
       }
@@ -30980,7 +31156,21 @@
         }
       }
 
-      if (!root) throw new Error("no root");
+      if (!root) throw new Error("no root"); // When imputing internal nodes, only introduce roots if needed.
+      // Then replace the imputed marker data with null.
+
+      if (path != null) {
+        while (root.data === imputed && root.children.length === 1) {
+          root = root.children[0], --n;
+        }
+
+        for (let i = nodes.length - 1; i >= 0; --i) {
+          node = nodes[i];
+          if (node.data !== imputed) break;
+          node.data = null;
+        }
+      }
+
       root.parent = preroot;
       root.eachBefore(function (node) {
         node.depth = node.parent.depth + 1;
@@ -30992,14 +31182,54 @@
     }
 
     stratify.id = function (x) {
-      return arguments.length ? (id = required(x), stratify) : id;
+      return arguments.length ? (id = optional(x), stratify) : id;
     };
 
     stratify.parentId = function (x) {
-      return arguments.length ? (parentId = required(x), stratify) : parentId;
+      return arguments.length ? (parentId = optional(x), stratify) : parentId;
+    };
+
+    stratify.path = function (x) {
+      return arguments.length ? (path = optional(x), stratify) : path;
     };
 
     return stratify;
+  } // To normalize a path, we coerce to a string, strip the trailing slash if any
+  // (as long as the trailing slash is not immediately preceded by another slash),
+  // and add leading slash if missing.
+
+  function normalize(path) {
+    path = "".concat(path);
+    let i = path.length;
+    if (slash(path, i - 1) && !slash(path, i - 2)) path = path.slice(0, -1);
+    return path[0] === "/" ? path : "/".concat(path);
+  } // Walk backwards to find the first slash that is not the leading slash, e.g.:
+  // "/foo/bar" ⇥ "/foo", "/foo" ⇥ "/", "/" ↦ "". (The root is special-cased
+  // because the id of the root must be a truthy value.)
+
+
+  function parentof(path) {
+    let i = path.length;
+    if (i < 2) return "";
+
+    while (--i > 1) if (slash(path, i)) break;
+
+    return path.slice(0, i);
+  } // Slashes can be escaped; to determine whether a slash is a path delimiter, we
+  // count the number of preceding backslashes escaping the forward slash: an odd
+  // number indicates an escaped forward slash.
+
+
+  function slash(path, i) {
+    if (path[i] === "/") {
+      let k = 0;
+
+      while (i > 0 && path[--i] === "\\") ++k;
+
+      if ((k & 1) === 0) return true;
+    }
+
+    return false;
   }
 
   function defaultSeparation$1(a, b) {
@@ -32115,10 +32345,7 @@
     treemap: Treemap
   });
 
-  const ALPHA_MASK = 0xff000000; // alpha value equivalent to opacity 0.0625
-
-  const INSIDE_OPACITY_IN_ALPHA = 0x10000000;
-  const INSIDE_OPACITY = 0.0625;
+  const ALPHA_MASK = 0xff000000;
 
   function baseBitmaps($, data) {
     const bitmap = $.bitmap(); // when there is no base mark but data points are to be avoided
@@ -32127,31 +32354,44 @@
     return [bitmap, undefined];
   }
 
-  function markBitmaps($, avoidMarks, labelInside, isGroupArea) {
+  function markBitmaps($, baseMark, avoidMarks, labelInside, isGroupArea) {
     // create canvas
     const width = $.width,
           height = $.height,
           border = labelInside || isGroupArea,
-          context = domCanvas(width, height).getContext('2d'); // render all marks to be avoided into canvas
+          context = domCanvas(width, height).getContext('2d'),
+          baseMarkContext = domCanvas(width, height).getContext('2d'),
+          strokeContext = border && domCanvas(width, height).getContext('2d'); // render all marks to be avoided into canvas
+
+    avoidMarks.forEach(items => draw(context, items, false));
+    draw(baseMarkContext, baseMark, false);
 
-    avoidMarks.forEach(items => draw(context, items, border)); // get canvas buffer, create bitmaps
+    if (border) {
+      draw(strokeContext, baseMark, true);
+    } // get canvas buffer, create bitmaps
 
-    const buffer = new Uint32Array(context.getImageData(0, 0, width, height).data.buffer),
+
+    const buffer = getBuffer(context, width, height),
+          baseMarkBuffer = getBuffer(baseMarkContext, width, height),
+          strokeBuffer = border && getBuffer(strokeContext, width, height),
           layer1 = $.bitmap(),
           layer2 = border && $.bitmap(); // populate bitmap layers
 
-    let x, y, u, v, alpha;
+    let x, y, u, v, index, alpha, strokeAlpha, baseMarkAlpha;
 
     for (y = 0; y < height; ++y) {
       for (x = 0; x < width; ++x) {
-        alpha = buffer[y * width + x] & ALPHA_MASK;
+        index = y * width + x;
+        alpha = buffer[index] & ALPHA_MASK;
+        baseMarkAlpha = baseMarkBuffer[index] & ALPHA_MASK;
+        strokeAlpha = border && strokeBuffer[index] & ALPHA_MASK;
 
-        if (alpha) {
+        if (alpha || strokeAlpha || baseMarkAlpha) {
           u = $(x);
           v = $(y);
-          if (!isGroupArea) layer1.set(u, v); // update interior bitmap
+          if (!isGroupArea && (alpha || baseMarkAlpha)) layer1.set(u, v); // update interior bitmap
 
-          if (border && alpha ^ INSIDE_OPACITY_IN_ALPHA) layer2.set(u, v); // update border bitmap
+          if (border && (alpha || strokeAlpha)) layer2.set(u, v); // update border bitmap
         }
       }
     }
@@ -32159,6 +32399,10 @@
     return [layer1, layer2];
   }
 
+  function getBuffer(context, width, height) {
+    return new Uint32Array(context.getImageData(0, 0, width, height).data.buffer);
+  }
+
   function draw(context, items, interior) {
     if (!items.length) return;
     const type = items[0].mark.marktype;
@@ -32183,15 +32427,12 @@
   function prepare(source) {
     const item = rederive(source, {});
 
-    if (item.stroke) {
-      item.strokeOpacity = 1;
-    }
-
-    if (item.fill) {
-      item.fillOpacity = INSIDE_OPACITY;
-      item.stroke = '#000';
-      item.strokeOpacity = 1;
-      item.strokeWidth = 2;
+    if (item.stroke && item.strokeOpacity !== 0 || item.fill && item.fillOpacity !== 0) {
+      return { ...item,
+        strokeOpacity: 1,
+        stroke: '#000',
+        fillOpacity: 0
+      };
     }
 
     return item;
@@ -32401,10 +32642,6 @@
     return x - r < 0 || x + r > width || y - (r = textHeight / 2) < 0 || y + r > height;
   }
 
-  function _outOfBounds() {
-    return false;
-  }
-
   function collision($, x, y, textHeight, textWidth, h, bm0, bm1) {
     const w = textWidth * h / (textHeight * 2),
           x1 = $(x - w),
@@ -32414,27 +32651,9 @@
     return bm0.outOfBounds(x1, y1, x2, y2) || bm0.getRange(x1, y1, x2, y2) || bm1 && bm1.getRange(x1, y1, x2, y2);
   }
 
-  function _collision($, x, y, textHeight, textWidth, h, bm0, bm1) {
-    const w = textWidth * h / (textHeight * 2);
-    let x1 = $(x - w),
-        x2 = $(x + w),
-        y1 = $(y - (h = h / 2)),
-        y2 = $(y + h);
-    x1 = x1 > 0 ? x1 : 0;
-    y1 = y1 > 0 ? y1 : 0;
-    x2 = x2 < $.width ? x2 : $.width - 1;
-    y2 = y2 < $.height ? y2 : $.height - 1;
-    return bm0.getRange(x1, y1, x2, y2) || bm1 && bm1.getRange(x1, y1, x2, y2);
-  }
-
-  function getTests(infPadding) {
-    return infPadding ? [_collision, _outOfBounds] : [collision, outOfBounds];
-  }
-
-  function placeAreaLabelReducedSearch($, bitmaps, avoidBaseMark, markIndex, infPadding) {
+  function placeAreaLabelReducedSearch($, bitmaps, avoidBaseMark, markIndex) {
     const width = $.width,
           height = $.height,
-          [collision, outOfBounds] = getTests(infPadding),
           bm0 = bitmaps[0],
           // where labels have been placed
     bm1 = bitmaps[1]; // area outlines
@@ -32579,10 +32798,9 @@
   const X_DIR = [-1, -1, 1, 1];
   const Y_DIR = [-1, 1, -1, 1];
 
-  function placeAreaLabelFloodFill($, bitmaps, avoidBaseMark, markIndex, infPadding) {
+  function placeAreaLabelFloodFill($, bitmaps, avoidBaseMark, markIndex) {
     const width = $.width,
           height = $.height,
-          [collision, outOfBounds] = getTests(infPadding),
           bm0 = bitmaps[0],
           // where labels have been placed
     bm1 = bitmaps[1],
@@ -32704,21 +32922,23 @@
   const Aligns = ['right', 'center', 'left'],
         Baselines = ['bottom', 'middle', 'top'];
 
-  function placeMarkLabel($, bitmaps, anchors, offsets, infPadding) {
+  function placeMarkLabel($, bitmaps, anchors, offsets) {
     const width = $.width,
           height = $.height,
           bm0 = bitmaps[0],
           bm1 = bitmaps[1],
           n = offsets.length;
     return function (d) {
+      var _d$textWidth;
+
       const boundary = d.boundary,
             textHeight = d.datum.fontSize; // can not be placed if the mark is not visible in the graph bound
 
-      if (!infPadding && (boundary[2] < 0 || boundary[5] < 0 || boundary[0] > width || boundary[3] > height)) {
+      if (boundary[2] < 0 || boundary[5] < 0 || boundary[0] > width || boundary[3] > height) {
         return false;
       }
 
-      let textWidth = 0,
+      let textWidth = (_d$textWidth = d.textWidth) !== null && _d$textWidth !== void 0 ? _d$textWidth : 0,
           dx,
           dy,
           isInside,
@@ -32750,12 +32970,6 @@
         _y1 = $(y1);
         _y2 = $(y2);
 
-        if (infPadding) {
-          _x1 = _x1 < 0 ? 0 : _x1;
-          _y1 = _y1 < 0 ? 0 : _y1;
-          _y2 = _y2 >= $.height ? $.height - 1 : _y2;
-        }
-
         if (!textWidth) {
           // to avoid finding width of text label,
           if (!test(_x1, _x1, _y1, _y2, bm0, bm1, x1, x1, y1, y2, boundary, isInside)) {
@@ -32773,11 +32987,6 @@
         _x1 = $(x1);
         _x2 = $(x2);
 
-        if (infPadding) {
-          _x1 = _x1 < 0 ? 0 : _x1;
-          _x2 = _x2 >= $.width ? $.width - 1 : _x2;
-        }
-
         if (test(_x1, _x2, _y1, _y2, bm0, bm1, x1, x2, y1, y2, boundary, isInside)) {
           // place label if the position is placeable
           d.x = !dx ? xc : dx * insideFactor < 0 ? x2 : x1;
@@ -32795,11 +33004,7 @@
 
 
   function test(_x1, _x2, _y1, _y2, bm0, bm1, x1, x2, y1, y2, boundary, isInside) {
-    return !(bm0.outOfBounds(_x1, _y1, _x2, _y2) || (isInside && bm1 ? bm1.getRange(_x1, _y1, _x2, _y2) || !isInMarkBound(x1, y1, x2, y2, boundary) : bm0.getRange(_x1, _y1, _x2, _y2)));
-  }
-
-  function isInMarkBound(x1, y1, x2, y2, boundary) {
-    return boundary[0] <= x1 && x2 <= boundary[2] && boundary[3] <= y1 && y2 <= boundary[5];
+    return !(bm0.outOfBounds(_x1, _y1, _x2, _y2) || (isInside && bm1 || bm0).getRange(_x1, _y1, _x2, _y2));
   }
 
   const TOP = 0x0,
@@ -32837,18 +33042,27 @@
           isGroupArea = grouptype === 'area',
           boundary = markBoundary(marktype, grouptype, lineAnchor, markIndex),
           infPadding = padding === null || padding === Infinity,
-          $ = scaler(size[0], size[1], infPadding ? 0 : padding),
-          isNaiveGroupArea = isGroupArea && method === 'naive'; // prepare text mark data for placing
-
-    const data = texts.map(d => ({
-      datum: d,
-      opacity: 0,
-      x: undefined,
-      y: undefined,
-      align: undefined,
-      baseline: undefined,
-      boundary: boundary(d)
-    }));
+          isNaiveGroupArea = isGroupArea && method === 'naive';
+    let maxTextWidth = -1,
+        maxTextHeight = -1; // prepare text mark data for placing
+
+    const data = texts.map(d => {
+      const textWidth = infPadding ? textMetrics.width(d, d.text) : undefined;
+      maxTextWidth = Math.max(maxTextWidth, textWidth);
+      maxTextHeight = Math.max(maxTextHeight, d.fontSize);
+      return {
+        datum: d,
+        opacity: 0,
+        x: undefined,
+        y: undefined,
+        align: undefined,
+        baseline: undefined,
+        boundary: boundary(d),
+        textWidth
+      };
+    });
+    padding = padding === null || padding === Infinity ? Math.max(maxTextWidth, maxTextHeight) + Math.max(...offset) : padding;
+    const $ = scaler(size[0], size[1], padding);
     let bitmaps;
 
     if (!isNaiveGroupArea) {
@@ -32868,16 +33082,13 @@
       // base mark is implicitly avoided if it is a group area
 
 
-      if (marktype && (avoidBaseMark || isGroupArea)) {
-        avoidMarks = [texts.map(d => d.datum)].concat(avoidMarks);
-      } // generate bitmaps for layout calculation
-
+      const baseMark = (marktype && avoidBaseMark || isGroupArea) && texts.map(d => d.datum); // generate bitmaps for layout calculation
 
-      bitmaps = avoidMarks.length ? markBitmaps($, avoidMarks, labelInside, isGroupArea) : baseBitmaps($, avoidBaseMark && data);
+      bitmaps = avoidMarks.length || baseMark ? markBitmaps($, baseMark || [], avoidMarks, labelInside, isGroupArea) : baseBitmaps($, avoidBaseMark && data);
     } // generate label placement function
 
 
-    const place = isGroupArea ? placeAreaLabel[method]($, bitmaps, avoidBaseMark, markIndex, infPadding) : placeMarkLabel($, bitmaps, anchors, offsets, infPadding); // place all labels
+    const place = isGroupArea ? placeAreaLabel[method]($, bitmaps, avoidBaseMark, markIndex) : placeMarkLabel($, bitmaps, anchors, offsets); // place all labels
 
     data.forEach(d => d.opacity = +place(d));
     return data;
@@ -32912,7 +33123,7 @@
    * Factory function for function for getting base mark boundary, depending
    * on mark and group type. When mark type is undefined, line or area: boundary
    * is the coordinate of each data point. When base mark is grouped line,
-   * boundary is either at the beginning or end of the line depending on the
+   * boundary is either at the start or end of the line depending on the
    * value of lineAnchor. Otherwise, use bounds of base mark.
    */
 
@@ -33326,10 +33537,285 @@
     regression: Regression
   });
 
+  const epsilon$1 = 1.1102230246251565e-16;
+  const splitter = 134217729;
+  const resulterrbound = (3 + 8 * epsilon$1) * epsilon$1; // fast_expansion_sum_zeroelim routine from oritinal code
+
+  function sum(elen, e, flen, f, h) {
+    let Q, Qnew, hh, bvirt;
+    let enow = e[0];
+    let fnow = f[0];
+    let eindex = 0;
+    let findex = 0;
+
+    if (fnow > enow === fnow > -enow) {
+      Q = enow;
+      enow = e[++eindex];
+    } else {
+      Q = fnow;
+      fnow = f[++findex];
+    }
+
+    let hindex = 0;
+
+    if (eindex < elen && findex < flen) {
+      if (fnow > enow === fnow > -enow) {
+        Qnew = enow + Q;
+        hh = Q - (Qnew - enow);
+        enow = e[++eindex];
+      } else {
+        Qnew = fnow + Q;
+        hh = Q - (Qnew - fnow);
+        fnow = f[++findex];
+      }
+
+      Q = Qnew;
+
+      if (hh !== 0) {
+        h[hindex++] = hh;
+      }
+
+      while (eindex < elen && findex < flen) {
+        if (fnow > enow === fnow > -enow) {
+          Qnew = Q + enow;
+          bvirt = Qnew - Q;
+          hh = Q - (Qnew - bvirt) + (enow - bvirt);
+          enow = e[++eindex];
+        } else {
+          Qnew = Q + fnow;
+          bvirt = Qnew - Q;
+          hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+          fnow = f[++findex];
+        }
+
+        Q = Qnew;
+
+        if (hh !== 0) {
+          h[hindex++] = hh;
+        }
+      }
+    }
+
+    while (eindex < elen) {
+      Qnew = Q + enow;
+      bvirt = Qnew - Q;
+      hh = Q - (Qnew - bvirt) + (enow - bvirt);
+      enow = e[++eindex];
+      Q = Qnew;
+
+      if (hh !== 0) {
+        h[hindex++] = hh;
+      }
+    }
+
+    while (findex < flen) {
+      Qnew = Q + fnow;
+      bvirt = Qnew - Q;
+      hh = Q - (Qnew - bvirt) + (fnow - bvirt);
+      fnow = f[++findex];
+      Q = Qnew;
+
+      if (hh !== 0) {
+        h[hindex++] = hh;
+      }
+    }
+
+    if (Q !== 0 || hindex === 0) {
+      h[hindex++] = Q;
+    }
+
+    return hindex;
+  }
+  function estimate(elen, e) {
+    let Q = e[0];
+
+    for (let i = 1; i < elen; i++) Q += e[i];
+
+    return Q;
+  }
+  function vec(n) {
+    return new Float64Array(n);
+  }
+
+  const ccwerrboundA = (3 + 16 * epsilon$1) * epsilon$1;
+  const ccwerrboundB = (2 + 12 * epsilon$1) * epsilon$1;
+  const ccwerrboundC = (9 + 64 * epsilon$1) * epsilon$1 * epsilon$1;
+  const B = vec(4);
+  const C1 = vec(8);
+  const C2 = vec(12);
+  const D = vec(16);
+  const u = vec(4);
+
+  function orient2dadapt(ax, ay, bx, by, cx, cy, detsum) {
+    let acxtail, acytail, bcxtail, bcytail;
+
+    let bvirt, c, ahi, alo, bhi, blo, _i, _j, _0, s1, s0, t1, t0, u3;
+
+    const acx = ax - cx;
+    const bcx = bx - cx;
+    const acy = ay - cy;
+    const bcy = by - cy;
+    s1 = acx * bcy;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcx;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    B[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    B[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    B[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    B[3] = u3;
+    let det = estimate(4, B);
+    let errbound = ccwerrboundB * detsum;
+
+    if (det >= errbound || -det >= errbound) {
+      return det;
+    }
+
+    bvirt = ax - acx;
+    acxtail = ax - (acx + bvirt) + (bvirt - cx);
+    bvirt = bx - bcx;
+    bcxtail = bx - (bcx + bvirt) + (bvirt - cx);
+    bvirt = ay - acy;
+    acytail = ay - (acy + bvirt) + (bvirt - cy);
+    bvirt = by - bcy;
+    bcytail = by - (bcy + bvirt) + (bvirt - cy);
+
+    if (acxtail === 0 && acytail === 0 && bcxtail === 0 && bcytail === 0) {
+      return det;
+    }
+
+    errbound = ccwerrboundC * detsum + resulterrbound * Math.abs(det);
+    det += acx * bcytail + bcy * acxtail - (acy * bcxtail + bcx * acytail);
+    if (det >= errbound || -det >= errbound) return det;
+    s1 = acxtail * bcy;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcy;
+    bhi = c - (c - bcy);
+    blo = bcy - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcx;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcx;
+    bhi = c - (c - bcx);
+    blo = bcx - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C1len = sum(4, B, 4, u, C1);
+    s1 = acx * bcytail;
+    c = splitter * acx;
+    ahi = c - (c - acx);
+    alo = acx - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acy * bcxtail;
+    c = splitter * acy;
+    ahi = c - (c - acy);
+    alo = acy - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const C2len = sum(C1len, C1, 4, u, C2);
+    s1 = acxtail * bcytail;
+    c = splitter * acxtail;
+    ahi = c - (c - acxtail);
+    alo = acxtail - ahi;
+    c = splitter * bcytail;
+    bhi = c - (c - bcytail);
+    blo = bcytail - bhi;
+    s0 = alo * blo - (s1 - ahi * bhi - alo * bhi - ahi * blo);
+    t1 = acytail * bcxtail;
+    c = splitter * acytail;
+    ahi = c - (c - acytail);
+    alo = acytail - ahi;
+    c = splitter * bcxtail;
+    bhi = c - (c - bcxtail);
+    blo = bcxtail - bhi;
+    t0 = alo * blo - (t1 - ahi * bhi - alo * bhi - ahi * blo);
+    _i = s0 - t0;
+    bvirt = s0 - _i;
+    u[0] = s0 - (_i + bvirt) + (bvirt - t0);
+    _j = s1 + _i;
+    bvirt = _j - s1;
+    _0 = s1 - (_j - bvirt) + (_i - bvirt);
+    _i = _0 - t1;
+    bvirt = _0 - _i;
+    u[1] = _0 - (_i + bvirt) + (bvirt - t1);
+    u3 = _j + _i;
+    bvirt = u3 - _j;
+    u[2] = _j - (u3 - bvirt) + (_i - bvirt);
+    u[3] = u3;
+    const Dlen = sum(C2len, C2, 4, u, D);
+    return D[Dlen - 1];
+  }
+
+  function orient2d(ax, ay, bx, by, cx, cy) {
+    const detleft = (ay - cy) * (bx - cx);
+    const detright = (ax - cx) * (by - cy);
+    const det = detleft - detright;
+    if (detleft === 0 || detright === 0 || detleft > 0 !== detright > 0) return det;
+    const detsum = Math.abs(detleft + detright);
+    if (Math.abs(det) >= ccwerrboundA * detsum) return det;
+    return -orient2dadapt(ax, ay, bx, by, cx, cy, detsum);
+  }
+
   const EPSILON = Math.pow(2, -52);
   const EDGE_STACK = new Uint32Array(512);
   class Delaunator {
-    static from(points, getX = defaultGetX, getY = defaultGetY) {
+    static from(points) {
+      let getX = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : defaultGetX;
+      let getY = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultGetY;
       const n = points.length;
       const coords = new Float64Array(n * 2);
 
@@ -33463,7 +33949,7 @@
       } // swap the order of the seed points for counter-clockwise orientation
 
 
-      if (orient(i0x, i0y, i1x, i1y, i2x, i2y)) {
+      if (orient2d(i0x, i0y, i1x, i1y, i2x, i2y) < 0) {
         const i = i1;
         const x = i1x;
         const y = i1y;
@@ -33524,7 +34010,7 @@
         let e = start,
             q;
 
-        while (q = hullNext[e], !orient(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1])) {
+        while (q = hullNext[e], orient2d(x, y, coords[2 * e], coords[2 * e + 1], coords[2 * q], coords[2 * q + 1]) >= 0) {
           e = q;
 
           if (e === start) {
@@ -33546,7 +34032,7 @@
 
         let n = hullNext[e];
 
-        while (q = hullNext[n], orient(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1])) {
+        while (q = hullNext[n], orient2d(x, y, coords[2 * n], coords[2 * n + 1], coords[2 * q], coords[2 * q + 1]) < 0) {
           t = this._addTriangle(n, i, q, hullTri[i], -1, hullTri[n]);
           hullTri[i] = this._legalize(t + 2);
           hullNext[n] = n; // mark as removed
@@ -33557,7 +34043,7 @@
 
 
         if (e === start) {
-          while (q = hullPrev[e], orient(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1])) {
+          while (q = hullPrev[e], orient2d(x, y, coords[2 * q], coords[2 * q + 1], coords[2 * e], coords[2 * e + 1]) < 0) {
             t = this._addTriangle(q, i, e, -1, hullTri[e], hullTri[q]);
 
             this._legalize(t + 2);
@@ -33712,19 +34198,6 @@
     const dx = ax - bx;
     const dy = ay - by;
     return dx * dx + dy * dy;
-  } // return 2d orientation sign if we're confident in it through J. Shewchuk's error bound check
-
-
-  function orientIfSure(px, py, rx, ry, qx, qy) {
-    const l = (ry - py) * (qx - px);
-    const r = (rx - px) * (qy - py);
-    return Math.abs(l - r) >= 3.3306690738754716e-16 * Math.abs(l + r) ? l - r : 0;
-  } // a more robust orientation test that's stable in a given triangle (to fix robustness issues)
-
-
-  function orient(rx, ry, qx, qy, px, py) {
-    const sign = orientIfSure(px, py, rx, ry, qx, qy) || orientIfSure(rx, ry, qx, qy, px, py) || orientIfSure(qx, qy, px, py, rx, ry);
-    return sign < 0;
   }
 
   function inCircle(ax, ay, bx, by, cx, cy, px, py) {
@@ -33837,7 +34310,7 @@
     }
 
     moveTo(x, y) {
-      this._ += `M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}`;
+      this._ += "M".concat(this._x0 = this._x1 = +x, ",").concat(this._y0 = this._y1 = +y);
     }
 
     closePath() {
@@ -33848,7 +34321,7 @@
     }
 
     lineTo(x, y) {
-      this._ += `L${this._x1 = +x},${this._y1 = +y}`;
+      this._ += "L".concat(this._x1 = +x, ",").concat(this._y1 = +y);
     }
 
     arc(x, y, r) {
@@ -33856,13 +34329,13 @@
       const x0 = x + r;
       const y0 = y;
       if (r < 0) throw new Error("negative radius");
-      if (this._x1 === null) this._ += `M${x0},${y0}`;else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) this._ += "L" + x0 + "," + y0;
+      if (this._x1 === null) this._ += "M".concat(x0, ",").concat(y0);else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) this._ += "L" + x0 + "," + y0;
       if (!r) return;
-      this._ += `A${r},${r},0,1,1,${x - r},${y}A${r},${r},0,1,1,${this._x1 = x0},${this._y1 = y0}`;
+      this._ += "A".concat(r, ",").concat(r, ",0,1,1,").concat(x - r, ",").concat(y, "A").concat(r, ",").concat(r, ",0,1,1,").concat(this._x1 = x0, ",").concat(this._y1 = y0);
     }
 
     rect(x, y, w, h) {
-      this._ += `M${this._x0 = this._x1 = +x},${this._y0 = this._y1 = +y}h${+w}v${+h}h${-w}Z`;
+      this._ += "M".concat(this._x0 = this._x1 = +x, ",").concat(this._y0 = this._y1 = +y, "h").concat(+w, "v").concat(+h, "h").concat(-w, "Z");
     }
 
     value() {
@@ -33895,7 +34368,8 @@
   }
 
   class Voronoi$1 {
-    constructor(delaunay, [xmin, ymin, xmax, ymax] = [0, 0, 960, 500]) {
+    constructor(delaunay) {
+      let [xmin, ymin, xmax, ymax] = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 960, 500];
       if (!((xmax = +xmax) >= (xmin = +xmin)) || !((ymax = +ymax) >= (ymin = +ymin))) throw new Error("invalid bounds");
       this.delaunay = delaunay;
       this._circumcenters = new Float64Array(delaunay.points.length * 2);
@@ -33940,20 +34414,26 @@
         const dy = y2 - y1;
         const ex = x3 - x1;
         const ey = y3 - y1;
-        const bl = dx * dx + dy * dy;
-        const cl = ex * ex + ey * ey;
         const ab = (dx * ey - dy * ex) * 2;
 
-        if (!ab) {
+        if (Math.abs(ab) < 1e-9) {
           // degenerate case (collinear diagram)
-          x = (x1 + x3) / 2 - 1e8 * ey;
-          y = (y1 + y3) / 2 + 1e8 * ex;
-        } else if (Math.abs(ab) < 1e-8) {
           // almost equal points (degenerate triangle)
-          x = (x1 + x3) / 2;
-          y = (y1 + y3) / 2;
+          // the circumcenter is at the infinity, in a
+          // direction that is:
+          // 1. orthogonal to the halfedge.
+          let a = 1e9; // 2. points away from the center; since the list of triangles starts
+          // in the center, the first point of the first triangle
+          // will be our reference
+
+          const r = triangles[0] * 2;
+          a *= Math.sign((points[r] - x1) * ey - (points[r + 1] - y1) * ex);
+          x = (x1 + x3) / 2 - a * ey;
+          y = (y1 + y3) / 2 + a * ex;
         } else {
           const d = 1 / ab;
+          const bl = dx * dx + dy * dy;
+          const cl = ex * ex + ey * ey;
           x = x1 + (ey * bl - dy * cl) * d;
           y = y1 + (dx * cl - ex * bl) * d;
         }
@@ -34162,7 +34642,8 @@
       let c0,
           c1 = this._regioncode(x1, y1);
 
-      let e0, e1;
+      let e0,
+          e1 = 0;
 
       for (let j = 0; j < n; j += 2) {
         x0 = x1, y0 = y1, x1 = points[j], y1 = points[j + 1];
@@ -34275,7 +34756,9 @@
             e0 = 0b0101, x = this.xmin, y = this.ymin;
             break;
           // left
-        }
+        } // Note: this implicitly checks for out of bounds: if P[j] or P[j+1] are
+        // undefined, the conditional statement will be executed.
+
 
         if ((P[j] !== x || P[j + 1] !== y) && this.contains(i, x, y)) {
           P.splice(j, 0, x, y), j += 2;
@@ -34366,7 +34849,10 @@
   }
 
   class Delaunay {
-    static from(points, fx = pointX, fy = pointY, that) {
+    static from(points) {
+      let fx = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : pointX;
+      let fy = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : pointY;
+      let that = arguments.length > 3 ? arguments[3] : undefined;
       return new Delaunay("length" in points ? flatArray(points, fx, fy, that) : Float64Array.from(flatIterable(points, fx, fy, that)));
     }
 
@@ -34436,10 +34922,13 @@
         this.triangles = new Int32Array(3).fill(-1);
         this.halfedges = new Int32Array(3).fill(-1);
         this.triangles[0] = hull[0];
-        this.triangles[1] = hull[1];
-        this.triangles[2] = hull[1];
         inedges[hull[0]] = 1;
-        if (hull.length === 2) inedges[hull[1]] = 0;
+
+        if (hull.length === 2) {
+          inedges[hull[1]] = 0;
+          this.triangles[1] = hull[1];
+          this.triangles[2] = hull[1];
+        }
       }
     }
 
@@ -34485,7 +34974,8 @@
       } while (e !== e0);
     }
 
-    find(x, y, i = 0) {
+    find(x, y) {
+      let i = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
       if ((x = +x, x !== x) || (y = +y, y !== y)) return -1;
       const i0 = i;
       let c;
@@ -34554,7 +35044,9 @@
       return buffer && buffer.value();
     }
 
-    renderPoints(context, r = 2) {
+    renderPoints(context, r) {
+      if (r === undefined && (!context || typeof context.moveTo !== "function")) r = context, context = null;
+      r = r == undefined ? 2 : +r;
       const buffer = context == null ? context = new Path() : undefined;
       const {
         points
@@ -36068,6 +36560,8 @@
     resolvefilter: ResolveFilter
   });
 
+  var version = "5.22.1";
+
   const RawCode = 'RawCode';
   const Literal = 'Literal';
   const Property = 'Property';
@@ -36248,11 +36742,20 @@
 
 
   function isIdentifierStart(ch) {
-    return ch === 0x24 || ch === 0x5F || ch >= 0x41 && ch <= 0x5A || ch >= 0x61 && ch <= 0x7A || ch === 0x5C || ch >= 0x80 && RegexNonAsciiIdentifierStart.test(String.fromCharCode(ch));
+    return ch === 0x24 || ch === 0x5F || // $ (dollar) and _ (underscore)
+    ch >= 0x41 && ch <= 0x5A || // A..Z
+    ch >= 0x61 && ch <= 0x7A || // a..z
+    ch === 0x5C || // \ (backslash)
+    ch >= 0x80 && RegexNonAsciiIdentifierStart.test(String.fromCharCode(ch));
   }
 
   function isIdentifierPart(ch) {
-    return ch === 0x24 || ch === 0x5F || ch >= 0x41 && ch <= 0x5A || ch >= 0x61 && ch <= 0x7A || ch >= 0x30 && ch <= 0x39 || ch === 0x5C || ch >= 0x80 && RegexNonAsciiIdentifierPart.test(String.fromCharCode(ch));
+    return ch === 0x24 || ch === 0x5F || // $ (dollar) and _ (underscore)
+    ch >= 0x41 && ch <= 0x5A || // A..Z
+    ch >= 0x61 && ch <= 0x7A || // a..z
+    ch >= 0x30 && ch <= 0x39 || // 0..9
+    ch === 0x5C || // \ (backslash)
+    ch >= 0x80 && RegexNonAsciiIdentifierPart.test(String.fromCharCode(ch));
   } // 7.6.1.1 Keywords
 
 
@@ -37742,7 +38245,7 @@
           functions = (opt.functions || Functions)(visit),
           globalvar = opt.globalvar,
           fieldvar = opt.fieldvar,
-          outputGlobal = isFunction(globalvar) ? globalvar : id => `${globalvar}["${id}"]`;
+          outputGlobal = isFunction(globalvar) ? globalvar : id => "".concat(globalvar, "[\"").concat(id, "\"]");
     let globals = {},
         fields = {},
         memberDepth = 0;
@@ -37827,70 +38330,15 @@
     return codegen;
   }
 
-  function ascending(a, b) {
-    return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
-  }
-
-  function bisector(f) {
-    let delta = f;
-    let compare = f;
-
-    if (f.length === 1) {
-      delta = (d, x) => f(d) - x;
-
-      compare = ascendingComparator(f);
-    }
-
-    function left(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
-
-      while (lo < hi) {
-        const mid = lo + hi >>> 1;
-        if (compare(a[mid], x) < 0) lo = mid + 1;else hi = mid;
-      }
-
-      return lo;
-    }
-
-    function right(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
-
-      while (lo < hi) {
-        const mid = lo + hi >>> 1;
-        if (compare(a[mid], x) > 0) hi = mid;else lo = mid + 1;
-      }
-
-      return lo;
-    }
-
-    function center(a, x, lo, hi) {
-      if (lo == null) lo = 0;
-      if (hi == null) hi = a.length;
-      const i = left(a, x, lo, hi - 1);
-      return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
-    }
-
-    return {
-      left,
-      center,
-      right
-    };
-  }
-
-  function ascendingComparator(f) {
-    return (d, x) => ascending(f(d), x);
-  }
-
   const Intersect = 'intersect';
   const Union = 'union';
   const VlMulti = 'vlMulti';
   const VlPoint = 'vlPoint';
   const Or = 'or';
   const And = 'and';
-  const SELECTION_ID = '_vgsid_',
-        TYPE_ENUM = 'E',
+  const SelectionId = '_vgsid_';
+  const $selectionId = field$1(SelectionId);
+  const TYPE_ENUM = 'E',
         TYPE_RANGE_INC = 'R',
         TYPE_RANGE_EXC = 'R-E',
         TYPE_RANGE_LE = 'R-LE',
@@ -37994,8 +38442,7 @@
     return n && intersect;
   }
 
-  const selectionId = field$1(SELECTION_ID),
-        bisect = bisector(selectionId),
+  const bisect = bisector($selectionId),
         bisectLeft = bisect.left,
         bisectRight = bisect.right;
 
@@ -38004,10 +38451,10 @@
           entries = data ? data.values.value : [],
           unitIdx = data ? data[UNIT_INDEX] && data[UNIT_INDEX].value : undefined,
           intersect = op === Intersect,
-          value = selectionId(datum),
+          value = $selectionId(datum),
           index = bisectLeft(entries, value);
     if (index === entries.length) return false;
-    if (selectionId(entries[index]) !== value) return false;
+    if ($selectionId(entries[index]) !== value) return false;
 
     if (unitIdx && intersect) {
       if (unitIdx.size === 1) return true;
@@ -38019,15 +38466,17 @@
   /**
    * Maps an array of scene graph items to an array of selection tuples.
    * @param {string} name  - The name of the dataset representing the selection.
-   * @param {string} unit  - The name of the unit view.
+   * @param {string} base  - The base object that generated tuples extend.
    *
    * @returns {array} An array of selection entries for the given unit.
    */
 
 
   function selectionTuples(array, base) {
-    return array.map(x => extend$1({
+    return array.map(x => extend$1(base.fields ? {
       values: base.fields.map(f => (f.getter || (f.getter = field$1(f.field)))(x.datum))
+    } : {
+      [SelectionId]: $selectionId(x.datum)
     }, base));
   }
   /**
@@ -38056,6 +38505,7 @@
         values,
         unit,
         field,
+        value,
         res,
         resUnit,
         type,
@@ -38071,32 +38521,55 @@
       fields = entry.fields;
       values = entry.values;
 
-      for (j = 0, m = fields.length; j < m; ++j) {
-        field = fields[j];
-        res = resolved[field.field] || (resolved[field.field] = {});
+      if (fields && values) {
+        // Intentional selection stores
+        for (j = 0, m = fields.length; j < m; ++j) {
+          field = fields[j];
+          res = resolved[field.field] || (resolved[field.field] = {});
+          resUnit = res[unit] || (res[unit] = []);
+          types[field.field] = type = field.type.charAt(0);
+          union = ops["".concat(type, "_union")];
+          res[unit] = union(resUnit, array$5(values[j]));
+        } // If the same multi-selection is repeated over views and projected over
+        // an encoding, it may operate over different fields making it especially
+        // tricky to reliably resolve it. At best, we can de-dupe identical entries
+        // but doing so may be more computationally expensive than it is worth.
+        // Instead, for now, we simply transform our store representation into
+        // a more human-friendly one.
+
+
+        if (isMulti) {
+          resUnit = multiRes[unit] || (multiRes[unit] = []);
+          resUnit.push(array$5(values).reduce((obj, curr, j) => (obj[fields[j].field] = curr, obj), {}));
+        }
+      } else {
+        // Short circuit extensional selectionId stores which hold sorted IDs unique to each unit.
+        field = SelectionId;
+        value = $selectionId(entry);
+        res = resolved[field] || (resolved[field] = {});
         resUnit = res[unit] || (res[unit] = []);
-        types[field.field] = type = field.type.charAt(0);
-        union = ops[type + '_union'];
-        res[unit] = union(resUnit, array$5(values[j]));
-      } // If the same multi-selection is repeated over views and projected over
-      // an encoding, it may operate over different fields making it especially
-      // tricky to reliably resolve it. At best, we can de-dupe identical entries
-      // but doing so may be more computationally expensive than it is worth.
-      // Instead, for now, we simply transform our store representation into
-      // a more human-friendly one.
-
+        resUnit.push(value);
 
-      if (isMulti) {
-        resUnit = multiRes[unit] || (multiRes[unit] = []);
-        resUnit.push(array$5(values).reduce((obj, curr, j) => (obj[fields[j].field] = curr, obj), {}));
+        if (isMulti) {
+          resUnit = multiRes[unit] || (multiRes[unit] = []);
+          resUnit.push({
+            [SelectionId]: value
+          });
+        }
       }
     } // Then resolve fields across units as per the op.
 
 
     op = op || Union;
-    Object.keys(resolved).forEach(field => {
-      resolved[field] = Object.keys(resolved[field]).map(unit => resolved[field][unit]).reduce((acc, curr) => acc === undefined ? curr : ops[types[field] + '_' + op](acc, curr));
-    });
+
+    if (resolved[SelectionId]) {
+      resolved[SelectionId] = ops["".concat(SelectionId, "_").concat(op)](...Object.values(resolved[SelectionId]));
+    } else {
+      Object.keys(resolved).forEach(field => {
+        resolved[field] = Object.keys(resolved[field]).map(unit => resolved[field][unit]).reduce((acc, curr) => acc === undefined ? curr : ops["".concat(types[field], "_").concat(op)](acc, curr));
+      });
+    }
+
     entries = Object.keys(multiRes);
 
     if (isMulti && entries.length) {
@@ -38114,6 +38587,8 @@
   }
 
   var ops = {
+    ["".concat(SelectionId, "_union")]: union,
+    ["".concat(SelectionId, "_intersect")]: intersection,
     E_union: function (base, value) {
       if (!base.length) return value;
       var i = 0,
@@ -38322,9 +38797,9 @@
 
 
     return {
-      _bandwidth: args => `this.__bandwidth(${ref(args[0])})`,
-      _range: args => `${ref(args[0])}.range()`,
-      _scale: args => `${ref(args[0])}(${codegen(args[1])})`
+      _bandwidth: args => "this.__bandwidth(".concat(ref(args[0]), ")"),
+      _range: args => "".concat(ref(args[0]), ".range()"),
+      _scale: args => "".concat(ref(args[0]), "(").concat(codegen(args[1]), ")")
     };
   }
 
@@ -38516,19 +38991,35 @@
     return array(seq) || (isString(seq) ? seq : null);
   }
 
-  function join(seq, ...args) {
+  function join(seq) {
+    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+      args[_key - 1] = arguments[_key];
+    }
+
     return array(seq).join(...args);
   }
 
-  function indexof(seq, ...args) {
+  function indexof(seq) {
+    for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      args[_key2 - 1] = arguments[_key2];
+    }
+
     return sequence(seq).indexOf(...args);
   }
 
-  function lastindexof(seq, ...args) {
+  function lastindexof(seq) {
+    for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
+      args[_key3 - 1] = arguments[_key3];
+    }
+
     return sequence(seq).lastIndexOf(...args);
   }
 
-  function slice(seq, ...args) {
+  function slice(seq) {
+    for (var _len4 = arguments.length, args = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
+      args[_key4 - 1] = arguments[_key4];
+    }
+
     return sequence(seq).slice(...args);
   }
 
@@ -38610,7 +39101,7 @@
   function pathShape(path) {
     let p = null;
     return function (context) {
-      return context ? pathRender(context, p = p || pathParse(path)) : path;
+      return context ? pathRender(context, p = p || parse$3(path)) : path;
     };
   }
 
@@ -38673,6 +39164,101 @@
 
     return p;
   }
+  /**
+   * Appends a new point to the lasso
+   * 
+   * @param {*} lasso the lasso in pixel space
+   * @param {*} x the x coordinate in pixel space
+   * @param {*} y the y coordinate in pixel space
+   * @param {*} minDist the minimum distance, in pixels, that thenew point needs to be apart from the last point
+   * @returns a new array containing the lasso with the new point
+   */
+
+
+  function lassoAppend(lasso, x, y) {
+    let minDist = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 5;
+    const last = lasso[lasso.length - 1]; // Add point to lasso if distance to last point exceed minDist or its the first point
+
+    if (last === undefined || Math.sqrt((last[0] - x) ** 2 + (last[1] - y) ** 2) > minDist) {
+      lasso.push([x, y]);
+      return [...lasso];
+    }
+
+    return lasso;
+  }
+  /**
+   * Generates a svg path command which draws a lasso
+   * 
+   * @param {*} lasso the lasso in pixel space in the form [[x,y], [x,y], ...]
+   * @returns the svg path command that draws the lasso
+   */
+
+
+  function lassoPath(lasso) {
+    return (lasso !== null && lasso !== void 0 ? lasso : []).reduce((svg, _ref, i) => {
+      let [x, y] = _ref;
+      return svg += i == 0 ? "M ".concat(x, ",").concat(y, " ") : i === lasso.length - 1 ? ' Z' : "L ".concat(x, ",").concat(y, " ");
+    }, '');
+  }
+  /**
+   * Inverts the lasso from pixel space to an array of vega scenegraph tuples
+   * 
+   * @param {*} data the dataset
+   * @param {*} pixelLasso the lasso in pixel space, [[x,y], [x,y], ...]
+   * @param {*} unit the unit where the lasso is defined
+   * 
+   * @returns an array of vega scenegraph tuples
+   */
+
+
+  function intersectLasso(markname, pixelLasso, unit) {
+    const {
+      x,
+      y,
+      mark
+    } = unit;
+    const bb = new Bounds().set(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER, Number.MIN_SAFE_INTEGER, Number.MIN_SAFE_INTEGER); // Get bounding box around lasso
+
+    for (const [px, py] of pixelLasso) {
+      if (px < bb.x1) bb.x1 = px;
+      if (px > bb.x2) bb.x2 = px;
+      if (py < bb.y1) bb.y1 = py;
+      if (py > bb.y2) bb.y2 = py;
+    } // Translate bb against unit coordinates
+
+
+    bb.translate(x, y);
+    const intersection = intersect([[bb.x1, bb.y1], [bb.x2, bb.y2]], markname, mark); // Check every point against the lasso
+
+    return intersection.filter(tuple => pointInPolygon(tuple.x, tuple.y, pixelLasso));
+  }
+  /**
+   * Performs a test if a point is inside a polygon based on the idea from
+   * https://wrf.ecse.rpi.edu/Research/Short_Notes/pnpoly.html
+   * 
+   * This method will not need the same start/end point since it wraps around the edges of the array
+   * 
+   * @param {*} test a point to test against
+   * @param {*} polygon a polygon in the form [[x,y], [x,y], ...]
+   * @returns true if the point lies inside the polygon, false otherwise
+   */
+
+
+  function pointInPolygon(testx, testy, polygon) {
+    let intersections = 0;
+
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+      const [prevX, prevY] = polygon[j];
+      const [x, y] = polygon[i]; // count intersections
+
+      if (y > testy != prevY > testy && testx < (prevX - x) * (testy - y) / (prevY - y) + x) {
+        intersections++;
+      }
+    } // point is in polygon if intersection count is odd
+
+
+    return intersections & 1;
+  }
 
   const functionContext = {
     random() {
@@ -38711,7 +39297,12 @@
     },
 
     toBoolean,
-    toDate,
+
+    toDate(_) {
+      return toDate(_);
+    },
+
+    // suppress extra arguments
     toNumber,
     toString,
     indexof,
@@ -38735,7 +39326,7 @@
     hsl: hsl$2,
     luminance,
     contrast,
-    sequence: range$1$1,
+    sequence: range$3,
     format,
     utcFormat,
     utcParse,
@@ -38759,7 +39350,12 @@
     warn,
     info,
     debug,
-    extent,
+
+    extent(_) {
+      return extent(_);
+    },
+
+    // suppress extra arguments
     inScope,
     intersect,
     clampRange,
@@ -38780,7 +39376,10 @@
     zoomPow,
     zoomSymlog,
     encode,
-    modify
+    modify,
+    lassoAppend,
+    lassoPath,
+    intersectLasso
   };
   const eventFunctions = ['view', 'item', 'group', 'xy', 'x', 'y'],
         // event functions
@@ -38795,7 +39394,7 @@
     forbidden: ['_'],
     allowed: ['datum', 'event', 'item'],
     fieldvar: 'datum',
-    globalvar: id => `_[${$(SignalPrefix + id)}]`,
+    globalvar: id => "_[".concat($(SignalPrefix + id), "]"),
     functions: buildFunctions,
     constants: Constants,
     visitors: astVisitors
@@ -38993,10 +39592,7 @@
 
 
   function _compare(u, v, lt, gt) {
-    return `((u = ${u}) < (v = ${v}) || u == null) && v != null ? ${lt}
-  : (u > v || v == null) && u != null ? ${gt}
-  : ((v = v instanceof Date ? +v : v), (u = u instanceof Date ? +u : u)) !== u && v === v ? ${lt}
-  : v !== v && u === u ? ${gt} : `;
+    return "((u = ".concat(u, ") < (v = ").concat(v, ") || u == null) && v != null ? ").concat(lt, "\n  : (u > v || v == null) && u != null ? ").concat(gt, "\n  : ((v = v instanceof Date ? +v : v), (u = u instanceof Date ? +u : u)) !== u && v === v ? ").concat(lt, "\n  : v !== v && u === u ? ").concat(gt, " : ");
   }
 
   var expressionCodegen = {
@@ -39019,7 +39615,7 @@
      * Parse an expression used to handle an event-driven operator update.
      */
     handler: (ctx, expr) => {
-      const code = `var datum=event.item&&event.item.datum;return ${expr.code};`;
+      const code = "var datum=event.item&&event.item.datum;return ".concat(expr.code, ";");
       return expression(ctx, ['_', 'event'], code);
     },
 
@@ -39035,7 +39631,7 @@
 
       for (const name in channels) {
         const o = 'o[' + $(name) + ']';
-        code += `$=${channels[name].code};if(${o}!==$)${o}=$,m=1;`;
+        code += "$=".concat(channels[name].code, ";if(").concat(o, "!==$)").concat(o, "=$,m=1;");
       }
 
       code += adjustSpatial(channels, marktype);
@@ -39048,8 +39644,8 @@
      */
     codegen: {
       get(path) {
-        const ref = `[${path.map($).join('][')}]`;
-        const get = Function('_', `return _${ref};`);
+        const ref = "[".concat(path.map($).join(']['), "]");
+        const get = Function('_', "return _".concat(ref, ";"));
         get.path = ref;
         return get;
       },
@@ -39062,12 +39658,12 @@
           let u, v;
 
           if (f.path) {
-            u = `a${f.path}`;
-            v = `b${f.path}`;
+            u = "a".concat(f.path);
+            v = "b".concat(f.path);
           } else {
             (t = t || {})['f' + i] = f;
-            u = `this.f${i}(a)`;
-            v = `this.f${i}(b)`;
+            u = "this.f".concat(i, "(a)");
+            v = "this.f".concat(i, "(b)");
           }
 
           return _compare(u, v, -o, o);
@@ -39844,7 +40440,7 @@
     const rule = view._eventConfig && view._eventConfig[key];
 
     if (rule === false || isObject(rule) && !rule[type]) {
-      view.warn(`Blocked ${key} ${type} event listener.`);
+      view.warn("Blocked ".concat(key, " ").concat(type, " event listener."));
       return false;
     }
 
@@ -40330,7 +40926,7 @@
 
     if (el && clear) {
       try {
-        el.innerHTML = '';
+        el.textContent = '';
       } catch (e) {
         el = null;
         view.error(e);
@@ -41345,14 +41941,14 @@
     };
   }
 
-  const scaleRef = scale => isString(scale) ? $(scale) : scale.signal ? `(${scale.signal})` : field(scale);
+  const scaleRef = scale => isString(scale) ? $(scale) : scale.signal ? "(".concat(scale.signal, ")") : field(scale);
 
   function entry$1(enc) {
     if (enc.gradient != null) {
       return gradient(enc);
     }
 
-    let value = enc.signal ? `(${enc.signal})` : enc.color ? color(enc.color) : enc.field != null ? field(enc.field) : enc.value !== undefined ? $(enc.value) : undefined;
+    let value = enc.signal ? "(".concat(enc.signal, ")") : enc.color ? color(enc.color) : enc.field != null ? field(enc.field) : enc.value !== undefined ? $(enc.value) : undefined;
 
     if (enc.scale != null) {
       value = scale(enc, value);
@@ -41363,25 +41959,25 @@
     }
 
     if (enc.exponent != null) {
-      value = `pow(${value},${property(enc.exponent)})`;
+      value = "pow(".concat(value, ",").concat(property(enc.exponent), ")");
     }
 
     if (enc.mult != null) {
-      value += `*${property(enc.mult)}`;
+      value += "*".concat(property(enc.mult));
     }
 
     if (enc.offset != null) {
-      value += `+${property(enc.offset)}`;
+      value += "+".concat(property(enc.offset));
     }
 
     if (enc.round) {
-      value = `round(${value})`;
+      value = "round(".concat(value, ")");
     }
 
     return value;
   }
 
-  const _color = (type, x, y, z) => `(${type}(${[x, y, z].map(entry$1).join(',')})+'')`;
+  const _color = (type, x, y, z) => "(".concat(type, "(").concat([x, y, z].map(entry$1).join(','), ")+'')");
 
   function color(enc) {
     return enc.c ? _color('hcl', enc.h, enc.c, enc.l) : enc.h || enc.s ? _color('hsl', enc.h, enc.s, enc.l) : enc.l || enc.a ? _color('lab', enc.l, enc.a, enc.b) : enc.r || enc.g || enc.b ? _color('rgb', enc.r, enc.g, enc.b) : null;
@@ -41394,7 +41990,7 @@
     while (args.length && peek$1(args) == null) args.pop();
 
     args.unshift(scaleRef(enc.gradient));
-    return `gradient(${args.join(',')})`;
+    return "gradient(".concat(args.join(','), ")");
   }
 
   function property(property) {
@@ -41446,17 +42042,17 @@
 
     if (enc.range != null) {
       // pull value from scale range
-      value = `lerp(_range(${scale}), ${+enc.range})`;
+      value = "lerp(_range(".concat(scale, "), ").concat(+enc.range, ")");
     } else {
       // run value through scale and/or pull scale bandwidth
-      if (value !== undefined) value = `_scale(${scale}, ${value})`;
+      if (value !== undefined) value = "_scale(".concat(scale, ", ").concat(value, ")");
 
       if (enc.band) {
-        value = (value ? value + '+' : '') + `_bandwidth(${scale})` + (+enc.band === 1 ? '' : '*' + property(enc.band));
+        value = (value ? value + '+' : '') + "_bandwidth(".concat(scale, ")") + (+enc.band === 1 ? '' : '*' + property(enc.band));
 
         if (enc.extra) {
           // include logic to handle extraneous elements
-          value = `(datum.extra ? _scale(${scale}, datum.extra.value) : ${value})`;
+          value = "(datum.extra ? _scale(".concat(scale, ", datum.extra.value) : ").concat(value, ")");
         }
       }
 
@@ -41470,7 +42066,7 @@
     let code = '';
     enc.forEach(rule => {
       const value = entry$1(rule);
-      code += rule.test ? `(${rule.test})?${value}:` : value;
+      code += rule.test ? "(".concat(rule.test, ")?").concat(value, ":") : value;
     }); // if no else clause, terminate with null (#1366)
 
     if (peek$1(code) === ':') {
@@ -42229,7 +42825,7 @@
   }
 
   function anchorExpr(s, e, m) {
-    return `item.anchor === '${Start}' ? ${s} : item.anchor === '${End}' ? ${e} : ${m}`;
+    return "item.anchor === '".concat(Start, "' ? ").concat(s, " : item.anchor === '").concat(End, "' ? ").concat(e, " : ").concat(m);
   }
 
   const alignExpr$1 = anchorExpr($(Left), $(Right), $(Center));
@@ -42248,15 +42844,15 @@
     } else if (v.signal) {
       // if signal, augment code to interpret values
       band = {
-        signal: `(${v.signal}) === 'extent' ? 1 : 0.5`
+        signal: "(".concat(v.signal, ") === 'extent' ? 1 : 0.5")
       };
       extra = {
-        signal: `(${v.signal}) === 'extent'`
+        signal: "(".concat(v.signal, ") === 'extent'")
       };
 
       if (!isObject(offset)) {
         offset = {
-          signal: `(${v.signal}) === 'extent' ? 0 : ${offset}`
+          signal: "(".concat(v.signal, ") === 'extent' ? 0 : ").concat(offset)
         };
       }
     } else if (v === 'extent') {
@@ -42406,8 +43002,8 @@
     }, userEncode);
   }
 
-  const alignExpr = `datum.${Perc}<=0?"${Left}":datum.${Perc}>=1?"${Right}":"${Center}"`,
-        baselineExpr = `datum.${Perc}<=0?"${Bottom}":datum.${Perc}>=1?"${Top}":"${Middle}"`;
+  const alignExpr = "datum.".concat(Perc, "<=0?\"").concat(Left, "\":datum.").concat(Perc, ">=1?\"").concat(Right, "\":\"").concat(Center, "\""),
+        baselineExpr = "datum.".concat(Perc, "<=0?\"").concat(Bottom, "\":datum.").concat(Perc, ">=1?\"").concat(Top, "\":\"").concat(Middle, "\"");
 
   function legendGradientLabels(spec, config, userEncode, dataRef) {
     const _ = lookup(spec, config),
@@ -42500,12 +43096,12 @@
           valueRef = {
       data: 'value'
     },
-          xSignal = `(${columns}) ? datum.${Offset} : datum.${Size}`,
+          xSignal = "(".concat(columns, ") ? datum.").concat(Offset, " : datum.").concat(Size),
           yEncode = height ? encoder(height) : {
       field: Size
     },
-          index = `datum.${Index}`,
-          ncols = `max(1, ${columns})`;
+          index = "datum.".concat(Index),
+          ncols = "max(1, ".concat(columns, ")");
 
     let encode, enter, update, nrows, sort;
     yEncode.mult = 0.5; // -- LEGEND SYMBOLS --
@@ -42634,22 +43230,22 @@
     }; // annotate and sort groups to ensure correct ordering
 
     if (_.isVertical(true)) {
-      nrows = `ceil(item.mark.items.length / ${ncols})`;
-      update.row.signal = `${index}%${nrows}`;
-      update.column.signal = `floor(${index} / ${nrows})`;
+      nrows = "ceil(item.mark.items.length / ".concat(ncols, ")");
+      update.row.signal = "".concat(index, "%").concat(nrows);
+      update.column.signal = "floor(".concat(index, " / ").concat(nrows, ")");
       sort = {
         field: ['row', index]
       };
     } else {
-      update.row.signal = `floor(${index} / ${ncols})`;
-      update.column.signal = `${index} % ${ncols}`;
+      update.row.signal = "floor(".concat(index, " / ").concat(ncols, ")");
+      update.column.signal = "".concat(index, " % ").concat(ncols);
       sort = {
         field: index
       };
     } // handle zero column case (implies infinite columns)
 
 
-    update.column.signal = `(${columns})?${update.column.signal}:${index}`; // facet legend entries into sub-groups
+    update.column.signal = "(".concat(columns, ")?").concat(update.column.signal, ":").concat(index); // facet legend entries into sub-groups
 
     dataRef = {
       facet: {
@@ -42689,14 +43285,14 @@
 
   const isL = 'item.orient === "left"',
         isR = 'item.orient === "right"',
-        isLR = `(${isL} || ${isR})`,
-        isVG = `datum.vgrad && ${isLR}`,
+        isLR = "(".concat(isL, " || ").concat(isR, ")"),
+        isVG = "datum.vgrad && ".concat(isLR),
         baseline = anchorExpr('"top"', '"bottom"', '"middle"'),
         alignFlip = anchorExpr('"right"', '"left"', '"center"'),
-        exprAlign = `datum.vgrad && ${isR} ? (${alignFlip}) : (${isLR} && !(datum.vgrad && ${isL})) ? "left" : ${alignExpr$1}`,
-        exprAnchor = `item._anchor || (${isLR} ? "middle" : "start")`,
-        exprAngle = `${isVG} ? (${isL} ? -90 : 90) : 0`,
-        exprBaseline = `${isLR} ? (datum.vgrad ? (${isR} ? "bottom" : "top") : ${baseline}) : "top"`;
+        exprAlign = "datum.vgrad && ".concat(isR, " ? (").concat(alignFlip, ") : (").concat(isLR, " && !(datum.vgrad && ").concat(isL, ")) ? \"left\" : ").concat(alignExpr$1),
+        exprAnchor = "item._anchor || (".concat(isLR, " ? \"middle\" : \"start\")"),
+        exprAngle = "".concat(isVG, " ? (").concat(isL, " ? -90 : 90) : 0"),
+        exprBaseline = "".concat(isLR, " ? (datum.vgrad ? (").concat(isR, " ? \"bottom\" : \"top\") : ").concat(baseline, ") : \"top\"");
 
   function legendTitle(spec, config, userEncode, dataRef) {
     const _ = lookup(spec, config);
@@ -43429,7 +44025,7 @@
     if (type === Gradient) {
       children = [legendGradient(spec, scale, config, encode.gradient), legendGradientLabels(spec, config, encode.labels, entryRef)]; // adjust default tick count based on the gradient length
 
-      params.count = params.count || scope.signalRef(`max(2,2*floor((${deref(_.gradientLength())})/100))`);
+      params.count = params.count || scope.signalRef("max(2,2*floor((".concat(deref(_.gradientLength()), ")/100))"));
     } // discrete gradient legend
     else if (type === Discrete) {
       children = [legendGradientDiscrete(spec, scale, config, encode.gradient, entryRef), legendGradientLabels(spec, config, encode.labels, entryRef)];
@@ -43513,18 +44109,18 @@
     const size = deref(getChannel('size', spec, marks)),
           strokeWidth = deref(getChannel('strokeWidth', spec, marks)),
           fontSize = deref(getFontSize(marks[1].encode, scope, GuideLabelStyle));
-    return parser(`max(ceil(sqrt(${size})+${strokeWidth}),${fontSize})`, scope);
+    return parser("max(ceil(sqrt(".concat(size, ")+").concat(strokeWidth, "),").concat(fontSize, ")"), scope);
   }
 
   function getChannel(name, spec, marks) {
-    return spec[name] ? `scale("${spec[name]}",datum)` : getEncoding(name, marks[0].encode);
+    return spec[name] ? "scale(\"".concat(spec[name], "\",datum)") : getEncoding(name, marks[0].encode);
   }
 
   function getFontSize(encode, scope, style) {
     return getEncoding('fontSize', encode) || getStyle('fontSize', scope, style);
   }
 
-  const angleExpr = `item.orient==="${Left}"?-90:item.orient==="${Right}"?90:0`;
+  const angleExpr = "item.orient===\"".concat(Left, "\"?-90:item.orient===\"").concat(Right, "\"?90:0");
 
   function parseTitle(spec, scope) {
     spec = isString(spec) ? {
@@ -43841,15 +44437,15 @@
     value: b
   };
 
-  const ifXEnc = ($orient, a, b) => ifEnc(`${$orient} === '${Top}' || ${$orient} === '${Bottom}'`, a, b);
+  const ifXEnc = ($orient, a, b) => ifEnc("".concat($orient, " === '").concat(Top, "' || ").concat($orient, " === '").concat(Bottom, "'"), a, b);
 
-  const ifYEnc = ($orient, a, b) => ifEnc(`${$orient} !== '${Top}' && ${$orient} !== '${Bottom}'`, a, b);
+  const ifYEnc = ($orient, a, b) => ifEnc("".concat($orient, " !== '").concat(Top, "' && ").concat($orient, " !== '").concat(Bottom, "'"), a, b);
 
-  const ifLeftTopExpr = ($orient, a, b) => ifExpr(`${$orient} === '${Left}' || ${$orient} === '${Top}'`, a, b);
+  const ifLeftTopExpr = ($orient, a, b) => ifExpr("".concat($orient, " === '").concat(Left, "' || ").concat($orient, " === '").concat(Top, "'"), a, b);
 
-  const ifTopExpr = ($orient, a, b) => ifExpr(`${$orient} === '${Top}'`, a, b);
+  const ifTopExpr = ($orient, a, b) => ifExpr("".concat($orient, " === '").concat(Top, "'"), a, b);
 
-  const ifRightExpr = ($orient, a, b) => ifExpr(`${$orient} === '${Right}'`, a, b);
+  const ifRightExpr = ($orient, a, b) => ifExpr("".concat($orient, " === '").concat(Right, "'"), a, b);
 
   const ifEnc = (test, a, b) => {
     // ensure inputs are encoder objects (or null)
@@ -43861,7 +44457,7 @@
       a = a ? a.signal || $(a.value) : null;
       b = b ? b.signal || $(b.value) : null;
       return {
-        signal: `${test} ? (${a}) : (${b})`
+        signal: "".concat(test, " ? (").concat(a, ") : (").concat(b, ")")
       };
     } else {
       // otherwise generate rule set
@@ -43874,17 +44470,17 @@
   const isSimple = enc => enc == null || Object.keys(enc).length === 1;
 
   const ifExpr = (test, a, b) => ({
-    signal: `${test} ? (${toExpr(a)}) : (${toExpr(b)})`
+    signal: "".concat(test, " ? (").concat(toExpr(a), ") : (").concat(toExpr(b), ")")
   });
 
   const ifOrient = ($orient, t, b, l, r) => ({
-    signal: (l != null ? `${$orient} === '${Left}' ? (${toExpr(l)}) : ` : '') + (b != null ? `${$orient} === '${Bottom}' ? (${toExpr(b)}) : ` : '') + (r != null ? `${$orient} === '${Right}' ? (${toExpr(r)}) : ` : '') + (t != null ? `${$orient} === '${Top}' ? (${toExpr(t)}) : ` : '') + '(null)'
+    signal: (l != null ? "".concat($orient, " === '").concat(Left, "' ? (").concat(toExpr(l), ") : ") : '') + (b != null ? "".concat($orient, " === '").concat(Bottom, "' ? (").concat(toExpr(b), ") : ") : '') + (r != null ? "".concat($orient, " === '").concat(Right, "' ? (").concat(toExpr(r), ") : ") : '') + (t != null ? "".concat($orient, " === '").concat(Top, "' ? (").concat(toExpr(t), ") : ") : '') + '(null)'
   });
 
   const toExpr = v => isSignal(v) ? v.signal : v == null ? null : $(v);
 
   const mult = (sign, value) => value === 0 ? 0 : isSignal(sign) ? {
-    signal: `(${sign.signal}) * ${value}`
+    signal: "(".concat(sign.signal, ") * ").concat(value)
   } : {
     value: sign * value
   };
@@ -44099,7 +44695,7 @@
   function offsetValue(offset, sign) {
     if (sign === 1) ;else if (!isObject(offset)) {
       offset = isSignal(sign) ? {
-        signal: `(${sign.signal}) * (${offset || 0})`
+        signal: "(".concat(sign.signal, ") * (").concat(offset || 0, ")")
       } : sign * (offset || 0);
     } else {
       let entry = offset = extend$1({}, offset);
@@ -44108,7 +44704,7 @@
         if (!isObject(entry.mult)) {
           entry.mult = isSignal(sign) // no offset if sign === 1
           ? {
-            signal: `(${entry.mult}) * (${sign.signal})`
+            signal: "(".concat(entry.mult, ") * (").concat(sign.signal, ")")
           } : entry.mult * sign;
           return offset;
         } else {
@@ -44205,7 +44801,7 @@
     const baseline = ifX(orient, ifTop(orient, 'bottom', 'top'), flushOn ? flushExpr(scale, flush, '"top"', '"bottom"', '"middle"') : {
       value: 'middle'
     });
-    const offsetExpr = flushExpr(scale, flush, `-(${flushOffset})`, flushOffset, 0);
+    const offsetExpr = flushExpr(scale, flush, "-(".concat(flushOffset, ")"), flushOffset, 0);
     flushOn = flushOn && flushOffset;
     const enter = {
       opacity: zero,
@@ -44307,7 +44903,7 @@
       }
     };
     const titlePos = {
-      signal: `lerp(range("${spec.scale}"), ${anchorExpr(0, 1, 0.5)})`
+      signal: "lerp(range(\"".concat(spec.scale, "\"), ").concat(anchorExpr(0, 1, 0.5), ")")
     };
     update.x = ifX(orient, titlePos);
     update.y = ifY(orient, titlePos);
@@ -44441,7 +45037,7 @@
       minExtent: _('minExtent'),
       maxExtent: _('maxExtent'),
       range: {
-        signal: `abs(span(range("${spec.scale}")))`
+        signal: "abs(span(range(\"".concat(spec.scale, "\")))")
       },
       translate: _('translate'),
       // accessibility support
@@ -45268,8 +45864,6 @@
   // -- Transforms -----
   extend$1(transforms, tx, vtx, encode$1, geo, force, label, tree, reg, voronoi, wordcloud, xf); // -- Exports -----
 
-  const version = pkg.version;
-
   exports.Bounds = Bounds;
   exports.CanvasHandler = CanvasHandler;
   exports.CanvasRenderer = CanvasRenderer;
@@ -45314,7 +45908,7 @@
   exports.accessorFields = accessorFields;
   exports.accessorName = accessorName;
   exports.array = array$5;
-  exports.ascending = ascending$3;
+  exports.ascending = ascending$2;
   exports.bandwidthNRD = estimateBandwidth;
   exports.bin = bin;
   exports.bootstrapCI = bootstrapCI;
@@ -45404,9 +45998,10 @@
   exports.parse = parse;
   exports.parseExpression = parser$1;
   exports.parseSelector = eventSelector;
+  exports.path = path$3;
   exports.pathCurves = curves;
   exports.pathEqual = pathEqual;
-  exports.pathParse = pathParse;
+  exports.pathParse = parse$3;
   exports.pathRectangle = vg_rect;
   exports.pathRender = pathRender;
   exports.pathSymbols = symbols;
@@ -45499,4 +46094,4 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));