@hema-to/regl-scatterplot 1.14.1 → 1.16.0-hemato.0

package/dist/regl-scatterplot.js

@@ -172,306 +172,113 @@
     }
     return e;
   }
-  function _regeneratorRuntime() {
-    _regeneratorRuntime = function () {
-      return e;
-    };
-    var t,
-      e = {},
-      r = Object.prototype,
-      n = r.hasOwnProperty,
-      o = Object.defineProperty || function (t, e, r) {
-        t[e] = r.value;
-      },
-      i = "function" == typeof Symbol ? Symbol : {},
-      a = i.iterator || "@@iterator",
-      c = i.asyncIterator || "@@asyncIterator",
-      u = i.toStringTag || "@@toStringTag";
-    function define(t, e, r) {
-      return Object.defineProperty(t, e, {
-        value: r,
-        enumerable: true,
-        configurable: true,
-        writable: true
-      }), t[e];
-    }
-    try {
-      define({}, "");
-    } catch (t) {
-      define = function (t, e, r) {
-        return t[e] = r;
-      };
-    }
-    function wrap(t, e, r, n) {
-      var i = e && e.prototype instanceof Generator ? e : Generator,
-        a = Object.create(i.prototype),
-        c = new Context(n || []);
-      return o(a, "_invoke", {
-        value: makeInvokeMethod(t, r, c)
-      }), a;
-    }
-    function tryCatch(t, e, r) {
-      try {
-        return {
-          type: "normal",
-          arg: t.call(e, r)
-        };
-      } catch (t) {
-        return {
-          type: "throw",
-          arg: t
-        };
-      }
-    }
-    e.wrap = wrap;
-    var h = "suspendedStart",
-      l = "suspendedYield",
-      f = "executing",
-      s = "completed",
-      y = {};
-    function Generator() {}
-    function GeneratorFunction() {}
-    function GeneratorFunctionPrototype() {}
-    var p = {};
-    define(p, a, function () {
-      return this;
-    });
-    var d = Object.getPrototypeOf,
-      v = d && d(d(values([])));
-    v && v !== r && n.call(v, a) && (p = v);
-    var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
-    function defineIteratorMethods(t) {
-      ["next", "throw", "return"].forEach(function (e) {
-        define(t, e, function (t) {
-          return this._invoke(e, t);
-        });
-      });
-    }
-    function AsyncIterator(t, e) {
-      function invoke(r, o, i, a) {
-        var c = tryCatch(t[r], t, o);
-        if ("throw" !== c.type) {
-          var u = c.arg,
-            h = u.value;
-          return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
-            invoke("next", t, i, a);
-          }, function (t) {
-            invoke("throw", t, i, a);
-          }) : e.resolve(h).then(function (t) {
-            u.value = t, i(u);
-          }, function (t) {
-            return invoke("throw", t, i, a);
-          });
-        }
-        a(c.arg);
-      }
-      var r;
-      o(this, "_invoke", {
-        value: function (t, n) {
-          function callInvokeWithMethodAndArg() {
-            return new e(function (e, r) {
-              invoke(t, n, e, r);
-            });
+  function _regenerator() {
+    /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/babel/babel/blob/main/packages/babel-helpers/LICENSE */
+    var e,
+      t,
+      r = "function" == typeof Symbol ? Symbol : {},
+      n = r.iterator || "@@iterator",
+      o = r.toStringTag || "@@toStringTag";
+    function i(r, n, o, i) {
+      var c = n && n.prototype instanceof Generator ? n : Generator,
+        u = Object.create(c.prototype);
+      return _regeneratorDefine(u, "_invoke", function (r, n, o) {
+        var i,
+          c,
+          u,
+          f = 0,
+          p = o || [],
+          y = false,
+          G = {
+            p: 0,
+            n: 0,
+            v: e,
+            a: d,
+            f: d.bind(e, 4),
+            d: function (t, r) {
+              return i = t, c = 0, u = e, G.n = r, a;
+            }
+          };
+        function d(r, n) {
+          for (c = r, u = n, t = 0; !y && f && !o && t < p.length; t++) {
+            var o,
+              i = p[t],
+              d = G.p,
+              l = i[2];
+            r > 3 ? (o = l === n) && (u = i[(c = i[4]) ? 5 : (c = 3, 3)], i[4] = i[5] = e) : i[0] <= d && ((o = r < 2 && d < i[1]) ? (c = 0, G.v = n, G.n = i[1]) : d < l && (o = r < 3 || i[0] > n || n > l) && (i[4] = r, i[5] = n, G.n = l, c = 0));
           }
-          return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+          if (o || r > 1) return a;
+          throw y = true, n;
         }
-      });
-    }
-    function makeInvokeMethod(e, r, n) {
-      var o = h;
-      return function (i, a) {
-        if (o === f) throw Error("Generator is already running");
-        if (o === s) {
-          if ("throw" === i) throw a;
+        return function (o, p, l) {
+          if (f > 1) throw TypeError("Generator is already running");
+          for (y && 1 === p && d(p, l), c = p, u = l; (t = c < 2 ? e : u) || !y;) {
+            i || (c ? c < 3 ? (c > 1 && (G.n = -1), d(c, u)) : G.n = u : G.v = u);
+            try {
+              if (f = 2, i) {
+                if (c || (o = "next"), t = i[o]) {
+                  if (!(t = t.call(i, u))) throw TypeError("iterator result is not an object");
+                  if (!t.done) return t;
+                  u = t.value, c < 2 && (c = 0);
+                } else 1 === c && (t = i.return) && t.call(i), c < 2 && (u = TypeError("The iterator does not provide a '" + o + "' method"), c = 1);
+                i = e;
+              } else if ((t = (y = G.n < 0) ? u : r.call(n, G)) !== a) break;
+            } catch (t) {
+              i = e, c = 1, u = t;
+            } finally {
+              f = 1;
+            }
+          }
           return {
             value: t,
-            done: true
+            done: y
           };
-        }
-        for (n.method = i, n.arg = a;;) {
-          var c = n.delegate;
-          if (c) {
-            var u = maybeInvokeDelegate(c, n);
-            if (u) {
-              if (u === y) continue;
-              return u;
-            }
-          }
-          if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
-            if (o === h) throw o = s, n.arg;
-            n.dispatchException(n.arg);
-          } else "return" === n.method && n.abrupt("return", n.arg);
-          o = f;
-          var p = tryCatch(e, r, n);
-          if ("normal" === p.type) {
-            if (o = n.done ? s : l, p.arg === y) continue;
-            return {
-              value: p.arg,
-              done: n.done
-            };
-          }
-          "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
-        }
-      };
-    }
-    function maybeInvokeDelegate(e, r) {
-      var n = r.method,
-        o = e.iterator[n];
-      if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
-      var i = tryCatch(o, e.iterator, r.arg);
-      if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
-      var a = i.arg;
-      return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
-    }
-    function pushTryEntry(t) {
-      var e = {
-        tryLoc: t[0]
-      };
-      1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
-    }
-    function resetTryEntry(t) {
-      var e = t.completion || {};
-      e.type = "normal", delete e.arg, t.completion = e;
-    }
-    function Context(t) {
-      this.tryEntries = [{
-        tryLoc: "root"
-      }], t.forEach(pushTryEntry, this), this.reset(true);
+        };
+      }(r, o, i), true), u;
     }
-    function values(e) {
-      if (e || "" === e) {
-        var r = e[a];
-        if (r) return r.call(e);
-        if ("function" == typeof e.next) return e;
-        if (!isNaN(e.length)) {
-          var o = -1,
-            i = function next() {
-              for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = false, next;
-              return next.value = t, next.done = true, next;
-            };
-          return i.next = i;
-        }
-      }
-      throw new TypeError(typeof e + " is not iterable");
+    var a = {};
+    function Generator() {}
+    function GeneratorFunction() {}
+    function GeneratorFunctionPrototype() {}
+    t = Object.getPrototypeOf;
+    var c = [][n] ? t(t([][n]())) : (_regeneratorDefine(t = {}, n, function () {
+        return this;
+      }), t),
+      u = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(c);
+    function f(e) {
+      return Object.setPrototypeOf ? Object.setPrototypeOf(e, GeneratorFunctionPrototype) : (e.__proto__ = GeneratorFunctionPrototype, _regeneratorDefine(e, o, "GeneratorFunction")), e.prototype = Object.create(u), e;
     }
-    return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
-      value: GeneratorFunctionPrototype,
-      configurable: true
-    }), o(GeneratorFunctionPrototype, "constructor", {
-      value: GeneratorFunction,
-      configurable: true
-    }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
-      var e = "function" == typeof t && t.constructor;
-      return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
-    }, e.mark = function (t) {
-      return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
-    }, e.awrap = function (t) {
-      return {
-        __await: t
-      };
-    }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
-      return this;
-    }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
-      void 0 === i && (i = Promise);
-      var a = new AsyncIterator(wrap(t, r, n, o), i);
-      return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
-        return t.done ? t.value : a.next();
-      });
-    }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return GeneratorFunction.prototype = GeneratorFunctionPrototype, _regeneratorDefine(u, "constructor", GeneratorFunctionPrototype), _regeneratorDefine(GeneratorFunctionPrototype, "constructor", GeneratorFunction), GeneratorFunction.displayName = "GeneratorFunction", _regeneratorDefine(GeneratorFunctionPrototype, o, "GeneratorFunction"), _regeneratorDefine(u), _regeneratorDefine(u, o, "Generator"), _regeneratorDefine(u, n, function () {
       return this;
-    }), define(g, "toString", function () {
+    }), _regeneratorDefine(u, "toString", function () {
       return "[object Generator]";
-    }), e.keys = function (t) {
-      var e = Object(t),
-        r = [];
-      for (var n in e) r.push(n);
-      return r.reverse(), function next() {
-        for (; r.length;) {
-          var t = r.pop();
-          if (t in e) return next.value = t, next.done = false, next;
-        }
-        return next.done = true, next;
+    }), (_regenerator = function () {
+      return {
+        w: i,
+        m: f
       };
-    }, e.values = values, Context.prototype = {
-      constructor: Context,
-      reset: function (e) {
-        if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
-      },
-      stop: function () {
-        this.done = true;
-        var t = this.tryEntries[0].completion;
-        if ("throw" === t.type) throw t.arg;
-        return this.rval;
-      },
-      dispatchException: function (e) {
-        if (this.done) throw e;
-        var r = this;
-        function handle(n, o) {
-          return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
-        }
-        for (var o = this.tryEntries.length - 1; o >= 0; --o) {
-          var i = this.tryEntries[o],
-            a = i.completion;
-          if ("root" === i.tryLoc) return handle("end");
-          if (i.tryLoc <= this.prev) {
-            var c = n.call(i, "catchLoc"),
-              u = n.call(i, "finallyLoc");
-            if (c && u) {
-              if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
-              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-            } else if (c) {
-              if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
-            } else {
-              if (!u) throw Error("try statement without catch or finally");
-              if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
-            }
-          }
-        }
-      },
-      abrupt: function (t, e) {
-        for (var r = this.tryEntries.length - 1; r >= 0; --r) {
-          var o = this.tryEntries[r];
-          if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
-            var i = o;
-            break;
-          }
-        }
-        i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
-        var a = i ? i.completion : {};
-        return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
-      },
-      complete: function (t, e) {
-        if ("throw" === t.type) throw t.arg;
-        return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
-      },
-      finish: function (t) {
-        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-          var r = this.tryEntries[e];
-          if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
-        }
-      },
-      catch: function (t) {
-        for (var e = this.tryEntries.length - 1; e >= 0; --e) {
-          var r = this.tryEntries[e];
-          if (r.tryLoc === t) {
-            var n = r.completion;
-            if ("throw" === n.type) {
-              var o = n.arg;
-              resetTryEntry(r);
-            }
-            return o;
-          }
-        }
-        throw Error("illegal catch attempt");
-      },
-      delegateYield: function (e, r, n) {
-        return this.delegate = {
-          iterator: values(e),
-          resultName: r,
-          nextLoc: n
-        }, "next" === this.method && (this.arg = t), y;
-      }
-    }, e;
+    })();
+  }
+  function _regeneratorDefine(e, r, n, t) {
+    var i = Object.defineProperty;
+    try {
+      i({}, "", {});
+    } catch (e) {
+      i = 0;
+    }
+    _regeneratorDefine = function (e, r, n, t) {
+      function o(r, n) {
+        _regeneratorDefine(e, r, function (e) {
+          return this._invoke(r, n, e);
+        });
+      }
+      r ? i ? i(e, r, {
+        value: n,
+        enumerable: !t,
+        configurable: !t,
+        writable: !t
+      }) : e[r] = n : (o("next", 0), o("throw", 1), o("return", 2));
+    }, _regeneratorDefine(e, r, n, t);
   }
   function _slicedToArray(r, e) {
     return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
@@ -501,88 +308,92 @@
     }
   }
 
-  // @flekschas/utils v0.32.2 Copyright 2023 Fritz Lekschas
   /* eslint no-param-reassign:0 */
-
   /**
    * Cubic in easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} The eased time
+   * @return The eased time
    */
   const cubicIn = t => t * t * t;
-
   /**
    * Cubic in and out easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} The eased time
+   * @return The eased time
    */
   const cubicInOut = t => t < 0.5 ? 4 * t * t * t : (t - 1) * (2 * t - 2) * (2 * t - 2) + 1;
-
   /**
    * Cubic out easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} The eased time
+   * @return The eased time
    */
   const cubicOut = t => --t * t * t + 1;
-
   /**
    * Linear easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} Same as the input
+   * @return Same as the input
    */
   const linear = t => t;
-
   /**
    * Quadratic in easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} The eased time
+   * @return The eased time
    */
   const quadIn = t => t * t;
-
   /**
    * Quadratic in and out easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} The eased time
+   * @return The eased time
    */
   const quadInOut = t => t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
-
   /**
    * Quadratic out easing function
-   * @param {number} t - The input time to be eased. Must be in [0, 1] where `0`
+   * @param t - The input time to be eased. Must be in [0, 1] where `0`
    *   refers to the start and `1` to the end
-   * @return {number} The eased time
+   * @return The eased time
    */
   const quadOut = t => t * (2 - t);
 
+  /**
+   * Restrict value to be within [min, max]
+   * @description About 18% faster than `Math.max(min, Math.min(max, value))`
+   * @param value - Value to be clamped
+   * @param min - Min value
+   * @param max - Max value
+   * @return Clamped value
+   */
   /**
    * Identity function
-   * @type {<T>(x: T) => T}
-   * @param {*} x - Any kind of value
-   * @return {*} `x`
+   * @param x - Any kind of value
+   * @return `x`
    */
   const identity = x => x;
 
   /**
    * Check if two arrays contain the same elements
-   * @type {<T>(a: T[], b: T[]) => Boolean}
-   * @param {array} a - First array
-   * @param {array} b - Second array
-   * @return {boolean} If `true` the two arrays contain the same elements
+   * @param a - First array
+   * @param b - Second array
+   * @return If `true` the two arrays contain the same elements
    */
   const hasSameElements = (a, b) => {
-    if (a === b) return true;
-    if (a.length !== b.length) return false;
+    if (a === b) {
+      return true;
+    }
+    if (a.length !== b.length) {
+      return false;
+    }
     const aSet = new Set(a);
     const bSet = new Set(b);
     // Since the arrays could contain duplicates, we have to check the set length
     // as well
-    if (aSet.size !== bSet.size) return false;
+    if (aSet.size !== bSet.size) {
+      return false;
+    }
     return b.every(element => aSet.has(element));
   };
 
@@ -592,11 +403,10 @@
    * @description
    * This is identical but much faster than `Math.hypot(...v)`
    *
-   * @param {number[]} v - Numerical vector
-   * @return {number} L2 norm
+   * @param v - Numerical vector
+   * @return L2 norm
    */
   const l2Norm = v => Math.sqrt(v.reduce((sum, x) => sum + x ** 2, 0));
-
   /**
    * Get the maximum number of a vector while ignoring NaNs
    *
@@ -604,35 +414,32 @@
    * This version is muuuch faster than `Math.max(...v)` and supports vectors
    * longer than 256^2, which is a limitation of `Math.max.apply(null, v)`.
    *
-   * @param {number[]} v - Numerical vector
-   * @return {number} The largest number
+   * @param v - Numerical vector
+   * @return The largest number
    */
-  const max$1 = v => v.reduce((_max, a) => a > _max ? a : _max, -Infinity);
-
+  const max$1 = v => v.reduce((_max, a) => a > _max ? a : _max, Number.NEGATIVE_INFINITY);
   /**
    * Initialize an array of a certain length using a mapping function
    *
    * @description
    * This is equivalent to `Array.from({ length }, mapFn)` but about 60% faster
    *
-   * @param {number} length - Size of the array
-   * @param {function} mapFn - Mapping function
-   * @return {array} Initialized array
-   * @type {<T = number>(length: number, mapFn: (i: number, length: number) => T) => T[]}
+   * @param length - Size of the array
+   * @param mapFn - Mapping function
+   * @return Initialized array
    */
-  const rangeMap = (length, mapFn = x => x) => {
+  const rangeMap = (length, mapFn = identity) => {
     const out = [];
     for (let i = 0; i < length; i++) {
       out.push(mapFn(i, length));
     }
     return out;
   };
-
   /**
    * Get the unique union of two vectors of integers
-   * @param {number[]} v - First vector of integers
-   * @param {number[]} w - Second vector of integers
-   * @return {number[]} Unique union of `v` and `w`
+   * @param v - First vector of integers
+   * @param w - Second vector of integers
+   * @return Unique union of `v` and `w`
    */
   const unionIntegers = (v, w) => {
     const a = [];
@@ -651,9 +458,9 @@
   /**
    * Assign properties, constructors, etc. to an object
    *
-   * @param {object} target - The target object that gets `sources` assigned to it
-   * @param {}
-   * @return {object}
+   * @param target - The target object that gets `sources` assigned to it
+   * @param sources - The sources to be assigned to the target object
+   * @return An object representing the union of the target and sources objects
    */
   const assign = (target, ...sources) => {
     sources.forEach(source => {
@@ -662,11 +469,10 @@
         descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
         return descriptors;
       }, {});
-
       // By default, Object.assign copies enumerable Symbols, too
       Object.getOwnPropertySymbols(source).forEach(symbol => {
         const descriptor = Object.getOwnPropertyDescriptor(source, symbol);
-        if (descriptor.enumerable) {
+        if (descriptor?.enumerable) {
           descriptors[symbol] = descriptor;
         }
       });
@@ -677,30 +483,25 @@
 
   /**
    * Convenience function to compose functions
-   * @param {...function} fns - Array of functions
-   * @return {function} The composed function
-   */
-  const pipe = (...fns) =>
-  /**
-   * @param {*} x - Some value
-   * @return {*} Output of the composed function
+   * @param fns - Array of functions
+   * @return The composed function
    */
-  x => fns.reduce((y, f) => f(y), x);
-
+  function pipe(...fns) {
+    return x => fns.reduce((y, f) => f(y), x);
+  }
   /**
    * Assign a constructor to the object
-   * @param {function} constructor - Constructor functions
+   * @param constructorFn - Constructor functions
    */
-  const withConstructor = constructor => self => assign({
+  const withConstructor = constructorFn => self => assign({
     __proto__: {
-      constructor
+      constructor: constructorFn
     }
   }, self);
-
   /**
    * Assign a static property to an object
-   * @param {string} name - Name of the property
-   * @param {*} value - Static value
+   * @param name - Name of the property
+   * @param value - Static value
    */
   const withStaticProperty = (name, value) => self => assign(self, {
     get [name]() {
@@ -708,43 +509,61 @@
     }
   });
 
+  /**
+   * L distance between a pair of vectors
+   *
+   * @description
+   * Identical but much faster than `lDist(l)([fromX, fromY], [toX, toY])`
+   *
+   * @param l - Defines the Lp space
+   */
   /**
    * L2 distance between a pair of points
    *
    * @description
    * Identical but much faster than `l2Dist([fromX, fromY], [toX, toY])`
    *
-   * @param {number} fromX - X coordinate of the first point
-   * @param {number} fromY - Y coordinate of the first point
-   * @param {number} toX - X coordinate of the second point
-   * @param {number} toY - Y coordinate of the first point
-   * @return {number} L2 distance
+   * @paramfromX - X coordinate of the first point
+   * @paramfromY - Y coordinate of the first point
+   * @paramtoX - X coordinate of the second point
+   * @paramtoY - Y coordinate of the first point
+   * @returnL2 distance
    */
   const l2PointDist = (fromX, fromY, toX, toY) => Math.sqrt((fromX - toX) ** 2 + (fromY - toY) ** 2);
 
   /**
    * Create a worker from a function
-   * @param {function} fn - Function to be turned into a worker
-   * @return {Worker} Worker function
+   * @param fn - Function to be turned into a worker
+   * @return Worker function
    */
   const createWorker$1 = fn => new Worker(window.URL.createObjectURL(new Blob([`(${fn.toString()})()`], {
-    type: 'text/javascript'
+    type: "text/javascript"
   })));
 
+  /**
+   * Debounce a function call.
+   *
+   * @description
+   * Function calls are delayed by `wait` milliseconds and only one out of
+   * multiple function calls is executed.
+   *
+   * @param fn - Function to be debounced
+   * @param wait - Number of milliseconds to debounce the function call.
+   * @return Debounced function
+   */
   /**
    * Get a promise that resolves after the next `n` animation frames
-   * @param {number} n - Number of animation frames to wait
-   * @return {Promise} A promise that resolves after the next `n` animation frames
+   * @param n - Number of animation frames to wait
+   * @return A promise that resolves after the next `n` animation frames
    */
   const nextAnimationFrame = (n = 1) => new Promise(resolve => {
     let i = 0;
     const raf = () => requestAnimationFrame(() => {
       i++;
-      if (i < n) raf();else resolve();
+      if (i < n) raf();else resolve(undefined);
     });
     raf();
   });
-
   /**
    * Throttle and debounce a function call
    *
@@ -767,17 +586,15 @@
    * 6. No call           => nothing
    * 7. No call           => f(args5) called due to debouncing
    *
-   * @param {functon} fn - Function to be throttled and debounced
-   * @param {number} throttleTime - Throttle intevals in milliseconds
-   * @param {number} debounceTime - Debounce wait time in milliseconds. By default
-   *   this is the same as `throttleTime`.
-   * @return {function} - Throttled and debounced function
+   * @param fn - Function to be throttled and debounced
+   * @param throttleTime - Throttle intevals in milliseconds
+   * @param debounceTime - Debounce wait time in milliseconds. By default this is
+   *   the same as `throttleTime`.
+   * @return Throttled and debounced function
    */
-  const throttleAndDebounce = (fn, throttleTime, debounceTime = null) => {
+  const throttleAndDebounce = (fn, throttleTime, debounceTime) => {
     let timeout;
     let blockedCalls = 0;
-
-    // eslint-disable-next-line no-param-reassign
     debounceTime = debounceTime === null ? throttleTime : debounceTime;
     const debounced = (...args) => {
       const later = () => {
@@ -795,7 +612,10 @@
     };
     let isWaiting = false;
     const throttledAndDebounced = (...args) => {
-      if (!isWaiting) {
+      if (isWaiting) {
+        blockedCalls++;
+        debounced(...args);
+      } else {
         fn(...args);
         debounced(...args);
         isWaiting = true;
@@ -803,9 +623,6 @@
         setTimeout(() => {
           isWaiting = false;
         }, throttleTime);
-      } else {
-        blockedCalls++;
-        debounced(...args);
       }
     };
     throttledAndDebounced.reset = () => {
@@ -822,17 +639,10 @@
    * Common utilities
    * @module glMatrix
    */
+
   // Configuration Constants
   var EPSILON = 0.000001;
-  var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
-  if (!Math.hypot) Math.hypot = function () {
-    var y = 0,
-      i = arguments.length;
-    while (i--) {
-      y += arguments[i] * arguments[i];
-    }
-    return Math.sqrt(y);
-  };
+  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
 
   /**
    * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.
@@ -844,7 +654,6 @@
    *
    * @returns {mat4} a new 4x4 matrix
    */
-
   function create$2() {
     var out = new ARRAY_TYPE(16);
     if (ARRAY_TYPE != Float32Array) {
@@ -867,13 +676,13 @@
     out[15] = 1;
     return out;
   }
+
   /**
    * Creates a new mat4 initialized with values from an existing matrix
    *
    * @param {ReadonlyMat4} a matrix to clone
    * @returns {mat4} a new 4x4 matrix
    */
-
   function clone(a) {
     var out = new ARRAY_TYPE(16);
     out[0] = a[0];
@@ -894,14 +703,14 @@
     out[15] = a[15];
     return out;
   }
+
   /**
    * Inverts a mat4
    *
    * @param {mat4} out the receiving matrix
    * @param {ReadonlyMat4} a the source matrix
-   * @returns {mat4} out
+   * @returns {mat4 | null} out, or null if source matrix is not invertible
    */
-
   function invert(out, a) {
     var a00 = a[0],
       a01 = a[1],
@@ -930,8 +739,9 @@
     var b08 = a20 * a33 - a23 * a30;
     var b09 = a21 * a32 - a22 * a31;
     var b10 = a21 * a33 - a23 * a31;
-    var b11 = a22 * a33 - a23 * a32; // Calculate the determinant
+    var b11 = a22 * a33 - a23 * a32;
 
+    // Calculate the determinant
     var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;
     if (!det) {
       return null;
@@ -955,6 +765,7 @@
     out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;
     return out;
   }
+
   /**
    * Multiplies two mat4s
    *
@@ -963,7 +774,6 @@
    * @param {ReadonlyMat4} b the second operand
    * @returns {mat4} out
    */
-
   function multiply(out, a, b) {
     var a00 = a[0],
       a01 = a[1],
@@ -980,8 +790,9 @@
     var a30 = a[12],
       a31 = a[13],
       a32 = a[14],
-      a33 = a[15]; // Cache only the current line of the second matrix
+      a33 = a[15];
 
+    // Cache only the current line of the second matrix
     var b0 = b[0],
       b1 = b[1],
       b2 = b[2],
@@ -1016,6 +827,7 @@
     out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
     return out;
   }
+
   /**
    * Creates a matrix from a vector translation
    * This is equivalent to (but much faster than):
@@ -1027,7 +839,6 @@
    * @param {ReadonlyVec3} v Translation vector
    * @returns {mat4} out
    */
-
   function fromTranslation(out, v) {
     out[0] = 1;
     out[1] = 0;
@@ -1047,6 +858,7 @@
     out[15] = 1;
     return out;
   }
+
   /**
    * Creates a matrix from a vector scaling
    * This is equivalent to (but much faster than):
@@ -1058,7 +870,6 @@
    * @param {ReadonlyVec3} v Scaling vector
    * @returns {mat4} out
    */
-
   function fromScaling(out, v) {
     out[0] = v[0];
     out[1] = 0;
@@ -1078,6 +889,7 @@
     out[15] = 1;
     return out;
   }
+
   /**
    * Creates a matrix from a given angle around a given axis
    * This is equivalent to (but much faster than):
@@ -1090,12 +902,11 @@
    * @param {ReadonlyVec3} axis the axis to rotate around
    * @returns {mat4} out
    */
-
   function fromRotation(out, rad, axis) {
     var x = axis[0],
       y = axis[1],
       z = axis[2];
-    var len = Math.hypot(x, y, z);
+    var len = Math.sqrt(x * x + y * y + z * z);
     var s, c, t;
     if (len < EPSILON) {
       return null;
@@ -1106,8 +917,9 @@
     z *= len;
     s = Math.sin(rad);
     c = Math.cos(rad);
-    t = 1 - c; // Perform rotation-specific matrix multiplication
+    t = 1 - c;
 
+    // Perform rotation-specific matrix multiplication
     out[0] = x * x * t + c;
     out[1] = y * x * t + z * s;
     out[2] = z * x * t - y * s;
@@ -1126,6 +938,7 @@
     out[15] = 1;
     return out;
   }
+
   /**
    * Returns the translation vector component of a transformation
    *  matrix. If a matrix is built with fromRotationTranslation,
@@ -1135,24 +948,23 @@
    * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
    * @return {vec3} out
    */
-
   function getTranslation(out, mat) {
     out[0] = mat[12];
     out[1] = mat[13];
     out[2] = mat[14];
     return out;
   }
+
   /**
    * Returns the scaling factor component of a transformation
    *  matrix. If a matrix is built with fromRotationTranslationScale
-   *  with a normalized Quaternion paramter, the returned vector will be
+   *  with a normalized Quaternion parameter, the returned vector will be
    *  the same as the scaling vector
    *  originally supplied.
    * @param  {vec3} out Vector to receive scaling factor component
    * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)
    * @return {vec3} out
    */
-
   function getScaling(out, mat) {
     var m11 = mat[0];
     var m12 = mat[1];
@@ -1163,9 +975,9 @@
     var m31 = mat[8];
     var m32 = mat[9];
     var m33 = mat[10];
-    out[0] = Math.hypot(m11, m12, m13);
-    out[1] = Math.hypot(m21, m22, m23);
-    out[2] = Math.hypot(m31, m32, m33);
+    out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);
+    out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);
+    out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);
     return out;
   }
 
@@ -1179,7 +991,6 @@
    *
    * @returns {vec4} a new 4D vector
    */
-
   function create$1() {
     var out = new ARRAY_TYPE(4);
     if (ARRAY_TYPE != Float32Array) {
@@ -1190,6 +1001,7 @@
     }
     return out;
   }
+
   /**
    * Transforms the vec4 with a mat4.
    *
@@ -1198,7 +1010,6 @@
    * @param {ReadonlyMat4} m matrix to transform with
    * @returns {vec4} out
    */
-
   function transformMat4(out, a, m) {
     var x = a[0],
       y = a[1],
@@ -1210,6 +1021,7 @@
     out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;
     return out;
   }
+
   /**
    * Perform some operation over an array of vec4s.
    *
@@ -1222,7 +1034,6 @@
    * @returns {Array} a
    * @function
    */
-
   (function () {
     var vec = create$1();
     return function (a, stride, offset, count, fn, arg) {
@@ -1263,7 +1074,6 @@
    *
    * @returns {vec2} a new 2D vector
    */
-
   function create() {
     var out = new ARRAY_TYPE(2);
     if (ARRAY_TYPE != Float32Array) {
@@ -1272,25 +1082,21 @@
     }
     return out;
   }
+
   /**
-   * Get the angle between two 2D vectors
+   * Get the smallest angle between two 2D vectors
    * @param {ReadonlyVec2} a The first operand
    * @param {ReadonlyVec2} b The second operand
    * @returns {Number} The angle in radians
    */
-
   function angle(a, b) {
-    var x1 = a[0],
-      y1 = a[1],
-      x2 = b[0],
-      y2 = b[1],
-      // mag is the product of the magnitudes of a and b
-      mag = Math.sqrt(x1 * x1 + y1 * y1) * Math.sqrt(x2 * x2 + y2 * y2),
-      // mag &&.. short circuits if mag == 0
-      cosine = mag && (x1 * x2 + y1 * y2) / mag; // Math.min(Math.max(cosine, -1), 1) clamps the cosine between -1 and 1
-
-    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+    var ax = a[0],
+      ay = a[1],
+      bx = b[0],
+      by = b[1];
+    return Math.abs(Math.atan2(ay * bx - ax * by, ax * bx + ay * by));
   }
+
   /**
    * Perform some operation over an array of vec2s.
    *
@@ -1303,7 +1109,6 @@
    * @returns {Array} a
    * @function
    */
-
   (function () {
     var vec = create();
     return function (a, stride, offset, count, fn, arg) {
@@ -1751,10 +1556,10 @@
 
     // if the shape is not too simple, we'll use z-order curve hash later; calculate polygon bbox
     if (data.length > 80 * dim) {
-      minX = Infinity;
-      minY = Infinity;
-      let maxX = -Infinity;
-      let maxY = -Infinity;
+      minX = data[0];
+      minY = data[1];
+      let maxX = minX;
+      let maxY = minY;
       for (let i = dim; i < outerLen; i += dim) {
         const x = data[i];
         const y = data[i + 1];
@@ -2056,7 +1861,7 @@
   // check if a diagonal between two polygon nodes is valid (lies in polygon interior)
   function isValidDiagonal(a, b) {
     return a.next.i !== b.i && a.prev.i !== b.i && !intersectsPolygon(a, b) && (
-    // dones't intersect other edges
+    // doesn't intersect other edges
     locallyInside(a, b) && locallyInside(b, a) && middleInside(a, b) && (
     // locally visible
     area(a.prev, a, b.prev) || area(a, b.prev, b)) ||
@@ -2700,105 +2505,281 @@ void main() {
     };
   };
 
-  /**
-   * KDBush - A fast static index for 2D points
-   * @license ISC License
-   * @copyright Vladimir Agafonkin 2018
-   * @version 4.0.2
-   * @see https://github.com/mourner/kdbush/
-   */
-  var createKDBushClass = (function () {
-    var ARRAY_TYPES = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+  var version = "1.16.0-hemato.0";
 
-    /** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
+  const FRAGMENT_SHADER$2 = `
+precision mediump float;
 
-    var VERSION = 1; // serialized format version
-    var HEADER_SIZE = 8;
-    var KDBush = /*#__PURE__*/function () {
-      /**
-       * Creates an index that will hold a given number of items.
-       * @param {number} numItems
-       * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
-       * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
-       * @param {ArrayBuffer} [data] (For internal use only)
-       */
-      function KDBush(numItems) {
-        var nodeSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 64;
-        var ArrayType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Float64Array;
-        var data = arguments.length > 3 ? arguments[3] : undefined;
-        _classCallCheck(this, KDBush);
-        if (isNaN(numItems) || numItems < 0) throw new Error("Unexpected numItems value: ".concat(numItems, "."));
-        this.numItems = +numItems;
-        this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
-        this.ArrayType = ArrayType;
-        this.IndexArrayType = numItems < 65536 ? Uint16Array : Uint32Array;
-        var arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
-        var coordsByteSize = numItems * 2 * this.ArrayType.BYTES_PER_ELEMENT;
-        var idsByteSize = numItems * this.IndexArrayType.BYTES_PER_ELEMENT;
-        var padCoords = (8 - idsByteSize % 8) % 8;
-        if (arrayTypeIndex < 0) {
-          throw new Error("Unexpected typed array class: ".concat(ArrayType, "."));
-        }
-        if (data && data instanceof ArrayBuffer) {
-          // reconstruct an index from a buffer
-          this.data = data;
-          this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
-          this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
-          this._pos = numItems * 2;
-          this._finished = true;
-        } else {
-          // initialize a new index
-          this.data = new ArrayBuffer(HEADER_SIZE + coordsByteSize + idsByteSize + padCoords);
-          this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
-          this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
-          this._pos = 0;
-          this._finished = false;
+uniform sampler2D texture;
 
-          // set header
-          new Uint8Array(this.data, 0, 2).set([0xdb, (VERSION << 4) + arrayTypeIndex]);
-          new Uint16Array(this.data, 2, 1)[0] = nodeSize;
-          new Uint32Array(this.data, 4, 1)[0] = numItems;
-        }
-      }
+varying vec2 uv;
 
-      /**
-       * Add a point to the index.
-       * @param {number} x
-       * @param {number} y
-       * @returns {number} An incremental index associated with the added item (starting from `0`).
-       */
-      return _createClass(KDBush, [{
-        key: "add",
-        value: function add(x, y) {
-          var index = this._pos >> 1;
-          this.ids[index] = index;
-          this.coords[this._pos++] = x;
-          this.coords[this._pos++] = y;
-          return index;
-        }
+void main () {
+  gl_FragColor = texture2D(texture, uv);
+}
+`;
 
-        /**
-         * Perform indexing of the added points.
-         */
-      }, {
-        key: "finish",
-        value: function finish() {
-          var numAdded = this._pos >> 1;
-          if (numAdded !== this.numItems) {
-            throw new Error("Added ".concat(numAdded, " items when expected ").concat(this.numItems, "."));
-          }
-          // kd-sort both arrays for efficient search
-          sort(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0);
-          this._finished = true;
-          return this;
-        }
+  const VERTEX_SHADER = `
+precision mediump float;
 
-        /**
-         * Search the index for items within a given bounding box.
-         * @param {number} minX
-         * @param {number} minY
-         * @param {number} maxX
-         * @param {number} maxY
+uniform mat4 modelViewProjection;
+
+attribute vec2 position;
+
+varying vec2 uv;
+
+void main () {
+  uv = position;
+  gl_Position = modelViewProjection * vec4(-1.0 + 2.0 * uv.x, 1.0 - 2.0 * uv.y, 0, 1);
+}
+`;
+
+  var AUTO = 'auto';
+  var COLOR_NORMAL_IDX = 0;
+  var COLOR_ACTIVE_IDX = 1;
+  var COLOR_HOVER_IDX = 2;
+  var COLOR_BG_IDX = 3;
+  var COLOR_NUM_STATES = 4;
+  var FLOAT_BYTES = Float32Array.BYTES_PER_ELEMENT;
+  var GL_EXTENSIONS = ['OES_texture_float', 'OES_element_index_uint', 'WEBGL_color_buffer_float', 'EXT_float_blend'];
+  var CLEAR_OPTIONS = {
+    color: [0, 0, 0, 0],
+    // Transparent background color
+    depth: 1
+  };
+  var MOUSE_MODE_PANZOOM = 'panZoom';
+  var MOUSE_MODE_LASSO = 'lasso';
+  var MOUSE_MODE_ROTATE = 'rotate';
+  var MOUSE_MODES = [MOUSE_MODE_PANZOOM, MOUSE_MODE_LASSO, MOUSE_MODE_ROTATE];
+  var DEFAULT_MOUSE_MODE = MOUSE_MODE_PANZOOM;
+
+  // Easing
+  var EASING_FNS = {
+    cubicIn: cubicIn,
+    cubicInOut: cubicInOut,
+    cubicOut: cubicOut,
+    linear: linear,
+    quadIn: quadIn,
+    quadInOut: quadInOut,
+    quadOut: quadOut
+  };
+  var DEFAULT_EASING = cubicInOut;
+  var CONTINUOUS = 'continuous';
+  var CATEGORICAL = 'categorical';
+  var VALUE_ZW_DATA_TYPES = [CONTINUOUS, CATEGORICAL];
+
+  // Default lasso
+  var LASSO_CLEAR_ON_DESELECT = 'deselect';
+  var LASSO_CLEAR_ON_END = 'lassoEnd';
+  var LASSO_CLEAR_EVENTS = [LASSO_CLEAR_ON_DESELECT, LASSO_CLEAR_ON_END];
+  var LASSO_BRUSH_MIN_MIN_DIST = 3;
+  var DEFAULT_LASSO_COLOR = [0, 0.666666667, 1, 1];
+  var DEFAULT_LASSO_LINE_WIDTH = 2;
+  var DEFAULT_LASSO_INITIATOR = false;
+  var DEFAULT_LASSO_MIN_DELAY$1 = 10;
+  var DEFAULT_LASSO_MIN_DIST$1 = 3;
+  var DEFAULT_LASSO_CLEAR_EVENT = LASSO_CLEAR_ON_END;
+  var DEFAULT_LASSO_ON_LONG_PRESS = false;
+  var DEFAULT_LASSO_LONG_PRESS_TIME = 750;
+  var DEFAULT_LASSO_LONG_PRESS_AFTER_EFFECT_TIME = 500;
+  var DEFAULT_LASSO_LONG_PRESS_EFFECT_DELAY = 100;
+  var DEFAULT_LASSO_LONG_PRESS_REVERT_EFFECT_TIME = 250;
+  var DEFAULT_LASSO_BRUSH_SIZE = 24;
+  var DEFAULT_LASSO_MODE = null;
+
+  // Key mapping
+  var KEY_ACTION_INTERSECT = 'intersect';
+  var KEY_ACTION_LASSO = 'lasso';
+  var KEY_ACTION_ROTATE = 'rotate';
+  var KEY_ACTION_MERGE = 'merge';
+  var KEY_ACTION_REMOVE = 'remove';
+  var KEY_ACTIONS = [KEY_ACTION_LASSO, KEY_ACTION_ROTATE, KEY_ACTION_INTERSECT, KEY_ACTION_MERGE, KEY_ACTION_REMOVE];
+  var KEY_ALT = 'alt';
+  var KEY_CMD = 'cmd';
+  var KEY_CTRL = 'ctrl';
+  var KEY_META = 'meta';
+  var KEY_SHIFT = 'shift';
+  var KEYS = [KEY_ALT, KEY_CMD, KEY_CTRL, KEY_META, KEY_SHIFT];
+  var DEFAULT_ACTION_KEY_MAP = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, KEY_ACTION_REMOVE, KEY_ALT), KEY_ACTION_ROTATE, KEY_ALT), KEY_ACTION_LASSO, KEY_SHIFT), KEY_ACTION_MERGE, KEY_CMD);
+
+  // Default attribute
+  var DEFAULT_DATA_ASPECT_RATIO = 1;
+  var DEFAULT_WIDTH = AUTO;
+  var DEFAULT_HEIGHT = AUTO;
+  var DEFAULT_GAMMA = 1;
+
+  // Default styles
+  var MIN_POINT_SIZE = 1;
+  var DEFAULT_POINT_SCALE_MODE = 'asinh';
+  var DEFAULT_POINT_SIZE = 6;
+  var DEFAULT_POINT_SIZE_SELECTED = 2;
+  var DEFAULT_POINT_OUTLINE_WIDTH = 2;
+  var DEFAULT_SIZE_BY = null;
+  var DEFAULT_POINT_ORDER = null;
+  var DEFAULT_POINT_CONNECTION_SIZE = 2;
+  var DEFAULT_POINT_CONNECTION_SIZE_ACTIVE = 2;
+  var DEFAULT_POINT_CONNECTION_SIZE_BY = null;
+  var DEFAULT_POINT_CONNECTION_OPACITY = null;
+  var DEFAULT_POINT_CONNECTION_OPACITY_BY = null;
+  var DEFAULT_POINT_CONNECTION_OPACITY_ACTIVE = 0.66;
+  var DEFAULT_OPACITY = 1;
+  var DEFAULT_OPACITY_BY = null;
+  var DEFAULT_OPACITY_BY_DENSITY_FILL = 0.15;
+  var DEFAULT_OPACITY_BY_DENSITY_DEBOUNCE_TIME = 25;
+  var DEFAULT_OPACITY_INACTIVE_MAX = 1;
+  var DEFAULT_OPACITY_INACTIVE_SCALE = 1;
+  var DEFAULT_COLOR_BY = null;
+  var DEFAULT_COLOR_NORMAL = [0.66, 0.66, 0.66, DEFAULT_OPACITY];
+  var DEFAULT_COLOR_ACTIVE = [0, 0.55, 1, 1];
+  var DEFAULT_COLOR_HOVER = [1, 1, 1, 1];
+  var DEFAULT_COLOR_BG = [0, 0, 0, 1];
+  var DEFAULT_POINT_CONNECTION_COLOR_BY = null;
+  var DEFAULT_POINT_CONNECTION_COLOR_NORMAL = [0.66, 0.66, 0.66, 0.2];
+  var DEFAULT_POINT_CONNECTION_COLOR_ACTIVE = [0, 0.55, 1, 1];
+  var DEFAULT_POINT_CONNECTION_COLOR_HOVER = [1, 1, 1, 1];
+
+  // Annotations
+  var DEFAULT_ANNOTATION_LINE_COLOR = [1, 1, 1, 0.5];
+  var DEFAULT_ANNOTATION_LINE_WIDTH = 1;
+  var DEFAULT_ANNOTATION_HVLINE_LIMIT = 1000;
+
+  // Default view
+  var DEFAULT_TARGET = [0, 0];
+  var DEFAULT_DISTANCE = 1;
+  var DEFAULT_ROTATION = 0;
+  // biome-ignore format: the array should not be formatted
+  var DEFAULT_VIEW = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
+
+  // Error codes
+  var IMAGE_LOAD_ERROR = 'IMAGE_LOAD_ERROR';
+
+  // Default misc
+  var DEFAULT_BACKGROUND_IMAGE = null;
+  var DEFAULT_SHOW_RETICLE = false;
+  var DEFAULT_RETICLE_COLOR = [1, 1, 1, 0.5];
+  var DEFAULT_DESELECT_ON_DBL_CLICK = true;
+  var DEFAULT_DESELECT_ON_ESCAPE = true;
+  var DEFAULT_SHOW_POINT_CONNECTIONS = false;
+  var DEFAULT_POINT_CONNECTION_MAX_INT_POINTS_PER_SEGMENT = 100;
+  var DEFAULT_POINT_CONNECTION_INT_POINTS_TOLERANCE = 1 / 500;
+  var DEFAULT_POINT_SIZE_MOUSE_DETECTION = 'auto';
+  var DEFAULT_PERFORMANCE_MODE = false;
+  var SINGLE_CLICK_DELAY = 200;
+  var LONG_CLICK_TIME = 500;
+  var Z_NAMES = new Set(['z', 'valueZ', 'valueA', 'value1', 'category']);
+  var W_NAMES = new Set(['w', 'valueW', 'valueB', 'value2', 'value']);
+  var DEFAULT_IMAGE_LOAD_TIMEOUT = 15000;
+  var DEFAULT_SPATIAL_INDEX_USE_WORKER = undefined;
+  var DEFAULT_CAMERA_IS_FIXED = false;
+  var DEFAULT_ANTI_ALIASING = 0.5;
+  var DEFAULT_PIXEL_ALIGNED = false;
+  var DEFAULT_LASSO_TYPE$1 = 'lasso';
+  var SKIP_DEPRECATION_VALUE_TRANSLATION = Symbol('SKIP_DEPRECATION_VALUE_TRANSLATION');
+
+  // Error messages
+  var ERROR_POINTS_NOT_DRAWN = 'Points have not been drawn';
+  var ERROR_INSTANCE_IS_DESTROYED = 'The instance was already destroyed';
+  var ERROR_IS_DRAWING = 'Ignoring draw call as the previous draw call has not yet finished. To avoid this warning `await` the draw call.';
+
+  /**
+   * KDBush - A fast static index for 2D points
+   * @license ISC License
+   * @copyright Vladimir Agafonkin 2018
+   * @version 4.0.2
+   * @see https://github.com/mourner/kdbush/
+   */
+  var createKDBushClass = (function () {
+    var ARRAY_TYPES = [Int8Array, Uint8Array, Uint8ClampedArray, Int16Array, Uint16Array, Int32Array, Uint32Array, Float32Array, Float64Array];
+
+    /** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
+
+    var VERSION = 1; // serialized format version
+    var HEADER_SIZE = 8;
+    var KDBush = /*#__PURE__*/function () {
+      /**
+       * Creates an index that will hold a given number of items.
+       * @param {number} numItems
+       * @param {number} [nodeSize=64] Size of the KD-tree node (64 by default).
+       * @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+       * @param {ArrayBuffer} [data] (For internal use only)
+       */
+      function KDBush(numItems) {
+        var nodeSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 64;
+        var ArrayType = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Float64Array;
+        var data = arguments.length > 3 ? arguments[3] : undefined;
+        _classCallCheck(this, KDBush);
+        if (isNaN(numItems) || numItems < 0) throw new Error("Unexpected numItems value: ".concat(numItems, "."));
+        this.numItems = +numItems;
+        this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+        this.ArrayType = ArrayType;
+        this.IndexArrayType = numItems < 65536 ? Uint16Array : Uint32Array;
+        var arrayTypeIndex = ARRAY_TYPES.indexOf(this.ArrayType);
+        var coordsByteSize = numItems * 2 * this.ArrayType.BYTES_PER_ELEMENT;
+        var idsByteSize = numItems * this.IndexArrayType.BYTES_PER_ELEMENT;
+        var padCoords = (8 - idsByteSize % 8) % 8;
+        if (arrayTypeIndex < 0) {
+          throw new Error("Unexpected typed array class: ".concat(ArrayType, "."));
+        }
+        if (data && data instanceof ArrayBuffer) {
+          // reconstruct an index from a buffer
+          this.data = data;
+          this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
+          this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
+          this._pos = numItems * 2;
+          this._finished = true;
+        } else {
+          // initialize a new index
+          this.data = new ArrayBuffer(HEADER_SIZE + coordsByteSize + idsByteSize + padCoords);
+          this.ids = new this.IndexArrayType(this.data, HEADER_SIZE, numItems);
+          this.coords = new this.ArrayType(this.data, HEADER_SIZE + idsByteSize + padCoords, numItems * 2);
+          this._pos = 0;
+          this._finished = false;
+
+          // set header
+          new Uint8Array(this.data, 0, 2).set([0xdb, (VERSION << 4) + arrayTypeIndex]);
+          new Uint16Array(this.data, 2, 1)[0] = nodeSize;
+          new Uint32Array(this.data, 4, 1)[0] = numItems;
+        }
+      }
+
+      /**
+       * Add a point to the index.
+       * @param {number} x
+       * @param {number} y
+       * @returns {number} An incremental index associated with the added item (starting from `0`).
+       */
+      return _createClass(KDBush, [{
+        key: "add",
+        value: function add(x, y) {
+          var index = this._pos >> 1;
+          this.ids[index] = index;
+          this.coords[this._pos++] = x;
+          this.coords[this._pos++] = y;
+          return index;
+        }
+
+        /**
+         * Perform indexing of the added points.
+         */
+      }, {
+        key: "finish",
+        value: function finish() {
+          var numAdded = this._pos >> 1;
+          if (numAdded !== this.numItems) {
+            throw new Error("Added ".concat(numAdded, " items when expected ").concat(this.numItems, "."));
+          }
+          // kd-sort both arrays for efficient search
+          sort(this.ids, this.coords, this.nodeSize, 0, this.numItems - 1, 0);
+          this._finished = true;
+          return this;
+        }
+
+        /**
+         * Search the index for items within a given bounding box.
+         * @param {number} minX
+         * @param {number} minY
+         * @param {number} maxX
+         * @param {number} maxY
          * @returns {number[]} An array of indices correponding to the found items.
          */
       }, {
@@ -3049,8 +3030,6 @@ void main() {
           error: new Error('Invalid point data')
         });
       }
-
-      // biome-ignore lint/correctness/noUndeclaredVariables: KDBush is made available during compilation
       var index = new KDBush(points.length, event.data.nodeSize);
       var _iterator = _createForOfIteratorHelper(points),
         _step;
@@ -3071,15 +3050,12 @@ void main() {
     });
   });
 
-  // biome-ignore lint/style/useNamingConvention: KDBush is a library name
   var KDBush$1 = createKDBushClass();
   var WORKER_THRESHOLD = 1000000;
   var createWorker = function createWorker(fn) {
     var kdbushStr = createKDBushClass.toString();
     var fnStr = fn.toString();
-    var workerStr =
-    // biome-ignore lint/style/useTemplate: Prefer one assignment per line
-    "const createKDBushClass = ".concat(kdbushStr, ";") + 'KDBush = createKDBushClass();' + "const createWorker = ".concat(fnStr, ";") + 'createWorker();';
+    var workerStr = "const createKDBushClass = ".concat(kdbushStr, ";") + 'KDBush = createKDBushClass();' + "const createWorker = ".concat(fnStr, ";") + 'createWorker();';
     var blob = new Blob([workerStr], {
       type: 'text/javascript'
     });
@@ -3140,161 +3116,18 @@ void main() {
       }
     });
   };
+  var kdbushFrom = function kdbushFrom(buffer) {
+    return KDBush$1.from(buffer);
+  };
 
   var DEFAULT_LASSO_START_INITIATOR_SHOW = true;
-  var DEFAULT_LASSO_MIN_DELAY$1 = 8;
-  var DEFAULT_LASSO_MIN_DIST$1 = 2;
-  var DEFAULT_LASSO_TYPE$1 = 'freeform';
+  var DEFAULT_LASSO_MIN_DELAY = 8;
+  var DEFAULT_LASSO_MIN_DIST = 2;
+  var DEFAULT_LASSO_TYPE = 'freeform';
   var DEFAULT_BRUSH_SIZE = 24;
   var LASSO_SHOW_START_INITIATOR_TIME = 2500;
   var LASSO_HIDE_START_INITIATOR_TIME = 250;
 
-  var AUTO = 'auto';
-  var COLOR_NORMAL_IDX = 0;
-  var COLOR_ACTIVE_IDX = 1;
-  var COLOR_HOVER_IDX = 2;
-  var COLOR_BG_IDX = 3;
-  var COLOR_NUM_STATES = 4;
-  var FLOAT_BYTES = Float32Array.BYTES_PER_ELEMENT;
-  var GL_EXTENSIONS = ['OES_texture_float', 'OES_element_index_uint', 'WEBGL_color_buffer_float', 'EXT_float_blend'];
-  var CLEAR_OPTIONS = {
-    color: [0, 0, 0, 0],
-    // Transparent background color
-    depth: 1
-  };
-  var MOUSE_MODE_PANZOOM = 'panZoom';
-  var MOUSE_MODE_LASSO = 'lasso';
-  var MOUSE_MODE_ROTATE = 'rotate';
-  var MOUSE_MODES = [MOUSE_MODE_PANZOOM, MOUSE_MODE_LASSO, MOUSE_MODE_ROTATE];
-  var DEFAULT_MOUSE_MODE = MOUSE_MODE_PANZOOM;
-
-  // Easing
-  var EASING_FNS = {
-    cubicIn: cubicIn,
-    cubicInOut: cubicInOut,
-    cubicOut: cubicOut,
-    linear: linear,
-    quadIn: quadIn,
-    quadInOut: quadInOut,
-    quadOut: quadOut
-  };
-  var DEFAULT_EASING = cubicInOut;
-  var CONTINUOUS = 'continuous';
-  var CATEGORICAL = 'categorical';
-  var VALUE_ZW_DATA_TYPES = [CONTINUOUS, CATEGORICAL];
-
-  // Default lasso
-  var LASSO_CLEAR_ON_DESELECT = 'deselect';
-  var LASSO_CLEAR_ON_END = 'lassoEnd';
-  var LASSO_CLEAR_EVENTS = [LASSO_CLEAR_ON_DESELECT, LASSO_CLEAR_ON_END];
-  var LASSO_BRUSH_MIN_MIN_DIST = 3;
-  var DEFAULT_LASSO_COLOR = [0, 0.666666667, 1, 1];
-  var DEFAULT_LASSO_LINE_WIDTH = 2;
-  var DEFAULT_LASSO_INITIATOR = false;
-  var DEFAULT_LASSO_MIN_DELAY = 10;
-  var DEFAULT_LASSO_MIN_DIST = 3;
-  var DEFAULT_LASSO_CLEAR_EVENT = LASSO_CLEAR_ON_END;
-  var DEFAULT_LASSO_ON_LONG_PRESS = false;
-  var DEFAULT_LASSO_LONG_PRESS_TIME = 750;
-  var DEFAULT_LASSO_LONG_PRESS_AFTER_EFFECT_TIME = 500;
-  var DEFAULT_LASSO_LONG_PRESS_EFFECT_DELAY = 100;
-  var DEFAULT_LASSO_LONG_PRESS_REVERT_EFFECT_TIME = 250;
-  var DEFAULT_LASSO_BRUSH_SIZE = 24;
-  var DEFAULT_LASSO_MODE = null;
-
-  // Key mapping
-  var KEY_ACTION_INTERSECT = 'intersect';
-  var KEY_ACTION_LASSO = 'lasso';
-  var KEY_ACTION_ROTATE = 'rotate';
-  var KEY_ACTION_MERGE = 'merge';
-  var KEY_ACTION_REMOVE = 'remove';
-  var KEY_ACTIONS = [KEY_ACTION_LASSO, KEY_ACTION_ROTATE, KEY_ACTION_INTERSECT, KEY_ACTION_MERGE, KEY_ACTION_REMOVE];
-  var KEY_ALT = 'alt';
-  var KEY_CMD = 'cmd';
-  var KEY_CTRL = 'ctrl';
-  var KEY_META = 'meta';
-  var KEY_SHIFT = 'shift';
-  var KEYS = [KEY_ALT, KEY_CMD, KEY_CTRL, KEY_META, KEY_SHIFT];
-  var DEFAULT_ACTION_KEY_MAP = _defineProperty(_defineProperty(_defineProperty(_defineProperty({}, KEY_ACTION_REMOVE, KEY_ALT), KEY_ACTION_ROTATE, KEY_ALT), KEY_ACTION_LASSO, KEY_SHIFT), KEY_ACTION_MERGE, KEY_CMD);
-
-  // Default attribute
-  var DEFAULT_DATA_ASPECT_RATIO = 1;
-  var DEFAULT_WIDTH = AUTO;
-  var DEFAULT_HEIGHT = AUTO;
-  var DEFAULT_GAMMA = 1;
-
-  // Default styles
-  var MIN_POINT_SIZE = 1;
-  var DEFAULT_POINT_SCALE_MODE = 'asinh';
-  var DEFAULT_POINT_SIZE = 6;
-  var DEFAULT_POINT_SIZE_SELECTED = 2;
-  var DEFAULT_POINT_OUTLINE_WIDTH = 2;
-  var DEFAULT_SIZE_BY = null;
-  var DEFAULT_POINT_CONNECTION_SIZE = 2;
-  var DEFAULT_POINT_CONNECTION_SIZE_ACTIVE = 2;
-  var DEFAULT_POINT_CONNECTION_SIZE_BY = null;
-  var DEFAULT_POINT_CONNECTION_OPACITY = null;
-  var DEFAULT_POINT_CONNECTION_OPACITY_BY = null;
-  var DEFAULT_POINT_CONNECTION_OPACITY_ACTIVE = 0.66;
-  var DEFAULT_OPACITY = 1;
-  var DEFAULT_OPACITY_BY = null;
-  var DEFAULT_OPACITY_BY_DENSITY_FILL = 0.15;
-  var DEFAULT_OPACITY_BY_DENSITY_DEBOUNCE_TIME = 25;
-  var DEFAULT_OPACITY_INACTIVE_MAX = 1;
-  var DEFAULT_OPACITY_INACTIVE_SCALE = 1;
-  var DEFAULT_COLOR_BY = null;
-  var DEFAULT_COLOR_NORMAL = [0.66, 0.66, 0.66, DEFAULT_OPACITY];
-  var DEFAULT_COLOR_ACTIVE = [0, 0.55, 1, 1];
-  var DEFAULT_COLOR_HOVER = [1, 1, 1, 1];
-  var DEFAULT_COLOR_BG = [0, 0, 0, 1];
-  var DEFAULT_POINT_CONNECTION_COLOR_BY = null;
-  var DEFAULT_POINT_CONNECTION_COLOR_NORMAL = [0.66, 0.66, 0.66, 0.2];
-  var DEFAULT_POINT_CONNECTION_COLOR_ACTIVE = [0, 0.55, 1, 1];
-  var DEFAULT_POINT_CONNECTION_COLOR_HOVER = [1, 1, 1, 1];
-
-  // Annotations
-  var DEFAULT_ANNOTATION_LINE_COLOR = [1, 1, 1, 0.5];
-  var DEFAULT_ANNOTATION_LINE_WIDTH = 1;
-  var DEFAULT_ANNOTATION_HVLINE_LIMIT = 1000;
-
-  // Default view
-  var DEFAULT_TARGET = [0, 0];
-  var DEFAULT_DISTANCE = 1;
-  var DEFAULT_ROTATION = 0;
-  // biome-ignore format: the array should not be formatted
-  var DEFAULT_VIEW = new Float32Array([1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1]);
-
-  // Error codes
-  var IMAGE_LOAD_ERROR = 'IMAGE_LOAD_ERROR';
-
-  // Default misc
-  var DEFAULT_BACKGROUND_IMAGE = null;
-  var DEFAULT_SHOW_RETICLE = false;
-  var DEFAULT_RETICLE_COLOR = [1, 1, 1, 0.5];
-  var DEFAULT_DESELECT_ON_DBL_CLICK = true;
-  var DEFAULT_DESELECT_ON_ESCAPE = true;
-  var DEFAULT_SHOW_POINT_CONNECTIONS = false;
-  var DEFAULT_POINT_CONNECTION_MAX_INT_POINTS_PER_SEGMENT = 100;
-  var DEFAULT_POINT_CONNECTION_INT_POINTS_TOLERANCE = 1 / 500;
-  var DEFAULT_POINT_SIZE_MOUSE_DETECTION = 'auto';
-  var DEFAULT_PERFORMANCE_MODE = false;
-  var SINGLE_CLICK_DELAY = 200;
-  var LONG_CLICK_TIME = 500;
-  var Z_NAMES = new Set(['z', 'valueZ', 'valueA', 'value1', 'category']);
-  var W_NAMES = new Set(['w', 'valueW', 'valueB', 'value2', 'value']);
-  var DEFAULT_IMAGE_LOAD_TIMEOUT = 15000;
-  var DEFAULT_SPATIAL_INDEX_USE_WORKER = undefined;
-  var DEFAULT_CAMERA_IS_FIXED = false;
-  var DEFAULT_ANTI_ALIASING = 0.5;
-  var DEFAULT_PIXEL_ALIGNED = false;
-  var DEFAULT_LASSO_TYPE = 'lasso';
-  var SKIP_DEPRECATION_VALUE_TRANSLATION = Symbol('SKIP_DEPRECATION_VALUE_TRANSLATION');
-
-  // Error messages
-  var ERROR_POINTS_NOT_DRAWN = 'Points have not been drawn';
-  var ERROR_INSTANCE_IS_DESTROYED = 'The instance was already destroyed';
-  var ERROR_IS_DRAWING = 'Ignoring draw call as the previous draw call has not yet finished. To avoid this warning `await` the draw call.';
-
   var getInTime = function getInTime(p, time, extraTime) {
     return (1 - p) * time + extraTime;
   };
@@ -3572,13 +3405,13 @@ void main() {
       _ref$longPressIndicat = _ref.longPressIndicatorParentElement,
       initialLongPressIndicatorParentElement = _ref$longPressIndicat === void 0 ? document.body : _ref$longPressIndicat,
       _ref$minDelay = _ref.minDelay,
-      initialMinDelay = _ref$minDelay === void 0 ? DEFAULT_LASSO_MIN_DELAY$1 : _ref$minDelay,
+      initialMinDelay = _ref$minDelay === void 0 ? DEFAULT_LASSO_MIN_DELAY : _ref$minDelay,
       _ref$minDist = _ref.minDist,
-      initialMinDist = _ref$minDist === void 0 ? DEFAULT_LASSO_MIN_DIST$1 : _ref$minDist,
+      initialMinDist = _ref$minDist === void 0 ? DEFAULT_LASSO_MIN_DIST : _ref$minDist,
       _ref$pointNorm = _ref.pointNorm,
       initialPointNorm = _ref$pointNorm === void 0 ? identity : _ref$pointNorm,
       _ref$type = _ref.type,
-      initialType = _ref$type === void 0 ? DEFAULT_LASSO_TYPE$1 : _ref$type,
+      initialType = _ref$type === void 0 ? DEFAULT_LASSO_TYPE : _ref$type,
       _ref$brushSize = _ref.brushSize,
       initialBrushSize = _ref$brushSize === void 0 ? DEFAULT_BRUSH_SIZE : _ref$brushSize;
     var enableInitiator = initialenableInitiator;
@@ -4177,1002 +4010,998 @@ void main() {
     return pipe(withStaticProperty('initiator', initiator), withStaticProperty('longPressIndicator', longPress), withPublicMethods(), withConstructor(_createLasso))({});
   };
 
-  /**
-   * Check if all GL extensions are supported and enabled and warn otherwise
-   * @param   {import('regl').Regl}  regl  Regl instance to be tested
-   * @param   {boolean}  silent  If `true` the function will not print `console.warn` statements
-   * @return  {boolean}  If `true` all required GL extensions are supported
-   */
-  var checkReglExtensions = function checkReglExtensions(regl, silent) {
-    if (!regl) {
-      return false;
-    }
-    return GL_EXTENSIONS.reduce(function (every, extension) {
-      if (!regl.hasExtension(extension)) {
-        if (!silent) {
-          // biome-ignore lint/suspicious/noConsole: This is a legitimately useful warning
-          console.warn("WebGL: ".concat(extension, " extension not supported. Scatterplot might not render properly"));
-        }
-        return false;
-      }
-      return every;
-    }, true);
-  };
-
-  /**
-   * Create a new Regl instance with `GL_EXTENSIONS` enables
-   * @param   {HTMLCanvasElement}  canvas  Canvas element to be rendered on
-   * @return  {import('regl').Regl}  New Regl instance
-   */
-  var createRegl = function createRegl(canvas) {
-    var gl = canvas.getContext('webgl', {
-      antialias: true,
-      preserveDrawingBuffer: true
-    });
-    var extensions = [];
+  const FRAGMENT_SHADER$1 = `
+precision highp float;
 
-    // Needed to run the tests properly as the headless-gl doesn't support all
-    // extensions, which is fine for the functional tests.
-    var _iterator = _createForOfIteratorHelper(GL_EXTENSIONS),
-      _step;
-    try {
-      for (_iterator.s(); !(_step = _iterator.n()).done;) {
-        var extension = _step.value;
-        if (gl.getExtension(extension)) {
-          extensions.push(extension);
-        } else {
-          // biome-ignore lint/suspicious/noConsole: This is a legitimately useful warning
-          console.warn("WebGL: ".concat(extension, " extension not supported. Scatterplot might not render properly"));
-        }
-      }
-    } catch (err) {
-      _iterator.e(err);
-    } finally {
-      _iterator.f();
-    }
-    return createOriginalRegl__default.default({
-      gl: gl,
-      extensions: extensions
-    });
-  };
+uniform float antiAliasing;
 
-  /**
-   * L2 distance between a pair of 2D points
-   * @param   {number}  x1  X coordinate of the first point
-   * @param   {number}  y1  Y coordinate of the first point
-   * @param   {number}  x2  X coordinate of the second point
-   * @param   {number}  y2  Y coordinate of the first point
-   * @return  {number}  L2 distance
-   */
-  var dist = function dist(x1, y1, x2, y2) {
-    return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
-  };
+varying vec4 color;
+varying float finalPointSize;
 
-  /**
-   * Get the bounding box of a set of 2D positions
-   * @param   {array}  positions2d  2D positions to be checked
-   * @return  {array}  Quadruple of form `[xMin, yMin, xMax, yMax]` defining the
-   *  bounding box
-   */
-  // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
-  var getBBox = function getBBox(positions2d) {
-    var xMin = Number.POSITIVE_INFINITY;
-    var xMax = Number.NEGATIVE_INFINITY;
-    var yMin = Number.POSITIVE_INFINITY;
-    var yMax = Number.NEGATIVE_INFINITY;
-    for (var i = 0; i < positions2d.length; i += 2) {
-      xMin = positions2d[i] < xMin ? positions2d[i] : xMin;
-      xMax = positions2d[i] > xMax ? positions2d[i] : xMax;
-      yMin = positions2d[i + 1] < yMin ? positions2d[i + 1] : yMin;
-      yMax = positions2d[i + 1] > yMax ? positions2d[i + 1] : yMax;
-    }
-    return [xMin, yMin, xMax, yMax];
-  };
+float linearstep(float edge0, float edge1, float x) {
+  return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
+}
 
-  /**
-   * Test whether a bounding box is actually specifying an area
-   * @param   {array}  bBox  The bounding box to be checked
-   * @return  {array}  `true` if the bounding box is valid
-   */
-  // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
-  var isValidBBox = function isValidBBox(_ref) {
-    var _ref2 = _slicedToArray(_ref, 4),
-      xMin = _ref2[0],
-      yMin = _ref2[1],
-      xMax = _ref2[2],
-      yMax = _ref2[3];
-    return Number.isFinite(xMin) && Number.isFinite(yMin) && Number.isFinite(xMax) && Number.isFinite(yMax) && xMax - xMin > 0 && yMax - yMin > 0;
-  };
-  var REGEX_HEX_TO_RGB = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
+void main() {
+  vec2 c = gl_PointCoord * 2.0 - 1.0;
+  float sdf = length(c) * finalPointSize;
+  float alpha = linearstep(finalPointSize + antiAliasing, finalPointSize - antiAliasing, sdf);
 
-  /**
-   * Convert a HEX-encoded color to an RGB-encoded color
-   * @param   {string}  hex  HEX-encoded color string.
-   * @param   {boolean}  isNormalize  If `true` the returned RGB values will be
-   *   normalized to `[0,1]`.
-   * @return  {array}  Triple holding the RGB values.
-   */
-  var hexToRgb = function hexToRgb(hex) {
-    var isNormalize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    return hex.replace(REGEX_HEX_TO_RGB, function (_m, r, g, b) {
-      return "#".concat(r).concat(r).concat(g).concat(g).concat(b).concat(b);
-    }).substring(1).match(/.{2}/g).map(function (x) {
-      return Number.parseInt(x, 16) / Math.pow(255, isNormalize);
-    });
-  };
-  var isConditionalArray = function isConditionalArray(a, condition) {
-    var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-      _ref3$minLength = _ref3.minLength,
-      minLength = _ref3$minLength === void 0 ? 0 : _ref3$minLength;
-    return Array.isArray(a) && a.length >= minLength && a.every(condition);
-  };
-  var isPositiveNumber = function isPositiveNumber(x) {
-    return !Number.isNaN(+x) && +x >= 0;
-  };
-  var isStrictlyPositiveNumber = function isStrictlyPositiveNumber(x) {
-    return !Number.isNaN(+x) && +x > 0;
-  };
+  gl_FragColor = vec4(color.rgb, alpha * color.a);
+}
+`;
 
-  /**
-   * Create a function to limit choices to a predefined list
-   * @param   {array}  choices  Array of acceptable choices
-   * @param   {*}  defaultOption  Default choice
-   * @return  {function}  Function limiting the choices
-   */
-  var limit = function limit(choices, defaultChoice) {
-    return function (choice) {
-      return choices.indexOf(choice) >= 0 ? choice : defaultChoice;
-    };
-  };
+  const createVertexShader = (globalState) => `
+precision highp float;
 
-  /**
-   * Promised-based image loading
-   * @param {string}  src  Remote image source, i.e., a URL
-   * @param {boolean} isCrossOrigin If `true` allow loading image from a source of another origin.
-   * @return  {Promise<HTMLImageElement>}  Promise resolving to the image once its loaded
-   */
-  var loadImage = function loadImage(src) {
-    var isCrossOrigin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_IMAGE_LOAD_TIMEOUT;
-    return new Promise(function (resolve, reject) {
-      var image = new Image();
-      if (isCrossOrigin) {
-        image.crossOrigin = 'anonymous';
-      }
-      image.src = src;
-      image.onload = function () {
-        resolve(image);
-      };
-      var rejectPromise = function rejectPromise() {
-        reject(new Error(IMAGE_LOAD_ERROR));
-      };
-      image.onerror = rejectPromise;
-      setTimeout(rejectPromise, timeout);
-    });
-  };
+uniform sampler2D colorTex;
+uniform float colorTexRes;
+uniform float colorTexEps;
+uniform sampler2D stateTex;
+uniform float stateTexRes;
+uniform float stateTexEps;
+uniform float devicePixelRatio;
+uniform sampler2D encodingTex;
+uniform float encodingTexRes;
+uniform float encodingTexEps;
+uniform float pointSizeExtra;
+uniform float pointOpacityMax;
+uniform float pointOpacityScale;
+uniform float numPoints;
+uniform float globalState;
+uniform float isColoredByZ;
+uniform float isColoredByW;
+uniform float isOpacityByZ;
+uniform float isOpacityByW;
+uniform float isOpacityByDensity;
+uniform float isSizedByZ;
+uniform float isSizedByW;
+uniform float isPixelAligned;
+uniform float colorMultiplicator;
+uniform float opacityMultiplicator;
+uniform float opacityDensity;
+uniform float sizeMultiplicator;
+uniform float numColorStates;
+uniform float pointScale;
+uniform float drawingBufferWidth;
+uniform float drawingBufferHeight;
+uniform mat4 modelViewProjection;
 
-  /**
-   * @deprecated Please use `scatterplot.createTextureFromUrl(url)`
-   *
-   * Create a Regl texture from an URL.
-   * @param   {import('regl').Regl}  regl  Regl instance used for creating the texture.
-   * @param   {string}  url  Source URL of the image.
-   * @return  {Promise<import('regl').Texture2D>}  Promise resolving to the texture object.
-   */
-  var createTextureFromUrl = function createTextureFromUrl(regl, url) {
-    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_IMAGE_LOAD_TIMEOUT;
-    return new Promise(function (resolve, reject) {
-      loadImage(url, url.indexOf(window.location.origin) !== 0 && url.indexOf('base64') === -1, timeout).then(function (image) {
-        resolve(regl.texture(image));
-      })["catch"](function (error) {
-        reject(error);
-      });
-    });
-  };
+attribute vec2 stateIndex;
 
-  /**
-   * Convert a HEX-encoded color to an RGBA-encoded color
-   * @param   {string}  hex  HEX-encoded color string.
-   * @param   {boolean}  isNormalize  If `true` the returned RGBA values will be
-   *   normalized to `[0,1]`.
-   * @return  {array}  Triple holding the RGBA values.
-   */
-  var hexToRgba = function hexToRgba(hex) {
-    var isNormalize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    return [].concat(_toConsumableArray(hexToRgb(hex, isNormalize)), [Math.pow(255, !isNormalize)]);
-  };
-  var REGEX_IS_HEX = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i;
+varying vec4 color;
+varying float finalPointSize;
 
-  /**
-   * Tests if a string is a valid HEX color encoding
-   * @param   {string}  hex  HEX-encoded color string.
-   * @return  {boolean}  If `true` the string is a valid HEX color encoding.
-   */
-  var isHex = function isHex(hex) {
-    return REGEX_IS_HEX.test(hex);
-  };
+void main() {
+  vec4 state = texture2D(stateTex, stateIndex);
 
-  /**
-   * Tests if a number is in `[0,1]`.
-   * @param   {number}  x  Number to be tested.
-   * @return  {boolean}  If `true` the number is in `[0,1]`.
-   */
-  var isNormFloat = function isNormFloat(x) {
-    return x >= 0 && x <= 1;
-  };
+  if (isPixelAligned < 0.5) {
+    gl_Position = modelViewProjection * vec4(state.x, state.y, 0.0, 1.0);
+  } else {
+    vec4 clipSpacePosition = modelViewProjection * vec4(state.x, state.y, 0.0, 1.0);
+    vec2 ndcPosition = clipSpacePosition.xy / clipSpacePosition.w;
+    vec2 pixelPos = 0.5 * (ndcPosition + 1.0) * vec2(drawingBufferWidth, drawingBufferHeight);
+    pixelPos = floor(pixelPos + 0.5); // Snap to nearest pixel
+    vec2 snappedPosition = (pixelPos / vec2(drawingBufferWidth, drawingBufferHeight)) * 2.0 - 1.0;
+    gl_Position = vec4(snappedPosition, 0.0, 1.0);
+  }
 
-  /**
-   * Tests if an array consist of normalized numbers that are in `[0,1]` only.
-   * @param   {array}  a  Array to be tested
-   * @return  {boolean}  If `true` the array contains only numbers in `[0,1]`.
-   */
-  var isNormFloatArray = function isNormFloatArray(a) {
-    return Array.isArray(a) && a.every(isNormFloat);
-  };
 
-  /**
-   * Computes the cross product to determine the orientation of three points
-   * @param   {number}  x1  X-coordinate of first point
-   * @param   {number}  y1  Y-coordinate of first point
-   * @param   {number}  x2  X-coordinate of second point
-   * @param   {number}  y2  Y-coordinate of second point
-   * @param   {number}  px  X-coordinate of test point
-   * @param   {number}  py  Y-coordinate of test point
-   * @return  {number}  Positive if counterclockwise, negative if clockwise
-   */
-  function crossProduct(x1, y1, x2, y2, px, py) {
-    return (x2 - x1) * (py - y1) - (px - x1) * (y2 - y1);
-  }
+  // Determine color index
+  float colorIndexZ =  isColoredByZ * floor(state.z * colorMultiplicator);
+  float colorIndexW =  isColoredByW * floor(state.w * colorMultiplicator);
 
-  /**
-   * Determines if a point lies within a polygon using the non-zero winding rule.
-   * This handles self-intersecting polygons and overlapping areas correctly.
-   * @param   {Array}  polygon  1D list of vertices defining the polygon [x1,y1,x2,y2,...]
-   * @param   {Array}  point    Tuple of the form [x,y] to be tested
-   * @return  {boolean} True if point lies within the polygon
-   */
-  var isPointInPolygon = function isPointInPolygon(polygon) {
-    var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [],
-      _ref5 = _slicedToArray(_ref4, 2),
-      px = _ref5[0],
-      py = _ref5[1];
-    var winding = 0;
-    for (var i = 0, j = polygon.length - 2; i < polygon.length; i += 2) {
-      var x1 = polygon[i];
-      var y1 = polygon[i + 1];
-      var x2 = polygon[j];
-      var y2 = polygon[j + 1];
-      if (y1 <= py) {
-        if (y2 > py) {
-          var orientation = crossProduct(x1, y1, x2, y2, px, py);
-          if (orientation > 0) {
-            winding++;
-          }
-        }
-      } else if (y2 <= py) {
-        var _orientation = crossProduct(x1, y1, x2, y2, px, py);
-        if (_orientation < 0) {
-          winding--;
-        }
-      }
-      j = i;
-    }
-    return winding !== 0;
-  };
+  // Multiply by the number of color states per color
+  // I.e., normal, active, hover, background, etc.
+  float colorIndex = (colorIndexZ + colorIndexW) * numColorStates;
 
-  /**
-   * Tests if a variable is a string
-   * @param   {*}  s  Variable to be tested
-   * @return  {boolean}  If `true` variable is a string
-   */
-  var isString = function isString(s) {
-    return typeof s === 'string' || s instanceof String;
-  };
+  // Half a "pixel" or "texel" in texture coordinates
+  float colorLinearIndex = colorIndex + globalState;
 
-  /**
-   * Tests if a number is an interger and in `[0,255]`.
-   * @param   {number}  x  Number to be tested.
-   * @return  {boolean}  If `true` the number is an interger and in `[0,255]`.
-   */
-  var isUint8 = function isUint8(x) {
-    return Number.isInteger(x) && x >= 0 && x <= 255;
-  };
+  // Need to add cEps here to avoid floating point issue that can lead to
+  // dramatic changes in which color is loaded as floor(3/2.9999) = 1 but
+  // floor(3/3.0001) = 0!
+  float colorRowIndex = floor((colorLinearIndex + colorTexEps) / colorTexRes);
 
-  /**
-   * Tests if an array consist of Uint8 numbers only.
-   * @param   {array}  a  Array to be tested.
-   * @return  {boolean}  If `true` the array contains only Uint8 numbers.
-   */
-  var isUint8Array = function isUint8Array(a) {
-    return Array.isArray(a) && a.every(isUint8);
-  };
+  vec2 colorTexIndex = vec2(
+    (colorLinearIndex / colorTexRes) - colorRowIndex + colorTexEps,
+    colorRowIndex / colorTexRes + colorTexEps
+  );
+
+  color = texture2D(colorTex, colorTexIndex);
+
+  // Retrieve point size
+  float pointSizeIndexZ = isSizedByZ * floor(state.z * sizeMultiplicator);
+  float pointSizeIndexW = isSizedByW * floor(state.w * sizeMultiplicator);
+  float pointSizeIndex = pointSizeIndexZ + pointSizeIndexW;
+
+  float pointSizeRowIndex = floor((pointSizeIndex + encodingTexEps) / encodingTexRes);
+  vec2 pointSizeTexIndex = vec2(
+    (pointSizeIndex / encodingTexRes) - pointSizeRowIndex + encodingTexEps,
+    pointSizeRowIndex / encodingTexRes + encodingTexEps
+  );
+  float pointSize = texture2D(encodingTex, pointSizeTexIndex).x;
+
+  // Retrieve opacity
+  ${
+    (() => {
+      // Drawing the inner border of selected points
+      if (globalState === 3) return '';
+
+      // Draw points with opacity encoding or dynamic opacity
+      return `
+        if (isOpacityByDensity < 0.5) {
+          float opacityIndexZ = isOpacityByZ * floor(state.z * opacityMultiplicator);
+          float opacityIndexW = isOpacityByW * floor(state.w * opacityMultiplicator);
+          float opacityIndex = opacityIndexZ + opacityIndexW;
+
+          float opacityRowIndex = floor((opacityIndex + encodingTexEps) / encodingTexRes);
+          vec2 opacityTexIndex = vec2(
+            (opacityIndex / encodingTexRes) - opacityRowIndex + encodingTexEps,
+            opacityRowIndex / encodingTexRes + encodingTexEps
+          );
+          color.a = texture2D(encodingTex, opacityTexIndex)[${1 + globalState}];
+        } else {
+          color.a = min(1.0, opacityDensity + globalState);
+        }
+      `;
+    })()
+  }
+
+  color.a = min(pointOpacityMax, color.a) * pointOpacityScale;
+  finalPointSize = (pointSize * pointScale) + pointSizeExtra;
+  gl_PointSize = finalPointSize;
+}
+`;
+
+  const FRAGMENT_SHADER = `precision highp float;
+
+varying vec4 color;
+
+void main() {
+  gl_FragColor = color;
+}
+`;
+
+  const SHADER$1 = `precision highp float;
+
+uniform sampler2D startStateTex;
+uniform sampler2D endStateTex;
+uniform float t;
+
+varying vec2 particleTextureIndex;
+
+void main() {
+  // Interpolate x, y, and value
+  vec3 start = texture2D(startStateTex, particleTextureIndex).xyw;
+  vec3 end = texture2D(endStateTex, particleTextureIndex).xyw;
+  vec3 curr = start * (1.0 - t) + end * t;
+
+  // The category cannot be interpolated
+  float endCategory = texture2D(endStateTex, particleTextureIndex).z;
+
+  gl_FragColor = vec4(curr.xy, endCategory, curr.z);
+}`;
+
+  const SHADER = `precision highp float;
+
+attribute vec2 position;
+varying vec2 particleTextureIndex;
+
+void main() {
+  // map normalized device coords to texture coords
+  particleTextureIndex = 0.5 * (1.0 + position);
+
+  gl_Position = vec4(position, 0, 1);
+}`;
 
   /**
-   * Tests if an array is encoding an RGB color.
-   * @param   {array}  rgb  Array to be tested
-   * @return  {boolean}  If `true` the array hold a triple of Uint8 numbers or
-   *   a triple of normalized floats.
+   * Check if all GL extensions are supported and enabled and warn otherwise
+   * @param   {import('regl').Regl}  regl  Regl instance to be tested
+   * @param   {boolean}  silent  If `true` the function will not print `console.warn` statements
+   * @return  {boolean}  If `true` all required GL extensions are supported
    */
-  var isRgb = function isRgb(rgb) {
-    return rgb.length === 3 && (isNormFloatArray(rgb) || isUint8Array(rgb));
+  var checkReglExtensions = function checkReglExtensions(regl, silent) {
+    if (!regl) {
+      return false;
+    }
+    return GL_EXTENSIONS.reduce(function (every, extension) {
+      if (!regl.hasExtension(extension)) {
+        if (!silent) {
+          // biome-ignore lint/suspicious/noConsole: This is a legitimately useful warning
+          console.warn("WebGL: ".concat(extension, " extension not supported. Scatterplot might not render properly"));
+        }
+        return false;
+      }
+      return every;
+    }, true);
   };
 
   /**
-   * Tests if an array is encoding an RGBA color.
-   * @param   {array}  rgb  Array to be tested
-   * @return  {boolean}  If `true` the array hold a quadruple of Uint8 numbers or
-   *   a quadruple of normalized floats.
+   * Create a new Regl instance with `GL_EXTENSIONS` enables
+   * @param   {HTMLCanvasElement}  canvas  Canvas element to be rendered on
+   * @return  {import('regl').Regl}  New Regl instance
    */
-  var isRgba = function isRgba(rgba) {
-    return rgba.length === 4 && (isNormFloatArray(rgba) || isUint8Array(rgba));
+  var createRegl = function createRegl(canvas) {
+    var gl = canvas.getContext('webgl', {
+      antialias: true,
+      preserveDrawingBuffer: true
+    });
+    var extensions = [];
+
+    // Needed to run the tests properly as the headless-gl doesn't support all
+    // extensions, which is fine for the functional tests.
+    var _iterator = _createForOfIteratorHelper(GL_EXTENSIONS),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var extension = _step.value;
+        if (gl.getExtension(extension)) {
+          extensions.push(extension);
+        } else {
+          // biome-ignore lint/suspicious/noConsole: This is a legitimately useful warning
+          console.warn("WebGL: ".concat(extension, " extension not supported. Scatterplot might not render properly"));
+        }
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return createOriginalRegl__default.default({
+      gl: gl,
+      extensions: extensions
+    });
   };
 
   /**
-   * Test if a color is multiple colors
-   * @param   {*}  color  To be tested
-   * @return  {boolean}  If `true`, `color` is an array of colors.
+   * L2 distance between a pair of 2D points
+   * @param   {number}  x1  X coordinate of the first point
+   * @param   {number}  y1  Y coordinate of the first point
+   * @param   {number}  x2  X coordinate of the second point
+   * @param   {number}  y2  Y coordinate of the first point
+   * @return  {number}  L2 distance
    */
-  var isMultipleColors = function isMultipleColors(color) {
-    return Array.isArray(color) && color.length > 0 && (Array.isArray(color[0]) || isString(color[0]));
+  var dist = function dist(x1, y1, x2, y2) {
+    return Math.sqrt(Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2));
   };
 
   /**
-   * Test if two arrays contain the same RGBA quadruples
+   * Get the bounding box of a set of 2D positions
+   * @param   {array}  positions2d  2D positions to be checked
+   * @return  {array}  Quadruple of form `[xMin, yMin, xMax, yMax]` defining the
+   *  bounding box
    */
-  var isSameRgbas = function isSameRgbas(a, b) {
-    if (!(Array.isArray(a) && Array.isArray(b)) || a.length !== b.length) {
-      return false;
-    }
-    if (a.length === 0) {
-      return true;
-    }
-
-    // We need to test whether a and b are arrays of RGBA quadruples
-    if (!(Array.isArray(a[0]) && Array.isArray(b[0]))) {
-      return false;
+  var getBBox = function getBBox(positions2d) {
+    var xMin = Number.POSITIVE_INFINITY;
+    var xMax = Number.NEGATIVE_INFINITY;
+    var yMin = Number.POSITIVE_INFINITY;
+    var yMax = Number.NEGATIVE_INFINITY;
+    for (var i = 0; i < positions2d.length; i += 2) {
+      xMin = positions2d[i] < xMin ? positions2d[i] : xMin;
+      xMax = positions2d[i] > xMax ? positions2d[i] : xMax;
+      yMin = positions2d[i + 1] < yMin ? positions2d[i + 1] : yMin;
+      yMax = positions2d[i + 1] > yMax ? positions2d[i + 1] : yMax;
     }
-    return a.every(function (_ref6, i) {
-      var _ref7 = _slicedToArray(_ref6, 4),
-        r1 = _ref7[0],
-        g1 = _ref7[1],
-        b1 = _ref7[2],
-        a1 = _ref7[3];
-      var _b$i = _slicedToArray(b[i], 4),
-        r2 = _b$i[0],
-        g2 = _b$i[1],
-        b2 = _b$i[2],
-        a2 = _b$i[3];
-      return r1 === r2 && g1 === g2 && b1 === b2 && a1 === a2;
-    });
+    return [xMin, yMin, xMax, yMax];
   };
 
   /**
-   * Fast version of `Math.max`. Based on
-   *   https://jsperf.com/math-min-max-vs-ternary-vs-if/24 `Math.max` is not
-   *   very fast
-   * @param   {number}  a  Value A
-   * @param   {number}  b  Value B
-   * @return  {boolean}  If `true` A is greater than B.
+   * Test whether a bounding box is actually specifying an area
+   * @param   {array}  bBox  The bounding box to be checked
+   * @return  {array}  `true` if the bounding box is valid
    */
-  var max = function max(a, b) {
-    return a > b ? a : b;
+  var isValidBBox = function isValidBBox(_ref) {
+    var _ref2 = _slicedToArray(_ref, 4),
+      xMin = _ref2[0],
+      yMin = _ref2[1],
+      xMax = _ref2[2],
+      yMax = _ref2[3];
+    return Number.isFinite(xMin) && Number.isFinite(yMin) && Number.isFinite(xMax) && Number.isFinite(yMax) && xMax - xMin > 0 && yMax - yMin > 0;
   };
+  var REGEX_HEX_TO_RGB = /^#?([a-f\d])([a-f\d])([a-f\d])$/i;
 
   /**
-   * Fast version of `Math.min`. Based on
-   *   https://jsperf.com/math-min-max-vs-ternary-vs-if/24 `Math.max` is not
-   *   very fast
-   * @param   {number}  a  Value A
-   * @param   {number}  b  Value B
-   * @return  {boolean}  If `true` A is smaller than B.
+   * Convert a HEX-encoded color to an RGB-encoded color
+   * @param   {string}  hex  HEX-encoded color string.
+   * @param   {boolean}  isNormalize  If `true` the returned RGB values will be
+   *   normalized to `[0,1]`.
+   * @return  {array}  Triple holding the RGB values.
    */
-  var min = function min(a, b) {
-    return a < b ? a : b;
+  var hexToRgb = function hexToRgb(hex) {
+    var isNormalize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return hex.replace(REGEX_HEX_TO_RGB, function (_m, r, g, b) {
+      return "#".concat(r).concat(r).concat(g).concat(g).concat(b).concat(b);
+    }).substring(1).match(/.{2}/g).map(function (x) {
+      return Number.parseInt(x, 16) / Math.pow(255, isNormalize);
+    });
+  };
+  var isConditionalArray = function isConditionalArray(a, condition) {
+    var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+      _ref3$minLength = _ref3.minLength,
+      minLength = _ref3$minLength === void 0 ? 0 : _ref3$minLength;
+    return Array.isArray(a) && a.length >= minLength && a.every(condition);
+  };
+  var isPositiveNumber = function isPositiveNumber(x) {
+    return !Number.isNaN(+x) && +x >= 0;
+  };
+  var isStrictlyPositiveNumber = function isStrictlyPositiveNumber(x) {
+    return !Number.isNaN(+x) && +x > 0;
   };
 
   /**
-   * Convert a color to an RGBA color
-   * @param   {*}  color  Color to be converted. Currently supports:
-   *   HEX, RGB, or RGBA.
-   * @param   {boolean}  isNormalize  If `true` the returned RGBA values will be
-   *   normalized to `[0,1]`.
-   * @return  {array}  Quadruple defining an RGBA color.
+   * Create a function to limit choices to a predefined list
+   * @param   {array}  choices  Array of acceptable choices
+   * @param   {*}  defaultOption  Default choice
+   * @return  {function}  Function limiting the choices
    */
-  var toRgba = function toRgba(color, shouldNormalize) {
-    if (isRgba(color)) {
-      var isNormalized = isNormFloatArray(color);
-      if (shouldNormalize && isNormalized || !(shouldNormalize || isNormalized)) {
-        return color;
-      }
-      if (shouldNormalize && !isNormalized) {
-        return color.map(function (x) {
-          return x / 255;
-        });
+  var limit = function limit(choices, defaultChoice) {
+    return function (choice) {
+      return choices.indexOf(choice) >= 0 ? choice : defaultChoice;
+    };
+  };
+
+  /**
+   * Promised-based image loading
+   * @param {string}  src  Remote image source, i.e., a URL
+   * @param {boolean} isCrossOrigin If `true` allow loading image from a source of another origin.
+   * @return  {Promise<HTMLImageElement>}  Promise resolving to the image once its loaded
+   */
+  var loadImage = function loadImage(src) {
+    var isCrossOrigin = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_IMAGE_LOAD_TIMEOUT;
+    return new Promise(function (resolve, reject) {
+      var image = new Image();
+      if (isCrossOrigin) {
+        image.crossOrigin = 'anonymous';
       }
-      return color.map(function (x) {
-        return x * 255;
+      image.src = src;
+      image.onload = function () {
+        resolve(image);
+      };
+      var rejectPromise = function rejectPromise() {
+        reject(new Error(IMAGE_LOAD_ERROR));
+      };
+      image.onerror = rejectPromise;
+      setTimeout(rejectPromise, timeout);
+    });
+  };
+
+  /**
+   * @deprecated Please use `scatterplot.createTextureFromUrl(url)`
+   *
+   * Create a Regl texture from an URL.
+   * @param   {import('regl').Regl}  regl  Regl instance used for creating the texture.
+   * @param   {string}  url  Source URL of the image.
+   * @return  {Promise<import('regl').Texture2D>}  Promise resolving to the texture object.
+   */
+  var createTextureFromUrl = function createTextureFromUrl(regl, url) {
+    var timeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DEFAULT_IMAGE_LOAD_TIMEOUT;
+    return new Promise(function (resolve, reject) {
+      loadImage(url, url.indexOf(window.location.origin) !== 0 && url.indexOf('base64') === -1, timeout).then(function (image) {
+        resolve(regl.texture(image));
+      })["catch"](function (error) {
+        reject(error);
       });
-    }
-    if (isRgb(color)) {
-      var base = Math.pow(255, !shouldNormalize);
-      var _isNormalized = isNormFloatArray(color);
-      if (shouldNormalize && _isNormalized || !(shouldNormalize || _isNormalized)) {
-        return [].concat(_toConsumableArray(color), [base]);
-      }
-      if (shouldNormalize && !_isNormalized) {
-        return [].concat(_toConsumableArray(color.map(function (x) {
-          return x / 255;
-        })), [base]);
-      }
-      return [].concat(_toConsumableArray(color.map(function (x) {
-        return x * 255;
-      })), [base]);
-    }
-    if (isHex(color)) {
-      return hexToRgba(color, shouldNormalize);
-    }
+    });
+  };
 
-    // biome-ignore lint/suspicious/noConsole: This is a legitimately useful warning
-    console.warn('Only HEX, RGB, and RGBA are handled by this function. Returning white instead.');
-    return shouldNormalize ? [1, 1, 1, 1] : [255, 255, 255, 255];
+  /**
+   * Convert a HEX-encoded color to an RGBA-encoded color
+   * @param   {string}  hex  HEX-encoded color string.
+   * @param   {boolean}  isNormalize  If `true` the returned RGBA values will be
+   *   normalized to `[0,1]`.
+   * @return  {array}  Triple holding the RGBA values.
+   */
+  var hexToRgba = function hexToRgba(hex) {
+    var isNormalize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    return [].concat(_toConsumableArray(hexToRgb(hex, isNormalize)), [Math.pow(255, !isNormalize)]);
   };
+  var REGEX_IS_HEX = /(^#[0-9A-F]{6}$)|(^#[0-9A-F]{3}$)/i;
 
   /**
-   * Flip the key-value pairs of an object
-   * @param {object} obj - Object to be flipped
-   * @return {object} Flipped object
+   * Tests if a string is a valid HEX color encoding
+   * @param   {string}  hex  HEX-encoded color string.
+   * @return  {boolean}  If `true` the string is a valid HEX color encoding.
    */
-  var flipObj = function flipObj(obj) {
-    return Object.entries(obj).reduce(function (out, _ref8) {
-      var _ref9 = _slicedToArray(_ref8, 2),
-        key = _ref9[0],
-        value = _ref9[1];
-      if (out[value]) {
-        out[value] = [].concat(_toConsumableArray(out[value]), [key]);
-      } else {
-        out[value] = key;
-      }
-      return out;
-    }, {});
+  var isHex = function isHex(hex) {
+    return REGEX_IS_HEX.test(hex);
   };
-  var rgbBrightness = function rgbBrightness(rgb) {
-    return 0.21 * rgb[0] + 0.72 * rgb[1] + 0.07 * rgb[2];
+
+  /**
+   * Tests if a number is in `[0,1]`.
+   * @param   {number}  x  Number to be tested.
+   * @return  {boolean}  If `true` the number is in `[0,1]`.
+   */
+  var isNormFloat = function isNormFloat(x) {
+    return x >= 0 && x <= 1;
   };
 
   /**
-   * Clip a number between min and max
-   * @param {number} value - The value to be clipped
-   * @param {number} minValue - The minimum value
-   * @param {number} maxValue - The maximum value
-   * @return {number} The clipped value
+   * Tests if an array consist of normalized numbers that are in `[0,1]` only.
+   * @param   {array}  a  Array to be tested
+   * @return  {boolean}  If `true` the array contains only numbers in `[0,1]`.
    */
-  var clip = function clip(value, minValue, maxValue) {
-    return Math.min(maxValue, Math.max(minValue, value));
+  var isNormFloatArray = function isNormFloatArray(a) {
+    return Array.isArray(a) && a.every(isNormFloat);
   };
 
   /**
-   * Convert object- or array-oriented points to array-oriented points
-   * @param {import('./types').Points} points - The point data
-   * @return {number[][]} Array-oriented points
+   * Computes the cross product to determine the orientation of three points
+   * @param   {number}  x1  X-coordinate of first point
+   * @param   {number}  y1  Y-coordinate of first point
+   * @param   {number}  x2  X-coordinate of second point
+   * @param   {number}  y2  Y-coordinate of second point
+   * @param   {number}  px  X-coordinate of test point
+   * @param   {number}  py  Y-coordinate of test point
+   * @return  {number}  Positive if counterclockwise, negative if clockwise
    */
-  var toArrayOrientedPoints = function toArrayOrientedPoints(points) {
-    return new Promise(function (resolve, reject) {
-      if (!points || Array.isArray(points)) {
-        resolve(points);
-      } else {
-        var length = Array.isArray(points.x) || ArrayBuffer.isView(points.x) ? points.x.length : 0;
-        var getX = (Array.isArray(points.x) || ArrayBuffer.isView(points.x)) && function (i) {
-          return points.x[i];
-        };
-        var getY = (Array.isArray(points.y) || ArrayBuffer.isView(points.y)) && function (i) {
-          return points.y[i];
-        };
-        var getL = (Array.isArray(points.line) || ArrayBuffer.isView(points.line)) && function (i) {
-          return points.line[i];
-        };
+  function crossProduct(x1, y1, x2, y2, px, py) {
+    return (x2 - x1) * (py - y1) - (px - x1) * (y2 - y1);
+  }
 
-        // biome-ignore lint/style/useNamingConvention: LO stands for line and order
-        var getLO = (Array.isArray(points.lineOrder) || ArrayBuffer.isView(points.lineOrder)) && function (i) {
-          return points.lineOrder[i];
-        };
-        var components = Object.keys(points);
-        var getZ = function () {
-          var z = components.find(function (c) {
-            return Z_NAMES.has(c);
-          });
-          return z && (Array.isArray(points[z]) || ArrayBuffer.isView(points[z])) && function (i) {
-            return points[z][i];
-          };
-        }();
-        var getW = function () {
-          var w = components.find(function (c) {
-            return W_NAMES.has(c);
-          });
-          return w && (Array.isArray(points[w]) || ArrayBuffer.isView(points[w])) && function (i) {
-            return points[w][i];
-          };
-        }();
-        if (getX && getY && getZ && getW && getL && getLO) {
-          resolve(points.x.map(function (x, i) {
-            return [x, getY(i), getZ(i), getW(i), getL(i), getLO(i)];
-          }));
-        } else if (getX && getY && getZ && getW && getL) {
-          resolve(Array.from({
-            length: length
-          }, function (_, i) {
-            return [getX(i), getY(i), getZ(i), getW(i), getL(i)];
-          }));
-        } else if (getX && getY && getZ && getW) {
-          resolve(Array.from({
-            length: length
-          }, function (_, i) {
-            return [getX(i), getY(i), getZ(i), getW(i)];
-          }));
-        } else if (getX && getY && getZ) {
-          resolve(Array.from({
-            length: length
-          }, function (_, i) {
-            return [getX(i), getY(i), getZ(i)];
-          }));
-        } else if (getX && getY) {
-          resolve(Array.from({
-            length: length
-          }, function (_, i) {
-            return [getX(i), getY(i)];
-          }));
-        } else {
-          reject(new Error('You need to specify at least x and y'));
+  /**
+   * Determines if a point lies within a polygon using the non-zero winding rule.
+   * This handles self-intersecting polygons and overlapping areas correctly.
+   * @param   {Array}  polygon  1D list of vertices defining the polygon [x1,y1,x2,y2,...]
+   * @param   {Array}  point    Tuple of the form [x,y] to be tested
+   * @return  {boolean} True if point lies within the polygon
+   */
+  var isPointInPolygon = function isPointInPolygon(polygon) {
+    var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [],
+      _ref5 = _slicedToArray(_ref4, 2),
+      px = _ref5[0],
+      py = _ref5[1];
+    var winding = 0;
+    for (var i = 0, j = polygon.length - 2; i < polygon.length; i += 2) {
+      var x1 = polygon[i];
+      var y1 = polygon[i + 1];
+      var x2 = polygon[j];
+      var y2 = polygon[j + 1];
+      if (y1 <= py) {
+        if (y2 > py) {
+          var orientation = crossProduct(x1, y1, x2, y2, px, py);
+          if (orientation > 0) {
+            winding++;
+          }
+        }
+      } else if (y2 <= py) {
+        var _orientation = crossProduct(x1, y1, x2, y2, px, py);
+        if (_orientation < 0) {
+          winding--;
         }
       }
-    });
+      j = i;
+    }
+    return winding !== 0;
   };
-  var isHorizontalLine = function isHorizontalLine(annotation) {
-    return Number.isFinite(annotation.y) && !('x' in annotation);
+
+  /**
+   * Tests if a variable is a string
+   * @param   {*}  s  Variable to be tested
+   * @return  {boolean}  If `true` variable is a string
+   */
+  var isString = function isString(s) {
+    return typeof s === 'string' || s instanceof String;
   };
-  var isVerticalLine = function isVerticalLine(annotation) {
-    return Number.isFinite(annotation.x) && !('y' in annotation);
+
+  /**
+   * Tests if a number is an interger and in `[0,255]`.
+   * @param   {number}  x  Number to be tested.
+   * @return  {boolean}  If `true` the number is an interger and in `[0,255]`.
+   */
+  var isUint8 = function isUint8(x) {
+    return Number.isInteger(x) && x >= 0 && x <= 255;
   };
-  var isDomRect = function isDomRect(annotation) {
-    return Number.isFinite(annotation.x) && Number.isFinite(annotation.y) && Number.isFinite(annotation.width) && Number.isFinite(annotation.height);
+
+  /**
+   * Tests if an array consist of Uint8 numbers only.
+   * @param   {array}  a  Array to be tested.
+   * @return  {boolean}  If `true` the array contains only Uint8 numbers.
+   */
+  var isUint8Array = function isUint8Array(a) {
+    return Array.isArray(a) && a.every(isUint8);
   };
-  var isRect = function isRect(annotation) {
-    return Number.isFinite(annotation.x1) && Number.isFinite(annotation.y1) && Number.isFinite(annotation.x2) && Number.isFinite(annotation.x2);
+
+  /**
+   * Tests if an array is encoding an RGB color.
+   * @param   {array}  rgb  Array to be tested
+   * @return  {boolean}  If `true` the array hold a triple of Uint8 numbers or
+   *   a triple of normalized floats.
+   */
+  var isRgb = function isRgb(rgb) {
+    return rgb.length === 3 && (isNormFloatArray(rgb) || isUint8Array(rgb));
   };
-  var isPolygon = function isPolygon(annotation) {
-    return 'vertices' in annotation && annotation.vertices.length > 1;
+
+  /**
+   * Tests if an array is encoding an RGBA color.
+   * @param   {array}  rgb  Array to be tested
+   * @return  {boolean}  If `true` the array hold a quadruple of Uint8 numbers or
+   *   a quadruple of normalized floats.
+   */
+  var isRgba = function isRgba(rgba) {
+    return rgba.length === 4 && (isNormFloatArray(rgba) || isUint8Array(rgba));
   };
-  var insertionSort = function insertionSort(array) {
-    var end = array.length;
-    for (var i = 1; i < end; i++) {
-      // Choosing the first element in our unsorted subarray
-      var current = array[i];
-      // The last element of our sorted subarray
-      var j = i - 1;
-      while (j > -1 && current < array[j]) {
-        array[j + 1] = array[j];
-        j--;
-      }
-      array[j + 1] = current;
-    }
-    return array;
+
+  /**
+   * Test if a color is multiple colors
+   * @param   {*}  color  To be tested
+   * @return  {boolean}  If `true`, `color` is an array of colors.
+   */
+  var isMultipleColors = function isMultipleColors(color) {
+    return Array.isArray(color) && color.length > 0 && (Array.isArray(color[0]) || isString(color[0]));
   };
 
-  var createRenderer = function createRenderer() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var regl = options.regl,
-      _options$canvas = options.canvas,
-      canvas = _options$canvas === void 0 ? document.createElement('canvas') : _options$canvas,
-      _options$gamma = options.gamma,
-      _gamma = _options$gamma === void 0 ? DEFAULT_GAMMA : _options$gamma;
-    var isDestroyed = false;
-    if (!regl) {
-      regl = createRegl(canvas);
+  /**
+   * Test if two arrays contain the same RGBA quadruples
+   */
+  var isSameRgbas = function isSameRgbas(a, b) {
+    if (!(Array.isArray(a) && Array.isArray(b)) || a.length !== b.length) {
+      return false;
+    }
+    if (a.length === 0) {
+      return true;
     }
-    var isSupportingAllGlExtensions = checkReglExtensions(regl);
-    var fboRes = [canvas.width, canvas.height];
-    var fbo = regl.framebuffer({
-      width: fboRes[0],
-      height: fboRes[1],
-      colorFormat: 'rgba',
-      colorType: 'float'
-    });
 
-    /**
-     * Render the float32 framebuffer to the internal canvas
-     *
-     * From https://observablehq.com/@rreusser/selecting-the-right-opacity-for-2d-point-clouds
-     */
-    var renderToCanvas = regl({
-      vert: "\n      precision highp float;\n      attribute vec2 xy;\n      void main () {\n        gl_Position = vec4(xy, 0, 1);\n      }",
-      frag: "\n      precision highp float;\n      uniform vec2 srcRes;\n      uniform sampler2D src;\n      uniform float gamma;\n\n      vec3 approxLinearToSRGB (vec3 rgb, float gamma) {\n        return pow(clamp(rgb, vec3(0), vec3(1)), vec3(1.0 / gamma));\n      }\n\n      void main () {\n        vec4 color = texture2D(src, gl_FragCoord.xy / srcRes);\n        gl_FragColor = vec4(approxLinearToSRGB(color.rgb, gamma), color.a);\n      }",
-      attributes: {
-        xy: [-4, -4, 4, -4, 0, 4]
-      },
-      uniforms: {
-        src: function src() {
-          return fbo;
-        },
-        srcRes: function srcRes() {
-          return fboRes;
-        },
-        gamma: function gamma() {
-          return _gamma;
-        }
-      },
-      count: 3,
-      depth: {
-        enable: false
-      },
-      blend: {
-        enable: true,
-        func: {
-          // biome-ignore lint/style/useNamingConvention: Regl internal
-          srcRGB: 'one',
-          srcAlpha: 'one',
-          // biome-ignore lint/style/useNamingConvention: Regl internal
-          dstRGB: 'one minus src alpha',
-          dstAlpha: 'one minus src alpha'
-        }
-      }
+    // We need to test whether a and b are arrays of RGBA quadruples
+    if (!(Array.isArray(a[0]) && Array.isArray(b[0]))) {
+      return false;
+    }
+    return a.every(function (_ref6, i) {
+      var _ref7 = _slicedToArray(_ref6, 4),
+        r1 = _ref7[0],
+        g1 = _ref7[1],
+        b1 = _ref7[2],
+        a1 = _ref7[3];
+      var _b$i = _slicedToArray(b[i], 4),
+        r2 = _b$i[0],
+        g2 = _b$i[1],
+        b2 = _b$i[2],
+        a2 = _b$i[3];
+      return r1 === r2 && g1 === g2 && b1 === b2 && a1 === a2;
     });
+  };
 
-    /**
-     * Copy the pixels from the internal canvas onto the target canvas
-     */
-    var copyTo = function copyTo(targetCanvas) {
-      var ctx = targetCanvas.getContext('2d');
-      ctx.clearRect(0, 0, targetCanvas.width, targetCanvas.height);
-      ctx.drawImage(canvas, (canvas.width - targetCanvas.width) / 2, (canvas.height - targetCanvas.height) / 2, targetCanvas.width, targetCanvas.height, 0, 0, targetCanvas.width, targetCanvas.height);
-    };
+  /**
+   * Fast version of `Math.max`. Based on
+   *   https://jsperf.com/math-min-max-vs-ternary-vs-if/24 `Math.max` is not
+   *   very fast
+   * @param   {number}  a  Value A
+   * @param   {number}  b  Value B
+   * @return  {boolean}  If `true` A is greater than B.
+   */
+  var max = function max(a, b) {
+    return a > b ? a : b;
+  };
 
-    /**
-     * The render function
-     */
-    var render = function render(/** @type {(): void} */draw, /** @type {HTMLCanvasElement} */targetCanvas) {
-      // Clear internal canvas
-      regl.clear(CLEAR_OPTIONS);
-      fbo.use(function () {
-        // Clear framebuffer
-        regl.clear(CLEAR_OPTIONS);
-        draw();
+  /**
+   * Fast version of `Math.min`. Based on
+   *   https://jsperf.com/math-min-max-vs-ternary-vs-if/24 `Math.max` is not
+   *   very fast
+   * @param   {number}  a  Value A
+   * @param   {number}  b  Value B
+   * @return  {boolean}  If `true` A is smaller than B.
+   */
+  var min = function min(a, b) {
+    return a < b ? a : b;
+  };
+
+  /**
+   * Convert a color to an RGBA color
+   * @param   {*}  color  Color to be converted. Currently supports:
+   *   HEX, RGB, or RGBA.
+   * @param   {boolean}  isNormalize  If `true` the returned RGBA values will be
+   *   normalized to `[0,1]`.
+   * @return  {array}  Quadruple defining an RGBA color.
+   */
+  var toRgba = function toRgba(color, shouldNormalize) {
+    if (isRgba(color)) {
+      var isNormalized = isNormFloatArray(color);
+      if (shouldNormalize && isNormalized || !(shouldNormalize || isNormalized)) {
+        return color;
+      }
+      if (shouldNormalize && !isNormalized) {
+        return color.map(function (x) {
+          return x / 255;
+        });
+      }
+      return color.map(function (x) {
+        return x * 255;
       });
-      renderToCanvas();
-      copyTo(targetCanvas);
-    };
+    }
+    if (isRgb(color)) {
+      var base = Math.pow(255, !shouldNormalize);
+      var _isNormalized = isNormFloatArray(color);
+      if (shouldNormalize && _isNormalized || !(shouldNormalize || _isNormalized)) {
+        return [].concat(_toConsumableArray(color), [base]);
+      }
+      if (shouldNormalize && !_isNormalized) {
+        return [].concat(_toConsumableArray(color.map(function (x) {
+          return x / 255;
+        })), [base]);
+      }
+      return [].concat(_toConsumableArray(color.map(function (x) {
+        return x * 255;
+      })), [base]);
+    }
+    if (isHex(color)) {
+      return hexToRgba(color, shouldNormalize);
+    }
 
-    /**
-     * Update Regl's viewport, drawingBufferWidth, and drawingBufferHeight
-     *
-     * @description Call this method after the viewport has changed, e.g., width
-     * or height have been altered
-     */
-    var refresh = function refresh() {
-      regl.poll();
-    };
-    var drawFns = new Set();
+    // biome-ignore lint/suspicious/noConsole: This is a legitimately useful warning
+    console.warn('Only HEX, RGB, and RGBA are handled by this function. Returning white instead.');
+    return shouldNormalize ? [1, 1, 1, 1] : [255, 255, 255, 255];
+  };
 
-    /**
-     * Register an draw function that is going to be invoked on every animation
-     * frame.
-     */
-    var onFrame = function onFrame(/** @type {(): void} */draw) {
-      drawFns.add(draw);
-      return function () {
-        drawFns["delete"](draw);
-      };
-    };
-    var frame = regl.frame(function () {
-      var iterator = drawFns.values();
-      var result = iterator.next();
-      while (!result.done) {
-        result.value(); // The draw function
-        result = iterator.next();
+  /**
+   * Flip the key-value pairs of an object
+   * @param {object} obj - Object to be flipped
+   * @return {object} Flipped object
+   */
+  var flipObj = function flipObj(obj) {
+    return Object.entries(obj).reduce(function (out, _ref8) {
+      var _ref9 = _slicedToArray(_ref8, 2),
+        key = _ref9[0],
+        value = _ref9[1];
+      if (out[value]) {
+        out[value] = [].concat(_toConsumableArray(out[value]), [key]);
+      } else {
+        out[value] = key;
+      }
+      return out;
+    }, {});
+  };
+  var rgbBrightness = function rgbBrightness(rgb) {
+    return 0.21 * rgb[0] + 0.72 * rgb[1] + 0.07 * rgb[2];
+  };
+
+  /**
+   * Clip a number between min and max
+   * @param {number} value - The value to be clipped
+   * @param {number} minValue - The minimum value
+   * @param {number} maxValue - The maximum value
+   * @return {number} The clipped value
+   */
+  var clip = function clip(value, minValue, maxValue) {
+    return Math.min(maxValue, Math.max(minValue, value));
+  };
+
+  /**
+   * Convert object- or array-oriented points to array-oriented points
+   * @param {import('./types').Points} points - The point data
+   * @return {number[][]} Array-oriented points
+   */
+  var toArrayOrientedPoints = function toArrayOrientedPoints(points) {
+    return new Promise(function (resolve, reject) {
+      if (!points || Array.isArray(points)) {
+        resolve(points);
+      } else {
+        var length = Array.isArray(points.x) || ArrayBuffer.isView(points.x) ? points.x.length : 0;
+        var getX = (Array.isArray(points.x) || ArrayBuffer.isView(points.x)) && function (i) {
+          return points.x[i];
+        };
+        var getY = (Array.isArray(points.y) || ArrayBuffer.isView(points.y)) && function (i) {
+          return points.y[i];
+        };
+        var getL = (Array.isArray(points.line) || ArrayBuffer.isView(points.line)) && function (i) {
+          return points.line[i];
+        };
+        var getLO = (Array.isArray(points.lineOrder) || ArrayBuffer.isView(points.lineOrder)) && function (i) {
+          return points.lineOrder[i];
+        };
+        var components = Object.keys(points);
+        var getZ = function () {
+          var z = components.find(function (c) {
+            return Z_NAMES.has(c);
+          });
+          return z && (Array.isArray(points[z]) || ArrayBuffer.isView(points[z])) && function (i) {
+            return points[z][i];
+          };
+        }();
+        var getW = function () {
+          var w = components.find(function (c) {
+            return W_NAMES.has(c);
+          });
+          return w && (Array.isArray(points[w]) || ArrayBuffer.isView(points[w])) && function (i) {
+            return points[w][i];
+          };
+        }();
+        if (getX && getY && getZ && getW && getL && getLO) {
+          resolve(points.x.map(function (x, i) {
+            return [x, getY(i), getZ(i), getW(i), getL(i), getLO(i)];
+          }));
+        } else if (getX && getY && getZ && getW && getL) {
+          resolve(Array.from({
+            length: length
+          }, function (_, i) {
+            return [getX(i), getY(i), getZ(i), getW(i), getL(i)];
+          }));
+        } else if (getX && getY && getZ && getW) {
+          resolve(Array.from({
+            length: length
+          }, function (_, i) {
+            return [getX(i), getY(i), getZ(i), getW(i)];
+          }));
+        } else if (getX && getY && getZ) {
+          resolve(Array.from({
+            length: length
+          }, function (_, i) {
+            return [getX(i), getY(i), getZ(i)];
+          }));
+        } else if (getX && getY) {
+          resolve(Array.from({
+            length: length
+          }, function (_, i) {
+            return [getX(i), getY(i)];
+          }));
+        } else {
+          reject(new Error('You need to specify at least x and y'));
+        }
       }
     });
-    var resize = function resize(/** @type {number} */customWidth, /** @type {number} */customHeight) {
-      // We need to limit the width and height by the screen size to prevent
-      // a bug in VSCode where the window height is said to be taller than the
-      // screen height. The problem with too large dimensions is that at some
-      // point WebGL will break down because there's an upper limit on how large
-      // any buffer and texture can be. It also harms the performance quite a bit.
-      //
-      // By restricting the widht/height to the screen size we should have a safe
-      // upper limit for the canvas size.
-      //
-      // @see
-      // https://github.com/microsoft/vscode/issues/225808
-      // https://github.com/flekschas/jupyter-scatter/issues/37
-      var width = customWidth === undefined ? Math.min(window.innerWidth, window.screen.availWidth) : customWidth;
-      var height = customHeight === undefined ? Math.min(window.innerHeight, window.screen.availHeight) : customHeight;
-      canvas.width = width * window.devicePixelRatio;
-      canvas.height = height * window.devicePixelRatio;
-      fboRes[0] = canvas.width;
-      fboRes[1] = canvas.height;
-      fbo.resize.apply(fbo, fboRes);
-    };
-    var resizeHandler = function resizeHandler() {
-      resize();
-    };
-    if (!options.canvas) {
-      window.addEventListener('resize', resizeHandler);
-      window.addEventListener('orientationchange', resizeHandler);
-      resize();
+  };
+  var isHorizontalLine = function isHorizontalLine(annotation) {
+    return Number.isFinite(annotation.y) && !('x' in annotation);
+  };
+  var isVerticalLine = function isVerticalLine(annotation) {
+    return Number.isFinite(annotation.x) && !('y' in annotation);
+  };
+  var isDomRect = function isDomRect(annotation) {
+    return Number.isFinite(annotation.x) && Number.isFinite(annotation.y) && Number.isFinite(annotation.width) && Number.isFinite(annotation.height);
+  };
+  var isRect = function isRect(annotation) {
+    return Number.isFinite(annotation.x1) && Number.isFinite(annotation.y1) && Number.isFinite(annotation.x2) && Number.isFinite(annotation.x2);
+  };
+  var isPolygonAnnotation = function isPolygonAnnotation(annotation) {
+    return 'vertices' in annotation && annotation.vertices.length > 1;
+  };
+
+  /**
+   * Check if an array is a valid list of 2D vertices
+   * @param {any} arg - The argument to check
+   * @returns {boolean} True if argument is an array of [x, y] coordinate pairs
+   */
+  var isVertices = function isVertices(arg) {
+    if (!Array.isArray(arg) || arg.length < 3) {
+      return false;
+    }
+    var _iterator2 = _createForOfIteratorHelper(arg),
+      _step2;
+    try {
+      for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+        var vertex = _step2.value;
+        if (!Array.isArray(vertex) || vertex.length !== 2 || typeof vertex[0] !== 'number' || typeof vertex[1] !== 'number') {
+          return false;
+        }
+      }
+    } catch (err) {
+      _iterator2.e(err);
+    } finally {
+      _iterator2.f();
+    }
+    return true;
+  };
+
+  /**
+   * Ensure a list of vertices forms a closed polygon
+   * @param {Array<[number, number]>} vertices - Array of [x, y] coordinates
+   * @returns {Array<[number, number]>} Closed polygon (first vertex repeated at end if needed)
+   */
+  var verticesToPolygon = function verticesToPolygon(vertices) {
+    var polygon = _toConsumableArray(vertices);
+    var firstVertex = vertices.at(0);
+    var lastVertex = vertices.at(-1);
+    if (firstVertex[0] !== lastVertex[0] || firstVertex[1] !== lastVertex[1]) {
+      polygon.push(firstVertex);
+    }
+    return polygon;
+  };
+  var insertionSort = function insertionSort(array) {
+    var end = array.length;
+    for (var i = 1; i < end; i++) {
+      // Choosing the first element in our unsorted subarray
+      var current = array[i];
+      // The last element of our sorted subarray
+      var j = i - 1;
+      while (j > -1 && current < array[j]) {
+        array[j + 1] = array[j];
+        j--;
+      }
+      array[j + 1] = current;
+    }
+    return array;
+  };
+
+  var createRenderer = function createRenderer() {
+    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var regl = options.regl,
+      _options$canvas = options.canvas,
+      canvas = _options$canvas === void 0 ? document.createElement('canvas') : _options$canvas,
+      _options$gamma = options.gamma,
+      _gamma = _options$gamma === void 0 ? DEFAULT_GAMMA : _options$gamma;
+    var isDestroyed = false;
+    if (!regl) {
+      regl = createRegl(canvas);
     }
+    var isSupportingAllGlExtensions = checkReglExtensions(regl);
+    var fboRes = [canvas.width, canvas.height];
+    var fbo = regl.framebuffer({
+      width: fboRes[0],
+      height: fboRes[1],
+      colorFormat: 'rgba',
+      colorType: 'float'
+    });
 
     /**
-     * Destroy the renderer to free resources and cancel animation frames
+     * Render the float32 framebuffer to the internal canvas
+     *
+     * From https://observablehq.com/@rreusser/selecting-the-right-opacity-for-2d-point-clouds
      */
-    var destroy = function destroy() {
-      isDestroyed = true;
-      window.removeEventListener('resize', resizeHandler);
-      window.removeEventListener('orientationchange', resizeHandler);
-      frame.cancel();
-      canvas = undefined;
-      regl.destroy();
-      regl = undefined;
-    };
-    return {
-      /**
-       * Get the associated canvas element
-       * @return {HTMLCanvasElement} The associated canvas element
-       */
-      get canvas() {
-        return canvas;
-      },
-      /**
-       * Get the associated Regl instance
-       * @return {import('regl').Regl} The associated Regl instance
-       */
-      get regl() {
-        return regl;
-      },
-      /**
-       * Get the gamma value
-       * @return {number} The gamma value
-       */
-      get gamma() {
-        return _gamma;
-      },
-      /**
-       * Set gamma to a new value
-       * @param {number} newGamma - The new gamma value
-       */
-      set gamma(newGamma) {
-        _gamma = +newGamma;
+    var renderToCanvas = regl({
+      vert: "\n      precision highp float;\n      attribute vec2 xy;\n      void main () {\n        gl_Position = vec4(xy, 0, 1);\n      }",
+      frag: "\n      precision highp float;\n      uniform vec2 srcRes;\n      uniform sampler2D src;\n      uniform float gamma;\n\n      vec3 approxLinearToSRGB (vec3 rgb, float gamma) {\n        return pow(clamp(rgb, vec3(0), vec3(1)), vec3(1.0 / gamma));\n      }\n\n      void main () {\n        vec4 color = texture2D(src, gl_FragCoord.xy / srcRes);\n        gl_FragColor = vec4(approxLinearToSRGB(color.rgb, gamma), color.a);\n      }",
+      attributes: {
+        xy: [-4, -4, 4, -4, 0, 4]
       },
-      /**
-       * Get whether the browser supports all necessary WebGL features
-       * @return {boolean} If `true` the browser supports all necessary WebGL features
-       */
-      get isSupported() {
-        return isSupportingAllGlExtensions;
+      uniforms: {
+        src: function src() {
+          return fbo;
+        },
+        srcRes: function srcRes() {
+          return fboRes;
+        },
+        gamma: function gamma() {
+          return _gamma;
+        }
       },
-      /**
-       * Get whether the renderer (and its Regl instance) is destroyed
-       * @return {boolean} If `true` the renderer is destroyed
-       */
-      get isDestroyed() {
-        return isDestroyed;
+      count: 3,
+      depth: {
+        enable: false
       },
-      render: render,
-      resize: resize,
-      onFrame: onFrame,
-      refresh: refresh,
-      destroy: destroy
-    };
-  };
-
-  const FRAGMENT_SHADER$2 = `
-precision mediump float;
-
-uniform sampler2D texture;
-
-varying vec2 uv;
-
-void main () {
-  gl_FragColor = texture2D(texture, uv);
-}
-`;
-
-  const VERTEX_SHADER = `
-precision mediump float;
-
-uniform mat4 modelViewProjection;
-
-attribute vec2 position;
-
-varying vec2 uv;
-
-void main () {
-  uv = position;
-  gl_Position = modelViewProjection * vec4(-1.0 + 2.0 * uv.x, 1.0 - 2.0 * uv.y, 0, 1);
-}
-`;
-
-  const FRAGMENT_SHADER$1 = `precision highp float;
-
-varying vec4 color;
-
-void main() {
-  gl_FragColor = color;
-}
-`;
-
-  const SHADER$1 = `precision highp float;
-
-uniform sampler2D startStateTex;
-uniform sampler2D endStateTex;
-uniform float t;
-
-varying vec2 particleTextureIndex;
-
-void main() {
-  // Interpolate x, y, and value
-  vec3 start = texture2D(startStateTex, particleTextureIndex).xyw;
-  vec3 end = texture2D(endStateTex, particleTextureIndex).xyw;
-  vec3 curr = start * (1.0 - t) + end * t;
-
-  // The category cannot be interpolated
-  float endCategory = texture2D(endStateTex, particleTextureIndex).z;
-
-  gl_FragColor = vec4(curr.xy, endCategory, curr.z);
-}`;
-
-  const SHADER = `precision highp float;
-
-attribute vec2 position;
-varying vec2 particleTextureIndex;
-
-void main() {
-  // map normalized device coords to texture coords
-  particleTextureIndex = 0.5 * (1.0 + position);
-
-  gl_Position = vec4(position, 0, 1);
-}`;
-
-  const FRAGMENT_SHADER = `
-precision highp float;
-
-uniform float antiAliasing;
-
-varying vec4 color;
-varying float finalPointSize;
-
-float linearstep(float edge0, float edge1, float x) {
-  return clamp((x - edge0) / (edge1 - edge0), 0.0, 1.0);
-}
-
-void main() {
-  vec2 c = gl_PointCoord * 2.0 - 1.0;
-  float sdf = length(c) * finalPointSize;
-  float alpha = linearstep(finalPointSize + antiAliasing, finalPointSize - antiAliasing, sdf);
-
-  gl_FragColor = vec4(color.rgb, alpha * color.a);
-}
-`;
-
-  const createVertexShader = (globalState) => `
-precision highp float;
-
-uniform sampler2D colorTex;
-uniform float colorTexRes;
-uniform float colorTexEps;
-uniform sampler2D stateTex;
-uniform float stateTexRes;
-uniform float stateTexEps;
-uniform float devicePixelRatio;
-uniform sampler2D encodingTex;
-uniform float encodingTexRes;
-uniform float encodingTexEps;
-uniform float pointSizeExtra;
-uniform float pointOpacityMax;
-uniform float pointOpacityScale;
-uniform float numPoints;
-uniform float globalState;
-uniform float isColoredByZ;
-uniform float isColoredByW;
-uniform float isOpacityByZ;
-uniform float isOpacityByW;
-uniform float isOpacityByDensity;
-uniform float isSizedByZ;
-uniform float isSizedByW;
-uniform float isPixelAligned;
-uniform float colorMultiplicator;
-uniform float opacityMultiplicator;
-uniform float opacityDensity;
-uniform float sizeMultiplicator;
-uniform float numColorStates;
-uniform float pointScale;
-uniform float drawingBufferWidth;
-uniform float drawingBufferHeight;
-uniform mat4 modelViewProjection;
-
-attribute vec2 stateIndex;
-
-varying vec4 color;
-varying float finalPointSize;
-
-void main() {
-  vec4 state = texture2D(stateTex, stateIndex);
-
-  if (isPixelAligned < 0.5) {
-    gl_Position = modelViewProjection * vec4(state.x, state.y, 0.0, 1.0);
-  } else {
-    vec4 clipSpacePosition = modelViewProjection * vec4(state.x, state.y, 0.0, 1.0);
-    vec2 ndcPosition = clipSpacePosition.xy / clipSpacePosition.w;
-    vec2 pixelPos = 0.5 * (ndcPosition + 1.0) * vec2(drawingBufferWidth, drawingBufferHeight);
-    pixelPos = floor(pixelPos + 0.5); // Snap to nearest pixel
-    vec2 snappedPosition = (pixelPos / vec2(drawingBufferWidth, drawingBufferHeight)) * 2.0 - 1.0;
-    gl_Position = vec4(snappedPosition, 0.0, 1.0);
-  }
-
-
-  // Determine color index
-  float colorIndexZ =  isColoredByZ * floor(state.z * colorMultiplicator);
-  float colorIndexW =  isColoredByW * floor(state.w * colorMultiplicator);
-
-  // Multiply by the number of color states per color
-  // I.e., normal, active, hover, background, etc.
-  float colorIndex = (colorIndexZ + colorIndexW) * numColorStates;
-
-  // Half a "pixel" or "texel" in texture coordinates
-  float colorLinearIndex = colorIndex + globalState;
-
-  // Need to add cEps here to avoid floating point issue that can lead to
-  // dramatic changes in which color is loaded as floor(3/2.9999) = 1 but
-  // floor(3/3.0001) = 0!
-  float colorRowIndex = floor((colorLinearIndex + colorTexEps) / colorTexRes);
-
-  vec2 colorTexIndex = vec2(
-    (colorLinearIndex / colorTexRes) - colorRowIndex + colorTexEps,
-    colorRowIndex / colorTexRes + colorTexEps
-  );
-
-  color = texture2D(colorTex, colorTexIndex);
-
-  // Retrieve point size
-  float pointSizeIndexZ = isSizedByZ * floor(state.z * sizeMultiplicator);
-  float pointSizeIndexW = isSizedByW * floor(state.w * sizeMultiplicator);
-  float pointSizeIndex = pointSizeIndexZ + pointSizeIndexW;
+      blend: {
+        enable: true,
+        func: {
+          srcRGB: 'one',
+          srcAlpha: 'one',
+          dstRGB: 'one minus src alpha',
+          dstAlpha: 'one minus src alpha'
+        }
+      }
+    });
 
-  float pointSizeRowIndex = floor((pointSizeIndex + encodingTexEps) / encodingTexRes);
-  vec2 pointSizeTexIndex = vec2(
-    (pointSizeIndex / encodingTexRes) - pointSizeRowIndex + encodingTexEps,
-    pointSizeRowIndex / encodingTexRes + encodingTexEps
-  );
-  float pointSize = texture2D(encodingTex, pointSizeTexIndex).x;
+    /**
+     * Copy the pixels from the internal canvas onto the target canvas
+     */
+    var copyTo = function copyTo(targetCanvas) {
+      var ctx = targetCanvas.getContext('2d');
+      ctx.clearRect(0, 0, targetCanvas.width, targetCanvas.height);
+      ctx.drawImage(canvas, (canvas.width - targetCanvas.width) / 2, (canvas.height - targetCanvas.height) / 2, targetCanvas.width, targetCanvas.height, 0, 0, targetCanvas.width, targetCanvas.height);
+    };
 
-  // Retrieve opacity
-  ${
-    (() => {
-      // Drawing the inner border of selected points
-      if (globalState === 3) return '';
+    /**
+     * The render function
+     */
+    var render = function render(/** @type {(): void} */draw, /** @type {HTMLCanvasElement} */targetCanvas) {
+      // Clear internal canvas
+      regl.clear(CLEAR_OPTIONS);
+      fbo.use(function () {
+        // Clear framebuffer
+        regl.clear(CLEAR_OPTIONS);
+        draw();
+      });
+      renderToCanvas();
+      copyTo(targetCanvas);
+    };
 
-      // Draw points with opacity encoding or dynamic opacity
-      return `
-        if (isOpacityByDensity < 0.5) {
-          float opacityIndexZ = isOpacityByZ * floor(state.z * opacityMultiplicator);
-          float opacityIndexW = isOpacityByW * floor(state.w * opacityMultiplicator);
-          float opacityIndex = opacityIndexZ + opacityIndexW;
+    /**
+     * Update Regl's viewport, drawingBufferWidth, and drawingBufferHeight
+     *
+     * @description Call this method after the viewport has changed, e.g., width
+     * or height have been altered
+     */
+    var refresh = function refresh() {
+      regl.poll();
+    };
+    var drawFns = new Set();
 
-          float opacityRowIndex = floor((opacityIndex + encodingTexEps) / encodingTexRes);
-          vec2 opacityTexIndex = vec2(
-            (opacityIndex / encodingTexRes) - opacityRowIndex + encodingTexEps,
-            opacityRowIndex / encodingTexRes + encodingTexEps
-          );
-          color.a = texture2D(encodingTex, opacityTexIndex)[${1 + globalState}];
-        } else {
-          color.a = min(1.0, opacityDensity + globalState);
-        }
-      `;
-    })()
-  }
+    /**
+     * Register an draw function that is going to be invoked on every animation
+     * frame.
+     */
+    var onFrame = function onFrame(/** @type {(): void} */draw) {
+      drawFns.add(draw);
+      return function () {
+        drawFns["delete"](draw);
+      };
+    };
+    var frame = regl.frame(function () {
+      var iterator = drawFns.values();
+      var result = iterator.next();
+      while (!result.done) {
+        result.value(); // The draw function
+        result = iterator.next();
+      }
+    });
+    var resize = function resize(/** @type {number} */customWidth, /** @type {number} */customHeight) {
+      var width = customWidth == null ? window.innerWidth : customWidth;
+      var height = customHeight == null ? window.innerHeight : customHeight;
+      canvas.width = width * window.devicePixelRatio;
+      canvas.height = height * window.devicePixelRatio;
+      fboRes[0] = canvas.width;
+      fboRes[1] = canvas.height;
+      fbo.resize.apply(fbo, fboRes);
+    };
+    var resizeHandler = function resizeHandler() {
+      resize();
+    };
+    if (!options.canvas) {
+      window.addEventListener('resize', resizeHandler);
+      window.addEventListener('orientationchange', resizeHandler);
+      resize();
+    }
 
-  color.a = min(pointOpacityMax, color.a) * pointOpacityScale;
-  finalPointSize = (pointSize * pointScale) + pointSizeExtra;
-  gl_PointSize = finalPointSize;
-}
-`;
+    /**
+     * Destroy the renderer to free resources and cancel animation frames
+     */
+    var destroy = function destroy() {
+      isDestroyed = true;
+      window.removeEventListener('resize', resizeHandler);
+      window.removeEventListener('orientationchange', resizeHandler);
+      frame.cancel();
+      canvas = undefined;
+      regl.destroy();
+      regl = undefined;
+    };
+    return {
+      /**
+       * Get the associated canvas element
+       * @return {HTMLCanvasElement} The associated canvas element
+       */
+      get canvas() {
+        return canvas;
+      },
+      /**
+       * Get the associated Regl instance
+       * @return {import('regl').Regl} The associated Regl instance
+       */
+      get regl() {
+        return regl;
+      },
+      /**
+       * Get the gamma value
+       * @return {number} The gamma value
+       */
+      get gamma() {
+        return _gamma;
+      },
+      /**
+       * Set gamma to a new value
+       * @param {number} newGamma - The new gamma value
+       */
+      set gamma(newGamma) {
+        _gamma = +newGamma;
+      },
+      /**
+       * Get whether the browser supports all necessary WebGL features
+       * @return {boolean} If `true` the browser supports all necessary WebGL features
+       */
+      get isSupported() {
+        return isSupportingAllGlExtensions;
+      },
+      /**
+       * Get whether the renderer (and its Regl instance) is destroyed
+       * @return {boolean} If `true` the renderer is destroyed
+       */
+      get isDestroyed() {
+        return isDestroyed;
+      },
+      render: render,
+      resize: resize,
+      onFrame: onFrame,
+      refresh: refresh,
+      destroy: destroy
+    };
+  };
 
   /* eslint-env worker */
   /* eslint no-restricted-globals: 1 */
@@ -5268,7 +5097,6 @@ void main() {
      * @param   {[type]}  simplified  [description]
      * @return  {[type]}  [description]
      */
-    // biome-ignore lint/style/useNamingConvention: DP stands for Douglas Peucker
     var _simplifyDPStep = function simplifyDPStep(points, first, last, tolerance, simplified) {
       var maxDist = tolerance;
       var index;
@@ -5363,7 +5191,6 @@ void main() {
     var groupPoints = function groupPoints(points) {
       var groupedPoints = {};
       var isOrdered = !Number.isNaN(+points[0][5]);
-      // biome-ignore lint/complexity/noForEach: somehow for .. of does not work in a worker
       points.forEach(function (point) {
         var segId = point[4];
         if (!groupedPoints[segId]) {
@@ -5377,7 +5204,6 @@ void main() {
       });
 
       // The filtering ensures that non-existing array entries are removed
-      // biome-ignore lint/complexity/noForEach: somehow for .. of does not work in a worker
       Object.entries(groupedPoints).forEach(function (idPoints) {
         groupedPoints[idPoints[0]] = idPoints[1].filter(function (v) {
           return v;
@@ -5429,8 +5255,6 @@ void main() {
     });
   };
 
-  var version = "1.14.1+1.0.1";
-
   var deprecations = {
     showRecticle: {
       replacement: 'showReticle',
@@ -5544,9 +5368,9 @@ void main() {
       _initialProperties$la2 = initialProperties.lassoLineWidth,
       lassoLineWidth = _initialProperties$la2 === void 0 ? DEFAULT_LASSO_LINE_WIDTH : _initialProperties$la2,
       _initialProperties$la3 = initialProperties.lassoMinDelay,
-      lassoMinDelay = _initialProperties$la3 === void 0 ? DEFAULT_LASSO_MIN_DELAY : _initialProperties$la3,
+      lassoMinDelay = _initialProperties$la3 === void 0 ? DEFAULT_LASSO_MIN_DELAY$1 : _initialProperties$la3,
       _initialProperties$la4 = initialProperties.lassoMinDist,
-      lassoMinDist = _initialProperties$la4 === void 0 ? DEFAULT_LASSO_MIN_DIST : _initialProperties$la4,
+      lassoMinDist = _initialProperties$la4 === void 0 ? DEFAULT_LASSO_MIN_DIST$1 : _initialProperties$la4,
       _initialProperties$la5 = initialProperties.lassoMode,
       lassoMode = _initialProperties$la5 === void 0 ? DEFAULT_LASSO_MODE : _initialProperties$la5,
       _initialProperties$la6 = initialProperties.lassoClearEvent,
@@ -5557,20 +5381,20 @@ void main() {
       lassoInitiatorParentElement = _initialProperties$la8 === void 0 ? document.body : _initialProperties$la8,
       _initialProperties$la9 = initialProperties.lassoLongPressIndicatorParentElement,
       lassoLongPressIndicatorParentElement = _initialProperties$la9 === void 0 ? document.body : _initialProperties$la9,
-      _initialProperties$la10 = initialProperties.lassoOnLongPress,
-      lassoOnLongPress = _initialProperties$la10 === void 0 ? DEFAULT_LASSO_ON_LONG_PRESS : _initialProperties$la10,
-      _initialProperties$la11 = initialProperties.lassoLongPressTime,
-      lassoLongPressTime = _initialProperties$la11 === void 0 ? DEFAULT_LASSO_LONG_PRESS_TIME : _initialProperties$la11,
-      _initialProperties$la12 = initialProperties.lassoLongPressAfterEffectTime,
-      lassoLongPressAfterEffectTime = _initialProperties$la12 === void 0 ? DEFAULT_LASSO_LONG_PRESS_AFTER_EFFECT_TIME : _initialProperties$la12,
-      _initialProperties$la13 = initialProperties.lassoLongPressEffectDelay,
-      lassoLongPressEffectDelay = _initialProperties$la13 === void 0 ? DEFAULT_LASSO_LONG_PRESS_EFFECT_DELAY : _initialProperties$la13,
-      _initialProperties$la14 = initialProperties.lassoLongPressRevertEffectTime,
-      lassoLongPressRevertEffectTime = _initialProperties$la14 === void 0 ? DEFAULT_LASSO_LONG_PRESS_REVERT_EFFECT_TIME : _initialProperties$la14,
-      _initialProperties$la15 = initialProperties.lassoType,
-      lassoType = _initialProperties$la15 === void 0 ? DEFAULT_LASSO_TYPE : _initialProperties$la15,
-      _initialProperties$la16 = initialProperties.lassoBrushSize,
-      lassoBrushSize = _initialProperties$la16 === void 0 ? DEFAULT_LASSO_BRUSH_SIZE : _initialProperties$la16,
+      _initialProperties$la0 = initialProperties.lassoOnLongPress,
+      lassoOnLongPress = _initialProperties$la0 === void 0 ? DEFAULT_LASSO_ON_LONG_PRESS : _initialProperties$la0,
+      _initialProperties$la1 = initialProperties.lassoLongPressTime,
+      lassoLongPressTime = _initialProperties$la1 === void 0 ? DEFAULT_LASSO_LONG_PRESS_TIME : _initialProperties$la1,
+      _initialProperties$la10 = initialProperties.lassoLongPressAfterEffectTime,
+      lassoLongPressAfterEffectTime = _initialProperties$la10 === void 0 ? DEFAULT_LASSO_LONG_PRESS_AFTER_EFFECT_TIME : _initialProperties$la10,
+      _initialProperties$la11 = initialProperties.lassoLongPressEffectDelay,
+      lassoLongPressEffectDelay = _initialProperties$la11 === void 0 ? DEFAULT_LASSO_LONG_PRESS_EFFECT_DELAY : _initialProperties$la11,
+      _initialProperties$la12 = initialProperties.lassoLongPressRevertEffectTime,
+      lassoLongPressRevertEffectTime = _initialProperties$la12 === void 0 ? DEFAULT_LASSO_LONG_PRESS_REVERT_EFFECT_TIME : _initialProperties$la12,
+      _initialProperties$la13 = initialProperties.lassoType,
+      lassoType = _initialProperties$la13 === void 0 ? DEFAULT_LASSO_TYPE$1 : _initialProperties$la13,
+      _initialProperties$la14 = initialProperties.lassoBrushSize,
+      lassoBrushSize = _initialProperties$la14 === void 0 ? DEFAULT_LASSO_BRUSH_SIZE : _initialProperties$la14,
       _initialProperties$ac = initialProperties.actionKeyMap,
       actionKeyMap = _initialProperties$ac === void 0 ? DEFAULT_ACTION_KEY_MAP : _initialProperties$ac,
       _initialProperties$mo = initialProperties.mouseMode,
@@ -5599,26 +5423,26 @@ void main() {
       pointConnectionOpacity = _initialProperties$po8 === void 0 ? DEFAULT_POINT_CONNECTION_OPACITY : _initialProperties$po8,
       _initialProperties$po9 = initialProperties.pointConnectionOpacityBy,
       pointConnectionOpacityBy = _initialProperties$po9 === void 0 ? DEFAULT_POINT_CONNECTION_OPACITY_BY : _initialProperties$po9,
-      _initialProperties$po10 = initialProperties.pointConnectionOpacityActive,
-      pointConnectionOpacityActive = _initialProperties$po10 === void 0 ? DEFAULT_POINT_CONNECTION_OPACITY_ACTIVE : _initialProperties$po10,
-      _initialProperties$po11 = initialProperties.pointConnectionSize,
-      pointConnectionSize = _initialProperties$po11 === void 0 ? DEFAULT_POINT_CONNECTION_SIZE : _initialProperties$po11,
-      _initialProperties$po12 = initialProperties.pointConnectionSizeActive,
-      pointConnectionSizeActive = _initialProperties$po12 === void 0 ? DEFAULT_POINT_CONNECTION_SIZE_ACTIVE : _initialProperties$po12,
-      _initialProperties$po13 = initialProperties.pointConnectionSizeBy,
-      pointConnectionSizeBy = _initialProperties$po13 === void 0 ? DEFAULT_POINT_CONNECTION_SIZE_BY : _initialProperties$po13,
-      _initialProperties$po14 = initialProperties.pointConnectionMaxIntPointsPerSegment,
-      pointConnectionMaxIntPointsPerSegment = _initialProperties$po14 === void 0 ? DEFAULT_POINT_CONNECTION_MAX_INT_POINTS_PER_SEGMENT : _initialProperties$po14,
-      _initialProperties$po15 = initialProperties.pointConnectionTolerance,
-      pointConnectionTolerance = _initialProperties$po15 === void 0 ? DEFAULT_POINT_CONNECTION_INT_POINTS_TOLERANCE : _initialProperties$po15,
-      _initialProperties$po16 = initialProperties.pointSize,
-      pointSize = _initialProperties$po16 === void 0 ? DEFAULT_POINT_SIZE : _initialProperties$po16,
-      _initialProperties$po17 = initialProperties.pointSizeSelected,
-      pointSizeSelected = _initialProperties$po17 === void 0 ? DEFAULT_POINT_SIZE_SELECTED : _initialProperties$po17,
-      _initialProperties$po18 = initialProperties.pointSizeMouseDetection,
-      pointSizeMouseDetection = _initialProperties$po18 === void 0 ? DEFAULT_POINT_SIZE_MOUSE_DETECTION : _initialProperties$po18,
-      _initialProperties$po19 = initialProperties.pointOutlineWidth,
-      pointOutlineWidth = _initialProperties$po19 === void 0 ? DEFAULT_POINT_OUTLINE_WIDTH : _initialProperties$po19,
+      _initialProperties$po0 = initialProperties.pointConnectionOpacityActive,
+      pointConnectionOpacityActive = _initialProperties$po0 === void 0 ? DEFAULT_POINT_CONNECTION_OPACITY_ACTIVE : _initialProperties$po0,
+      _initialProperties$po1 = initialProperties.pointConnectionSize,
+      pointConnectionSize = _initialProperties$po1 === void 0 ? DEFAULT_POINT_CONNECTION_SIZE : _initialProperties$po1,
+      _initialProperties$po10 = initialProperties.pointConnectionSizeActive,
+      pointConnectionSizeActive = _initialProperties$po10 === void 0 ? DEFAULT_POINT_CONNECTION_SIZE_ACTIVE : _initialProperties$po10,
+      _initialProperties$po11 = initialProperties.pointConnectionSizeBy,
+      pointConnectionSizeBy = _initialProperties$po11 === void 0 ? DEFAULT_POINT_CONNECTION_SIZE_BY : _initialProperties$po11,
+      _initialProperties$po12 = initialProperties.pointConnectionMaxIntPointsPerSegment,
+      pointConnectionMaxIntPointsPerSegment = _initialProperties$po12 === void 0 ? DEFAULT_POINT_CONNECTION_MAX_INT_POINTS_PER_SEGMENT : _initialProperties$po12,
+      _initialProperties$po13 = initialProperties.pointConnectionTolerance,
+      pointConnectionTolerance = _initialProperties$po13 === void 0 ? DEFAULT_POINT_CONNECTION_INT_POINTS_TOLERANCE : _initialProperties$po13,
+      _initialProperties$po14 = initialProperties.pointSize,
+      pointSize = _initialProperties$po14 === void 0 ? DEFAULT_POINT_SIZE : _initialProperties$po14,
+      _initialProperties$po15 = initialProperties.pointSizeSelected,
+      pointSizeSelected = _initialProperties$po15 === void 0 ? DEFAULT_POINT_SIZE_SELECTED : _initialProperties$po15,
+      _initialProperties$po16 = initialProperties.pointSizeMouseDetection,
+      pointSizeMouseDetection = _initialProperties$po16 === void 0 ? DEFAULT_POINT_SIZE_MOUSE_DETECTION : _initialProperties$po16,
+      _initialProperties$po17 = initialProperties.pointOutlineWidth,
+      pointOutlineWidth = _initialProperties$po17 === void 0 ? DEFAULT_POINT_OUTLINE_WIDTH : _initialProperties$po17,
       _initialProperties$op = initialProperties.opacity,
       opacity = _initialProperties$op === void 0 ? AUTO : _initialProperties$op,
       _initialProperties$op2 = initialProperties.opacityBy,
@@ -5631,8 +5455,10 @@ void main() {
       opacityInactiveScale = _initialProperties$op5 === void 0 ? DEFAULT_OPACITY_INACTIVE_SCALE : _initialProperties$op5,
       _initialProperties$si = initialProperties.sizeBy,
       sizeBy = _initialProperties$si === void 0 ? DEFAULT_SIZE_BY : _initialProperties$si,
-      _initialProperties$po20 = initialProperties.pointScaleMode,
-      pointScaleMode = _initialProperties$po20 === void 0 ? DEFAULT_POINT_SCALE_MODE : _initialProperties$po20,
+      _initialProperties$po18 = initialProperties.pointOrder,
+      pointOrder = _initialProperties$po18 === void 0 ? DEFAULT_POINT_ORDER : _initialProperties$po18,
+      _initialProperties$po19 = initialProperties.pointScaleMode,
+      pointScaleMode = _initialProperties$po19 === void 0 ? DEFAULT_POINT_SCALE_MODE : _initialProperties$po19,
       _initialProperties$he = initialProperties.height,
       height = _initialProperties$he === void 0 ? DEFAULT_HEIGHT : _initialProperties$he,
       _initialProperties$wi = initialProperties.width,
@@ -5702,9 +5528,7 @@ void main() {
     var pointConnections;
     var pointConnectionMap;
     var computingPointConnectionCurves;
-    // biome-ignore lint/style/useNamingConvention: HLine stands for HorizontalLine
     var reticleHLine;
-    // biome-ignore lint/style/useNamingConvention: VLine stands for VerticalLine
     var reticleVLine;
     var computedPointSizeMouseDetection;
     var lassoInitiatorTimeout;
@@ -5796,6 +5620,8 @@ void main() {
     var normalPointsIndexBuffer; // Buffer holding the indices pointing to the correct texel
     var selectedPointsIndexBuffer; // Used for pointing to the selected texels
     var hoveredPointIndexBuffer; // Used for pointing to the hovered texels
+    var pointOrderIndices = null; // Validated ordered point indices (Int32Array or null)
+    var pointOrderIndex = null; // Float32Array of tex coords in pointOrder sequence
 
     var cameraZoomTargetStart; // Stores the start (i.e., current) camera target for zooming
     var cameraZoomTargetEnd; // Stores the end camera target for zooming
@@ -5816,10 +5642,7 @@ void main() {
     var isPointsDrawn = false;
     var isAnnotationsDrawn = false;
     var isMouseOverCanvasChecked = false;
-
-    // biome-ignore lint/style/useNamingConvention: ZDate is not one word
     var valueZDataType = CATEGORICAL;
-    // biome-ignore lint/style/useNamingConvention: WDate is not one word
     var valueWDataType = CATEGORICAL;
 
     /** @type{number|undefined} */
@@ -5883,10 +5706,7 @@ void main() {
       }
       return points;
     };
-
-    // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
     var getPointsInBBox = function getPointsInBBox(x0, y0, x1, y1) {
-      // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
       var pointsInBBox = spatialIndex.range(x0, y0, x1, y1);
       if (isPointsFiltered) {
         return pointsInBBox.filter(function (i) {
@@ -5907,7 +5727,6 @@ void main() {
       var pointSizeNdc = getPointSizeNdc(4);
 
       // Get all points within a close range
-      // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
       var pointsInBBox = getPointsInBBox(xNdc - pointSizeNdc, yNdc - pointSizeNdc, xNdc + pointSizeNdc, yNdc + pointSizeNdc);
 
       // Find the closest point
@@ -5949,7 +5768,6 @@ void main() {
       }
 
       // ...to efficiently preselect potentially selected points
-      // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
       var pointsInBBox = getPointsInBBox.apply(void 0, _toConsumableArray(bBox));
       // next we test each point in the bounding box if it is in the polygon too
       var pointsInPolygon = [];
@@ -6050,6 +5868,49 @@ void main() {
       }
     };
 
+    /**
+     * Convert vertices from data space to GL space
+     * @param {Array<[number, number]>} vertices - Vertices in data space
+     * @returns {number[] | null} Flat array of GL coordinates or null if scales not defined
+     */
+    var verticesFromDataToGl = function verticesFromDataToGl(vertices) {
+      // Check if xScale/yScale are defined
+      if (!(xScale && yScale)) {
+        // biome-ignore lint/suspicious/noConsole: User warning for missing configuration
+        console.warn('xScale and yScale must be defined for programmatic lasso selection');
+        return null;
+      }
+      var verticesGl = [];
+      var _iterator5 = _createForOfIteratorHelper(vertices),
+        _step5;
+      try {
+        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+          var _step5$value = _slicedToArray(_step5.value, 2),
+            x = _step5$value[0],
+            y = _step5$value[1];
+          // Step 1: Data space → normalized [0, 1]
+          var xNorm = (x - xDomainStart) / xDomainSize;
+          var yNorm = (y - yDomainStart) / yDomainSize;
+
+          // Step 2: Normalized [0, 1] → NDC [-1, 1]
+          var xNdc = xNorm * 2 - 1;
+          var yNdc = yNorm * 2 - 1;
+
+          // Step 3: NDC → GL space (camera transform)
+          var _getScatterGlPos3 = getScatterGlPos(xNdc, yNdc),
+            _getScatterGlPos4 = _slicedToArray(_getScatterGlPos3, 2),
+            xGl = _getScatterGlPos4[0],
+            yGl = _getScatterGlPos4[1];
+          verticesGl.push(xGl, yGl);
+        }
+      } catch (err) {
+        _iterator5.e(err);
+      } finally {
+        _iterator5.f();
+      }
+      return verticesGl;
+    };
+
     /**
      * Select and highlight a set of points
      * @param {number | number[]} pointIdxs
@@ -6130,22 +5991,61 @@ void main() {
       setPointConnectionColorState(selectedPoints, 1);
       if (!preventEvent) {
         pubSub.publish('select', {
-          points: selectedPoints
+          points: selectedPoints,
+          lassoMode: lassoMode
         });
       }
       draw = true;
     };
 
+    /**
+     * Lasso a certain area and select contained points
+     * @param {[number, number][]} vertices - Lasso vertices in either data space (default) or GL space
+     * @param {import('./types').ScatterplotMethodOptions['lasso']}
+     */
+    var lassoSelect = function lassoSelect(vertices) {
+      var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref4$merge = _ref4.merge,
+        merge = _ref4$merge === void 0 ? false : _ref4$merge,
+        _ref4$remove = _ref4.remove,
+        remove = _ref4$remove === void 0 ? false : _ref4$remove,
+        _ref4$isGl = _ref4.isGl,
+        isGl = _ref4$isGl === void 0 ? false : _ref4$isGl;
+      if (!isVertices(vertices)) {
+        throw new Error('Lasso selection requires at least 3 vertices as [x, y] coordinate pairs');
+      }
+      var closedPolygon = verticesToPolygon(vertices);
+      var polygonGl;
+      var polygonGlFlat;
+      if (isGl) {
+        polygonGl = closedPolygon;
+        polygonGlFlat = closedPolygon.flat();
+      } else {
+        polygonGlFlat = verticesFromDataToGl(closedPolygon);
+        if (!polygonGlFlat) {
+          throw new Error('xScale and yScale must be defined to convert lasso vertices from data space to GL space');
+        }
+        polygonGl = [];
+        for (var i = 0; i < polygonGlFlat.length; i += 2) {
+          polygonGl.push([polygonGlFlat[i], polygonGlFlat[i + 1]]);
+        }
+      }
+      lassoEnd(polygonGl, polygonGlFlat, {
+        merge: merge,
+        remove: remove
+      });
+    };
+
     /**
      * @param {number} point
      * @param {import('./types').ScatterplotMethodOptions['hover']} options
      */
     var hover = function hover(point) {
-      var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        _ref4$showReticleOnce = _ref4.showReticleOnce,
-        showReticleOnce = _ref4$showReticleOnce === void 0 ? false : _ref4$showReticleOnce,
-        _ref4$preventEvent = _ref4.preventEvent,
-        preventEvent = _ref4$preventEvent === void 0 ? false : _ref4$preventEvent;
+      var _ref5 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref5$showReticleOnce = _ref5.showReticleOnce,
+        showReticleOnce = _ref5$showReticleOnce === void 0 ? false : _ref5$showReticleOnce,
+        _ref5$preventEvent = _ref5.preventEvent,
+        preventEvent = _ref5$preventEvent === void 0 ? false : _ref5$preventEvent;
       var needsRedraw = false;
       var isFilteredOut = isPointsFiltered && !filteredPointsSet.has(point);
       if (!isFilteredOut && point >= 0 && point < numPoints) {
@@ -6201,13 +6101,13 @@ void main() {
       pubSub.publish('lassoStart');
     };
     var lassoEnd = function lassoEnd(lassoPoints, lassoPointsFlat) {
-      var _ref5 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
-        _ref5$intersect = _ref5.intersect,
-        intersect = _ref5$intersect === void 0 ? false : _ref5$intersect,
-        _ref5$merge = _ref5.merge,
-        merge = _ref5$merge === void 0 ? false : _ref5$merge,
-        _ref5$remove = _ref5.remove,
-        remove = _ref5$remove === void 0 ? false : _ref5$remove;
+      var _ref6 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},
+        _ref6$intersect = _ref6.intersect,
+        intersect = _ref6$intersect === void 0 ? false : _ref6$intersect,
+        _ref6$merge = _ref6.merge,
+        merge = _ref6$merge === void 0 ? false : _ref6$merge,
+        _ref6$remove = _ref6.remove,
+        remove = _ref6$remove === void 0 ? false : _ref6$remove;
       camera.config({
         isFixed: cameraIsFixed
       });
@@ -6232,10 +6132,10 @@ void main() {
       enableInitiator: lassoInitiator,
       initiatorParentElement: lassoInitiatorParentElement,
       longPressIndicatorParentElement: lassoLongPressIndicatorParentElement,
-      pointNorm: function pointNorm(_ref6) {
-        var _ref7 = _slicedToArray(_ref6, 2),
-          x = _ref7[0],
-          y = _ref7[1];
+      pointNorm: function pointNorm(_ref7) {
+        var _ref8 = _slicedToArray(_ref7, 2),
+          x = _ref8[0],
+          y = _ref8[1];
         return getScatterGlPos(getNdcX(x), getNdcY(y));
       },
       minDelay: lassoMinDelay,
@@ -6697,6 +6597,46 @@ void main() {
     var setSizeBy = function setSizeBy(type) {
       sizeBy = getEncodingType(type, DEFAULT_SIZE_BY);
     };
+    var setPointOrder = function setPointOrder(newPointOrder) {
+      if (newPointOrder === null || newPointOrder === undefined) {
+        pointOrder = null;
+      } else if (Array.isArray(newPointOrder) || ArrayBuffer.isView(newPointOrder)) {
+        pointOrder = newPointOrder;
+      } else {
+        return;
+      }
+      if (isPointsDrawn) {
+        computePointOrderIndex();
+        if (isPointsFiltered) {
+          // Re-apply filter respecting the new point order
+          var filteredPointsBuffer = [];
+          if (pointOrderIndices !== null) {
+            for (var i = 0; i < pointOrderIndices.length; i++) {
+              if (filteredPointsSet.has(pointOrderIndices[i])) {
+                filteredPointsBuffer.push.apply(filteredPointsBuffer, indexToStateTexCoord(pointOrderIndices[i]));
+              }
+            }
+          } else {
+            var sortedFiltered = insertionSort(_toConsumableArray(filteredPointsSet));
+            var _iterator6 = _createForOfIteratorHelper(sortedFiltered),
+              _step6;
+            try {
+              for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+                var idx = _step6.value;
+                filteredPointsBuffer.push.apply(filteredPointsBuffer, indexToStateTexCoord(idx));
+              }
+            } catch (err) {
+              _iterator6.e(err);
+            } finally {
+              _iterator6.f();
+            }
+          }
+          normalPointsIndexBuffer.subdata(filteredPointsBuffer);
+        } else {
+          normalPointsIndexBuffer.subdata(getEffectivePointIndex(numPoints));
+        }
+      }
+    };
     var setPointConnectionColorBy = function setPointConnectionColorBy(type) {
       pointConnectionColorBy = getEncodingType(type, DEFAULT_POINT_CONNECTION_COLOR_BY, {
         allowSegment: true,
@@ -6912,15 +6852,13 @@ void main() {
       var getPointOpacityMax = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : getPointOpacityMaxBase;
       var getPointOpacityScale = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : getPointOpacityScaleBase;
       return renderer.regl({
-        frag: renderPointsAsSquares ? FRAGMENT_SHADER$1 : FRAGMENT_SHADER,
+        frag: renderPointsAsSquares ? FRAGMENT_SHADER : FRAGMENT_SHADER$1,
         vert: createVertexShader(globalState),
         blend: {
           enable: !disableAlphaBlending,
           func: {
-            // biome-ignore lint/style/useNamingConvention: Regl specific
             srcRGB: 'src alpha',
             srcAlpha: 'one',
-            // biome-ignore lint/style/useNamingConvention: Regl specific
             dstRGB: 'one minus src alpha',
             dstAlpha: 'one minus src alpha'
           }
@@ -7036,10 +6974,8 @@ void main() {
       blend: {
         enable: true,
         func: {
-          // biome-ignore lint/style/useNamingConvention: Regl specific
           srcRGB: 'src alpha',
           srcAlpha: 'one',
-          // biome-ignore lint/style/useNamingConvention: Regl specific
           dstRGB: 'one minus src alpha',
           dstAlpha: 'one minus src alpha'
         }
@@ -7107,6 +7043,41 @@ void main() {
       }
       return index;
     };
+    var computePointOrderIndex = function computePointOrderIndex() {
+      if (pointOrder === null) {
+        pointOrderIndices = null;
+        pointOrderIndex = null;
+        return;
+      }
+      var includedSet = new Set();
+      var orderedIndices = [];
+      for (var i = 0; i < pointOrder.length; i++) {
+        var idx = pointOrder[i];
+        if (Number.isFinite(idx) && idx >= 0 && idx < numPoints && !includedSet.has(idx)) {
+          orderedIndices.push(idx);
+          includedSet.add(idx);
+        }
+      }
+
+      // Append any missing indices in sequential order
+      for (var _i2 = 0; _i2 < numPoints; _i2++) {
+        if (!includedSet.has(_i2)) {
+          orderedIndices.push(_i2);
+        }
+      }
+      pointOrderIndices = orderedIndices;
+      pointOrderIndex = new Float32Array(orderedIndices.length * 2);
+      var j = 0;
+      for (var _i3 = 0; _i3 < orderedIndices.length; _i3++) {
+        var texCoord = indexToStateTexCoord(orderedIndices[_i3]);
+        pointOrderIndex[j] = texCoord[0];
+        pointOrderIndex[j + 1] = texCoord[1];
+        j += 2;
+      }
+    };
+    var getEffectivePointIndex = function getEffectivePointIndex(count) {
+      return pointOrderIndex !== null ? pointOrderIndex : createPointIndex(count);
+    };
     var createStateTexture = function createStateTexture(newPoints) {
       var dataTypes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       var numNewPoints = newPoints.length;
@@ -7185,8 +7156,17 @@ void main() {
       return new Promise(function (resolve) {
         isPointsDrawn = false;
         var preventFilterReset = (options === null || options === void 0 ? void 0 : options.preventFilterReset) && newPoints.length === numPoints;
+        var prevNumPoints = numPoints;
         numPoints = newPoints.length;
         numPointsInView = numPoints;
+
+        // Reset pointOrder when re-drawing with different-length data
+        // (ordering becomes meaningless). Skip on first draw (prevNumPoints === 0).
+        if (prevNumPoints > 0 && numPoints !== prevNumPoints) {
+          pointOrder = null;
+          pointOrderIndices = null;
+          pointOrderIndex = null;
+        }
         if (stateTex) {
           stateTex.destroy();
         }
@@ -7195,10 +7175,11 @@ void main() {
           w: options.wDataType
         });
         if (!preventFilterReset) {
+          computePointOrderIndex();
           normalPointsIndexBuffer({
             usage: 'static',
             type: 'float',
-            data: createPointIndex(numPoints)
+            data: getEffectivePointIndex(numPoints)
           });
         }
         createKdbush(options.spatialIndex || newPoints, {
@@ -7244,8 +7225,8 @@ void main() {
           colorIndices[index] = [0];
           var cumLength = 0;
           // Assign the color index based on the cumulative length
-          for (var _i2 = 0; _i2 < curve.length / 2 - 1; _i2++) {
-            cumLength += segLengths[_i2];
+          for (var _i4 = 0; _i4 < curve.length / 2 - 1; _i4++) {
+            cumLength += segLengths[_i4];
             // The `4` comes from the fact that we have 4 color states:
             // normal, active, hover, and background
             colorIndices[index].push(Math.floor(cumLength / totalLength * maxColorIdx) * 4);
@@ -7262,10 +7243,10 @@ void main() {
       if (colorEncoding) {
         var encodingIdx = getEncodingIdx(colorEncoding);
         var encodingValueToIdx = getEncodingValueToIdx(getEncodingDataType(colorEncoding), pointConnectionColorBy === 'inherit' ? pointColor : pointConnectionColor);
-        return pointConnectionMap.reduce(function (colorIndices, _ref8) {
-          var _ref9 = _slicedToArray(_ref8, 2),
-            index = _ref9[0],
-            referencePoint = _ref9[1];
+        return pointConnectionMap.reduce(function (colorIndices, _ref9) {
+          var _ref0 = _slicedToArray(_ref9, 2),
+            index = _ref0[0],
+            referencePoint = _ref0[1];
           // The `4` comes from the fact that we have 4 color states:
           // normal, active, hover, and background
           colorIndices[index] = encodingValueToIdx(referencePoint[encodingIdx]) * 4;
@@ -7281,11 +7262,11 @@ void main() {
         if (maxOpacityIdx < 1) {
           return [];
         }
-        return pointConnectionMap.reduce(function (opacities, _ref10) {
-          var _ref11 = _slicedToArray(_ref10, 3),
-            index = _ref11[0];
-            _ref11[1];
-            var length = _ref11[2];
+        return pointConnectionMap.reduce(function (opacities, _ref1) {
+          var _ref10 = _slicedToArray(_ref1, 3),
+            index = _ref10[0];
+            _ref10[1];
+            var length = _ref10[2];
           opacities[index] = rangeMap(length, function (i) {
             return pointConnectionOpacity[Math.floor(i / (length - 1) * maxOpacityIdx)];
           });
@@ -7296,10 +7277,10 @@ void main() {
         var encodingIdx = getEncodingIdx(opacityEncoding);
         var encodingRangeMap = pointConnectionOpacityBy === 'inherit' ? opacity : pointConnectionOpacity;
         var encodingValueToIdx = getEncodingValueToIdx(getEncodingDataType(opacityEncoding), encodingRangeMap);
-        return pointConnectionMap.reduce(function (opacities, _ref12) {
-          var _ref13 = _slicedToArray(_ref12, 2),
-            index = _ref13[0],
-            referencePoint = _ref13[1];
+        return pointConnectionMap.reduce(function (opacities, _ref11) {
+          var _ref12 = _slicedToArray(_ref11, 2),
+            index = _ref12[0],
+            referencePoint = _ref12[1];
           opacities[index] = encodingRangeMap[encodingValueToIdx(referencePoint[encodingIdx])];
           return opacities;
         }, []);
@@ -7313,11 +7294,11 @@ void main() {
         if (maxSizeIdx < 1) {
           return [];
         }
-        return pointConnectionMap.reduce(function (widths, _ref14) {
-          var _ref15 = _slicedToArray(_ref14, 3),
-            index = _ref15[0];
-            _ref15[1];
-            var length = _ref15[2];
+        return pointConnectionMap.reduce(function (widths, _ref13) {
+          var _ref14 = _slicedToArray(_ref13, 3),
+            index = _ref14[0];
+            _ref14[1];
+            var length = _ref14[2];
           widths[index] = rangeMap(length, function (i) {
             return pointConnectionSize[Math.floor(i / (length - 1) * maxSizeIdx)];
           });
@@ -7328,10 +7309,10 @@ void main() {
         var encodingIdx = getEncodingIdx(sizeEncoding);
         var encodingRangeMap = pointConnectionSizeBy === 'inherit' ? pointSize : pointConnectionSize;
         var encodingValueToIdx = getEncodingValueToIdx(getEncodingDataType(sizeEncoding), encodingRangeMap);
-        return pointConnectionMap.reduce(function (widths, _ref16) {
-          var _ref17 = _slicedToArray(_ref16, 2),
-            index = _ref17[0],
-            referencePoint = _ref17[1];
+        return pointConnectionMap.reduce(function (widths, _ref15) {
+          var _ref16 = _slicedToArray(_ref15, 2),
+            index = _ref16[0],
+            referencePoint = _ref16[1];
           widths[index] = encodingRangeMap[encodingValueToIdx(referencePoint[encodingIdx])];
           return widths;
         }, []);
@@ -7379,12 +7360,12 @@ void main() {
      * @param {import('./types').ScatterplotMethodOptions['filter']}
      */
     var unfilter = function unfilter() {
-      var _ref18 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref18$preventEvent = _ref18.preventEvent,
-        preventEvent = _ref18$preventEvent === void 0 ? false : _ref18$preventEvent;
+      var _ref17 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref17$preventEvent = _ref17.preventEvent,
+        preventEvent = _ref17$preventEvent === void 0 ? false : _ref17$preventEvent;
       isPointsFiltered = false;
       filteredPointsSet.clear();
-      normalPointsIndexBuffer.subdata(createPointIndex(numPoints));
+      normalPointsIndexBuffer.subdata(getEffectivePointIndex(numPoints));
       return new Promise(function (resolve) {
         var finish = function finish() {
           pubSub.subscribe('draw', function () {
@@ -7416,20 +7397,20 @@ void main() {
      * @param {import('./types').ScatterplotMethodOptions['filter']}
      */
     var filter = function filter(pointIdxs) {
-      var _ref19 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        _ref19$preventEvent = _ref19.preventEvent,
-        preventEvent = _ref19$preventEvent === void 0 ? false : _ref19$preventEvent;
+      var _ref18 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref18$preventEvent = _ref18.preventEvent,
+        preventEvent = _ref18$preventEvent === void 0 ? false : _ref18$preventEvent;
       isPointsFiltered = true;
       filteredPointsSet.clear();
       var pointIdxsArray = Array.isArray(pointIdxs) ? pointIdxs : [pointIdxs];
       var filteredPoints = [];
       var filteredPointsBuffer = [];
       var filteredSelectedPoints = [];
-      var _iterator5 = _createForOfIteratorHelper(pointIdxsArray),
-        _step5;
+      var _iterator7 = _createForOfIteratorHelper(pointIdxsArray),
+        _step7;
       try {
-        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
-          var pointIdx = _step5.value;
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var pointIdx = _step7.value;
           if (!Number.isFinite(pointIdx) || pointIdx < 0 || pointIdx >= numPoints) {
             // Skip invalid filtered points
             continue;
@@ -7441,24 +7422,35 @@ void main() {
           }
         }
       } catch (err) {
-        _iterator5.e(err);
+        _iterator7.e(err);
       } finally {
-        _iterator5.f();
+        _iterator7.f();
+      }
+      var orderedFilteredPoints;
+      if (pointOrderIndices !== null) {
+        // Maintain the custom point order within the filtered set
+        orderedFilteredPoints = [];
+        for (var i = 0; i < pointOrderIndices.length; i++) {
+          if (filteredPointsSet.has(pointOrderIndices[i])) {
+            orderedFilteredPoints.push(pointOrderIndices[i]);
+          }
+        }
+      } else {
+        orderedFilteredPoints = insertionSort([].concat(filteredPoints));
       }
-      var sortedFilteredPoints = insertionSort([].concat(filteredPoints));
-      var _iterator6 = _createForOfIteratorHelper(sortedFilteredPoints),
-        _step6;
+      var _iterator8 = _createForOfIteratorHelper(orderedFilteredPoints),
+        _step8;
       try {
-        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
-          var _pointIdx = _step6.value;
+        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
+          var _pointIdx = _step8.value;
           filteredPointsBuffer.push.apply(filteredPointsBuffer, indexToStateTexCoord(_pointIdx));
         }
 
         // Update the normal points index buffers
       } catch (err) {
-        _iterator6.e(err);
+        _iterator8.e(err);
       } finally {
-        _iterator6.f();
+        _iterator8.f();
       }
       normalPointsIndexBuffer.subdata(filteredPointsBuffer);
 
@@ -7558,11 +7550,11 @@ void main() {
       clearCachedCamera();
       pubSub.publish('transitionEnd');
     };
-    var startTransition = function startTransition(_ref20) {
-      var _ref20$duration = _ref20.duration,
-        duration = _ref20$duration === void 0 ? 500 : _ref20$duration,
-        _ref20$easing = _ref20.easing,
-        easing = _ref20$easing === void 0 ? DEFAULT_EASING : _ref20$easing;
+    var startTransition = function startTransition(_ref19) {
+      var _ref19$duration = _ref19.duration,
+        duration = _ref19$duration === void 0 ? 500 : _ref19$duration,
+        _ref19$easing = _ref19.easing,
+        easing = _ref19$easing === void 0 ? DEFAULT_EASING : _ref19$easing;
       if (isTransitioning) {
         pubSub.publish('transitionEnd');
       }
@@ -7752,11 +7744,11 @@ void main() {
             newColorIndices.push(_idx);
           }
         };
-        var _iterator7 = _createForOfIteratorHelper(newAnnotations),
-          _step7;
+        var _iterator9 = _createForOfIteratorHelper(newAnnotations),
+          _step9;
         try {
-          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
-            var annotation = _step7.value;
+          for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
+            var annotation = _step9.value;
             if (isHorizontalLine(annotation)) {
               var _annotation$x, _annotation$x2;
               newPoints.push([(_annotation$x = annotation.x1) !== null && _annotation$x !== void 0 ? _annotation$x : -annotationHVLineLimit, annotation.y, (_annotation$x2 = annotation.x2) !== null && _annotation$x2 !== void 0 ? _annotation$x2 : annotationHVLineLimit, annotation.y]);
@@ -7779,21 +7771,21 @@ void main() {
               addColorAndWidth(annotation);
               continue;
             }
-            if (isPolygon(annotation)) {
+            if (isPolygonAnnotation(annotation)) {
               newPoints.push(annotation.vertices.flatMap(identity));
               addColorAndWidth(annotation);
             }
           }
         } catch (err) {
-          _iterator7.e(err);
+          _iterator9.e(err);
         } finally {
-          _iterator7.f();
+          _iterator9.f();
         }
         annotations.setStyle({
           color: Array.from(newColors.values()).sort(function (a, b) {
             return a.idx > b.idx ? 1 : -1;
-          }).map(function (_ref21) {
-            var color = _ref21.color;
+          }).map(function (_ref20) {
+            var color = _ref20.color;
             return color;
           })
         });
@@ -7825,17 +7817,16 @@ void main() {
      * @param {number[]} pointIdxs - A list of point indices
      * @returns {import('./types').Rect} The bounding box
      */
-    // biome-ignore lint/style/useNamingConvention: BBox stands for BoundingBox
     var getBBoxOfPoints = function getBBoxOfPoints(pointIdxs) {
       var xMin = Number.POSITIVE_INFINITY;
       var xMax = Number.NEGATIVE_INFINITY;
       var yMin = Number.POSITIVE_INFINITY;
       var yMax = Number.NEGATIVE_INFINITY;
-      var _iterator8 = _createForOfIteratorHelper(pointIdxs),
-        _step8;
+      var _iterator0 = _createForOfIteratorHelper(pointIdxs),
+        _step0;
       try {
-        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
-          var pointIdx = _step8.value;
+        for (_iterator0.s(); !(_step0 = _iterator0.n()).done;) {
+          var pointIdx = _step0.value;
           var _points$pointIdx2 = _slicedToArray(points[pointIdx], 2),
             x = _points$pointIdx2[0],
             y = _points$pointIdx2[1];
@@ -7845,9 +7836,9 @@ void main() {
           yMax = Math.max(yMax, y);
         }
       } catch (err) {
-        _iterator8.e(err);
+        _iterator0.e(err);
       } finally {
-        _iterator8.f();
+        _iterator0.f();
       }
       return {
         x: xMin,
@@ -7871,7 +7862,6 @@ void main() {
         // Vertical field of view
         // The Arc Tangent is based on the original camera position. Otherwise
         // we would have to do `Math.atan(1 / camera.view[5])`
-        // biome-ignore lint/style/useNamingConvention: FOV stands for field of view
         var vFOV = 2 * Math.atan(1);
         var aspectRatio = viewAspectRatio / dataAspectRatio;
         var distance = rect.height * aspectRatio >= rect.width ?
@@ -8186,10 +8176,10 @@ void main() {
       }
     };
     var setActionKeyMap = function setActionKeyMap(newActionKeyMap) {
-      actionKeyMap = Object.entries(newActionKeyMap).reduce(function (map, _ref22) {
-        var _ref23 = _slicedToArray(_ref22, 2),
-          action = _ref23[0],
-          key = _ref23[1];
+      actionKeyMap = Object.entries(newActionKeyMap).reduce(function (map, _ref21) {
+        var _ref22 = _slicedToArray(_ref21, 2),
+          action = _ref22[0],
+          key = _ref22[1];
         if (KEYS.includes(key) && KEY_ACTIONS.includes(action)) {
           map[action] = key;
         }
@@ -8221,8 +8211,6 @@ void main() {
         color: reticleColor
       });
     };
-
-    // biome-ignore lint/style/useNamingConvention: XScale are two words
     var setXScale = function setXScale(newXScale) {
       if (!newXScale) {
         return;
@@ -8233,8 +8221,6 @@ void main() {
       xScale.range([0, currentWidth]);
       updateScales();
     };
-
-    // biome-ignore lint/style/useNamingConvention: YScale are two words
     var setYScale = function setYScale(newYScale) {
       if (!newYScale) {
         return;
@@ -8375,8 +8361,6 @@ void main() {
     var setAnnotationLineWidth = function setAnnotationLineWidth(newAnnotationLineWidth) {
       annotationLineWidth = +newAnnotationLineWidth;
     };
-
-    // biome-ignore lint/style/useNamingConvention: HVLine stands for horizontal vertical line
     var setAnnotationHVLineLimit = function setAnnotationHVLineLimit(newAnnotationHVLineLimit) {
       annotationHVLineLimit = +newAnnotationHVLineLimit;
     };
@@ -8434,6 +8418,9 @@ void main() {
       if (property === 'sizeBy') {
         return sizeBy;
       }
+      if (property === 'pointOrder') {
+        return pointOrder !== null ? _toConsumableArray(pointOrder) : null;
+      }
       if (property === 'deselectOnDblClick') {
         return deselectOnDblClick;
       }
@@ -8716,6 +8703,9 @@ void main() {
       if (properties.sizeBy !== undefined) {
         setSizeBy(properties.sizeBy);
       }
+      if (properties.pointOrder !== undefined) {
+        setPointOrder(properties.pointOrder);
+      }
       if (properties.opacity !== undefined) {
         setOpacity(properties.opacity);
       }
@@ -8899,9 +8889,9 @@ void main() {
      * @param {import('./types').ScatterplotMethodOptions['preventEvent']} options
      */
     var view = function view(cameraView) {
-      var _ref24 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-        _ref24$preventEvent = _ref24.preventEvent,
-        preventEvent = _ref24$preventEvent === void 0 ? false : _ref24$preventEvent;
+      var _ref23 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+        _ref23$preventEvent = _ref23.preventEvent,
+        preventEvent = _ref23$preventEvent === void 0 ? false : _ref23$preventEvent;
       setCameraView(cameraView);
       draw = true;
       preventEventView = preventEvent;
@@ -8929,9 +8919,9 @@ void main() {
      * @param {import('./types').ScatterplotMethodOptions['preventEvent']} options
      */
     var reset = function reset() {
-      var _ref25 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-        _ref25$preventEvent = _ref25.preventEvent,
-        preventEvent = _ref25$preventEvent === void 0 ? false : _ref25$preventEvent;
+      var _ref24 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref24$preventEvent = _ref24.preventEvent,
+        preventEvent = _ref24$preventEvent === void 0 ? false : _ref24$preventEvent;
       initCamera();
       updateScales();
       if (preventEvent) {
@@ -8944,8 +8934,8 @@ void main() {
         yScale: yScale
       });
     };
-    var keyUpHandler = function keyUpHandler(_ref26) {
-      var key = _ref26.key;
+    var keyUpHandler = function keyUpHandler(_ref25) {
+      var key = _ref25.key;
       switch (key) {
         case 'Escape':
           {
@@ -9018,10 +9008,10 @@ void main() {
      * @returns {Promise<ImageData>}
      */
     var exportFnAdvanced = /*#__PURE__*/function () {
-      var _ref27 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(options) {
+      var _ref26 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(options) {
         var dpr, currPointSize, currWidth, currHeight, currRendererWidth, currRendererHeight, currPixelAligned, currAntiAliasing, scale, newPointSize, newWidth, newHeight, imageData;
-        return _regeneratorRuntime().wrap(function _callee$(_context) {
-          while (1) switch (_context.prev = _context.next) {
+        return _regenerator().w(function (_context) {
+          while (1) switch (_context.n) {
             case 0:
               canvas.style.userSelect = 'none';
               dpr = window.devicePixelRatio;
@@ -9045,12 +9035,12 @@ void main() {
               setAntiAliasing((options === null || options === void 0 ? void 0 : options.antiAliasing) || antiAliasing);
               renderer.resize(width, height);
               renderer.refresh();
-              _context.next = 22;
+              _context.n = 1;
               return new Promise(function (resolve) {
                 pubSub.subscribe('draw', resolve, 1);
                 redraw();
               });
-            case 22:
+            case 1:
               imageData = canvas.getContext('2d').getImageData(0, 0, canvas.width, canvas.height);
               renderer.resize(currRendererWidth, currRendererHeight);
               renderer.refresh();
@@ -9059,22 +9049,19 @@ void main() {
               setHeight(currHeight);
               setPixelAligned(currPixelAligned);
               setAntiAliasing(currAntiAliasing);
-              _context.next = 32;
+              _context.n = 2;
               return new Promise(function (resolve) {
                 pubSub.subscribe('draw', resolve, 1);
                 redraw();
               });
-            case 32:
+            case 2:
               canvas.style.userSelect = null;
-              return _context.abrupt("return", imageData);
-            case 34:
-            case "end":
-              return _context.stop();
+              return _context.a(2, imageData);
           }
         }, _callee);
       }));
       return function exportFnAdvanced(_x) {
-        return _ref27.apply(this, arguments);
+        return _ref26.apply(this, arguments);
       };
     }();
 
@@ -9312,6 +9299,9 @@ void main() {
     };
     init();
     return {
+      attachSpatialIndex: function attachSpatialIndex(buffer) {
+        spatialIndex = kdbushFrom(buffer);
+      },
       /**
        * Get whether the browser supports all necessary WebGL features
        * @return {boolean} If `true` the browser supports all necessary WebGL features
@@ -9335,6 +9325,7 @@ void main() {
       get: get,
       getScreenPosition: getScreenPosition,
       hover: hover,
+      lassoSelect: lassoSelect,
       redraw: redraw,
       refresh: renderer.refresh,
       reset: withDraw(reset),