vega 0.3.1 → 0.4.0

data/vendor/assets/javascripts/vega-embed.js

@@ -506,7 +506,6 @@
         results[i] = applyOperation(document, patch[i], validateOperation, true, banPrototypeModifications, i);
         document = results[i].newDocument; // in case root was replaced
       }
-
       results.newDocument = document;
       return results;
     }
@@ -877,6 +876,10 @@
       unescapePathComponent
     });
 
+    function getDefaultExportFromCjs (x) {
+    	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+    }
+
     // Note: This regex matches even invalid JSON strings, but since we’re
     // working on the output of `JSON.stringify` we know that only valid strings
     // are present (unless the user supplied a weird `options.indent` but in
@@ -943,676 +946,59 @@
         return string;
       }(passedObj, "", 0);
     };
+    var stringify$1 = /*@__PURE__*/getDefaultExportFromCjs(jsonStringifyPrettyCompact);
 
-    var iterator;
-    var hasRequiredIterator;
-    function requireIterator() {
-      if (hasRequiredIterator) return iterator;
-      hasRequiredIterator = 1;
-      iterator = function (Yallist) {
-        Yallist.prototype[Symbol.iterator] = function* () {
-          for (let walker = this.head; walker; walker = walker.next) {
-            yield walker.value;
-          }
-        };
-      };
-      return iterator;
-    }
-
-    var yallist = Yallist$1;
-    Yallist$1.Node = Node;
-    Yallist$1.create = Yallist$1;
-    function Yallist$1(list) {
-      var self = this;
-      if (!(self instanceof Yallist$1)) {
-        self = new Yallist$1();
-      }
-      self.tail = null;
-      self.head = null;
-      self.length = 0;
-      if (list && typeof list.forEach === 'function') {
-        list.forEach(function (item) {
-          self.push(item);
-        });
-      } else if (arguments.length > 0) {
-        for (var i = 0, l = arguments.length; i < l; i++) {
-          self.push(arguments[i]);
-        }
-      }
-      return self;
-    }
-    Yallist$1.prototype.removeNode = function (node) {
-      if (node.list !== this) {
-        throw new Error('removing node which does not belong to this list');
-      }
-      var next = node.next;
-      var prev = node.prev;
-      if (next) {
-        next.prev = prev;
-      }
-      if (prev) {
-        prev.next = next;
-      }
-      if (node === this.head) {
-        this.head = next;
-      }
-      if (node === this.tail) {
-        this.tail = prev;
-      }
-      node.list.length--;
-      node.next = null;
-      node.prev = null;
-      node.list = null;
-      return next;
-    };
-    Yallist$1.prototype.unshiftNode = function (node) {
-      if (node === this.head) {
-        return;
-      }
-      if (node.list) {
-        node.list.removeNode(node);
-      }
-      var head = this.head;
-      node.list = this;
-      node.next = head;
-      if (head) {
-        head.prev = node;
-      }
-      this.head = node;
-      if (!this.tail) {
-        this.tail = node;
-      }
-      this.length++;
-    };
-    Yallist$1.prototype.pushNode = function (node) {
-      if (node === this.tail) {
-        return;
-      }
-      if (node.list) {
-        node.list.removeNode(node);
-      }
-      var tail = this.tail;
-      node.list = this;
-      node.prev = tail;
-      if (tail) {
-        tail.next = node;
-      }
-      this.tail = node;
-      if (!this.head) {
-        this.head = node;
-      }
-      this.length++;
-    };
-    Yallist$1.prototype.push = function () {
-      for (var i = 0, l = arguments.length; i < l; i++) {
-        push(this, arguments[i]);
-      }
-      return this.length;
-    };
-    Yallist$1.prototype.unshift = function () {
-      for (var i = 0, l = arguments.length; i < l; i++) {
-        unshift(this, arguments[i]);
-      }
-      return this.length;
-    };
-    Yallist$1.prototype.pop = function () {
-      if (!this.tail) {
-        return undefined;
-      }
-      var res = this.tail.value;
-      this.tail = this.tail.prev;
-      if (this.tail) {
-        this.tail.next = null;
-      } else {
-        this.head = null;
-      }
-      this.length--;
-      return res;
-    };
-    Yallist$1.prototype.shift = function () {
-      if (!this.head) {
-        return undefined;
-      }
-      var res = this.head.value;
-      this.head = this.head.next;
-      if (this.head) {
-        this.head.prev = null;
-      } else {
-        this.tail = null;
-      }
-      this.length--;
-      return res;
-    };
-    Yallist$1.prototype.forEach = function (fn, thisp) {
-      thisp = thisp || this;
-      for (var walker = this.head, i = 0; walker !== null; i++) {
-        fn.call(thisp, walker.value, i, this);
-        walker = walker.next;
-      }
-    };
-    Yallist$1.prototype.forEachReverse = function (fn, thisp) {
-      thisp = thisp || this;
-      for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
-        fn.call(thisp, walker.value, i, this);
-        walker = walker.prev;
-      }
-    };
-    Yallist$1.prototype.get = function (n) {
-      for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
-        // abort out of the list early if we hit a cycle
-        walker = walker.next;
-      }
-      if (i === n && walker !== null) {
-        return walker.value;
-      }
-    };
-    Yallist$1.prototype.getReverse = function (n) {
-      for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
-        // abort out of the list early if we hit a cycle
-        walker = walker.prev;
-      }
-      if (i === n && walker !== null) {
-        return walker.value;
-      }
-    };
-    Yallist$1.prototype.map = function (fn, thisp) {
-      thisp = thisp || this;
-      var res = new Yallist$1();
-      for (var walker = this.head; walker !== null;) {
-        res.push(fn.call(thisp, walker.value, this));
-        walker = walker.next;
-      }
-      return res;
-    };
-    Yallist$1.prototype.mapReverse = function (fn, thisp) {
-      thisp = thisp || this;
-      var res = new Yallist$1();
-      for (var walker = this.tail; walker !== null;) {
-        res.push(fn.call(thisp, walker.value, this));
-        walker = walker.prev;
-      }
-      return res;
-    };
-    Yallist$1.prototype.reduce = function (fn, initial) {
-      var acc;
-      var walker = this.head;
-      if (arguments.length > 1) {
-        acc = initial;
-      } else if (this.head) {
-        walker = this.head.next;
-        acc = this.head.value;
-      } else {
-        throw new TypeError('Reduce of empty list with no initial value');
-      }
-      for (var i = 0; walker !== null; i++) {
-        acc = fn(acc, walker.value, i);
-        walker = walker.next;
-      }
-      return acc;
-    };
-    Yallist$1.prototype.reduceReverse = function (fn, initial) {
-      var acc;
-      var walker = this.tail;
-      if (arguments.length > 1) {
-        acc = initial;
-      } else if (this.tail) {
-        walker = this.tail.prev;
-        acc = this.tail.value;
-      } else {
-        throw new TypeError('Reduce of empty list with no initial value');
-      }
-      for (var i = this.length - 1; walker !== null; i--) {
-        acc = fn(acc, walker.value, i);
-        walker = walker.prev;
-      }
-      return acc;
-    };
-    Yallist$1.prototype.toArray = function () {
-      var arr = new Array(this.length);
-      for (var i = 0, walker = this.head; walker !== null; i++) {
-        arr[i] = walker.value;
-        walker = walker.next;
-      }
-      return arr;
-    };
-    Yallist$1.prototype.toArrayReverse = function () {
-      var arr = new Array(this.length);
-      for (var i = 0, walker = this.tail; walker !== null; i++) {
-        arr[i] = walker.value;
-        walker = walker.prev;
-      }
-      return arr;
-    };
-    Yallist$1.prototype.slice = function (from, to) {
-      to = to || this.length;
-      if (to < 0) {
-        to += this.length;
-      }
-      from = from || 0;
-      if (from < 0) {
-        from += this.length;
-      }
-      var ret = new Yallist$1();
-      if (to < from || to < 0) {
-        return ret;
-      }
-      if (from < 0) {
-        from = 0;
-      }
-      if (to > this.length) {
-        to = this.length;
-      }
-      for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
-        walker = walker.next;
-      }
-      for (; walker !== null && i < to; i++, walker = walker.next) {
-        ret.push(walker.value);
-      }
-      return ret;
-    };
-    Yallist$1.prototype.sliceReverse = function (from, to) {
-      to = to || this.length;
-      if (to < 0) {
-        to += this.length;
-      }
-      from = from || 0;
-      if (from < 0) {
-        from += this.length;
-      }
-      var ret = new Yallist$1();
-      if (to < from || to < 0) {
-        return ret;
-      }
-      if (from < 0) {
-        from = 0;
-      }
-      if (to > this.length) {
-        to = this.length;
-      }
-      for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-        walker = walker.prev;
-      }
-      for (; walker !== null && i > from; i--, walker = walker.prev) {
-        ret.push(walker.value);
-      }
-      return ret;
-    };
-    Yallist$1.prototype.splice = function (start, deleteCount) {
-      if (start > this.length) {
-        start = this.length - 1;
-      }
-      if (start < 0) {
-        start = this.length + start;
-      }
-      for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-        walker = walker.next;
-      }
-      var ret = [];
-      for (var i = 0; walker && i < deleteCount; i++) {
-        ret.push(walker.value);
-        walker = this.removeNode(walker);
-      }
-      if (walker === null) {
-        walker = this.tail;
-      }
-      if (walker !== this.head && walker !== this.tail) {
-        walker = walker.prev;
-      }
-      for (var i = 0; i < (arguments.length <= 2 ? 0 : arguments.length - 2); i++) {
-        walker = insert(this, walker, i + 2 < 2 || arguments.length <= i + 2 ? undefined : arguments[i + 2]);
-      }
-      return ret;
-    };
-    Yallist$1.prototype.reverse = function () {
-      var head = this.head;
-      var tail = this.tail;
-      for (var walker = head; walker !== null; walker = walker.prev) {
-        var p = walker.prev;
-        walker.prev = walker.next;
-        walker.next = p;
-      }
-      this.head = tail;
-      this.tail = head;
-      return this;
-    };
-    function insert(self, node, value) {
-      var inserted = node === self.head ? new Node(value, null, node, self) : new Node(value, node, node.next, self);
-      if (inserted.next === null) {
-        self.tail = inserted;
-      }
-      if (inserted.prev === null) {
-        self.head = inserted;
-      }
-      self.length++;
-      return inserted;
-    }
-    function push(self, item) {
-      self.tail = new Node(item, self.tail, null, self);
-      if (!self.head) {
-        self.head = self.tail;
-      }
-      self.length++;
-    }
-    function unshift(self, item) {
-      self.head = new Node(item, null, self.head, self);
-      if (!self.tail) {
-        self.tail = self.head;
-      }
-      self.length++;
-    }
-    function Node(value, prev, next, list) {
-      if (!(this instanceof Node)) {
-        return new Node(value, prev, next, list);
-      }
-      this.list = list;
-      this.value = value;
-      if (prev) {
-        prev.next = this;
-        this.prev = prev;
-      } else {
-        this.prev = null;
-      }
-      if (next) {
-        next.prev = this;
-        this.next = next;
-      } else {
-        this.next = null;
-      }
-    }
-    try {
-      // add if support for Symbol.iterator is present
-      requireIterator()(Yallist$1);
-    } catch (er) {}
-
-    // A linked list to keep track of recently-used-ness
-    const Yallist = yallist;
-    const MAX = Symbol('max');
-    const LENGTH = Symbol('length');
-    const LENGTH_CALCULATOR = Symbol('lengthCalculator');
-    const ALLOW_STALE = Symbol('allowStale');
-    const MAX_AGE = Symbol('maxAge');
-    const DISPOSE = Symbol('dispose');
-    const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
-    const LRU_LIST = Symbol('lruList');
-    const CACHE = Symbol('cache');
-    const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
-    const naiveLength = () => 1;
-
-    // lruList is a yallist where the head is the youngest
-    // item, and the tail is the oldest.  the list contains the Hit
-    // objects as the entries.
-    // Each Hit object has a reference to its Yallist.Node.  This
-    // never changes.
-    //
-    // cache is a Map (or PseudoMap) that matches the keys to
-    // the Yallist.Node object.
     class LRUCache {
-      constructor(options) {
-        if (typeof options === 'number') options = {
-          max: options
-        };
-        if (!options) options = {};
-        if (options.max && (typeof options.max !== 'number' || options.max < 0)) throw new TypeError('max must be a non-negative number');
-        // Kind of weird to have a default max of Infinity, but oh well.
-        this[MAX] = options.max || Infinity;
-        const lc = options.length || naiveLength;
-        this[LENGTH_CALCULATOR] = typeof lc !== 'function' ? naiveLength : lc;
-        this[ALLOW_STALE] = options.stale || false;
-        if (options.maxAge && typeof options.maxAge !== 'number') throw new TypeError('maxAge must be a number');
-        this[MAX_AGE] = options.maxAge || 0;
-        this[DISPOSE] = options.dispose;
-        this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
-        this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
-        this.reset();
-      }
-
-      // resize the cache when the max changes.
-      set max(mL) {
-        if (typeof mL !== 'number' || mL < 0) throw new TypeError('max must be a non-negative number');
-        this[MAX] = mL || Infinity;
-        trim(this);
-      }
-      get max() {
-        return this[MAX];
-      }
-      set allowStale(allowStale) {
-        this[ALLOW_STALE] = !!allowStale;
-      }
-      get allowStale() {
-        return this[ALLOW_STALE];
-      }
-      set maxAge(mA) {
-        if (typeof mA !== 'number') throw new TypeError('maxAge must be a non-negative number');
-        this[MAX_AGE] = mA;
-        trim(this);
-      }
-      get maxAge() {
-        return this[MAX_AGE];
-      }
-
-      // resize the cache when the lengthCalculator changes.
-      set lengthCalculator(lC) {
-        if (typeof lC !== 'function') lC = naiveLength;
-        if (lC !== this[LENGTH_CALCULATOR]) {
-          this[LENGTH_CALCULATOR] = lC;
-          this[LENGTH] = 0;
-          this[LRU_LIST].forEach(hit => {
-            hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
-            this[LENGTH] += hit.length;
-          });
-        }
-        trim(this);
-      }
-      get lengthCalculator() {
-        return this[LENGTH_CALCULATOR];
-      }
-      get length() {
-        return this[LENGTH];
-      }
-      get itemCount() {
-        return this[LRU_LIST].length;
-      }
-      rforEach(fn, thisp) {
-        thisp = thisp || this;
-        for (let walker = this[LRU_LIST].tail; walker !== null;) {
-          const prev = walker.prev;
-          forEachStep(this, fn, walker, thisp);
-          walker = prev;
-        }
-      }
-      forEach(fn, thisp) {
-        thisp = thisp || this;
-        for (let walker = this[LRU_LIST].head; walker !== null;) {
-          const next = walker.next;
-          forEachStep(this, fn, walker, thisp);
-          walker = next;
-        }
-      }
-      keys() {
-        return this[LRU_LIST].toArray().map(k => k.key);
-      }
-      values() {
-        return this[LRU_LIST].toArray().map(k => k.value);
-      }
-      reset() {
-        if (this[DISPOSE] && this[LRU_LIST] && this[LRU_LIST].length) {
-          this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
-        }
-        this[CACHE] = new Map(); // hash of items by key
-        this[LRU_LIST] = new Yallist(); // list of items in order of use recency
-        this[LENGTH] = 0; // length of items in the list
-      }
-
-      dump() {
-        return this[LRU_LIST].map(hit => isStale(this, hit) ? false : {
-          k: hit.key,
-          v: hit.value,
-          e: hit.now + (hit.maxAge || 0)
-        }).toArray().filter(h => h);
-      }
-      dumpLru() {
-        return this[LRU_LIST];
-      }
-      set(key, value, maxAge) {
-        maxAge = maxAge || this[MAX_AGE];
-        if (maxAge && typeof maxAge !== 'number') throw new TypeError('maxAge must be a number');
-        const now = maxAge ? Date.now() : 0;
-        const len = this[LENGTH_CALCULATOR](value, key);
-        if (this[CACHE].has(key)) {
-          if (len > this[MAX]) {
-            del(this, this[CACHE].get(key));
-            return false;
-          }
-          const node = this[CACHE].get(key);
-          const item = node.value;
-
-          // dispose of the old one before overwriting
-          // split out into 2 ifs for better coverage tracking
-          if (this[DISPOSE]) {
-            if (!this[NO_DISPOSE_ON_SET]) this[DISPOSE](key, item.value);
-          }
-          item.now = now;
-          item.maxAge = maxAge;
-          item.value = value;
-          this[LENGTH] += len - item.length;
-          item.length = len;
-          this.get(key);
-          trim(this);
-          return true;
-        }
-        const hit = new Entry(key, value, len, now, maxAge);
-
-        // oversized objects fall out of cache automatically.
-        if (hit.length > this[MAX]) {
-          if (this[DISPOSE]) this[DISPOSE](key, value);
-          return false;
-        }
-        this[LENGTH] += hit.length;
-        this[LRU_LIST].unshift(hit);
-        this[CACHE].set(key, this[LRU_LIST].head);
-        trim(this);
-        return true;
-      }
-      has(key) {
-        if (!this[CACHE].has(key)) return false;
-        const hit = this[CACHE].get(key).value;
-        return !isStale(this, hit);
+      constructor() {
+        this.max = 1000;
+        this.map = new Map();
       }
       get(key) {
-        return get(this, key, true);
-      }
-      peek(key) {
-        return get(this, key, false);
-      }
-      pop() {
-        const node = this[LRU_LIST].tail;
-        if (!node) return null;
-        del(this, node);
-        return node.value;
-      }
-      del(key) {
-        del(this, this[CACHE].get(key));
-      }
-      load(arr) {
-        // reset the cache
-        this.reset();
-        const now = Date.now();
-        // A previous serialized cache has the most recent items first
-        for (let l = arr.length - 1; l >= 0; l--) {
-          const hit = arr[l];
-          const expiresAt = hit.e || 0;
-          if (expiresAt === 0)
-            // the item was created without expiration in a non aged cache
-            this.set(hit.k, hit.v);else {
-            const maxAge = expiresAt - now;
-            // dont add already expired items
-            if (maxAge > 0) {
-              this.set(hit.k, hit.v, maxAge);
-            }
-          }
+        const value = this.map.get(key);
+        if (value === undefined) {
+          return undefined;
+        } else {
+          // Remove the key from the map and add it to the end
+          this.map.delete(key);
+          this.map.set(key, value);
+          return value;
         }
       }
-      prune() {
-        this[CACHE].forEach((value, key) => get(this, key, false));
+      delete(key) {
+        return this.map.delete(key);
       }
-    }
-    const get = (self, key, doUse) => {
-      const node = self[CACHE].get(key);
-      if (node) {
-        const hit = node.value;
-        if (isStale(self, hit)) {
-          del(self, node);
-          if (!self[ALLOW_STALE]) return undefined;
-        } else {
-          if (doUse) {
-            if (self[UPDATE_AGE_ON_GET]) node.value.now = Date.now();
-            self[LRU_LIST].unshiftNode(node);
+      set(key, value) {
+        const deleted = this.delete(key);
+        if (!deleted && value !== undefined) {
+          // If cache is full, delete the least recently used item
+          if (this.map.size >= this.max) {
+            const firstKey = this.map.keys().next().value;
+            this.delete(firstKey);
           }
+          this.map.set(key, value);
         }
-        return hit.value;
-      }
-    };
-    const isStale = (self, hit) => {
-      if (!hit || !hit.maxAge && !self[MAX_AGE]) return false;
-      const diff = Date.now() - hit.now;
-      return hit.maxAge ? diff > hit.maxAge : self[MAX_AGE] && diff > self[MAX_AGE];
-    };
-    const trim = self => {
-      if (self[LENGTH] > self[MAX]) {
-        for (let walker = self[LRU_LIST].tail; self[LENGTH] > self[MAX] && walker !== null;) {
-          // We know that we're about to delete this one, and also
-          // what the next least recently used key will be, so just
-          // go ahead and set it now.
-          const prev = walker.prev;
-          del(self, walker);
-          walker = prev;
-        }
-      }
-    };
-    const del = (self, node) => {
-      if (node) {
-        const hit = node.value;
-        if (self[DISPOSE]) self[DISPOSE](hit.key, hit.value);
-        self[LENGTH] -= hit.length;
-        self[CACHE].delete(hit.key);
-        self[LRU_LIST].removeNode(node);
-      }
-    };
-    class Entry {
-      constructor(key, value, length, now, maxAge) {
-        this.key = key;
-        this.value = value;
-        this.length = length;
-        this.now = now;
-        this.maxAge = maxAge || 0;
+        return this;
       }
     }
-    const forEachStep = (self, fn, node, thisp) => {
-      let hit = node.value;
-      if (isStale(self, hit)) {
-        del(self, node);
-        if (!self[ALLOW_STALE]) hit = undefined;
-      }
-      if (hit) fn.call(thisp, hit.value, hit.key, self);
-    };
-    var lruCache = LRUCache;
+    var lrucache = LRUCache;
 
-    // parse out just the options we care about so we always get a consistent
-    // obj with keys in a consistent order.
-    const opts = ['includePrerelease', 'loose', 'rtl'];
-    const parseOptions$1 = options => !options ? {} : typeof options !== 'object' ? {
+    // parse out just the options we care about
+    const looseOption = Object.freeze({
       loose: true
-    } : opts.filter(k => options[k]).reduce((o, k) => {
-      o[k] = true;
-      return o;
-    }, {});
+    });
+    const emptyOpts = Object.freeze({});
+    const parseOptions$1 = options => {
+      if (!options) {
+        return emptyOpts;
+      }
+      if (typeof options !== 'object') {
+        return looseOption;
+      }
+      return options;
+    };
     var parseOptions_1 = parseOptions$1;
 
-    var reExports = {};
-    var re$1 = {
-      get exports(){ return reExports; },
-      set exports(v){ reExports = v; },
-    };
+    var re$1 = {exports: {}};
 
     // Note: this is the semver.org version of the spec that it implements
     // Not necessarily the package version of this code.
@@ -1622,39 +1008,63 @@
 
     // Max safe segment length for coercion.
     const MAX_SAFE_COMPONENT_LENGTH = 16;
+
+    // Max safe length for a build identifier. The max length minus 6 characters for
+    // the shortest version with a build 0.0.0+BUILD.
+    const MAX_SAFE_BUILD_LENGTH = MAX_LENGTH$1 - 6;
+    const RELEASE_TYPES = ['major', 'premajor', 'minor', 'preminor', 'patch', 'prepatch', 'prerelease'];
     var constants = {
-      SEMVER_SPEC_VERSION,
       MAX_LENGTH: MAX_LENGTH$1,
+      MAX_SAFE_COMPONENT_LENGTH,
+      MAX_SAFE_BUILD_LENGTH,
       MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1,
-      MAX_SAFE_COMPONENT_LENGTH
+      RELEASE_TYPES,
+      SEMVER_SPEC_VERSION,
+      FLAG_INCLUDE_PRERELEASE: 0b001,
+      FLAG_LOOSE: 0b010
     };
 
-    const debug$1 = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? function () {
-      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-        args[_key] = arguments[_key];
-      }
-      return console.error('SEMVER', ...args);
-    } : () => {};
+    const debug$1 = typeof process === 'object' && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args) => console.error('SEMVER', ...args) : () => {};
     var debug_1 = debug$1;
 
     (function (module, exports) {
       const {
-        MAX_SAFE_COMPONENT_LENGTH
+        MAX_SAFE_COMPONENT_LENGTH,
+        MAX_SAFE_BUILD_LENGTH,
+        MAX_LENGTH
       } = constants;
       const debug = debug_1;
       exports = module.exports = {};
 
       // The actual regexps go on exports.re
       const re = exports.re = [];
+      const safeRe = exports.safeRe = [];
       const src = exports.src = [];
       const t = exports.t = {};
       let R = 0;
+      const LETTERDASHNUMBER = '[a-zA-Z0-9-]';
+
+      // Replace some greedy regex tokens to prevent regex dos issues. These regex are
+      // used internally via the safeRe object since all inputs in this library get
+      // normalized first to trim and collapse all extra whitespace. The original
+      // regexes are exported for userland consumption and lower level usage. A
+      // future breaking change could export the safer regex only with a note that
+      // all input should have extra whitespace removed.
+      const safeRegexReplacements = [['\\s', 1], ['\\d', MAX_LENGTH], [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]];
+      const makeSafeRegex = value => {
+        for (const [token, max] of safeRegexReplacements) {
+          value = value.split(`${token}*`).join(`${token}{0,${max}}`).split(`${token}+`).join(`${token}{1,${max}}`);
+        }
+        return value;
+      };
       const createToken = (name, value, isGlobal) => {
+        const safe = makeSafeRegex(value);
         const index = R++;
         debug(name, index, value);
         t[name] = index;
         src[index] = value;
         re[index] = new RegExp(value, isGlobal ? 'g' : undefined);
+        safeRe[index] = new RegExp(safe, isGlobal ? 'g' : undefined);
       };
 
       // The following Regular Expressions can be used for tokenizing,
@@ -1664,13 +1074,13 @@
       // A single `0`, or a non-zero digit followed by zero or more digits.
 
       createToken('NUMERICIDENTIFIER', '0|[1-9]\\d*');
-      createToken('NUMERICIDENTIFIERLOOSE', '[0-9]+');
+      createToken('NUMERICIDENTIFIERLOOSE', '\\d+');
 
       // ## Non-numeric Identifier
       // Zero or more digits, followed by a letter or hyphen, and then zero or
       // more letters, digits, or hyphens.
 
-      createToken('NONNUMERICIDENTIFIER', '\\d*[a-zA-Z-][a-zA-Z0-9-]*');
+      createToken('NONNUMERICIDENTIFIER', `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
 
       // ## Main Version
       // Three dot-separated numeric identifiers.
@@ -1694,7 +1104,7 @@
       // ## Build Metadata Identifier
       // Any combination of digits, letters, or hyphens.
 
-      createToken('BUILDIDENTIFIER', '[0-9A-Za-z-]+');
+      createToken('BUILDIDENTIFIER', `${LETTERDASHNUMBER}+`);
 
       // ## Build Metadata
       // Plus sign, followed by one or more period-separated build metadata
@@ -1733,8 +1143,11 @@
 
       // Coercion.
       // Extract anything that could conceivably be a part of a valid semver
-      createToken('COERCE', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:$|[^\\d])`);
+      createToken('COERCEPLAIN', `${'(^|[^\\d])' + '(\\d{1,'}${MAX_SAFE_COMPONENT_LENGTH}})` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?` + `(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
+      createToken('COERCE', `${src[t.COERCEPLAIN]}(?:$|[^\\d])`);
+      createToken('COERCEFULL', src[t.COERCEPLAIN] + `(?:${src[t.PRERELEASE]})?` + `(?:${src[t.BUILD]})?` + `(?:$|[^\\d])`);
       createToken('COERCERTL', src[t.COERCE], true);
+      createToken('COERCERTLFULL', src[t.COERCEFULL], true);
 
       // Tilde ranges.
       // Meaning is "reasonably at or greater than"
@@ -1773,7 +1186,8 @@
       // >=0.0.0 is like a star
       createToken('GTE0', '^\\s*>=\\s*0\\.0\\.0\\s*$');
       createToken('GTE0PRE', '^\\s*>=\\s*0\\.0\\.0-0\\s*$');
-    })(re$1, reExports);
+    })(re$1, re$1.exports);
+    var reExports = re$1.exports;
 
     const numeric = /^[0-9]+$/;
     const compareIdentifiers$1 = (a, b) => {
@@ -1797,7 +1211,7 @@
       MAX_SAFE_INTEGER
     } = constants;
     const {
-      re,
+      safeRe: re,
       t
     } = reExports;
     const parseOptions = parseOptions_1;
@@ -1814,7 +1228,7 @@
             version = version.version;
           }
         } else if (typeof version !== 'string') {
-          throw new TypeError(`Invalid Version: ${version}`);
+          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version}".`);
         }
         if (version.length > MAX_LENGTH) {
           throw new TypeError(`version is longer than ${MAX_LENGTH} characters`);
@@ -1930,7 +1344,7 @@
         do {
           const a = this.build[i];
           const b = other.build[i];
-          debug('prerelease compare', i, a, b);
+          debug('build compare', i, a, b);
           if (a === undefined && b === undefined) {
             return 0;
           } else if (b === undefined) {
@@ -1947,36 +1361,36 @@
 
       // preminor will bump the version up to the next minor release, and immediately
       // down to pre-release. premajor and prepatch work the same way.
-      inc(release, identifier) {
+      inc(release, identifier, identifierBase) {
         switch (release) {
           case 'premajor':
             this.prerelease.length = 0;
             this.patch = 0;
             this.minor = 0;
             this.major++;
-            this.inc('pre', identifier);
+            this.inc('pre', identifier, identifierBase);
             break;
           case 'preminor':
             this.prerelease.length = 0;
             this.patch = 0;
             this.minor++;
-            this.inc('pre', identifier);
+            this.inc('pre', identifier, identifierBase);
             break;
           case 'prepatch':
             // If this is already a prerelease, it will bump to the next version
             // drop any prereleases that might already exist, since they are not
             // relevant at this point.
             this.prerelease.length = 0;
-            this.inc('patch', identifier);
-            this.inc('pre', identifier);
+            this.inc('patch', identifier, identifierBase);
+            this.inc('pre', identifier, identifierBase);
             break;
           // If the input is a non-prerelease version, this acts the same as
           // prepatch.
           case 'prerelease':
             if (this.prerelease.length === 0) {
-              this.inc('patch', identifier);
+              this.inc('patch', identifier, identifierBase);
             }
-            this.inc('pre', identifier);
+            this.inc('pre', identifier, identifierBase);
             break;
           case 'major':
             // If this is a pre-major version, bump up to the same major version.
@@ -2014,38 +1428,53 @@
           // This probably shouldn't be used publicly.
           // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
           case 'pre':
-            if (this.prerelease.length === 0) {
-              this.prerelease = [0];
-            } else {
-              let i = this.prerelease.length;
-              while (--i >= 0) {
-                if (typeof this.prerelease[i] === 'number') {
-                  this.prerelease[i]++;
-                  i = -2;
-                }
+            {
+              const base = Number(identifierBase) ? 1 : 0;
+              if (!identifier && identifierBase === false) {
+                throw new Error('invalid increment argument: identifier is empty');
               }
-              if (i === -1) {
-                // didn't increment anything
-                this.prerelease.push(0);
+              if (this.prerelease.length === 0) {
+                this.prerelease = [base];
+              } else {
+                let i = this.prerelease.length;
+                while (--i >= 0) {
+                  if (typeof this.prerelease[i] === 'number') {
+                    this.prerelease[i]++;
+                    i = -2;
+                  }
+                }
+                if (i === -1) {
+                  // didn't increment anything
+                  if (identifier === this.prerelease.join('.') && identifierBase === false) {
+                    throw new Error('invalid increment argument: identifier already exists');
+                  }
+                  this.prerelease.push(base);
+                }
               }
-            }
-            if (identifier) {
-              // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
-              // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
-              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
-                if (isNaN(this.prerelease[1])) {
-                  this.prerelease = [identifier, 0];
+              if (identifier) {
+                // 1.2.0-beta.1 bumps to 1.2.0-beta.2,
+                // 1.2.0-beta.fooblz or 1.2.0-beta bumps to 1.2.0-beta.0
+                let prerelease = [identifier, base];
+                if (identifierBase === false) {
+                  prerelease = [identifier];
+                }
+                if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
+                  if (isNaN(this.prerelease[1])) {
+                    this.prerelease = prerelease;
+                  }
+                } else {
+                  this.prerelease = prerelease;
                 }
-              } else {
-                this.prerelease = [identifier, 0];
               }
+              break;
             }
-            break;
           default:
             throw new Error(`invalid increment argument: ${release}`);
         }
-        this.format();
-        this.raw = this.version;
+        this.raw = this.format();
+        if (this.build.length) {
+          this.raw += `+${this.build.join('.')}`;
+        }
         return this;
       }
     };
@@ -2143,6 +1572,7 @@
               comp = comp.value;
             }
           }
+          comp = comp.trim().split(/\s+/).join(' ');
           debug('comparator', comp, options);
           this.options = options;
           this.loose = !!options.loose;
@@ -2193,12 +1623,6 @@
           if (!(comp instanceof Comparator)) {
             throw new TypeError('a Comparator is required');
           }
-          if (!options || typeof options !== 'object') {
-            options = {
-              loose: !!options,
-              includePrerelease: false
-            };
-          }
           if (this.operator === '') {
             if (this.value === '') {
               return true;
@@ -2210,19 +1634,43 @@
             }
             return new Range(this.value, options).test(comp.semver);
           }
-          const sameDirectionIncreasing = (this.operator === '>=' || this.operator === '>') && (comp.operator === '>=' || comp.operator === '>');
-          const sameDirectionDecreasing = (this.operator === '<=' || this.operator === '<') && (comp.operator === '<=' || comp.operator === '<');
-          const sameSemVer = this.semver.version === comp.semver.version;
-          const differentDirectionsInclusive = (this.operator === '>=' || this.operator === '<=') && (comp.operator === '>=' || comp.operator === '<=');
-          const oppositeDirectionsLessThan = cmp(this.semver, '<', comp.semver, options) && (this.operator === '>=' || this.operator === '>') && (comp.operator === '<=' || comp.operator === '<');
-          const oppositeDirectionsGreaterThan = cmp(this.semver, '>', comp.semver, options) && (this.operator === '<=' || this.operator === '<') && (comp.operator === '>=' || comp.operator === '>');
-          return sameDirectionIncreasing || sameDirectionDecreasing || sameSemVer && differentDirectionsInclusive || oppositeDirectionsLessThan || oppositeDirectionsGreaterThan;
+          options = parseOptions(options);
+
+          // Special cases where nothing can possibly be lower
+          if (options.includePrerelease && (this.value === '<0.0.0-0' || comp.value === '<0.0.0-0')) {
+            return false;
+          }
+          if (!options.includePrerelease && (this.value.startsWith('<0.0.0') || comp.value.startsWith('<0.0.0'))) {
+            return false;
+          }
+
+          // Same direction increasing (> or >=)
+          if (this.operator.startsWith('>') && comp.operator.startsWith('>')) {
+            return true;
+          }
+          // Same direction decreasing (< or <=)
+          if (this.operator.startsWith('<') && comp.operator.startsWith('<')) {
+            return true;
+          }
+          // same SemVer and both sides are inclusive (<= or >=)
+          if (this.semver.version === comp.semver.version && this.operator.includes('=') && comp.operator.includes('=')) {
+            return true;
+          }
+          // opposite directions less than
+          if (cmp(this.semver, '<', comp.semver, options) && this.operator.startsWith('>') && comp.operator.startsWith('<')) {
+            return true;
+          }
+          // opposite directions greater than
+          if (cmp(this.semver, '>', comp.semver, options) && this.operator.startsWith('<') && comp.operator.startsWith('>')) {
+            return true;
+          }
+          return false;
         }
       }
       comparator = Comparator;
       const parseOptions = parseOptions_1;
       const {
-        re,
+        safeRe: re,
         t
       } = reExports;
       const cmp = cmp_1;
@@ -2259,9 +1707,13 @@
           this.loose = !!options.loose;
           this.includePrerelease = !!options.includePrerelease;
 
-          // First, split based on boolean or ||
-          this.raw = range;
-          this.set = range.split('||')
+          // First reduce all whitespace as much as possible so we do not have to rely
+          // on potentially slow regexes like \s*. This is then stored and used for
+          // future error messages as well.
+          this.raw = range.trim().split(/\s+/).join(' ');
+
+          // First, split on ||
+          this.set = this.raw.split('||')
           // map the range to a 2d array of comparators
           .map(r => this.parseRange(r.trim()))
           // throw out any comparator lists that are empty
@@ -2269,7 +1721,7 @@
           // in loose mode, but will still throw if the WHOLE range is invalid.
           .filter(c => c.length);
           if (!this.set.length) {
-            throw new TypeError(`Invalid SemVer Range: ${range}`);
+            throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
           }
 
           // if we have any that are not the null set, throw out null sets.
@@ -2292,21 +1744,17 @@
           this.format();
         }
         format() {
-          this.range = this.set.map(comps => {
-            return comps.join(' ').trim();
-          }).join('||').trim();
+          this.range = this.set.map(comps => comps.join(' ').trim()).join('||').trim();
           return this.range;
         }
         toString() {
           return this.range;
         }
         parseRange(range) {
-          range = range.trim();
-
           // memoize range parsing for performance.
           // this is a very hot path, and fully deterministic.
-          const memoOpts = Object.keys(this.options).join(',');
-          const memoKey = `parseRange:${memoOpts}:${range}`;
+          const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
+          const memoKey = memoOpts + ':' + range;
           const cached = cache.get(memoKey);
           if (cached) {
             return cached;
@@ -2316,18 +1764,18 @@
           const hr = loose ? re[t.HYPHENRANGELOOSE] : re[t.HYPHENRANGE];
           range = range.replace(hr, hyphenReplace(this.options.includePrerelease));
           debug('hyphen replace', range);
+
           // `> 1.2.3 < 1.2.5` => `>1.2.3 <1.2.5`
           range = range.replace(re[t.COMPARATORTRIM], comparatorTrimReplace);
           debug('comparator trim', range);
 
           // `~ 1.2.3` => `~1.2.3`
           range = range.replace(re[t.TILDETRIM], tildeTrimReplace);
+          debug('tilde trim', range);
 
           // `^ 1.2.3` => `^1.2.3`
           range = range.replace(re[t.CARETTRIM], caretTrimReplace);
-
-          // normalize spaces
-          range = range.split(/\s+/).join(' ');
+          debug('caret trim', range);
 
           // At this point, the range is completely trimmed and
           // ready to be split into comparators.
@@ -2398,21 +1846,23 @@
         }
       }
       range = Range;
-      const LRU = lruCache;
-      const cache = new LRU({
-        max: 1000
-      });
+      const LRU = lrucache;
+      const cache = new LRU();
       const parseOptions = parseOptions_1;
       const Comparator = requireComparator();
       const debug = debug_1;
       const SemVer = semver;
       const {
-        re,
+        safeRe: re,
         t,
         comparatorTrimReplace,
         tildeTrimReplace,
         caretTrimReplace
       } = reExports;
+      const {
+        FLAG_INCLUDE_PRERELEASE,
+        FLAG_LOOSE
+      } = constants;
       const isNullSet = c => c.value === '<0.0.0-0';
       const isAny = c => c.value === '';
 
@@ -2455,9 +1905,9 @@
       // ~1.2.3, ~>1.2.3 --> >=1.2.3 <1.3.0-0
       // ~1.2.0, ~>1.2.0 --> >=1.2.0 <1.3.0-0
       // ~0.0.1 --> >=0.0.1 <0.1.0-0
-      const replaceTildes = (comp, options) => comp.trim().split(/\s+/).map(c => {
-        return replaceTilde(c, options);
-      }).join(' ');
+      const replaceTildes = (comp, options) => {
+        return comp.trim().split(/\s+/).map(c => replaceTilde(c, options)).join(' ');
+      };
       const replaceTilde = (comp, options) => {
         const r = options.loose ? re[t.TILDELOOSE] : re[t.TILDE];
         return comp.replace(r, (_, M, m, p, pr) => {
@@ -2490,9 +1940,9 @@
       // ^1.2.0 --> >=1.2.0 <2.0.0-0
       // ^0.0.1 --> >=0.0.1 <0.0.2-0
       // ^0.1.0 --> >=0.1.0 <0.2.0-0
-      const replaceCarets = (comp, options) => comp.trim().split(/\s+/).map(c => {
-        return replaceCaret(c, options);
-      }).join(' ');
+      const replaceCarets = (comp, options) => {
+        return comp.trim().split(/\s+/).map(c => replaceCaret(c, options)).join(' ');
+      };
       const replaceCaret = (comp, options) => {
         debug('caret', comp, options);
         const r = options.loose ? re[t.CARETLOOSE] : re[t.CARET];
@@ -2539,9 +1989,7 @@
       };
       const replaceXRanges = (comp, options) => {
         debug('replaceXRanges', comp, options);
-        return comp.split(/\s+/).map(c => {
-          return replaceXRange(c, options);
-        }).join(' ');
+        return comp.split(/\s+/).map(c => replaceXRange(c, options)).join(' ');
       };
       const replaceXRange = (comp, options) => {
         comp = comp.trim();
@@ -2627,7 +2075,8 @@
       // 1.2 - 3.4.5 => >=1.2.0 <=3.4.5
       // 1.2.3 - 3.4 => >=1.2.0 <3.5.0-0 Any 3.4.x will do
       // 1.2 - 3.4 => >=1.2.0 <3.5.0-0
-      const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr, tb) => {
+      // TODO build?
+      const hyphenReplace = incPr => ($0, from, fM, fm, fp, fpr, fb, to, tM, tm, tp, tpr) => {
         if (isX(fM)) {
           from = '';
         } else if (isX(fm)) {
@@ -2697,6 +2146,7 @@
       return range.test(version);
     };
     var satisfies_1 = satisfies;
+    var satisfies$1 = /*@__PURE__*/getDefaultExportFromCjs(satisfies_1);
 
     function adjustSpatial(item, encode, swap) {
       let t;
@@ -2857,6 +2307,8 @@
       test: (r, t) => RegExp(r).test(t)
     };
     const EventFunctions = ['view', 'item', 'group', 'xy', 'x', 'y'];
+    const DisallowedMethods = new Set([Function, eval, setTimeout, setInterval]);
+    if (typeof setImmediate === 'function') DisallowedMethods.add(setImmediate);
     const Visitors = {
       Literal: ($, n) => n.value,
       Identifier: ($, n) => {
@@ -2869,17 +2321,24 @@
         if (d) $.memberDepth += 1;
         const p = $(n.property);
         if (d) $.memberDepth -= 1;
+        if (DisallowedMethods.has(o[p])) {
+          // eslint-disable-next-line no-console
+          console.error(`Prevented interpretation of member "${p}" which could lead to insecure code execution`);
+          return;
+        }
         return o[p];
       },
       CallExpression: ($, n) => {
         const args = n.arguments;
-        let name = n.callee.name; // handle special internal functions used by encoders
-        // re-route to corresponding standard function
+        let name = n.callee.name;
 
+        // handle special internal functions used by encoders
+        // re-route to corresponding standard function
         if (name.startsWith('_')) {
           name = name.slice(1);
-        } // special case "if" due to conditional evaluation of branches
+        }
 
+        // special case "if" due to conditional evaluation of branches
         return name === 'if' ? $(args[0]) ? $(args[1]) : $(args[2]) : ($.fn[name] || Functions[name]).apply($.fn, args.map($));
       },
       ArrayExpression: ($, n) => n.elements.map($),
@@ -2891,7 +2350,12 @@
         $.memberDepth += 1;
         const k = $(p.key);
         $.memberDepth -= 1;
-        o[k] = $(p.value);
+        if (DisallowedMethods.has($(p.value))) {
+          // eslint-disable-next-line no-console
+          console.error(`Prevented interpretation of property "${k}" which could lead to insecure code execution`);
+        } else {
+          o[k] = $(p.value);
+        }
         return o;
       }, {})
     };
@@ -2902,8 +2366,9 @@
       $.params = params;
       $.datum = datum;
       $.event = event;
-      $.item = item; // route event functions to annotated vega event context
+      $.item = item;
 
+      // route event functions to annotated vega event context
       EventFunctions.forEach(f => $.fn[f] = function () {
         return event.vega[f](...arguments);
       });
@@ -2983,7 +2448,7 @@
     }
 
     var name$1 = "vega-themes";
-    var version$1$1 = "2.12.1";
+    var version$1$1 = "2.15.0";
     var description$1 = "Themes for stylized Vega and Vega-Lite visualizations.";
     var keywords$1 = ["vega", "vega-lite", "themes", "style"];
     var license$1 = "BSD-3-Clause";
@@ -3024,28 +2489,35 @@
       preversion: "yarn lint",
       serve: "browser-sync start -s -f build examples --serveStatic examples",
       start: "yarn build && concurrently --kill-others -n Server,Rollup 'yarn serve' 'rollup -c -w'",
-      prepare: "beemo create-config",
-      eslintbase: "beemo eslint .",
-      format: "yarn eslintbase --fix",
-      lint: "yarn eslintbase",
+      format: "eslint . --fix",
+      lint: "eslint .",
       release: "release-it"
     };
     var devDependencies$1 = {
-      "@release-it/conventional-changelog": "^5.1.1",
-      "@rollup/plugin-json": "^6.0.0",
-      "@rollup/plugin-node-resolve": "^15.0.1",
-      "@rollup/plugin-terser": "^0.4.0",
-      "browser-sync": "^2.27.10",
-      concurrently: "^7.3.0",
-      "gh-pages": "^5.0.0",
-      "release-it": "^15.6.0",
+      "@babel/core": "^7.24.6",
+      "@babel/plugin-transform-runtime": "^7.24.6",
+      "@babel/preset-env": "^7.24.6",
+      "@babel/preset-typescript": "^7.24.6",
+      "@release-it/conventional-changelog": "^8.0.1",
+      "@rollup/plugin-json": "^6.1.0",
+      "@rollup/plugin-node-resolve": "^15.2.3",
+      "@rollup/plugin-terser": "^0.4.4",
+      "@typescript-eslint/eslint-plugin": "^7.11.0",
+      "@typescript-eslint/parser": "^7.11.0",
+      "browser-sync": "^3.0.2",
+      concurrently: "^8.2.2",
+      eslint: "^8.45.0",
+      "eslint-config-prettier": "^9.1.0",
+      "eslint-plugin-prettier": "^5.1.3",
+      "gh-pages": "^6.1.1",
+      prettier: "^3.2.5",
+      "release-it": "^17.3.0",
+      rollup: "^4.18.0",
       "rollup-plugin-bundle-size": "^1.0.3",
-      "rollup-plugin-ts": "^3.0.2",
-      rollup: "^3.15.0",
-      typescript: "^4.7.4",
-      "vega-lite-dev-config": "^0.21.0",
-      "vega-lite": "^5.0.0",
-      vega: "^5.19.1"
+      "rollup-plugin-ts": "^3.4.5",
+      typescript: "^5.4.5",
+      vega: "^5.25.0",
+      "vega-lite": "^5.9.3"
     };
     var peerDependencies$1 = {
       vega: "*",
@@ -3622,9 +3094,10 @@
      * license that can be found in the LICENSE file or at
      * https://developers.google.com/open-source/licenses/bsd
      */
+
     const markColor = '#3366CC';
     const gridColor = '#ccc';
-    const defaultFont = 'Arial, sans-serif';
+    const defaultFont$1 = 'Arial, sans-serif';
     const googlechartsTheme = {
       arc: {
         fill: markColor
@@ -3656,20 +3129,20 @@
       },
       style: {
         'guide-label': {
-          font: defaultFont,
+          font: defaultFont$1,
           fontSize: 12
         },
         'guide-title': {
-          font: defaultFont,
+          font: defaultFont$1,
           fontSize: 12
         },
         'group-title': {
-          font: defaultFont,
+          font: defaultFont$1,
           fontSize: 12
         }
       },
       title: {
-        font: defaultFont,
+        font: defaultFont$1,
         fontSize: 14,
         fontWeight: 'bold',
         dy: -3,
@@ -3807,10 +3280,151 @@
         ordinal: ordinalPalette
       }
     };
+    const defaultFont = 'IBM Plex Sans,system-ui,-apple-system,BlinkMacSystemFont,".sfnstext-regular",sans-serif';
+    const condensedFont = 'IBM Plex Sans Condensed, system-ui, -apple-system, BlinkMacSystemFont, ".SFNSText-Regular", sans-serif';
+    const fontWeight = 400;
+    const TOKENS = {
+      textPrimary: {
+        g90: '#f4f4f4',
+        g100: '#f4f4f4',
+        white: '#161616',
+        g10: '#161616'
+      },
+      textSecondary: {
+        g90: '#c6c6c6',
+        g100: '#c6c6c6',
+        white: '#525252',
+        g10: '#525252'
+      },
+      // layer
+      layerAccent01: {
+        white: '#e0e0e0',
+        g10: '#e0e0e0',
+        g90: '#525252',
+        g100: '#393939'
+      },
+      // grid
+      gridBg: {
+        white: '#ffffff',
+        g10: '#ffffff',
+        g90: '#161616',
+        g100: '#161616'
+      }
+    };
+    const darkCategories = ['#8a3ffc', '#33b1ff', '#007d79', '#ff7eb6', '#fa4d56', '#fff1f1', '#6fdc8c', '#4589ff', '#d12771', '#d2a106', '#08bdba', '#bae6ff', '#ba4e00', '#d4bbff'];
+    const lightCategories = ['#6929c4', '#1192e8', '#005d5d', '#9f1853', '#fa4d56', '#570408', '#198038', '#002d9c', '#ee538b', '#b28600', '#009d9a', '#012749', '#8a3800', '#a56eff'];
+    function genCarbonConfig({
+      theme,
+      background
+    }) {
+      const type = ['white', 'g10'].includes(theme) ? 'light' : 'dark';
+      const viewbg = TOKENS.gridBg[theme];
+      const titleColor = TOKENS.textPrimary[theme];
+      const textColor = TOKENS.textSecondary[theme];
+      const category = type === 'dark' ? darkCategories : lightCategories;
+      const markColor = type === 'dark' ? '#d4bbff' : '#6929c4';
+      return {
+        background,
+        arc: {
+          fill: markColor
+        },
+        area: {
+          fill: markColor
+        },
+        path: {
+          stroke: markColor
+        },
+        rect: {
+          fill: markColor
+        },
+        shape: {
+          stroke: markColor
+        },
+        symbol: {
+          stroke: markColor
+        },
+        circle: {
+          fill: markColor
+        },
+        view: {
+          fill: viewbg,
+          stroke: viewbg
+        },
+        group: {
+          fill: viewbg
+        },
+        title: {
+          color: titleColor,
+          anchor: 'start',
+          dy: -15,
+          fontSize: 16,
+          font: defaultFont,
+          fontWeight: 600
+        },
+        axis: {
+          // Axis labels
+          labelColor: textColor,
+          labelFontSize: 12,
+          labelFont: condensedFont,
+          labelFontWeight: fontWeight,
+          // Axis titles
+          titleColor: titleColor,
+          titleFontWeight: 600,
+          titleFontSize: 12,
+          // MISC
+          grid: true,
+          gridColor: TOKENS.layerAccent01[theme],
+          labelAngle: 0
+        },
+        axisX: {
+          titlePadding: 10
+        },
+        axisY: {
+          titlePadding: 2.5
+        },
+        style: {
+          'guide-label': {
+            font: defaultFont,
+            fill: textColor,
+            fontWeight: fontWeight
+          },
+          'guide-title': {
+            font: defaultFont,
+            fill: textColor,
+            fontWeight: fontWeight
+          }
+        },
+        range: {
+          category,
+          diverging: ['#750e13', '#a2191f', '#da1e28', '#fa4d56', '#ff8389', '#ffb3b8', '#ffd7d9', '#fff1f1', '#e5f6ff', '#bae6ff', '#82cfff', '#33b1ff', '#1192e8', '#0072c3', '#00539a', '#003a6d'],
+          heatmap: ['#f6f2ff', '#e8daff', '#d4bbff', '#be95ff', '#a56eff', '#8a3ffc', '#6929c4', '#491d8b', '#31135e', '#1c0f30']
+        }
+      };
+    }
+    const carbonwhite = genCarbonConfig({
+      theme: 'white',
+      background: '#ffffff'
+    });
+    const carbong10 = genCarbonConfig({
+      theme: 'g10',
+      background: '#f4f4f4'
+    });
+    const carbong90 = genCarbonConfig({
+      theme: 'g90',
+      background: '#262626'
+    });
+    const carbong100 = genCarbonConfig({
+      theme: 'g100',
+      background: '#161616'
+    });
     const version$2 = pkg$1.version;
 
     var themes = /*#__PURE__*/Object.freeze({
         __proto__: null,
+        carbong10: carbong10,
+        carbong100: carbong100,
+        carbong90: carbong90,
+        carbonwhite: carbonwhite,
         dark: darkTheme,
         excel: excelTheme,
         fivethirtyeight: fiveThirtyEightTheme,
@@ -3865,8 +3479,7 @@
       for (i = j = 0; j < n; ++j) {
         c = p[j];
         if (c === '\\') {
-          s += p.substring(i, j);
-          s += p.substring(++j, ++j);
+          s += p.substring(i, j++);
           i = j;
         } else if (c === q) {
           push();
@@ -3907,7 +3520,7 @@
     function field(field, name, opt) {
       const path = splitAccessPath(field);
       field = path.length === 1 ? path[0] : field;
-      return accessor((opt && opt.get || getter)(path), [field], name || field);
+      return accessor((getter)(path), [field], field);
     }
     field('id');
     accessor(_ => _, [], 'identity');
@@ -3923,59 +3536,35 @@
       return typeof _ === 'string';
     }
 
-    /******************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __rest(s, e) {
-      var t = {};
-      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-      if (s != null && typeof Object.getOwnPropertySymbols === "function") for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) t[p[i]] = s[p[i]];
-      }
-      return t;
-    }
-
     /**
      * Format the value to be shown in the tooltip.
      *
      * @param value The value to show in the tooltip.
      * @param valueToHtml Function to convert a single cell value to an HTML string
      */
-    function formatValue(value, valueToHtml, maxDepth) {
+    function formatValue(value, valueToHtml, maxDepth, baseURL) {
       if (isArray(value)) {
         return `[${value.map(v => valueToHtml(isString(v) ? v : stringify(v, maxDepth))).join(', ')}]`;
       }
       if (isObject(value)) {
         let content = '';
-        const _a = value,
-          {
-            title,
-            image
-          } = _a,
-          rest = __rest(_a, ["title", "image"]);
+        const {
+          title,
+          image,
+          ...rest
+        } = value;
         if (title) {
           content += `<h2>${valueToHtml(title)}</h2>`;
         }
         if (image) {
-          content += `<img src="${valueToHtml(image)}">`;
+          content += `<img src="${new URL(valueToHtml(image), baseURL || location.href).href}">`;
         }
         const keys = Object.keys(rest);
         if (keys.length > 0) {
           content += '<table>';
           for (const key of keys) {
             let val = rest[key];
+
             // ignore undefined properties
             if (val === undefined) {
               continue;
@@ -3983,13 +3572,12 @@
             if (isObject(val)) {
               val = stringify(val, maxDepth);
             }
-            content += `<tr><td class="key">${valueToHtml(key)}:</td><td class="value">${valueToHtml(val)}</td></tr>`;
+            content += `<tr><td class="key">${valueToHtml(key)}</td><td class="value">${valueToHtml(val)}</td></tr>`;
           }
           content += `</table>`;
         }
         return content || '{}'; // show empty object if there are no properties
       }
-
       return valueToHtml(value);
     }
     function replacer(maxDepth) {
@@ -4010,6 +3598,7 @@
         return value;
       };
     }
+
     /**
      * Stringify any JS object to valid JSON
      */
@@ -4040,10 +3629,6 @@
   margin-bottom: 10px;
   font-size: 13px;
 }
-#vg-tooltip-element img {
-  max-width: 200px;
-  max-height: 200px;
-}
 #vg-tooltip-element table {
   border-spacing: 0;
 }
@@ -4119,9 +3704,14 @@
        * A function to customize the rendered HTML of the tooltip.
        * @param value A value string, or object of value strings keyed by field
        * @param sanitize The `sanitize` function from `options.sanitize`
+       * @param baseURL The `baseURL` from `options.baseURL`
        * @returns {string} The returned string will become the `innerHTML` of the tooltip element
        */
-      formatTooltip: formatValue
+      formatTooltip: formatValue,
+      /**
+       * The baseurl to use in image paths.
+       */
+      baseURL: ''
     };
     /**
      * Escape special HTML characters.
@@ -4166,17 +3756,34 @@
      * The tooltip handler class.
      */
     class Handler {
+      /**
+       * The handler function. We bind this to this function in the constructor.
+       */
+
+      /**
+       * Complete tooltip options.
+       */
+
+      /**
+       * The tooltip html element.
+       */
+
       /**
        * Create the tooltip handler and initialize the element and style.
        *
        * @param options Tooltip Options
        */
       constructor(options) {
-        this.options = Object.assign(Object.assign({}, DEFAULT_OPTIONS), options);
+        this.options = {
+          ...DEFAULT_OPTIONS,
+          ...options
+        };
         const elementId = this.options.id;
         this.el = null;
+
         // bind this to call
         this.call = this.tooltipHandler.bind(this);
+
         // prepend a default stylesheet for tooltips to the head
         if (!this.options.disableDefaultStyle && !document.getElementById(this.options.styleId)) {
           const style = document.createElement('style');
@@ -4190,28 +3797,32 @@
           }
         }
       }
+
       /**
        * The tooltip handler function.
        */
       tooltipHandler(handler, event, item, value) {
         // console.log(handler, event, item, value);
-        var _a;
+
         // append a div element that we use as a tooltip unless it already exists
         this.el = document.getElementById(this.options.id);
         if (!this.el) {
           this.el = document.createElement('div');
           this.el.setAttribute('id', this.options.id);
           this.el.classList.add('vg-tooltip');
-          const tooltipContainer = (_a = document.fullscreenElement) !== null && _a !== void 0 ? _a : document.body;
+          const tooltipContainer = document.fullscreenElement ?? document.body;
           tooltipContainer.appendChild(this.el);
         }
+
         // hide tooltip for null, undefined, or empty string values
         if (value == null || value === '') {
           this.el.classList.remove('visible', `${this.options.theme}-theme`);
           return;
         }
+
         // set the tooltip content
-        this.el.innerHTML = this.options.formatTooltip(value, this.options.sanitize, this.options.maxDepth);
+        this.el.innerHTML = this.options.formatTooltip(value, this.options.sanitize, this.options.maxDepth, this.options.baseURL);
+
         // make the tooltip visible
         this.el.classList.add('visible', `${this.options.theme}-theme`);
         const {
@@ -4378,20 +3989,10 @@
 }
 `;
 
-    // polyfill for IE
-    if (!String.prototype.startsWith) {
-      // eslint-disable-next-line no-extend-native,func-names
-      String.prototype.startsWith = function (search, pos) {
-        return this.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
-      };
-    }
     function isURL(s) {
       return s.startsWith('http://') || s.startsWith('https://') || s.startsWith('//');
     }
-    function mergeDeep(dest) {
-      for (var _len = arguments.length, src = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        src[_key - 1] = arguments[_key];
-      }
+    function mergeDeep(dest, ...src) {
       for (const s of src) {
         deepMerge_(dest, s);
       }
@@ -4404,7 +4005,7 @@
     }
 
     var name = "vega-embed";
-    var version$1 = "6.21.3";
+    var version$1 = "6.26.0";
     var description = "Publish Vega visualizations as embedded web components.";
     var keywords = ["vega", "data", "visualization", "component", "embed"];
     var repository = {
@@ -4429,31 +4030,53 @@
     var unpkg = "build/vega-embed.min.js";
     var jsdelivr = "build/vega-embed.min.js";
     var types = "build/vega-embed.module.d.ts";
-    var files = ["src", "build", "build-es5", "patches"];
+    var files = ["src", "build"];
+    var exports$1 = {
+      ".": {
+        "import": {
+          types: "./build/vega-embed.module.d.ts",
+          "default": "./build/vega-embed.module.js"
+        },
+        require: {
+          "default": "./build/vega-embed.js"
+        }
+      }
+    };
     var devDependencies = {
-      "@babel/plugin-transform-runtime": "^7.19.6",
-      "@release-it/conventional-changelog": "^5.1.1",
-      "@rollup/plugin-commonjs": "24.0.1",
-      "@rollup/plugin-json": "^6.0.0",
-      "@rollup/plugin-node-resolve": "^15.0.1",
-      "@rollup/plugin-terser": "^0.4.0",
-      "@types/semver": "^7.3.13",
-      "browser-sync": "^2.27.11",
-      concurrently: "^7.6.0",
-      "del-cli": "^5.0.0",
-      "jest-canvas-mock": "^2.4.0",
-      "jest-environment-jsdom": "^29.4.3",
-      "patch-package": "^6.5.1",
+      "@babel/core": "^7.24.7",
+      "@babel/eslint-parser": "^7.24.7",
+      "@babel/plugin-transform-runtime": "^7.24.7",
+      "@babel/preset-env": "^7.24.7",
+      "@babel/preset-typescript": "^7.24.7",
+      "@release-it/conventional-changelog": "^8.0.1",
+      "@rollup/plugin-commonjs": "26.0.1",
+      "@rollup/plugin-json": "^6.1.0",
+      "@rollup/plugin-node-resolve": "^15.2.3",
+      "@rollup/plugin-terser": "^0.4.4",
+      "@types/semver": "^7.5.8",
+      "@typescript-eslint/parser": "^7.15.0",
+      "@vitest/coverage-v8": "^1.6.0",
+      "browser-sync": "^3.0.2",
+      concurrently: "^8.2.2",
+      "del-cli": "^5.1.0",
+      eslint: "^9.6.0",
+      "eslint-config-prettier": "^9.1.0",
+      "eslint-plugin-prettier": "^5.1.3",
+      "eslint-plugin-vitest": "^0.5.4",
+      jsdom: "^24.1.0",
       "postinstall-postinstall": "^2.1.0",
-      "release-it": "^15.6.0",
+      prettier: "^3.3.2",
+      "release-it": "^17.4.1",
+      rollup: "4.18.0",
       "rollup-plugin-bundle-size": "^1.0.3",
-      "rollup-plugin-ts": "^3.2.0",
-      rollup: "3.15.0",
-      sass: "^1.58.1",
-      typescript: "^4.9.5",
-      "vega-lite-dev-config": "^0.21.0",
-      "vega-lite": "^5.2.0",
-      vega: "^5.22.1"
+      "rollup-plugin-ts": "^3.4.5",
+      sass: "^1.77.6",
+      typescript: "^5.5.3",
+      "typescript-eslint": "^7.15.0",
+      vega: "^5.30.0",
+      "vega-lite": "^5.19.0",
+      vitest: "^1.6.0",
+      "vitest-canvas-mock": "^0.3.3"
     };
     var peerDependencies = {
       vega: "^5.21.0",
@@ -4462,31 +4085,27 @@
     var dependencies = {
       "fast-json-patch": "^3.1.1",
       "json-stringify-pretty-compact": "^3.0.0",
-      semver: "^7.3.8",
-      tslib: "^2.5.0",
-      "vega-interpreter": "^1.0.4",
+      semver: "^7.6.2",
+      tslib: "^2.6.3",
+      "vega-interpreter": "^1.0.5",
       "vega-schema-url-parser": "^2.2.0",
-      "vega-themes": "^2.12.1",
-      "vega-tooltip": "^0.30.1"
+      "vega-themes": "^2.15.0",
+      "vega-tooltip": "^0.34.0"
     };
-    var bundledDependencies = ["yallist"];
     var scripts = {
       prebuild: "yarn clean && yarn build:style",
       build: "rollup -c",
       "build:style": "./build-style.sh",
-      clean: "del-cli build build-es5 src/style.ts",
+      clean: "del-cli build src/style.ts",
       prepublishOnly: "yarn clean && yarn build",
       preversion: "yarn lint && yarn test",
       serve: "browser-sync start --directory -s -f build *.html",
       start: "yarn build && concurrently --kill-others -n Server,Rollup 'yarn serve' 'rollup -c -w'",
       pretest: "yarn build:style",
-      test: "beemo jest --stdio stream",
-      "test:inspect": "node --inspect-brk ./node_modules/.bin/jest --runInBand",
-      prepare: "beemo create-config && npx patch-package",
-      prettierbase: "beemo prettier '*.{css,scss,html}'",
-      eslintbase: "beemo eslint .",
-      format: "yarn eslintbase --fix && yarn prettierbase --write",
-      lint: "yarn eslintbase && yarn prettierbase --check",
+      test: "vitest run",
+      prettierbase: "prettier '*.{css,scss,html}'",
+      format: "eslint . --fix && yarn prettierbase --write",
+      lint: "eslint . && yarn prettierbase --check",
       release: "release-it"
     };
     var pkg = {
@@ -4506,21 +4125,20 @@
       jsdelivr: jsdelivr,
       types: types,
       files: files,
+      exports: exports$1,
       devDependencies: devDependencies,
       peerDependencies: peerDependencies,
       dependencies: dependencies,
-      bundledDependencies: bundledDependencies,
       scripts: scripts
     };
 
-    var _w$vl;
     const version = pkg.version;
     const vega = vegaImport__namespace;
     let vegaLite = vegaLiteImport__namespace;
 
     // For backwards compatibility with Vega-Lite before v4.
     const w = typeof window !== 'undefined' ? window : undefined;
-    if (vegaLite === undefined && w !== null && w !== void 0 && (_w$vl = w.vl) !== null && _w$vl !== void 0 && _w$vl.compile) {
+    if (vegaLite === undefined && w?.vl?.compile) {
       vegaLite = w.vl;
     }
     const DEFAULT_ACTIONS = {
@@ -4586,7 +4204,7 @@
           console.warn(`The given visualization spec is written in ${NAMES[parsed.library]}, but mode argument sets ${NAMES[providedMode] ?? providedMode}.`);
         }
         const mode = parsed.library;
-        if (!satisfies_1(VERSION[mode], `^${parsed.version.slice(1)}`)) {
+        if (!satisfies$1(VERSION[mode], `^${parsed.version.slice(1)}`)) {
           console.warn(`The input spec uses ${NAMES[mode]} ${parsed.version}, but the current version of ${NAMES[mode]} is v${VERSION[mode]}.`);
         }
         return mode;
@@ -4608,8 +4226,7 @@
       return isLoader(opts) ? opts : vega.loader(opts);
     }
     function embedOptionsFromUsermeta(parsedSpec) {
-      var _parsedSpec$usermeta;
-      const opts = ((_parsedSpec$usermeta = parsedSpec.usermeta) === null || _parsedSpec$usermeta === void 0 ? void 0 : _parsedSpec$usermeta.embedOptions) ?? {};
+      const opts = parsedSpec.usermeta?.embedOptions ?? {};
       if (vegaImport.isString(opts.defaultStyle)) {
         // we don't allow styles set via usermeta since it would allow injection of logic (we set the style via innerHTML)
         opts.defaultStyle = false;
@@ -4625,8 +4242,7 @@
      *                  Object : The Vega/Vega-Lite specification as a parsed JSON object.
      * @param opts       A JavaScript object containing options for embedding.
      */
-    async function embed(el, spec) {
-      let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+    async function embed(el, spec, opts = {}) {
       let parsedSpec;
       let loader;
       if (vegaImport.isString(spec)) {
@@ -4673,9 +4289,7 @@
         rootContainer: document.head ?? document.body
       };
     }
-    async function _embed(el, spec) {
-      let opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-      let loader = arguments.length > 3 ? arguments[3] : undefined;
+    async function _embed(el, spec, opts = {}, loader) {
       const config = opts.theme ? vegaImport.mergeConfig(themes[opts.theme], opts.config ?? {}) : opts.config;
       const actions = vegaImport.isBoolean(opts.actions) ? opts.actions : mergeDeep({}, DEFAULT_ACTIONS, opts.actions ?? {});
       const i18n = {
@@ -4707,7 +4321,7 @@
       if (mode === 'vega-lite') {
         if (vgSpec.$schema) {
           const parsed = e(vgSpec.$schema);
-          if (!satisfies_1(VERSION.vega, `^${parsed.version.slice(1)}`)) {
+          if (!satisfies$1(VERSION.vega, `^${parsed.version.slice(1)}`)) {
             console.warn(`The compiled spec uses Vega ${parsed.version}, but current version is v${VERSION.vega}.`);
           }
         }
@@ -4783,9 +4397,17 @@
         }
       });
       if (opts.tooltip !== false) {
-        const handler = isTooltipHandler(opts.tooltip) ? opts.tooltip :
+        const {
+          loader: loader_,
+          tooltip
+        } = opts;
+        const baseURL = loader_ && !isLoader(loader_) ? loader_?.baseURL : undefined;
+        const handler = isTooltipHandler(tooltip) ? tooltip :
         // user provided boolean true or tooltip options
-        new Handler(opts.tooltip === true ? {} : opts.tooltip).call;
+        new Handler({
+          baseURL,
+          ...(tooltip === true ? {} : tooltip)
+        }).call;
         view.tooltip(handler);
       }
       let {
@@ -4816,7 +4438,7 @@
       let documentClickHandler;
       if (actions !== false) {
         let wrapper = element;
-        if (opts.defaultStyle !== false) {
+        if (opts.defaultStyle !== false || opts.forceActionsMenu) {
           const details = document.createElement('details');
           details.title = i18n.CLICK_TO_VIEW_ACTIONS;
           element.append(details);
@@ -4863,7 +4485,7 @@
           viewSourceLink.text = i18n.SOURCE_ACTION;
           viewSourceLink.href = '#';
           viewSourceLink.addEventListener('click', function (e) {
-            viewSource(jsonStringifyPrettyCompact(spec), opts.sourceHeader ?? '', opts.sourceFooter ?? '', mode);
+            viewSource(stringify$1(spec), opts.sourceHeader ?? '', opts.sourceFooter ?? '', mode);
             e.preventDefault();
           });
           ctrl.append(viewSourceLink);
@@ -4875,7 +4497,7 @@
           compileLink.text = i18n.COMPILED_ACTION;
           compileLink.href = '#';
           compileLink.addEventListener('click', function (e) {
-            viewSource(jsonStringifyPrettyCompact(vgSpec), opts.sourceHeader ?? '', opts.sourceFooter ?? '', 'vega');
+            viewSource(stringify$1(vgSpec), opts.sourceHeader ?? '', opts.sourceFooter ?? '', 'vega');
             e.preventDefault();
           });
           ctrl.append(compileLink);
@@ -4890,9 +4512,9 @@
           editorLink.addEventListener('click', function (e) {
             post(window, editorUrl, {
               config: config,
-              mode,
+              mode: patch ? 'vega' : mode,
               renderer,
-              spec: jsonStringifyPrettyCompact(spec)
+              spec: stringify$1(patch ? vgSpec : spec)
             });
             e.preventDefault();
           });
@@ -4920,8 +4542,7 @@
      *
      * The main use case is in [Observable](https://observablehq.com/).
      */
-    async function container (spec) {
-      let opt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    async function container (spec, opt = {}) {
       const wrapper = document.createElement('div');
       wrapper.classList.add('vega-embed-wrapper');
       const div = document.createElement('div');
@@ -4931,11 +4552,11 @@
         source: false,
         compiled: true,
         editor: true,
-        ...(opt.actions ?? {})
+        ...opt.actions
       };
       const result = await embed(div, spec, {
         actions,
-        ...(opt ?? {})
+        ...opt
       });
       wrapper.value = result.view;
       return wrapper;
@@ -4947,11 +4568,11 @@
     function isElement(obj) {
       return obj instanceof HTMLElement;
     }
-    const wrapper = function () {
-      if (arguments.length > 1 && (vegaImport.isString(arguments.length <= 0 ? undefined : arguments[0]) && !isURL(arguments.length <= 0 ? undefined : arguments[0]) || isElement(arguments.length <= 0 ? undefined : arguments[0]) || arguments.length === 3)) {
-        return embed(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1], arguments.length <= 2 ? undefined : arguments[2]);
+    const wrapper = (...args) => {
+      if (args.length > 1 && (vegaImport.isString(args[0]) && !isURL(args[0]) || isElement(args[0]) || args.length === 3)) {
+        return embed(args[0], args[1], args[2]);
       }
-      return container(arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1]);
+      return container(args[0], args[1]);
     };
     wrapper.vegaLite = vegaLite;
     wrapper.vl = vegaLite; // backwards compatibility