@next-core/brick-kit 2.188.3 → 2.189.0

package/dist/index.bundle.js

@@ -177,6 +177,8 @@
     K["OTHER_ERROR"] = "OTHER_ERROR";
     K["GO_BACK_PREVIOUS_PAGE"] = "GO_BACK_PREVIOUS_PAGE";
     K["GO_BACK_HOME_PAGE"] = "GO_BACK_HOME_PAGE";
+    K["LOGIN_CHANGED"] = "LOGIN_CHANGED";
+    K["LOGOUT_APPLIED"] = "LOGOUT_APPLIED";
   })(K || (K = {}));
 
   /**
@@ -706,12 +708,7 @@
             suffix = getBasePath() + suffix;
           }
           if (window.APP_ID && window.APP_ID !== appId) {
-            return suffix.replace(new RegExp("/(".concat(window.APP_ID, "|\\d+.\\d+.\\d+)/"), "g"), (_, p1) => {
-              if (p1 === window.APP_ID) {
-                return "/".concat(appId, "/");
-              }
-              return "/".concat(version, "/");
-            });
+            return suffix.replace(new RegExp("(^|/)".concat(_.escapeRegExp(window.APP_ID), "/")), "$1".concat(appId, "/")).replace(/\/\d+\.\d+\.\d+\//, "/".concat(version, "/"));
           }
           return suffix;
         };
@@ -1211,7 +1208,9 @@
     [K.NO_PERMISSION]: "Unauthorized access, unable to retrieve the required resources for this page",
     [K.OTHER_ERROR]: "Oops! Something went wrong",
     [K.GO_BACK_PREVIOUS_PAGE]: "Go back to previous page",
-    [K.GO_BACK_HOME_PAGE]: "Back to home page"
+    [K.GO_BACK_HOME_PAGE]: "Back to home page",
+    [K.LOGIN_CHANGED]: "You have logged in as another account, click OK to refresh the page.",
+    [K.LOGOUT_APPLIED]: "Your account has been logged out, click OK to refresh the page."
   };
   var en = locale$7;
 
@@ -1228,7 +1227,9 @@
     [K.NO_PERMISSION]: "没有权限，无法获取页面所需要的资源",
     [K.OTHER_ERROR]: "糟糕！页面出现了一些问题",
     [K.GO_BACK_PREVIOUS_PAGE]: "回到上一页",
-    [K.GO_BACK_HOME_PAGE]: "回到首页"
+    [K.GO_BACK_HOME_PAGE]: "回到首页",
+    [K.LOGIN_CHANGED]: "您已经登录另一个账号，点击确定刷新页面。",
+    [K.LOGOUT_APPLIED]: "您的账号已经登出，点击确定刷新页面。"
   };
   var zh = locale$6;
 
@@ -1631,9 +1632,9 @@
   }
 
   /*! (c) Andrea Giammarchi - ISC */
-  var self = {};
+  var self$1 = {};
   try {
-    self.EventTarget = new EventTarget().constructor;
+    self$1.EventTarget = new EventTarget().constructor;
   } catch (EventTarget) {
     (function (Object, wm) {
       var create = Object.create;
@@ -1670,7 +1671,7 @@
           }
         }
       });
-      self.EventTarget = EventTarget;
+      self$1.EventTarget = EventTarget;
       function EventTarget() {
 
         wm.set(this, create(null));
@@ -1690,7 +1691,7 @@
       }
     })(Object, new WeakMap());
   }
-  var EventTarget$1 = self.EventTarget;
+  var EventTarget$1 = self$1.EventTarget;
 
   /** @internal */
   function looseCheckIf$1(ifContainer, context) {
@@ -8791,6 +8792,63 @@
     return misc;
   }
 
+  var REFRESH_CHANNEL = "brick-next:authentication-change";
+  var warnedToRefresh = false;
+  function refreshPageIfAuthenticationChanged(_x) {
+    return _refreshPageIfAuthenticationChanged.apply(this, arguments);
+  }
+  function _refreshPageIfAuthenticationChanged() {
+    _refreshPageIfAuthenticationChanged = _asyncToGenerator__default["default"](function* (auth) {
+      if (window.BroadcastChannel) {
+        var channel = new BroadcastChannel(REFRESH_CHANNEL);
+        channel.postMessage({
+          type: "check-login",
+          org: auth.org,
+          username: auth.username
+        });
+        channel.addEventListener("message", e => {
+          handleAuthenticationChange(e.data, auth);
+        });
+      } else {
+        var PolyfillChannel = (yield Promise.resolve().then(function () { return index; })).BroadcastChannel;
+        var _channel = new PolyfillChannel(REFRESH_CHANNEL);
+        _channel.postMessage({
+          type: "check-login",
+          org: auth.org,
+          username: auth.username
+        });
+        // The npm package `broadcast-channel` dispatch message as raw data instead of a MessageEvent.
+        _channel.addEventListener("message", data => {
+          handleAuthenticationChange(data, auth);
+        });
+      }
+    });
+    return _refreshPageIfAuthenticationChanged.apply(this, arguments);
+  }
+  function handleAuthenticationChange(_x2, _x3) {
+    return _handleAuthenticationChange.apply(this, arguments);
+  }
+  function _handleAuthenticationChange() {
+    _handleAuthenticationChange = _asyncToGenerator__default["default"](function* (payload, auth) {
+      if (!warnedToRefresh && (payload.type === "logout" || payload.type === "check-login" && (payload.org !== auth.org || payload.username !== auth.username)) && getRuntime().getFeatureFlags()["refresh-page-if-authentication-changed"]) {
+        // Only warn the user once.
+        warnedToRefresh = true;
+        // Open a modal to ask the user to refresh the page.
+        // window.alert(i18next.t(`${NS_BRICK_KIT}:${payload.type === "logout" ? K.LOGOUT_APPLIED : K.LOGIN_CHANGED}`));
+        antd.Modal.warning({
+          icon: /*#__PURE__*/React__default["default"].createElement(icons.ExclamationCircleOutlined, null),
+          content: i18next__default["default"].t("".concat(NS_BRICK_KIT, ":").concat(payload.type === "logout" ? K.LOGOUT_APPLIED : K.LOGIN_CHANGED)),
+          okText: i18next__default["default"].t("".concat(NS_BRICK_KIT, ":").concat(K.MODAL_OK)),
+          keyboard: false,
+          onOk: () => {
+            location.reload();
+          }
+        });
+      }
+    });
+    return _handleAuthenticationChange.apply(this, arguments);
+  }
+
   var _excluded$3 = ["params"];
   var V3WidgetMates = ["basic.v3-widget-mate"];
   class Kernel {
@@ -8997,6 +9055,7 @@
           var auth = yield checkLogin();
           if (auth.loggedIn) {
             authenticate(auth);
+            refreshPageIfAuthenticationChanged(auth);
           }
         }
       })();
@@ -15013,6 +15072,1600 @@
     });
   }
 
+  /**
+   * returns true if the given object is a promise
+   */
+  function isPromise(obj) {
+    return obj && typeof obj.then === 'function';
+  }
+  var PROMISE_RESOLVED_FALSE = Promise.resolve(false);
+  var PROMISE_RESOLVED_TRUE = Promise.resolve(true);
+  var PROMISE_RESOLVED_VOID = Promise.resolve();
+  function sleep(time, resolveWith) {
+    if (!time) time = 0;
+    return new Promise(function (res) {
+      return setTimeout(function () {
+        return res(resolveWith);
+      }, time);
+    });
+  }
+  function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1) + min);
+  }
+
+  /**
+   * https://stackoverflow.com/a/8084248
+   */
+  function randomToken() {
+    return Math.random().toString(36).substring(2);
+  }
+  var lastMs = 0;
+  var additional = 0;
+
+  /**
+   * returns the current time in micro-seconds,
+   * WARNING: This is a pseudo-function
+   * Performance.now is not reliable in webworkers, so we just make sure to never return the same time.
+   * This is enough in browsers, and this function will not be used in nodejs.
+   * The main reason for this hack is to ensure that BroadcastChannel behaves equal to production when it is used in fast-running unit tests.
+   */
+  function microSeconds$4() {
+    var ms = Date.now();
+    if (ms === lastMs) {
+      additional++;
+      return ms * 1000 + additional;
+    } else {
+      lastMs = ms;
+      additional = 0;
+      return ms * 1000;
+    }
+  }
+
+  /**
+   * Check if WebLock API is supported.
+   * @link https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
+   */
+  function supportsWebLockAPI() {
+    if (typeof navigator !== 'undefined' && typeof navigator.locks !== 'undefined' && typeof navigator.locks.request === 'function') {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  var microSeconds$3 = microSeconds$4;
+  var type$3 = 'native';
+  function create$3(channelName) {
+    var state = {
+      messagesCallback: null,
+      bc: new BroadcastChannel(channelName),
+      subFns: [] // subscriberFunctions
+    };
+
+    state.bc.onmessage = function (msg) {
+      if (state.messagesCallback) {
+        state.messagesCallback(msg.data);
+      }
+    };
+    return state;
+  }
+  function close$3(channelState) {
+    channelState.bc.close();
+    channelState.subFns = [];
+  }
+  function postMessage$3(channelState, messageJson) {
+    try {
+      channelState.bc.postMessage(messageJson, false);
+      return PROMISE_RESOLVED_VOID;
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+  function onMessage$3(channelState, fn) {
+    channelState.messagesCallback = fn;
+  }
+  function canBeUsed$3() {
+    if ((typeof window !== 'undefined' || typeof self !== 'undefined') && typeof BroadcastChannel === 'function') {
+      if (BroadcastChannel._pubkey) {
+        throw new Error('BroadcastChannel: Do not overwrite window.BroadcastChannel with this module, this is not a polyfill');
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+  function averageResponseTime$3() {
+    return 150;
+  }
+  var NativeMethod = {
+    create: create$3,
+    close: close$3,
+    onMessage: onMessage$3,
+    postMessage: postMessage$3,
+    canBeUsed: canBeUsed$3,
+    type: type$3,
+    averageResponseTime: averageResponseTime$3,
+    microSeconds: microSeconds$3
+  };
+
+  /**
+   * this is a set which automatically forgets
+   * a given entry when a new entry is set and the ttl
+   * of the old one is over
+   */
+  var ObliviousSet = /** @class */function () {
+    function ObliviousSet(ttl) {
+      this.ttl = ttl;
+      this.map = new Map();
+      /**
+       * Creating calls to setTimeout() is expensive,
+       * so we only do that if there is not timeout already open.
+       */
+      this._to = false;
+    }
+    ObliviousSet.prototype.has = function (value) {
+      return this.map.has(value);
+    };
+    ObliviousSet.prototype.add = function (value) {
+      var _this = this;
+      this.map.set(value, now());
+      /**
+       * When a new value is added,
+       * start the cleanup at the next tick
+       * to not block the cpu for more important stuff
+       * that might happen.
+       */
+      if (!this._to) {
+        this._to = true;
+        setTimeout(function () {
+          _this._to = false;
+          removeTooOldValues(_this);
+        }, 0);
+      }
+    };
+    ObliviousSet.prototype.clear = function () {
+      this.map.clear();
+    };
+    return ObliviousSet;
+  }();
+  /**
+   * Removes all entries from the set
+   * where the TTL has expired
+   */
+  function removeTooOldValues(obliviousSet) {
+    var olderThen = now() - obliviousSet.ttl;
+    var iterator = obliviousSet.map[Symbol.iterator]();
+    /**
+     * Because we can assume the new values are added at the bottom,
+     * we start from the top and stop as soon as we reach a non-too-old value.
+     */
+    while (true) {
+      var next = iterator.next().value;
+      if (!next) {
+        return; // no more elements
+      }
+
+      var value = next[0];
+      var time = next[1];
+      if (time < olderThen) {
+        obliviousSet.map.delete(value);
+      } else {
+        // We reached a value that is not old enough
+        return;
+      }
+    }
+  }
+  function now() {
+    return new Date().getTime();
+  }
+
+  function fillOptionsWithDefaults$1() {
+    var originalOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var options = JSON.parse(JSON.stringify(originalOptions));
+
+    // main
+    if (typeof options.webWorkerSupport === 'undefined') options.webWorkerSupport = true;
+
+    // indexed-db
+    if (!options.idb) options.idb = {};
+    //  after this time the messages get deleted
+    if (!options.idb.ttl) options.idb.ttl = 1000 * 45;
+    if (!options.idb.fallbackInterval) options.idb.fallbackInterval = 150;
+    //  handles abrupt db onclose events.
+    if (originalOptions.idb && typeof originalOptions.idb.onclose === 'function') options.idb.onclose = originalOptions.idb.onclose;
+
+    // localstorage
+    if (!options.localstorage) options.localstorage = {};
+    if (!options.localstorage.removeTimeout) options.localstorage.removeTimeout = 1000 * 60;
+
+    // custom methods
+    if (originalOptions.methods) options.methods = originalOptions.methods;
+
+    // node
+    if (!options.node) options.node = {};
+    if (!options.node.ttl) options.node.ttl = 1000 * 60 * 2; // 2 minutes;
+    /**
+     * On linux use 'ulimit -Hn' to get the limit of open files.
+     * On ubuntu this was 4096 for me, so we use half of that as maxParallelWrites default.
+     */
+    if (!options.node.maxParallelWrites) options.node.maxParallelWrites = 2048;
+    if (typeof options.node.useFastPath === 'undefined') options.node.useFastPath = true;
+    return options;
+  }
+
+  /**
+   * this method uses indexeddb to store the messages
+   * There is currently no observerAPI for idb
+   * @link https://github.com/w3c/IndexedDB/issues/51
+   * 
+   * When working on this, ensure to use these performance optimizations:
+   * @link https://rxdb.info/slow-indexeddb.html
+   */
+  var microSeconds$2 = microSeconds$4;
+  var DB_PREFIX = 'pubkey.broadcast-channel-0-';
+  var OBJECT_STORE_ID = 'messages';
+
+  /**
+   * Use relaxed durability for faster performance on all transactions.
+   * @link https://nolanlawson.com/2021/08/22/speeding-up-indexeddb-reads-and-writes/
+   */
+  var TRANSACTION_SETTINGS = {
+    durability: 'relaxed'
+  };
+  var type$2 = 'idb';
+  function getIdb() {
+    if (typeof indexedDB !== 'undefined') return indexedDB;
+    if (typeof window !== 'undefined') {
+      if (typeof window.mozIndexedDB !== 'undefined') return window.mozIndexedDB;
+      if (typeof window.webkitIndexedDB !== 'undefined') return window.webkitIndexedDB;
+      if (typeof window.msIndexedDB !== 'undefined') return window.msIndexedDB;
+    }
+    return false;
+  }
+
+  /**
+   * If possible, we should explicitly commit IndexedDB transactions
+   * for better performance.
+   * @link https://nolanlawson.com/2021/08/22/speeding-up-indexeddb-reads-and-writes/
+   */
+  function commitIndexedDBTransaction(tx) {
+    if (tx.commit) {
+      tx.commit();
+    }
+  }
+  function createDatabase(channelName) {
+    var IndexedDB = getIdb();
+
+    // create table
+    var dbName = DB_PREFIX + channelName;
+
+    /**
+     * All IndexedDB databases are opened without version
+     * because it is a bit faster, especially on firefox
+     * @link http://nparashuram.com/IndexedDB/perf/#Open%20Database%20with%20version
+     */
+    var openRequest = IndexedDB.open(dbName);
+    openRequest.onupgradeneeded = function (ev) {
+      var db = ev.target.result;
+      db.createObjectStore(OBJECT_STORE_ID, {
+        keyPath: 'id',
+        autoIncrement: true
+      });
+    };
+    return new Promise(function (res, rej) {
+      openRequest.onerror = function (ev) {
+        return rej(ev);
+      };
+      openRequest.onsuccess = function () {
+        res(openRequest.result);
+      };
+    });
+  }
+
+  /**
+   * writes the new message to the database
+   * so other readers can find it
+   */
+  function writeMessage(db, readerUuid, messageJson) {
+    var time = Date.now();
+    var writeObject = {
+      uuid: readerUuid,
+      time: time,
+      data: messageJson
+    };
+    var tx = db.transaction([OBJECT_STORE_ID], 'readwrite', TRANSACTION_SETTINGS);
+    return new Promise(function (res, rej) {
+      tx.oncomplete = function () {
+        return res();
+      };
+      tx.onerror = function (ev) {
+        return rej(ev);
+      };
+      var objectStore = tx.objectStore(OBJECT_STORE_ID);
+      objectStore.add(writeObject);
+      commitIndexedDBTransaction(tx);
+    });
+  }
+  function getMessagesHigherThan(db, lastCursorId) {
+    var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);
+    var objectStore = tx.objectStore(OBJECT_STORE_ID);
+    var ret = [];
+    var keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);
+
+    /**
+     * Optimization shortcut,
+     * if getAll() can be used, do not use a cursor.
+     * @link https://rxdb.info/slow-indexeddb.html
+     */
+    if (objectStore.getAll) {
+      var getAllRequest = objectStore.getAll(keyRangeValue);
+      return new Promise(function (res, rej) {
+        getAllRequest.onerror = function (err) {
+          return rej(err);
+        };
+        getAllRequest.onsuccess = function (e) {
+          res(e.target.result);
+        };
+      });
+    }
+    function openCursor() {
+      // Occasionally Safari will fail on IDBKeyRange.bound, this
+      // catches that error, having it open the cursor to the first
+      // item. When it gets data it will advance to the desired key.
+      try {
+        keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);
+        return objectStore.openCursor(keyRangeValue);
+      } catch (e) {
+        return objectStore.openCursor();
+      }
+    }
+    return new Promise(function (res, rej) {
+      var openCursorRequest = openCursor();
+      openCursorRequest.onerror = function (err) {
+        return rej(err);
+      };
+      openCursorRequest.onsuccess = function (ev) {
+        var cursor = ev.target.result;
+        if (cursor) {
+          if (cursor.value.id < lastCursorId + 1) {
+            cursor["continue"](lastCursorId + 1);
+          } else {
+            ret.push(cursor.value);
+            cursor["continue"]();
+          }
+        } else {
+          commitIndexedDBTransaction(tx);
+          res(ret);
+        }
+      };
+    });
+  }
+  function removeMessagesById(channelState, ids) {
+    if (channelState.closed) {
+      return Promise.resolve([]);
+    }
+    var tx = channelState.db.transaction(OBJECT_STORE_ID, 'readwrite', TRANSACTION_SETTINGS);
+    var objectStore = tx.objectStore(OBJECT_STORE_ID);
+    return Promise.all(ids.map(function (id) {
+      var deleteRequest = objectStore["delete"](id);
+      return new Promise(function (res) {
+        deleteRequest.onsuccess = function () {
+          return res();
+        };
+      });
+    }));
+  }
+  function getOldMessages(db, ttl) {
+    var olderThen = Date.now() - ttl;
+    var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);
+    var objectStore = tx.objectStore(OBJECT_STORE_ID);
+    var ret = [];
+    return new Promise(function (res) {
+      objectStore.openCursor().onsuccess = function (ev) {
+        var cursor = ev.target.result;
+        if (cursor) {
+          var msgObk = cursor.value;
+          if (msgObk.time < olderThen) {
+            ret.push(msgObk);
+            //alert("Name for SSN " + cursor.key + " is " + cursor.value.name);
+            cursor["continue"]();
+          } else {
+            // no more old messages,
+            commitIndexedDBTransaction(tx);
+            res(ret);
+          }
+        } else {
+          res(ret);
+        }
+      };
+    });
+  }
+  function cleanOldMessages(channelState) {
+    return getOldMessages(channelState.db, channelState.options.idb.ttl).then(function (tooOld) {
+      return removeMessagesById(channelState, tooOld.map(function (msg) {
+        return msg.id;
+      }));
+    });
+  }
+  function create$2(channelName, options) {
+    options = fillOptionsWithDefaults$1(options);
+    return createDatabase(channelName).then(function (db) {
+      var state = {
+        closed: false,
+        lastCursorId: 0,
+        channelName: channelName,
+        options: options,
+        uuid: randomToken(),
+        /**
+         * emittedMessagesIds
+         * contains all messages that have been emitted before
+         * @type {ObliviousSet}
+         */
+        eMIs: new ObliviousSet(options.idb.ttl * 2),
+        // ensures we do not read messages in parallel
+        writeBlockPromise: PROMISE_RESOLVED_VOID,
+        messagesCallback: null,
+        readQueuePromises: [],
+        db: db
+      };
+
+      /**
+       * Handle abrupt closes that do not originate from db.close().
+       * This could happen, for example, if the underlying storage is
+       * removed or if the user clears the database in the browser's
+       * history preferences.
+       */
+      db.onclose = function () {
+        state.closed = true;
+        if (options.idb.onclose) options.idb.onclose();
+      };
+
+      /**
+       * if service-workers are used,
+       * we have no 'storage'-event if they post a message,
+       * therefore we also have to set an interval
+       */
+      _readLoop(state);
+      return state;
+    });
+  }
+  function _readLoop(state) {
+    if (state.closed) return;
+    readNewMessages(state).then(function () {
+      return sleep(state.options.idb.fallbackInterval);
+    }).then(function () {
+      return _readLoop(state);
+    });
+  }
+  function _filterMessage(msgObj, state) {
+    if (msgObj.uuid === state.uuid) return false; // send by own
+    if (state.eMIs.has(msgObj.id)) return false; // already emitted
+    if (msgObj.data.time < state.messagesCallbackTime) return false; // older then onMessageCallback
+    return true;
+  }
+
+  /**
+   * reads all new messages from the database and emits them
+   */
+  function readNewMessages(state) {
+    // channel already closed
+    if (state.closed) return PROMISE_RESOLVED_VOID;
+
+    // if no one is listening, we do not need to scan for new messages
+    if (!state.messagesCallback) return PROMISE_RESOLVED_VOID;
+    return getMessagesHigherThan(state.db, state.lastCursorId).then(function (newerMessages) {
+      var useMessages = newerMessages
+      /**
+       * there is a bug in iOS where the msgObj can be undefined sometimes
+       * so we filter them out
+       * @link https://github.com/pubkey/broadcast-channel/issues/19
+       */.filter(function (msgObj) {
+        return !!msgObj;
+      }).map(function (msgObj) {
+        if (msgObj.id > state.lastCursorId) {
+          state.lastCursorId = msgObj.id;
+        }
+        return msgObj;
+      }).filter(function (msgObj) {
+        return _filterMessage(msgObj, state);
+      }).sort(function (msgObjA, msgObjB) {
+        return msgObjA.time - msgObjB.time;
+      }); // sort by time
+      useMessages.forEach(function (msgObj) {
+        if (state.messagesCallback) {
+          state.eMIs.add(msgObj.id);
+          state.messagesCallback(msgObj.data);
+        }
+      });
+      return PROMISE_RESOLVED_VOID;
+    });
+  }
+  function close$2(channelState) {
+    channelState.closed = true;
+    channelState.db.close();
+  }
+  function postMessage$2(channelState, messageJson) {
+    channelState.writeBlockPromise = channelState.writeBlockPromise.then(function () {
+      return writeMessage(channelState.db, channelState.uuid, messageJson);
+    }).then(function () {
+      if (randomInt(0, 10) === 0) {
+        /* await (do not await) */
+        cleanOldMessages(channelState);
+      }
+    });
+    return channelState.writeBlockPromise;
+  }
+  function onMessage$2(channelState, fn, time) {
+    channelState.messagesCallbackTime = time;
+    channelState.messagesCallback = fn;
+    readNewMessages(channelState);
+  }
+  function canBeUsed$2() {
+    return !!getIdb();
+  }
+  function averageResponseTime$2(options) {
+    return options.idb.fallbackInterval * 2;
+  }
+  var IndexedDBMethod = {
+    create: create$2,
+    close: close$2,
+    onMessage: onMessage$2,
+    postMessage: postMessage$2,
+    canBeUsed: canBeUsed$2,
+    type: type$2,
+    averageResponseTime: averageResponseTime$2,
+    microSeconds: microSeconds$2
+  };
+
+  /**
+   * A localStorage-only method which uses localstorage and its 'storage'-event
+   * This does not work inside webworkers because they have no access to localstorage
+   * This is basically implemented to support IE9 or your grandmother's toaster.
+   * @link https://caniuse.com/#feat=namevalue-storage
+   * @link https://caniuse.com/#feat=indexeddb
+   */
+  var microSeconds$1 = microSeconds$4;
+  var KEY_PREFIX = 'pubkey.broadcastChannel-';
+  var type$1 = 'localstorage';
+
+  /**
+   * copied from crosstab
+   * @link https://github.com/tejacques/crosstab/blob/master/src/crosstab.js#L32
+   */
+  function getLocalStorage() {
+    var localStorage;
+    if (typeof window === 'undefined') return null;
+    try {
+      localStorage = window.localStorage;
+      localStorage = window['ie8-eventlistener/storage'] || window.localStorage;
+    } catch (e) {
+      // New versions of Firefox throw a Security exception
+      // if cookies are disabled. See
+      // https://bugzilla.mozilla.org/show_bug.cgi?id=1028153
+    }
+    return localStorage;
+  }
+  function storageKey(channelName) {
+    return KEY_PREFIX + channelName;
+  }
+
+  /**
+  * writes the new message to the storage
+  * and fires the storage-event so other readers can find it
+  */
+  function postMessage$1(channelState, messageJson) {
+    return new Promise(function (res) {
+      sleep().then(function () {
+        var key = storageKey(channelState.channelName);
+        var writeObj = {
+          token: randomToken(),
+          time: Date.now(),
+          data: messageJson,
+          uuid: channelState.uuid
+        };
+        var value = JSON.stringify(writeObj);
+        getLocalStorage().setItem(key, value);
+
+        /**
+         * StorageEvent does not fire the 'storage' event
+         * in the window that changes the state of the local storage.
+         * So we fire it manually
+         */
+        var ev = document.createEvent('Event');
+        ev.initEvent('storage', true, true);
+        ev.key = key;
+        ev.newValue = value;
+        window.dispatchEvent(ev);
+        res();
+      });
+    });
+  }
+  function addStorageEventListener(channelName, fn) {
+    var key = storageKey(channelName);
+    var listener = function listener(ev) {
+      if (ev.key === key) {
+        fn(JSON.parse(ev.newValue));
+      }
+    };
+    window.addEventListener('storage', listener);
+    return listener;
+  }
+  function removeStorageEventListener(listener) {
+    window.removeEventListener('storage', listener);
+  }
+  function create$1(channelName, options) {
+    options = fillOptionsWithDefaults$1(options);
+    if (!canBeUsed$1()) {
+      throw new Error('BroadcastChannel: localstorage cannot be used');
+    }
+    var uuid = randomToken();
+
+    /**
+     * eMIs
+     * contains all messages that have been emitted before
+     * @type {ObliviousSet}
+     */
+    var eMIs = new ObliviousSet(options.localstorage.removeTimeout);
+    var state = {
+      channelName: channelName,
+      uuid: uuid,
+      eMIs: eMIs // emittedMessagesIds
+    };
+
+    state.listener = addStorageEventListener(channelName, function (msgObj) {
+      if (!state.messagesCallback) return; // no listener
+      if (msgObj.uuid === uuid) return; // own message
+      if (!msgObj.token || eMIs.has(msgObj.token)) return; // already emitted
+      if (msgObj.data.time && msgObj.data.time < state.messagesCallbackTime) return; // too old
+
+      eMIs.add(msgObj.token);
+      state.messagesCallback(msgObj.data);
+    });
+    return state;
+  }
+  function close$1(channelState) {
+    removeStorageEventListener(channelState.listener);
+  }
+  function onMessage$1(channelState, fn, time) {
+    channelState.messagesCallbackTime = time;
+    channelState.messagesCallback = fn;
+  }
+  function canBeUsed$1() {
+    var ls = getLocalStorage();
+    if (!ls) return false;
+    try {
+      var key = '__broadcastchannel_check';
+      ls.setItem(key, 'works');
+      ls.removeItem(key);
+    } catch (e) {
+      // Safari 10 in private mode will not allow write access to local
+      // storage and fail with a QuotaExceededError. See
+      // https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API#Private_Browsing_Incognito_modes
+      return false;
+    }
+    return true;
+  }
+  function averageResponseTime$1() {
+    var defaultTime = 120;
+    var userAgent = navigator.userAgent.toLowerCase();
+    if (userAgent.includes('safari') && !userAgent.includes('chrome')) {
+      // safari is much slower so this time is higher
+      return defaultTime * 2;
+    }
+    return defaultTime;
+  }
+  var LocalstorageMethod = {
+    create: create$1,
+    close: close$1,
+    onMessage: onMessage$1,
+    postMessage: postMessage$1,
+    canBeUsed: canBeUsed$1,
+    type: type$1,
+    averageResponseTime: averageResponseTime$1,
+    microSeconds: microSeconds$1
+  };
+
+  var microSeconds = microSeconds$4;
+  var type = 'simulate';
+  var SIMULATE_CHANNELS = new Set();
+  function create(channelName) {
+    var state = {
+      name: channelName,
+      messagesCallback: null
+    };
+    SIMULATE_CHANNELS.add(state);
+    return state;
+  }
+  function close(channelState) {
+    SIMULATE_CHANNELS["delete"](channelState);
+  }
+  function postMessage(channelState, messageJson) {
+    return new Promise(function (res) {
+      return setTimeout(function () {
+        var channelArray = Array.from(SIMULATE_CHANNELS);
+        channelArray.filter(function (channel) {
+          return channel.name === channelState.name;
+        }).filter(function (channel) {
+          return channel !== channelState;
+        }).filter(function (channel) {
+          return !!channel.messagesCallback;
+        }).forEach(function (channel) {
+          return channel.messagesCallback(messageJson);
+        });
+        res();
+      }, 5);
+    });
+  }
+  function onMessage(channelState, fn) {
+    channelState.messagesCallback = fn;
+  }
+  function canBeUsed() {
+    return true;
+  }
+  function averageResponseTime() {
+    return 5;
+  }
+  var SimulateMethod = {
+    create: create,
+    close: close,
+    onMessage: onMessage,
+    postMessage: postMessage,
+    canBeUsed: canBeUsed,
+    type: type,
+    averageResponseTime: averageResponseTime,
+    microSeconds: microSeconds
+  };
+
+  // the line below will be removed from es5/browser builds
+
+  // order is important
+  var METHODS = [NativeMethod,
+  // fastest
+  IndexedDBMethod, LocalstorageMethod];
+  function chooseMethod(options) {
+    var chooseMethods = [].concat(options.methods, METHODS).filter(Boolean);
+
+    // the line below will be removed from es5/browser builds
+
+    // directly chosen
+    if (options.type) {
+      if (options.type === 'simulate') {
+        // only use simulate-method if directly chosen
+        return SimulateMethod;
+      }
+      var ret = chooseMethods.find(function (m) {
+        return m.type === options.type;
+      });
+      if (!ret) throw new Error('method-type ' + options.type + ' not found');else return ret;
+    }
+
+    /**
+     * if no webworker support is needed,
+     * remove idb from the list so that localstorage will be chosen
+     */
+    if (!options.webWorkerSupport) {
+      chooseMethods = chooseMethods.filter(function (m) {
+        return m.type !== 'idb';
+      });
+    }
+    var useMethod = chooseMethods.find(function (method) {
+      return method.canBeUsed();
+    });
+    if (!useMethod) {
+      throw new Error("No usable method found in " + JSON.stringify(METHODS.map(function (m) {
+        return m.type;
+      })));
+    } else {
+      return useMethod;
+    }
+  }
+
+  /**
+   * Contains all open channels,
+   * used in tests to ensure everything is closed.
+   */
+  var OPEN_BROADCAST_CHANNELS = new Set();
+  var lastId = 0;
+  var BroadcastChannel$1 = function BroadcastChannel(name, options) {
+    // identifier of the channel to debug stuff
+    this.id = lastId++;
+    OPEN_BROADCAST_CHANNELS.add(this);
+    this.name = name;
+    if (ENFORCED_OPTIONS) {
+      options = ENFORCED_OPTIONS;
+    }
+    this.options = fillOptionsWithDefaults$1(options);
+    this.method = chooseMethod(this.options);
+
+    // isListening
+    this._iL = false;
+
+    /**
+     * _onMessageListener
+     * setting onmessage twice,
+     * will overwrite the first listener
+     */
+    this._onML = null;
+
+    /**
+     * _addEventListeners
+     */
+    this._addEL = {
+      message: [],
+      internal: []
+    };
+
+    /**
+     * Unsent message promises
+     * where the sending is still in progress
+     * @type {Set<Promise>}
+     */
+    this._uMP = new Set();
+
+    /**
+     * _beforeClose
+     * array of promises that will be awaited
+     * before the channel is closed
+     */
+    this._befC = [];
+
+    /**
+     * _preparePromise
+     */
+    this._prepP = null;
+    _prepareChannel(this);
+  };
+
+  // STATICS
+
+  /**
+   * used to identify if someone overwrites
+   * window.BroadcastChannel with this
+   * See methods/native.js
+   */
+  BroadcastChannel$1._pubkey = true;
+
+  /**
+   * clears the tmp-folder if is node
+   * @return {Promise<boolean>} true if has run, false if not node
+   */
+  function clearNodeFolder(options) {
+    options = fillOptionsWithDefaults$1(options);
+    var method = chooseMethod(options);
+    if (method.type === 'node') {
+      return method.clearNodeFolder().then(function () {
+        return true;
+      });
+    } else {
+      return PROMISE_RESOLVED_FALSE;
+    }
+  }
+
+  /**
+   * if set, this method is enforced,
+   * no mather what the options are
+   */
+  var ENFORCED_OPTIONS;
+  function enforceOptions(options) {
+    ENFORCED_OPTIONS = options;
+  }
+
+  // PROTOTYPE
+  BroadcastChannel$1.prototype = {
+    postMessage: function postMessage(msg) {
+      if (this.closed) {
+        throw new Error('BroadcastChannel.postMessage(): ' + 'Cannot post message after channel has closed ' +
+        /**
+         * In the past when this error appeared, it was really hard to debug.
+         * So now we log the msg together with the error so it at least
+         * gives some clue about where in your application this happens.
+         */
+        JSON.stringify(msg));
+      }
+      return _post(this, 'message', msg);
+    },
+    postInternal: function postInternal(msg) {
+      return _post(this, 'internal', msg);
+    },
+    set onmessage(fn) {
+      var time = this.method.microSeconds();
+      var listenObj = {
+        time: time,
+        fn: fn
+      };
+      _removeListenerObject(this, 'message', this._onML);
+      if (fn && typeof fn === 'function') {
+        this._onML = listenObj;
+        _addListenerObject(this, 'message', listenObj);
+      } else {
+        this._onML = null;
+      }
+    },
+    addEventListener: function addEventListener(type, fn) {
+      var time = this.method.microSeconds();
+      var listenObj = {
+        time: time,
+        fn: fn
+      };
+      _addListenerObject(this, type, listenObj);
+    },
+    removeEventListener: function removeEventListener(type, fn) {
+      var obj = this._addEL[type].find(function (obj) {
+        return obj.fn === fn;
+      });
+      _removeListenerObject(this, type, obj);
+    },
+    close: function close() {
+      var _this = this;
+      if (this.closed) {
+        return;
+      }
+      OPEN_BROADCAST_CHANNELS["delete"](this);
+      this.closed = true;
+      var awaitPrepare = this._prepP ? this._prepP : PROMISE_RESOLVED_VOID;
+      this._onML = null;
+      this._addEL.message = [];
+      return awaitPrepare
+      // wait until all current sending are processed
+      .then(function () {
+        return Promise.all(Array.from(_this._uMP));
+      })
+      // run before-close hooks
+      .then(function () {
+        return Promise.all(_this._befC.map(function (fn) {
+          return fn();
+        }));
+      })
+      // close the channel
+      .then(function () {
+        return _this.method.close(_this._state);
+      });
+    },
+    get type() {
+      return this.method.type;
+    },
+    get isClosed() {
+      return this.closed;
+    }
+  };
+
+  /**
+   * Post a message over the channel
+   * @returns {Promise} that resolved when the message sending is done
+   */
+  function _post(broadcastChannel, type, msg) {
+    var time = broadcastChannel.method.microSeconds();
+    var msgObj = {
+      time: time,
+      type: type,
+      data: msg
+    };
+    var awaitPrepare = broadcastChannel._prepP ? broadcastChannel._prepP : PROMISE_RESOLVED_VOID;
+    return awaitPrepare.then(function () {
+      var sendPromise = broadcastChannel.method.postMessage(broadcastChannel._state, msgObj);
+
+      // add/remove to unsent messages list
+      broadcastChannel._uMP.add(sendPromise);
+      sendPromise["catch"]().then(function () {
+        return broadcastChannel._uMP["delete"](sendPromise);
+      });
+      return sendPromise;
+    });
+  }
+  function _prepareChannel(channel) {
+    var maybePromise = channel.method.create(channel.name, channel.options);
+    if (isPromise(maybePromise)) {
+      channel._prepP = maybePromise;
+      maybePromise.then(function (s) {
+        // used in tests to simulate slow runtime
+        /*if (channel.options.prepareDelay) {
+             await new Promise(res => setTimeout(res, this.options.prepareDelay));
+        }*/
+        channel._state = s;
+      });
+    } else {
+      channel._state = maybePromise;
+    }
+  }
+  function _hasMessageListeners(channel) {
+    if (channel._addEL.message.length > 0) return true;
+    if (channel._addEL.internal.length > 0) return true;
+    return false;
+  }
+  function _addListenerObject(channel, type, obj) {
+    channel._addEL[type].push(obj);
+    _startListening(channel);
+  }
+  function _removeListenerObject(channel, type, obj) {
+    channel._addEL[type] = channel._addEL[type].filter(function (o) {
+      return o !== obj;
+    });
+    _stopListening(channel);
+  }
+  function _startListening(channel) {
+    if (!channel._iL && _hasMessageListeners(channel)) {
+      // someone is listening, start subscribing
+
+      var listenerFn = function listenerFn(msgObj) {
+        channel._addEL[msgObj.type].forEach(function (listenerObject) {
+          /**
+           * Getting the current time in JavaScript has no good precision.
+           * So instead of only listening to events that happened 'after' the listener
+           * was added, we also listen to events that happened 100ms before it.
+           * This ensures that when another process, like a WebWorker, sends events
+           * we do not miss them out because their timestamp is a bit off compared to the main process.
+           * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.
+           * @link https://johnresig.com/blog/accuracy-of-javascript-time/
+           */
+          var hundredMsInMicro = 100 * 1000;
+          var minMessageTime = listenerObject.time - hundredMsInMicro;
+          if (msgObj.time >= minMessageTime) {
+            listenerObject.fn(msgObj.data);
+          }
+        });
+      };
+      var time = channel.method.microSeconds();
+      if (channel._prepP) {
+        channel._prepP.then(function () {
+          channel._iL = true;
+          channel.method.onMessage(channel._state, listenerFn, time);
+        });
+      } else {
+        channel._iL = true;
+        channel.method.onMessage(channel._state, listenerFn, time);
+      }
+    }
+  }
+  function _stopListening(channel) {
+    if (channel._iL && !_hasMessageListeners(channel)) {
+      // no one is listening, stop subscribing
+      channel._iL = false;
+      var time = channel.method.microSeconds();
+      channel.method.onMessage(channel._state, null, time);
+    }
+  }
+
+  /* global WorkerGlobalScope */
+
+  function addBrowser(fn) {
+    if (typeof WorkerGlobalScope === 'function' && self instanceof WorkerGlobalScope) {
+      /**
+       * Because killing a worker does directly stop the excution
+       * of the code, our only chance is to overwrite the close function
+       * which could work some times.
+       * @link https://stackoverflow.com/q/72903255/3443137
+       */
+      var oldClose = self.close.bind(self);
+      self.close = function () {
+        fn();
+        return oldClose();
+      };
+    } else {
+      /**
+       * if we are on react-native, there is no window.addEventListener
+       * @link https://github.com/pubkey/unload/issues/6
+       */
+      if (typeof window.addEventListener !== 'function') {
+        return;
+      }
+
+      /**
+       * for normal browser-windows, we use the beforeunload-event
+       */
+      window.addEventListener('beforeunload', function () {
+        fn();
+      }, true);
+
+      /**
+       * for iframes, we have to use the unload-event
+       * @link https://stackoverflow.com/q/47533670/3443137
+       */
+      window.addEventListener('unload', function () {
+        fn();
+      }, true);
+    }
+
+    /**
+     * TODO add fallback for safari-mobile
+     * @link https://stackoverflow.com/a/26193516/3443137
+     */
+  }
+
+  function addNode(fn) {
+    process.on('exit', function () {
+      return fn();
+    });
+
+    /**
+     * on the following events,
+     * the process will not end if there are
+     * event-handlers attached,
+     * therefore we have to call process.exit()
+     */
+    process.on('beforeExit', function () {
+      return fn().then(function () {
+        return process.exit();
+      });
+    });
+    // catches ctrl+c event
+    process.on('SIGINT', function () {
+      return fn().then(function () {
+        return process.exit();
+      });
+    });
+    // catches uncaught exceptions
+    process.on('uncaughtException', function (err) {
+      return fn().then(function () {
+        console.trace(err);
+        process.exit(101);
+      });
+    });
+  }
+
+  /**
+   * Use the code directly to prevent import problems
+   * with the detect-node package.
+   * @link https://github.com/iliakan/detect-node/blob/master/index.js
+   */
+  var isNode = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';
+  var USE_METHOD = isNode ? addNode : addBrowser;
+  var LISTENERS = new Set();
+  var startedListening = false;
+  function startListening() {
+    if (startedListening) {
+      return;
+    }
+    startedListening = true;
+    USE_METHOD(runAll);
+  }
+  function add(fn) {
+    startListening();
+    if (typeof fn !== 'function') {
+      throw new Error('Listener is no function');
+    }
+    LISTENERS.add(fn);
+    var addReturn = {
+      remove: function remove() {
+        return LISTENERS["delete"](fn);
+      },
+      run: function run() {
+        LISTENERS["delete"](fn);
+        return fn();
+      }
+    };
+    return addReturn;
+  }
+  function runAll() {
+    var promises = [];
+    LISTENERS.forEach(function (fn) {
+      promises.push(fn());
+      LISTENERS["delete"](fn);
+    });
+    return Promise.all(promises);
+  }
+
+  /**
+   * sends and internal message over the broadcast-channel
+   */
+  function sendLeaderMessage(leaderElector, action) {
+    var msgJson = {
+      context: 'leader',
+      action: action,
+      token: leaderElector.token
+    };
+    return leaderElector.broadcastChannel.postInternal(msgJson);
+  }
+  function beLeader(leaderElector) {
+    leaderElector.isLeader = true;
+    leaderElector._hasLeader = true;
+    var unloadFn = add(function () {
+      return leaderElector.die();
+    });
+    leaderElector._unl.push(unloadFn);
+    var isLeaderListener = function isLeaderListener(msg) {
+      if (msg.context === 'leader' && msg.action === 'apply') {
+        sendLeaderMessage(leaderElector, 'tell');
+      }
+      if (msg.context === 'leader' && msg.action === 'tell' && !leaderElector._dpLC) {
+        /**
+         * another instance is also leader!
+         * This can happen on rare events
+         * like when the CPU is at 100% for long time
+         * or the tabs are open very long and the browser throttles them.
+         * @link https://github.com/pubkey/broadcast-channel/issues/414
+         * @link https://github.com/pubkey/broadcast-channel/issues/385
+         */
+        leaderElector._dpLC = true;
+        leaderElector._dpL(); // message the lib user so the app can handle the problem
+        sendLeaderMessage(leaderElector, 'tell'); // ensure other leader also knows the problem
+      }
+    };
+
+    leaderElector.broadcastChannel.addEventListener('internal', isLeaderListener);
+    leaderElector._lstns.push(isLeaderListener);
+    return sendLeaderMessage(leaderElector, 'tell');
+  }
+
+  /**
+   * A faster version of the leader elector that uses the WebLock API
+   * @link https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API
+   */
+  var LeaderElectionWebLock = function LeaderElectionWebLock(broadcastChannel, options) {
+    var _this = this;
+    this.broadcastChannel = broadcastChannel;
+    broadcastChannel._befC.push(function () {
+      return _this.die();
+    });
+    this._options = options;
+    this.isLeader = false;
+    this.isDead = false;
+    this.token = randomToken();
+    this._lstns = [];
+    this._unl = [];
+    this._dpL = function () {}; // onduplicate listener
+    this._dpLC = false; // true when onduplicate called
+
+    this._wKMC = {}; // stuff for cleanup
+
+    // lock name
+    this.lN = 'pubkey-bc||' + broadcastChannel.method.type + '||' + broadcastChannel.name;
+  };
+  LeaderElectionWebLock.prototype = {
+    hasLeader: function hasLeader() {
+      var _this2 = this;
+      return navigator.locks.query().then(function (locks) {
+        var relevantLocks = locks.held ? locks.held.filter(function (lock) {
+          return lock.name === _this2.lN;
+        }) : [];
+        if (relevantLocks && relevantLocks.length > 0) {
+          return true;
+        } else {
+          return false;
+        }
+      });
+    },
+    awaitLeadership: function awaitLeadership() {
+      var _this3 = this;
+      if (!this._wLMP) {
+        this._wKMC.c = new AbortController();
+        var returnPromise = new Promise(function (res, rej) {
+          _this3._wKMC.res = res;
+          _this3._wKMC.rej = rej;
+        });
+        this._wLMP = new Promise(function (res) {
+          navigator.locks.request(_this3.lN, {
+            signal: _this3._wKMC.c.signal
+          }, function () {
+            // if the lock resolved, we can drop the abort controller
+            _this3._wKMC.c = undefined;
+            beLeader(_this3);
+            res();
+            return returnPromise;
+          })["catch"](function () {});
+        });
+      }
+      return this._wLMP;
+    },
+    set onduplicate(_fn) {
+      // Do nothing because there are no duplicates in the WebLock version
+    },
+    die: function die() {
+      var _this4 = this;
+      this._lstns.forEach(function (listener) {
+        return _this4.broadcastChannel.removeEventListener('internal', listener);
+      });
+      this._lstns = [];
+      this._unl.forEach(function (uFn) {
+        return uFn.remove();
+      });
+      this._unl = [];
+      if (this.isLeader) {
+        this.isLeader = false;
+      }
+      this.isDead = true;
+      if (this._wKMC.res) {
+        this._wKMC.res();
+      }
+      if (this._wKMC.c) {
+        this._wKMC.c.abort('LeaderElectionWebLock.die() called');
+      }
+      return sendLeaderMessage(this, 'death');
+    }
+  };
+
+  var LeaderElection = function LeaderElection(broadcastChannel, options) {
+    var _this = this;
+    this.broadcastChannel = broadcastChannel;
+    this._options = options;
+    this.isLeader = false;
+    this._hasLeader = false;
+    this.isDead = false;
+    this.token = randomToken();
+
+    /**
+     * Apply Queue,
+     * used to ensure we do not run applyOnce()
+     * in parallel.
+     */
+    this._aplQ = PROMISE_RESOLVED_VOID;
+    // amount of unfinished applyOnce() calls
+    this._aplQC = 0;
+
+    // things to clean up
+    this._unl = []; // _unloads
+    this._lstns = []; // _listeners
+    this._dpL = function () {}; // onduplicate listener
+    this._dpLC = false; // true when onduplicate called
+
+    /**
+     * Even when the own instance is not applying,
+     * we still listen to messages to ensure the hasLeader flag
+     * is set correctly.
+     */
+    var hasLeaderListener = function hasLeaderListener(msg) {
+      if (msg.context === 'leader') {
+        if (msg.action === 'death') {
+          _this._hasLeader = false;
+        }
+        if (msg.action === 'tell') {
+          _this._hasLeader = true;
+        }
+      }
+    };
+    this.broadcastChannel.addEventListener('internal', hasLeaderListener);
+    this._lstns.push(hasLeaderListener);
+  };
+  LeaderElection.prototype = {
+    hasLeader: function hasLeader() {
+      return Promise.resolve(this._hasLeader);
+    },
+    /**
+     * Returns true if the instance is leader,
+     * false if not.
+     * @async
+     */
+    applyOnce: function applyOnce(
+    // true if the applyOnce() call came from the fallbackInterval cycle
+    isFromFallbackInterval) {
+      var _this2 = this;
+      if (this.isLeader) {
+        return sleep(0, true);
+      }
+      if (this.isDead) {
+        return sleep(0, false);
+      }
+
+      /**
+       * Already applying more than once,
+       * -> wait for the apply queue to be finished.
+       */
+      if (this._aplQC > 1) {
+        return this._aplQ;
+      }
+
+      /**
+       * Add a new apply-run
+       */
+      var applyRun = function applyRun() {
+        /**
+         * Optimization shortcuts.
+         * Directly return if a previous run
+         * has already elected a leader.
+         */
+        if (_this2.isLeader) {
+          return PROMISE_RESOLVED_TRUE;
+        }
+        var stopCriteria = false;
+        var stopCriteriaPromiseResolve;
+        /**
+         * Resolves when a stop criteria is reached.
+         * Uses as a performance shortcut so we do not
+         * have to await the responseTime when it is already clear
+         * that the election failed.
+         */
+        var stopCriteriaPromise = new Promise(function (res) {
+          stopCriteriaPromiseResolve = function stopCriteriaPromiseResolve() {
+            stopCriteria = true;
+            res();
+          };
+        });
+        var handleMessage = function handleMessage(msg) {
+          if (msg.context === 'leader' && msg.token != _this2.token) {
+            if (msg.action === 'apply') {
+              // other is applying
+              if (msg.token > _this2.token) {
+                /**
+                 * other has higher token
+                 * -> stop applying and let other become leader.
+                 */
+                stopCriteriaPromiseResolve();
+              }
+            }
+            if (msg.action === 'tell') {
+              // other is already leader
+              stopCriteriaPromiseResolve();
+              _this2._hasLeader = true;
+            }
+          }
+        };
+        _this2.broadcastChannel.addEventListener('internal', handleMessage);
+
+        /**
+         * If the applyOnce() call came from the fallbackInterval,
+         * we can assume that the election runs in the background and
+         * not critical process is waiting for it.
+         * When this is true, we give the other instances
+         * more time to answer to messages in the election cycle.
+         * This makes it less likely to elect duplicate leaders.
+         * But also it takes longer which is not a problem because we anyway
+         * run in the background.
+         */
+        var waitForAnswerTime = isFromFallbackInterval ? _this2._options.responseTime * 4 : _this2._options.responseTime;
+        return sendLeaderMessage(_this2, 'apply') // send out that this one is applying
+        .then(function () {
+          return Promise.race([sleep(waitForAnswerTime), stopCriteriaPromise.then(function () {
+            return Promise.reject(new Error());
+          })]);
+        })
+        // send again in case another instance was just created
+        .then(function () {
+          return sendLeaderMessage(_this2, 'apply');
+        })
+        // let others time to respond
+        .then(function () {
+          return Promise.race([sleep(waitForAnswerTime), stopCriteriaPromise.then(function () {
+            return Promise.reject(new Error());
+          })]);
+        })["catch"](function () {}).then(function () {
+          _this2.broadcastChannel.removeEventListener('internal', handleMessage);
+          if (!stopCriteria) {
+            // no stop criteria -> own is leader
+            return beLeader(_this2).then(function () {
+              return true;
+            });
+          } else {
+            // other is leader
+            return false;
+          }
+        });
+      };
+      this._aplQC = this._aplQC + 1;
+      this._aplQ = this._aplQ.then(function () {
+        return applyRun();
+      }).then(function () {
+        _this2._aplQC = _this2._aplQC - 1;
+      });
+      return this._aplQ.then(function () {
+        return _this2.isLeader;
+      });
+    },
+    awaitLeadership: function awaitLeadership() {
+      if ( /* _awaitLeadershipPromise */
+      !this._aLP) {
+        this._aLP = _awaitLeadershipOnce(this);
+      }
+      return this._aLP;
+    },
+    set onduplicate(fn) {
+      this._dpL = fn;
+    },
+    die: function die() {
+      var _this3 = this;
+      this._lstns.forEach(function (listener) {
+        return _this3.broadcastChannel.removeEventListener('internal', listener);
+      });
+      this._lstns = [];
+      this._unl.forEach(function (uFn) {
+        return uFn.remove();
+      });
+      this._unl = [];
+      if (this.isLeader) {
+        this._hasLeader = false;
+        this.isLeader = false;
+      }
+      this.isDead = true;
+      return sendLeaderMessage(this, 'death');
+    }
+  };
+
+  /**
+   * @param leaderElector {LeaderElector}
+   */
+  function _awaitLeadershipOnce(leaderElector) {
+    if (leaderElector.isLeader) {
+      return PROMISE_RESOLVED_VOID;
+    }
+    return new Promise(function (res) {
+      var resolved = false;
+      function finish() {
+        if (resolved) {
+          return;
+        }
+        resolved = true;
+        leaderElector.broadcastChannel.removeEventListener('internal', whenDeathListener);
+        res(true);
+      }
+
+      // try once now
+      leaderElector.applyOnce().then(function () {
+        if (leaderElector.isLeader) {
+          finish();
+        }
+      });
+
+      /**
+       * Try on fallbackInterval
+       * @recursive
+       */
+      var tryOnFallBack = function tryOnFallBack() {
+        return sleep(leaderElector._options.fallbackInterval).then(function () {
+          if (leaderElector.isDead || resolved) {
+            return;
+          }
+          if (leaderElector.isLeader) {
+            finish();
+          } else {
+            return leaderElector.applyOnce(true).then(function () {
+              if (leaderElector.isLeader) {
+                finish();
+              } else {
+                tryOnFallBack();
+              }
+            });
+          }
+        });
+      };
+      tryOnFallBack();
+
+      // try when other leader dies
+      var whenDeathListener = function whenDeathListener(msg) {
+        if (msg.context === 'leader' && msg.action === 'death') {
+          leaderElector._hasLeader = false;
+          leaderElector.applyOnce().then(function () {
+            if (leaderElector.isLeader) {
+              finish();
+            }
+          });
+        }
+      };
+      leaderElector.broadcastChannel.addEventListener('internal', whenDeathListener);
+      leaderElector._lstns.push(whenDeathListener);
+    });
+  }
+  function fillOptionsWithDefaults(options, channel) {
+    if (!options) options = {};
+    options = JSON.parse(JSON.stringify(options));
+    if (!options.fallbackInterval) {
+      options.fallbackInterval = 3000;
+    }
+    if (!options.responseTime) {
+      options.responseTime = channel.method.averageResponseTime(channel.options);
+    }
+    return options;
+  }
+  function createLeaderElection(channel, options) {
+    if (channel._leaderElector) {
+      throw new Error('BroadcastChannel already has a leader-elector');
+    }
+    options = fillOptionsWithDefaults(options, channel);
+    var elector = supportsWebLockAPI() ? new LeaderElectionWebLock(channel, options) : new LeaderElection(channel, options);
+    channel._befC.push(function () {
+      return elector.die();
+    });
+    channel._leaderElector = elector;
+    return elector;
+  }
+
+  var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    BroadcastChannel: BroadcastChannel$1,
+    clearNodeFolder: clearNodeFolder,
+    enforceOptions: enforceOptions,
+    OPEN_BROADCAST_CHANNELS: OPEN_BROADCAST_CHANNELS,
+    createLeaderElection: createLeaderElection,
+    beLeader: beLeader
+  });
+
   exports.BrickAsComponent = BrickAsComponent;
   exports.BrickAsComponentFactory = BrickAsComponentFactory;
   exports.BrickWrapper = BrickWrapper;