vega-functions 5.12.1 → 5.13.0

package/build/vega-functions.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vega-util'), require('vega-expression'), require('d3-geo'), require('d3-color'), require('vega-dataflow'), require('vega-scale'), require('vega-scenegraph'), require('vega-selections'), require('vega-statistics'), require('vega-time'), require('d3-array')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'vega-util', 'vega-expression', 'd3-geo', 'd3-color', 'vega-dataflow', 'vega-scale', 'vega-scenegraph', 'vega-selections', 'vega-statistics', 'vega-time', 'd3-array'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vega = {}, global.vega, global.vega, global.d3, global.d3, global.vega, global.vega, global.vega, global.vega, global.vega, global.vega, global.d3));
-}(this, (function (exports, vegaUtil, vegaExpression, d3Geo, d3Color, vegaDataflow, vegaScale, vegaScenegraph, vegaSelections, vegaStatistics, vegaTime, d3Array) { 'use strict';
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vega-util'), require('vega-expression'), require('vega-dataflow'), require('vega-scale'), require('vega-scenegraph'), require('vega-selections'), require('vega-statistics'), require('vega-time')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'vega-util', 'vega-expression', 'vega-dataflow', 'vega-scale', 'vega-scenegraph', 'vega-selections', 'vega-statistics', 'vega-time'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.vega = {}, global.vega, global.vega, global.vega, global.vega, global.vega, global.vega, global.vega, global.vega));
+})(this, (function (exports, vegaUtil, vegaExpression, vegaDataflow, vegaScale, vegaScenegraph, vegaSelections, vegaStatistics, vegaTime) { 'use strict';
 
   function data(name) {
     const data = this.context.data[name];
@@ -142,6 +142,572 @@
     };
   }
 
+  // https://github.com/python/cpython/blob/a74eea238f5baba15797e2e8b570d153bc8690a7/Modules/mathmodule.c#L1423
+  class Adder {
+    constructor() {
+      this._partials = new Float64Array(32);
+      this._n = 0;
+    }
+
+    add(x) {
+      const p = this._partials;
+      let i = 0;
+
+      for (let j = 0; j < this._n && j < 32; j++) {
+        const y = p[j],
+              hi = x + y,
+              lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
+        if (lo) p[i++] = lo;
+        x = hi;
+      }
+
+      p[i] = x;
+      this._n = i + 1;
+      return this;
+    }
+
+    valueOf() {
+      const p = this._partials;
+      let n = this._n,
+          x,
+          y,
+          lo,
+          hi = 0;
+
+      if (n > 0) {
+        hi = p[--n];
+
+        while (n > 0) {
+          x = hi;
+          y = p[--n];
+          hi = x + y;
+          lo = y - (hi - x);
+          if (lo) break;
+        }
+
+        if (n > 0 && (lo < 0 && p[n - 1] < 0 || lo > 0 && p[n - 1] > 0)) {
+          y = lo * 2;
+          x = hi + y;
+          if (y == x - hi) hi = x;
+        }
+      }
+
+      return hi;
+    }
+
+  }
+
+  function range$2(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,
+        range = new Array(n);
+
+    while (++i < n) {
+      range[i] = start + i * step;
+    }
+
+    return range;
+  }
+
+  var epsilon = 1e-6;
+  var epsilon2 = 1e-12;
+  var pi = Math.PI;
+  var halfPi = pi / 2;
+  var quarterPi = pi / 4;
+  var tau = pi * 2;
+  var degrees$1 = 180 / pi;
+  var radians$1 = pi / 180;
+  var abs = Math.abs;
+  var atan2 = Math.atan2;
+  var cos = Math.cos;
+  var hypot = Math.hypot;
+  var sin = Math.sin;
+  var sqrt = Math.sqrt;
+  function asin(x) {
+    return x > 1 ? halfPi : x < -1 ? -halfPi : Math.asin(x);
+  }
+
+  function noop() {}
+
+  function streamGeometry(geometry, stream) {
+    if (geometry && streamGeometryType.hasOwnProperty(geometry.type)) {
+      streamGeometryType[geometry.type](geometry, stream);
+    }
+  }
+
+  var streamObjectType = {
+    Feature: function (object, stream) {
+      streamGeometry(object.geometry, stream);
+    },
+    FeatureCollection: function (object, stream) {
+      var features = object.features,
+          i = -1,
+          n = features.length;
+
+      while (++i < n) streamGeometry(features[i].geometry, stream);
+    }
+  };
+  var streamGeometryType = {
+    Sphere: function (object, stream) {
+      stream.sphere();
+    },
+    Point: function (object, stream) {
+      object = object.coordinates;
+      stream.point(object[0], object[1], object[2]);
+    },
+    MultiPoint: function (object, stream) {
+      var coordinates = object.coordinates,
+          i = -1,
+          n = coordinates.length;
+
+      while (++i < n) object = coordinates[i], stream.point(object[0], object[1], object[2]);
+    },
+    LineString: function (object, stream) {
+      streamLine(object.coordinates, stream, 0);
+    },
+    MultiLineString: function (object, stream) {
+      var coordinates = object.coordinates,
+          i = -1,
+          n = coordinates.length;
+
+      while (++i < n) streamLine(coordinates[i], stream, 0);
+    },
+    Polygon: function (object, stream) {
+      streamPolygon(object.coordinates, stream);
+    },
+    MultiPolygon: function (object, stream) {
+      var coordinates = object.coordinates,
+          i = -1,
+          n = coordinates.length;
+
+      while (++i < n) streamPolygon(coordinates[i], stream);
+    },
+    GeometryCollection: function (object, stream) {
+      var geometries = object.geometries,
+          i = -1,
+          n = geometries.length;
+
+      while (++i < n) streamGeometry(geometries[i], stream);
+    }
+  };
+
+  function streamLine(coordinates, stream, closed) {
+    var i = -1,
+        n = coordinates.length - closed,
+        coordinate;
+    stream.lineStart();
+
+    while (++i < n) coordinate = coordinates[i], stream.point(coordinate[0], coordinate[1], coordinate[2]);
+
+    stream.lineEnd();
+  }
+
+  function streamPolygon(coordinates, stream) {
+    var i = -1,
+        n = coordinates.length;
+    stream.polygonStart();
+
+    while (++i < n) streamLine(coordinates[i], stream, 1);
+
+    stream.polygonEnd();
+  }
+
+  function geoStream (object, stream) {
+    if (object && streamObjectType.hasOwnProperty(object.type)) {
+      streamObjectType[object.type](object, stream);
+    } else {
+      streamGeometry(object, stream);
+    }
+  }
+
+  var areaRingSum = new Adder(); // hello?
+
+  var areaSum = new Adder(),
+      lambda00$2,
+      phi00$2,
+      lambda0$1,
+      cosPhi0,
+      sinPhi0;
+  var areaStream = {
+    point: noop,
+    lineStart: noop,
+    lineEnd: noop,
+    polygonStart: function () {
+      areaRingSum = new Adder();
+      areaStream.lineStart = areaRingStart;
+      areaStream.lineEnd = areaRingEnd;
+    },
+    polygonEnd: function () {
+      var areaRing = +areaRingSum;
+      areaSum.add(areaRing < 0 ? tau + areaRing : areaRing);
+      this.lineStart = this.lineEnd = this.point = noop;
+    },
+    sphere: function () {
+      areaSum.add(tau);
+    }
+  };
+
+  function areaRingStart() {
+    areaStream.point = areaPointFirst;
+  }
+
+  function areaRingEnd() {
+    areaPoint(lambda00$2, phi00$2);
+  }
+
+  function areaPointFirst(lambda, phi) {
+    areaStream.point = areaPoint;
+    lambda00$2 = lambda, phi00$2 = phi;
+    lambda *= radians$1, phi *= radians$1;
+    lambda0$1 = lambda, cosPhi0 = cos(phi = phi / 2 + quarterPi), sinPhi0 = sin(phi);
+  }
+
+  function areaPoint(lambda, phi) {
+    lambda *= radians$1, phi *= radians$1;
+    phi = phi / 2 + quarterPi; // half the angular distance from south pole
+    // Spherical excess E for a spherical triangle with vertices: south pole,
+    // previous point, current point.  Uses a formula derived from Cagnoli’s
+    // theorem.  See Todhunter, Spherical Trig. (1871), Sec. 103, Eq. (2).
+
+    var dLambda = lambda - lambda0$1,
+        sdLambda = dLambda >= 0 ? 1 : -1,
+        adLambda = sdLambda * dLambda,
+        cosPhi = cos(phi),
+        sinPhi = sin(phi),
+        k = sinPhi0 * sinPhi,
+        u = cosPhi0 * cosPhi + k * cos(adLambda),
+        v = k * sdLambda * sin(adLambda);
+    areaRingSum.add(atan2(v, u)); // Advance the previous points.
+
+    lambda0$1 = lambda, cosPhi0 = cosPhi, sinPhi0 = sinPhi;
+  }
+
+  function area (object) {
+    areaSum = new Adder();
+    geoStream(object, areaStream);
+    return areaSum * 2;
+  }
+
+  function spherical(cartesian) {
+    return [atan2(cartesian[1], cartesian[0]), asin(cartesian[2])];
+  }
+  function cartesian(spherical) {
+    var lambda = spherical[0],
+        phi = spherical[1],
+        cosPhi = cos(phi);
+    return [cosPhi * cos(lambda), cosPhi * sin(lambda), sin(phi)];
+  }
+  function cartesianCross(a, b) {
+    return [a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]];
+  } // TODO return a
+
+  function cartesianNormalizeInPlace(d) {
+    var l = sqrt(d[0] * d[0] + d[1] * d[1] + d[2] * d[2]);
+    d[0] /= l, d[1] /= l, d[2] /= l;
+  }
+
+  var lambda0, phi0, lambda1, phi1, // bounds
+  lambda2, // previous lambda-coordinate
+  lambda00$1, phi00$1, // first point
+  p0, // previous 3D point
+  deltaSum, ranges, range$1;
+  var boundsStream = {
+    point: boundsPoint,
+    lineStart: boundsLineStart,
+    lineEnd: boundsLineEnd,
+    polygonStart: function () {
+      boundsStream.point = boundsRingPoint;
+      boundsStream.lineStart = boundsRingStart;
+      boundsStream.lineEnd = boundsRingEnd;
+      deltaSum = new Adder();
+      areaStream.polygonStart();
+    },
+    polygonEnd: function () {
+      areaStream.polygonEnd();
+      boundsStream.point = boundsPoint;
+      boundsStream.lineStart = boundsLineStart;
+      boundsStream.lineEnd = boundsLineEnd;
+      if (areaRingSum < 0) lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);else if (deltaSum > epsilon) phi1 = 90;else if (deltaSum < -epsilon) phi0 = -90;
+      range$1[0] = lambda0, range$1[1] = lambda1;
+    },
+    sphere: function () {
+      lambda0 = -(lambda1 = 180), phi0 = -(phi1 = 90);
+    }
+  };
+
+  function boundsPoint(lambda, phi) {
+    ranges.push(range$1 = [lambda0 = lambda, lambda1 = lambda]);
+    if (phi < phi0) phi0 = phi;
+    if (phi > phi1) phi1 = phi;
+  }
+
+  function linePoint(lambda, phi) {
+    var p = cartesian([lambda * radians$1, phi * radians$1]);
+
+    if (p0) {
+      var normal = cartesianCross(p0, p),
+          equatorial = [normal[1], -normal[0], 0],
+          inflection = cartesianCross(equatorial, normal);
+      cartesianNormalizeInPlace(inflection);
+      inflection = spherical(inflection);
+      var delta = lambda - lambda2,
+          sign = delta > 0 ? 1 : -1,
+          lambdai = inflection[0] * degrees$1 * sign,
+          phii,
+          antimeridian = abs(delta) > 180;
+
+      if (antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {
+        phii = inflection[1] * degrees$1;
+        if (phii > phi1) phi1 = phii;
+      } else if (lambdai = (lambdai + 360) % 360 - 180, antimeridian ^ (sign * lambda2 < lambdai && lambdai < sign * lambda)) {
+        phii = -inflection[1] * degrees$1;
+        if (phii < phi0) phi0 = phii;
+      } else {
+        if (phi < phi0) phi0 = phi;
+        if (phi > phi1) phi1 = phi;
+      }
+
+      if (antimeridian) {
+        if (lambda < lambda2) {
+          if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;
+        } else {
+          if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;
+        }
+      } else {
+        if (lambda1 >= lambda0) {
+          if (lambda < lambda0) lambda0 = lambda;
+          if (lambda > lambda1) lambda1 = lambda;
+        } else {
+          if (lambda > lambda2) {
+            if (angle(lambda0, lambda) > angle(lambda0, lambda1)) lambda1 = lambda;
+          } else {
+            if (angle(lambda, lambda1) > angle(lambda0, lambda1)) lambda0 = lambda;
+          }
+        }
+      }
+    } else {
+      ranges.push(range$1 = [lambda0 = lambda, lambda1 = lambda]);
+    }
+
+    if (phi < phi0) phi0 = phi;
+    if (phi > phi1) phi1 = phi;
+    p0 = p, lambda2 = lambda;
+  }
+
+  function boundsLineStart() {
+    boundsStream.point = linePoint;
+  }
+
+  function boundsLineEnd() {
+    range$1[0] = lambda0, range$1[1] = lambda1;
+    boundsStream.point = boundsPoint;
+    p0 = null;
+  }
+
+  function boundsRingPoint(lambda, phi) {
+    if (p0) {
+      var delta = lambda - lambda2;
+      deltaSum.add(abs(delta) > 180 ? delta + (delta > 0 ? 360 : -360) : delta);
+    } else {
+      lambda00$1 = lambda, phi00$1 = phi;
+    }
+
+    areaStream.point(lambda, phi);
+    linePoint(lambda, phi);
+  }
+
+  function boundsRingStart() {
+    areaStream.lineStart();
+  }
+
+  function boundsRingEnd() {
+    boundsRingPoint(lambda00$1, phi00$1);
+    areaStream.lineEnd();
+    if (abs(deltaSum) > epsilon) lambda0 = -(lambda1 = 180);
+    range$1[0] = lambda0, range$1[1] = lambda1;
+    p0 = null;
+  } // Finds the left-right distance between two longitudes.
+  // This is almost the same as (lambda1 - lambda0 + 360°) % 360°, except that we want
+  // the distance between ±180° to be 360°.
+
+
+  function angle(lambda0, lambda1) {
+    return (lambda1 -= lambda0) < 0 ? lambda1 + 360 : lambda1;
+  }
+
+  function rangeCompare(a, b) {
+    return a[0] - b[0];
+  }
+
+  function rangeContains(range, x) {
+    return range[0] <= range[1] ? range[0] <= x && x <= range[1] : x < range[0] || range[1] < x;
+  }
+
+  function bounds (feature) {
+    var i, n, a, b, merged, deltaMax, delta;
+    phi1 = lambda1 = -(lambda0 = phi0 = Infinity);
+    ranges = [];
+    geoStream(feature, boundsStream); // First, sort ranges by their minimum longitudes.
+
+    if (n = ranges.length) {
+      ranges.sort(rangeCompare); // Then, merge any ranges that overlap.
+
+      for (i = 1, a = ranges[0], merged = [a]; i < n; ++i) {
+        b = ranges[i];
+
+        if (rangeContains(a, b[0]) || rangeContains(a, b[1])) {
+          if (angle(a[0], b[1]) > angle(a[0], a[1])) a[1] = b[1];
+          if (angle(b[0], a[1]) > angle(a[0], a[1])) a[0] = b[0];
+        } else {
+          merged.push(a = b);
+        }
+      } // Finally, find the largest gap between the merged ranges.
+      // The final bounding box will be the inverse of this gap.
+
+
+      for (deltaMax = -Infinity, n = merged.length - 1, i = 0, a = merged[n]; i <= n; a = b, ++i) {
+        b = merged[i];
+        if ((delta = angle(a[1], b[0])) > deltaMax) deltaMax = delta, lambda0 = b[0], lambda1 = a[1];
+      }
+    }
+
+    ranges = range$1 = null;
+    return lambda0 === Infinity || phi0 === Infinity ? [[NaN, NaN], [NaN, NaN]] : [[lambda0, phi0], [lambda1, phi1]];
+  }
+
+  var W0, W1, X0, Y0, Z0, X1, Y1, Z1, X2, Y2, Z2, lambda00, phi00, // first point
+  x0, y0, z0; // previous point
+
+  var centroidStream = {
+    sphere: noop,
+    point: centroidPoint,
+    lineStart: centroidLineStart,
+    lineEnd: centroidLineEnd,
+    polygonStart: function () {
+      centroidStream.lineStart = centroidRingStart;
+      centroidStream.lineEnd = centroidRingEnd;
+    },
+    polygonEnd: function () {
+      centroidStream.lineStart = centroidLineStart;
+      centroidStream.lineEnd = centroidLineEnd;
+    }
+  }; // Arithmetic mean of Cartesian vectors.
+
+  function centroidPoint(lambda, phi) {
+    lambda *= radians$1, phi *= radians$1;
+    var cosPhi = cos(phi);
+    centroidPointCartesian(cosPhi * cos(lambda), cosPhi * sin(lambda), sin(phi));
+  }
+
+  function centroidPointCartesian(x, y, z) {
+    ++W0;
+    X0 += (x - X0) / W0;
+    Y0 += (y - Y0) / W0;
+    Z0 += (z - Z0) / W0;
+  }
+
+  function centroidLineStart() {
+    centroidStream.point = centroidLinePointFirst;
+  }
+
+  function centroidLinePointFirst(lambda, phi) {
+    lambda *= radians$1, phi *= radians$1;
+    var cosPhi = cos(phi);
+    x0 = cosPhi * cos(lambda);
+    y0 = cosPhi * sin(lambda);
+    z0 = sin(phi);
+    centroidStream.point = centroidLinePoint;
+    centroidPointCartesian(x0, y0, z0);
+  }
+
+  function centroidLinePoint(lambda, phi) {
+    lambda *= radians$1, phi *= radians$1;
+    var cosPhi = cos(phi),
+        x = cosPhi * cos(lambda),
+        y = cosPhi * sin(lambda),
+        z = sin(phi),
+        w = atan2(sqrt((w = y0 * z - z0 * y) * w + (w = z0 * x - x0 * z) * w + (w = x0 * y - y0 * x) * w), x0 * x + y0 * y + z0 * z);
+    W1 += w;
+    X1 += w * (x0 + (x0 = x));
+    Y1 += w * (y0 + (y0 = y));
+    Z1 += w * (z0 + (z0 = z));
+    centroidPointCartesian(x0, y0, z0);
+  }
+
+  function centroidLineEnd() {
+    centroidStream.point = centroidPoint;
+  } // See J. E. Brock, The Inertia Tensor for a Spherical Triangle,
+  // J. Applied Mechanics 42, 239 (1975).
+
+
+  function centroidRingStart() {
+    centroidStream.point = centroidRingPointFirst;
+  }
+
+  function centroidRingEnd() {
+    centroidRingPoint(lambda00, phi00);
+    centroidStream.point = centroidPoint;
+  }
+
+  function centroidRingPointFirst(lambda, phi) {
+    lambda00 = lambda, phi00 = phi;
+    lambda *= radians$1, phi *= radians$1;
+    centroidStream.point = centroidRingPoint;
+    var cosPhi = cos(phi);
+    x0 = cosPhi * cos(lambda);
+    y0 = cosPhi * sin(lambda);
+    z0 = sin(phi);
+    centroidPointCartesian(x0, y0, z0);
+  }
+
+  function centroidRingPoint(lambda, phi) {
+    lambda *= radians$1, phi *= radians$1;
+    var cosPhi = cos(phi),
+        x = cosPhi * cos(lambda),
+        y = cosPhi * sin(lambda),
+        z = sin(phi),
+        cx = y0 * z - z0 * y,
+        cy = z0 * x - x0 * z,
+        cz = x0 * y - y0 * x,
+        m = hypot(cx, cy, cz),
+        w = asin(m),
+        // line weight = angle
+    v = m && -w / m; // area weight multiplier
+
+    X2.add(v * cx);
+    Y2.add(v * cy);
+    Z2.add(v * cz);
+    W1 += w;
+    X1 += w * (x0 + (x0 = x));
+    Y1 += w * (y0 + (y0 = y));
+    Z1 += w * (z0 + (z0 = z));
+    centroidPointCartesian(x0, y0, z0);
+  }
+
+  function centroid (object) {
+    W0 = W1 = X0 = Y0 = Z0 = X1 = Y1 = Z1 = 0;
+    X2 = new Adder();
+    Y2 = new Adder();
+    Z2 = new Adder();
+    geoStream(object, centroidStream);
+    var x = +X2,
+        y = +Y2,
+        z = +Z2,
+        m = hypot(x, y, z); // If the area-weighted ccentroid is undefined, fall back to length-weighted ccentroid.
+
+    if (m < epsilon2) {
+      x = X1, y = Y1, z = Z1; // If the feature has zero length, fall back to arithmetic mean of point vectors.
+
+      if (W1 < epsilon) x = X0, y = Y0, z = Z0;
+      m = hypot(x, y, z); // If the feature still has an undefined ccentroid, then return.
+
+      if (m < epsilon2) return [NaN, NaN];
+    }
+
+    return [atan2(y, x) * degrees$1, asin(z / m) * degrees$1];
+  }
+
   function geoMethod(methodName, globalMethod) {
     return function (projection, geojson, group) {
       if (projection) {
@@ -155,9 +721,9 @@
     };
   }
 
-  const geoArea = geoMethod('area', d3Geo.geoArea);
-  const geoBounds = geoMethod('bounds', d3Geo.geoBounds);
-  const geoCentroid = geoMethod('centroid', d3Geo.geoCentroid);
+  const geoArea = geoMethod('area', area);
+  const geoBounds = geoMethod('bounds', bounds);
+  const geoCentroid = geoMethod('centroid', centroid);
 
   function inScope (item) {
     const group = this.context.group;
@@ -193,6 +759,466 @@
     return log(this.context.dataflow, 'debug', arguments);
   }
 
+  function define (constructor, factory, prototype) {
+    constructor.prototype = factory.prototype = prototype;
+    prototype.constructor = constructor;
+  }
+  function extend(parent, definition) {
+    var prototype = Object.create(parent.prototype);
+
+    for (var key in definition) prototype[key] = definition[key];
+
+    return prototype;
+  }
+
+  function Color() {}
+  var darker = 0.7;
+  var brighter = 1 / darker;
+  var reI = "\\s*([+-]?\\d+)\\s*",
+      reN = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)\\s*",
+      reP = "\\s*([+-]?\\d*\\.?\\d+(?:[eE][+-]?\\d+)?)%\\s*",
+      reHex = /^#([0-9a-f]{3,8})$/,
+      reRgbInteger = new RegExp("^rgb\\(" + [reI, reI, reI] + "\\)$"),
+      reRgbPercent = new RegExp("^rgb\\(" + [reP, reP, reP] + "\\)$"),
+      reRgbaInteger = new RegExp("^rgba\\(" + [reI, reI, reI, reN] + "\\)$"),
+      reRgbaPercent = new RegExp("^rgba\\(" + [reP, reP, reP, reN] + "\\)$"),
+      reHslPercent = new RegExp("^hsl\\(" + [reN, reP, reP] + "\\)$"),
+      reHslaPercent = new RegExp("^hsla\\(" + [reN, reP, reP, reN] + "\\)$");
+  var named = {
+    aliceblue: 0xf0f8ff,
+    antiquewhite: 0xfaebd7,
+    aqua: 0x00ffff,
+    aquamarine: 0x7fffd4,
+    azure: 0xf0ffff,
+    beige: 0xf5f5dc,
+    bisque: 0xffe4c4,
+    black: 0x000000,
+    blanchedalmond: 0xffebcd,
+    blue: 0x0000ff,
+    blueviolet: 0x8a2be2,
+    brown: 0xa52a2a,
+    burlywood: 0xdeb887,
+    cadetblue: 0x5f9ea0,
+    chartreuse: 0x7fff00,
+    chocolate: 0xd2691e,
+    coral: 0xff7f50,
+    cornflowerblue: 0x6495ed,
+    cornsilk: 0xfff8dc,
+    crimson: 0xdc143c,
+    cyan: 0x00ffff,
+    darkblue: 0x00008b,
+    darkcyan: 0x008b8b,
+    darkgoldenrod: 0xb8860b,
+    darkgray: 0xa9a9a9,
+    darkgreen: 0x006400,
+    darkgrey: 0xa9a9a9,
+    darkkhaki: 0xbdb76b,
+    darkmagenta: 0x8b008b,
+    darkolivegreen: 0x556b2f,
+    darkorange: 0xff8c00,
+    darkorchid: 0x9932cc,
+    darkred: 0x8b0000,
+    darksalmon: 0xe9967a,
+    darkseagreen: 0x8fbc8f,
+    darkslateblue: 0x483d8b,
+    darkslategray: 0x2f4f4f,
+    darkslategrey: 0x2f4f4f,
+    darkturquoise: 0x00ced1,
+    darkviolet: 0x9400d3,
+    deeppink: 0xff1493,
+    deepskyblue: 0x00bfff,
+    dimgray: 0x696969,
+    dimgrey: 0x696969,
+    dodgerblue: 0x1e90ff,
+    firebrick: 0xb22222,
+    floralwhite: 0xfffaf0,
+    forestgreen: 0x228b22,
+    fuchsia: 0xff00ff,
+    gainsboro: 0xdcdcdc,
+    ghostwhite: 0xf8f8ff,
+    gold: 0xffd700,
+    goldenrod: 0xdaa520,
+    gray: 0x808080,
+    green: 0x008000,
+    greenyellow: 0xadff2f,
+    grey: 0x808080,
+    honeydew: 0xf0fff0,
+    hotpink: 0xff69b4,
+    indianred: 0xcd5c5c,
+    indigo: 0x4b0082,
+    ivory: 0xfffff0,
+    khaki: 0xf0e68c,
+    lavender: 0xe6e6fa,
+    lavenderblush: 0xfff0f5,
+    lawngreen: 0x7cfc00,
+    lemonchiffon: 0xfffacd,
+    lightblue: 0xadd8e6,
+    lightcoral: 0xf08080,
+    lightcyan: 0xe0ffff,
+    lightgoldenrodyellow: 0xfafad2,
+    lightgray: 0xd3d3d3,
+    lightgreen: 0x90ee90,
+    lightgrey: 0xd3d3d3,
+    lightpink: 0xffb6c1,
+    lightsalmon: 0xffa07a,
+    lightseagreen: 0x20b2aa,
+    lightskyblue: 0x87cefa,
+    lightslategray: 0x778899,
+    lightslategrey: 0x778899,
+    lightsteelblue: 0xb0c4de,
+    lightyellow: 0xffffe0,
+    lime: 0x00ff00,
+    limegreen: 0x32cd32,
+    linen: 0xfaf0e6,
+    magenta: 0xff00ff,
+    maroon: 0x800000,
+    mediumaquamarine: 0x66cdaa,
+    mediumblue: 0x0000cd,
+    mediumorchid: 0xba55d3,
+    mediumpurple: 0x9370db,
+    mediumseagreen: 0x3cb371,
+    mediumslateblue: 0x7b68ee,
+    mediumspringgreen: 0x00fa9a,
+    mediumturquoise: 0x48d1cc,
+    mediumvioletred: 0xc71585,
+    midnightblue: 0x191970,
+    mintcream: 0xf5fffa,
+    mistyrose: 0xffe4e1,
+    moccasin: 0xffe4b5,
+    navajowhite: 0xffdead,
+    navy: 0x000080,
+    oldlace: 0xfdf5e6,
+    olive: 0x808000,
+    olivedrab: 0x6b8e23,
+    orange: 0xffa500,
+    orangered: 0xff4500,
+    orchid: 0xda70d6,
+    palegoldenrod: 0xeee8aa,
+    palegreen: 0x98fb98,
+    paleturquoise: 0xafeeee,
+    palevioletred: 0xdb7093,
+    papayawhip: 0xffefd5,
+    peachpuff: 0xffdab9,
+    peru: 0xcd853f,
+    pink: 0xffc0cb,
+    plum: 0xdda0dd,
+    powderblue: 0xb0e0e6,
+    purple: 0x800080,
+    rebeccapurple: 0x663399,
+    red: 0xff0000,
+    rosybrown: 0xbc8f8f,
+    royalblue: 0x4169e1,
+    saddlebrown: 0x8b4513,
+    salmon: 0xfa8072,
+    sandybrown: 0xf4a460,
+    seagreen: 0x2e8b57,
+    seashell: 0xfff5ee,
+    sienna: 0xa0522d,
+    silver: 0xc0c0c0,
+    skyblue: 0x87ceeb,
+    slateblue: 0x6a5acd,
+    slategray: 0x708090,
+    slategrey: 0x708090,
+    snow: 0xfffafa,
+    springgreen: 0x00ff7f,
+    steelblue: 0x4682b4,
+    tan: 0xd2b48c,
+    teal: 0x008080,
+    thistle: 0xd8bfd8,
+    tomato: 0xff6347,
+    turquoise: 0x40e0d0,
+    violet: 0xee82ee,
+    wheat: 0xf5deb3,
+    white: 0xffffff,
+    whitesmoke: 0xf5f5f5,
+    yellow: 0xffff00,
+    yellowgreen: 0x9acd32
+  };
+  define(Color, color, {
+    copy: function (channels) {
+      return Object.assign(new this.constructor(), this, channels);
+    },
+    displayable: function () {
+      return this.rgb().displayable();
+    },
+    hex: color_formatHex,
+    // Deprecated! Use color.formatHex.
+    formatHex: color_formatHex,
+    formatHsl: color_formatHsl,
+    formatRgb: color_formatRgb,
+    toString: color_formatRgb
+  });
+
+  function color_formatHex() {
+    return this.rgb().formatHex();
+  }
+
+  function color_formatHsl() {
+    return hslConvert(this).formatHsl();
+  }
+
+  function color_formatRgb() {
+    return this.rgb().formatRgb();
+  }
+
+  function color(format) {
+    var m, l;
+    format = (format + "").trim().toLowerCase();
+    return (m = reHex.exec(format)) ? (l = m[1].length, m = parseInt(m[1], 16), l === 6 ? rgbn(m) // #ff0000
+    : l === 3 ? new Rgb(m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, (m & 0xf) << 4 | m & 0xf, 1) // #f00
+    : l === 8 ? rgba(m >> 24 & 0xff, m >> 16 & 0xff, m >> 8 & 0xff, (m & 0xff) / 0xff) // #ff000000
+    : l === 4 ? rgba(m >> 12 & 0xf | m >> 8 & 0xf0, m >> 8 & 0xf | m >> 4 & 0xf0, m >> 4 & 0xf | m & 0xf0, ((m & 0xf) << 4 | m & 0xf) / 0xff) // #f000
+    : null // invalid hex
+    ) : (m = reRgbInteger.exec(format)) ? new Rgb(m[1], m[2], m[3], 1) // rgb(255, 0, 0)
+    : (m = reRgbPercent.exec(format)) ? new Rgb(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, 1) // rgb(100%, 0%, 0%)
+    : (m = reRgbaInteger.exec(format)) ? rgba(m[1], m[2], m[3], m[4]) // rgba(255, 0, 0, 1)
+    : (m = reRgbaPercent.exec(format)) ? rgba(m[1] * 255 / 100, m[2] * 255 / 100, m[3] * 255 / 100, m[4]) // rgb(100%, 0%, 0%, 1)
+    : (m = reHslPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, 1) // hsl(120, 50%, 50%)
+    : (m = reHslaPercent.exec(format)) ? hsla(m[1], m[2] / 100, m[3] / 100, m[4]) // hsla(120, 50%, 50%, 1)
+    : named.hasOwnProperty(format) ? rgbn(named[format]) // eslint-disable-line no-prototype-builtins
+    : format === "transparent" ? new Rgb(NaN, NaN, NaN, 0) : null;
+  }
+
+  function rgbn(n) {
+    return new Rgb(n >> 16 & 0xff, n >> 8 & 0xff, n & 0xff, 1);
+  }
+
+  function rgba(r, g, b, a) {
+    if (a <= 0) r = g = b = NaN;
+    return new Rgb(r, g, b, a);
+  }
+
+  function rgbConvert(o) {
+    if (!(o instanceof Color)) o = color(o);
+    if (!o) return new Rgb();
+    o = o.rgb();
+    return new Rgb(o.r, o.g, o.b, o.opacity);
+  }
+  function rgb(r, g, b, opacity) {
+    return arguments.length === 1 ? rgbConvert(r) : new Rgb(r, g, b, opacity == null ? 1 : opacity);
+  }
+  function Rgb(r, g, b, opacity) {
+    this.r = +r;
+    this.g = +g;
+    this.b = +b;
+    this.opacity = +opacity;
+  }
+  define(Rgb, rgb, extend(Color, {
+    brighter: function (k) {
+      k = k == null ? brighter : Math.pow(brighter, k);
+      return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+    },
+    darker: function (k) {
+      k = k == null ? darker : Math.pow(darker, k);
+      return new Rgb(this.r * k, this.g * k, this.b * k, this.opacity);
+    },
+    rgb: function () {
+      return this;
+    },
+    displayable: function () {
+      return -0.5 <= this.r && this.r < 255.5 && -0.5 <= this.g && this.g < 255.5 && -0.5 <= this.b && this.b < 255.5 && 0 <= this.opacity && this.opacity <= 1;
+    },
+    hex: rgb_formatHex,
+    // Deprecated! Use color.formatHex.
+    formatHex: rgb_formatHex,
+    formatRgb: rgb_formatRgb,
+    toString: rgb_formatRgb
+  }));
+
+  function rgb_formatHex() {
+    return "#" + hex(this.r) + hex(this.g) + hex(this.b);
+  }
+
+  function rgb_formatRgb() {
+    var a = this.opacity;
+    a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
+    return (a === 1 ? "rgb(" : "rgba(") + Math.max(0, Math.min(255, Math.round(this.r) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.g) || 0)) + ", " + Math.max(0, Math.min(255, Math.round(this.b) || 0)) + (a === 1 ? ")" : ", " + a + ")");
+  }
+
+  function hex(value) {
+    value = Math.max(0, Math.min(255, Math.round(value) || 0));
+    return (value < 16 ? "0" : "") + value.toString(16);
+  }
+
+  function hsla(h, s, l, a) {
+    if (a <= 0) h = s = l = NaN;else if (l <= 0 || l >= 1) h = s = NaN;else if (s <= 0) h = NaN;
+    return new Hsl(h, s, l, a);
+  }
+
+  function hslConvert(o) {
+    if (o instanceof Hsl) return new Hsl(o.h, o.s, o.l, o.opacity);
+    if (!(o instanceof Color)) o = color(o);
+    if (!o) return new Hsl();
+    if (o instanceof Hsl) return o;
+    o = o.rgb();
+    var r = o.r / 255,
+        g = o.g / 255,
+        b = o.b / 255,
+        min = Math.min(r, g, b),
+        max = Math.max(r, g, b),
+        h = NaN,
+        s = max - min,
+        l = (max + min) / 2;
+
+    if (s) {
+      if (r === max) h = (g - b) / s + (g < b) * 6;else if (g === max) h = (b - r) / s + 2;else h = (r - g) / s + 4;
+      s /= l < 0.5 ? max + min : 2 - max - min;
+      h *= 60;
+    } else {
+      s = l > 0 && l < 1 ? 0 : h;
+    }
+
+    return new Hsl(h, s, l, o.opacity);
+  }
+  function hsl(h, s, l, opacity) {
+    return arguments.length === 1 ? hslConvert(h) : new Hsl(h, s, l, opacity == null ? 1 : opacity);
+  }
+
+  function Hsl(h, s, l, opacity) {
+    this.h = +h;
+    this.s = +s;
+    this.l = +l;
+    this.opacity = +opacity;
+  }
+
+  define(Hsl, hsl, extend(Color, {
+    brighter: function (k) {
+      k = k == null ? brighter : Math.pow(brighter, k);
+      return new Hsl(this.h, this.s, this.l * k, this.opacity);
+    },
+    darker: function (k) {
+      k = k == null ? darker : Math.pow(darker, k);
+      return new Hsl(this.h, this.s, this.l * k, this.opacity);
+    },
+    rgb: function () {
+      var h = this.h % 360 + (this.h < 0) * 360,
+          s = isNaN(h) || isNaN(this.s) ? 0 : this.s,
+          l = this.l,
+          m2 = l + (l < 0.5 ? l : 1 - l) * s,
+          m1 = 2 * l - m2;
+      return new Rgb(hsl2rgb(h >= 240 ? h - 240 : h + 120, m1, m2), hsl2rgb(h, m1, m2), hsl2rgb(h < 120 ? h + 240 : h - 120, m1, m2), this.opacity);
+    },
+    displayable: function () {
+      return (0 <= this.s && this.s <= 1 || isNaN(this.s)) && 0 <= this.l && this.l <= 1 && 0 <= this.opacity && this.opacity <= 1;
+    },
+    formatHsl: function () {
+      var a = this.opacity;
+      a = isNaN(a) ? 1 : Math.max(0, Math.min(1, a));
+      return (a === 1 ? "hsl(" : "hsla(") + (this.h || 0) + ", " + (this.s || 0) * 100 + "%, " + (this.l || 0) * 100 + "%" + (a === 1 ? ")" : ", " + a + ")");
+    }
+  }));
+  /* From FvD 13.37, CSS Color Module Level 3 */
+
+  function hsl2rgb(h, m1, m2) {
+    return (h < 60 ? m1 + (m2 - m1) * h / 60 : h < 180 ? m2 : h < 240 ? m1 + (m2 - m1) * (240 - h) / 60 : m1) * 255;
+  }
+
+  const radians = Math.PI / 180;
+  const degrees = 180 / Math.PI;
+
+  const K = 18,
+        Xn = 0.96422,
+        Yn = 1,
+        Zn = 0.82521,
+        t0 = 4 / 29,
+        t1 = 6 / 29,
+        t2 = 3 * t1 * t1,
+        t3 = t1 * t1 * t1;
+
+  function labConvert(o) {
+    if (o instanceof Lab) return new Lab(o.l, o.a, o.b, o.opacity);
+    if (o instanceof Hcl) return hcl2lab(o);
+    if (!(o instanceof Rgb)) o = rgbConvert(o);
+    var r = rgb2lrgb(o.r),
+        g = rgb2lrgb(o.g),
+        b = rgb2lrgb(o.b),
+        y = xyz2lab((0.2225045 * r + 0.7168786 * g + 0.0606169 * b) / Yn),
+        x,
+        z;
+    if (r === g && g === b) x = z = y;else {
+      x = xyz2lab((0.4360747 * r + 0.3850649 * g + 0.1430804 * b) / Xn);
+      z = xyz2lab((0.0139322 * r + 0.0971045 * g + 0.7141733 * b) / Zn);
+    }
+    return new Lab(116 * y - 16, 500 * (x - y), 200 * (y - z), o.opacity);
+  }
+  function lab(l, a, b, opacity) {
+    return arguments.length === 1 ? labConvert(l) : new Lab(l, a, b, opacity == null ? 1 : opacity);
+  }
+  function Lab(l, a, b, opacity) {
+    this.l = +l;
+    this.a = +a;
+    this.b = +b;
+    this.opacity = +opacity;
+  }
+  define(Lab, lab, extend(Color, {
+    brighter: function (k) {
+      return new Lab(this.l + K * (k == null ? 1 : k), this.a, this.b, this.opacity);
+    },
+    darker: function (k) {
+      return new Lab(this.l - K * (k == null ? 1 : k), this.a, this.b, this.opacity);
+    },
+    rgb: function () {
+      var y = (this.l + 16) / 116,
+          x = isNaN(this.a) ? y : y + this.a / 500,
+          z = isNaN(this.b) ? y : y - this.b / 200;
+      x = Xn * lab2xyz(x);
+      y = Yn * lab2xyz(y);
+      z = Zn * lab2xyz(z);
+      return new Rgb(lrgb2rgb(3.1338561 * x - 1.6168667 * y - 0.4906146 * z), lrgb2rgb(-0.9787684 * x + 1.9161415 * y + 0.0334540 * z), lrgb2rgb(0.0719453 * x - 0.2289914 * y + 1.4052427 * z), this.opacity);
+    }
+  }));
+
+  function xyz2lab(t) {
+    return t > t3 ? Math.pow(t, 1 / 3) : t / t2 + t0;
+  }
+
+  function lab2xyz(t) {
+    return t > t1 ? t * t * t : t2 * (t - t0);
+  }
+
+  function lrgb2rgb(x) {
+    return 255 * (x <= 0.0031308 ? 12.92 * x : 1.055 * Math.pow(x, 1 / 2.4) - 0.055);
+  }
+
+  function rgb2lrgb(x) {
+    return (x /= 255) <= 0.04045 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4);
+  }
+
+  function hclConvert(o) {
+    if (o instanceof Hcl) return new Hcl(o.h, o.c, o.l, o.opacity);
+    if (!(o instanceof Lab)) o = labConvert(o);
+    if (o.a === 0 && o.b === 0) return new Hcl(NaN, 0 < o.l && o.l < 100 ? 0 : NaN, o.l, o.opacity);
+    var h = Math.atan2(o.b, o.a) * degrees;
+    return new Hcl(h < 0 ? h + 360 : h, Math.sqrt(o.a * o.a + o.b * o.b), o.l, o.opacity);
+  }
+  function hcl(h, c, l, opacity) {
+    return arguments.length === 1 ? hclConvert(h) : new Hcl(h, c, l, opacity == null ? 1 : opacity);
+  }
+  function Hcl(h, c, l, opacity) {
+    this.h = +h;
+    this.c = +c;
+    this.l = +l;
+    this.opacity = +opacity;
+  }
+
+  function hcl2lab(o) {
+    if (isNaN(o.h)) return new Lab(o.l, 0, 0, o.opacity);
+    var h = o.h * radians;
+    return new Lab(o.l, Math.cos(h) * o.c, Math.sin(h) * o.c, o.opacity);
+  }
+
+  define(Hcl, hcl, extend(Color, {
+    brighter: function (k) {
+      return new Hcl(this.h, this.c, this.l + K * (k == null ? 1 : k), this.opacity);
+    },
+    darker: function (k) {
+      return new Hcl(this.h, this.c, this.l - K * (k == null ? 1 : k), this.opacity);
+    },
+    rgb: function () {
+      return hcl2lab(this).rgb();
+    }
+  }));
+
   function channel_luminance_value(channelValue) {
     const val = channelValue / 255;
 
@@ -204,7 +1230,7 @@
   }
 
   function luminance(color) {
-    const c = d3Color.rgb(color),
+    const c = rgb(color),
           r = channel_luminance_value(c.r),
           g = channel_luminance_value(c.g),
           b = channel_luminance_value(c.b);
@@ -468,6 +1494,96 @@
     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, minDist = 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 ?? []).reduce((svg, [x, y], i) => {
+      return svg += i == 0 ? `M ${x},${y} ` : i === lasso.length - 1 ? ' Z' : `L ${x},${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 vegaScenegraph.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() {
       return vegaStatistics.random();
@@ -505,7 +1621,12 @@
     },
 
     toBoolean: vegaUtil.toBoolean,
-    toDate: vegaUtil.toDate,
+
+    toDate(_) {
+      return vegaUtil.toDate(_);
+    },
+
+    // suppress extra arguments
     toNumber: vegaUtil.toNumber,
     toString: vegaUtil.toString,
     indexof,
@@ -523,13 +1644,13 @@
     span: vegaUtil.span,
     inrange: vegaUtil.inrange,
     truncate: vegaUtil.truncate,
-    rgb: d3Color.rgb,
-    lab: d3Color.lab,
-    hcl: d3Color.hcl,
-    hsl: d3Color.hsl,
+    rgb,
+    lab,
+    hcl,
+    hsl,
     luminance,
     contrast,
-    sequence: d3Array.range,
+    sequence: range$2,
     format,
     utcFormat,
     utcParse,
@@ -553,7 +1674,12 @@
     warn,
     info,
     debug,
-    extent: vegaUtil.extent,
+
+    extent(_) {
+      return vegaUtil.extent(_);
+    },
+
+    // suppress extra arguments
     inScope,
     intersect,
     clampRange: vegaUtil.clampRange,
@@ -574,7 +1700,10 @@
     zoomPow: vegaUtil.zoomPow,
     zoomSymlog: vegaUtil.zoomSymlog,
     encode,
-    modify
+    modify,
+    lassoAppend,
+    lassoPath,
+    intersectLasso
   };
   const eventFunctions = ['view', 'item', 'group', 'xy', 'x', 'y'],
         // event functions
@@ -750,4 +1879,4 @@
 
   Object.defineProperty(exports, '__esModule', { value: true });
 
-})));
+}));