{"version":3,"file":"static/js/6146.cdc56be6.chunk.js","mappings":"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","sources":["webpack:///./node_modules/detect-node/browser.js","webpack:///./node_modules/p-cancelable/index.js","webpack:///./node_modules/tiny-emitter/index.js","webpack:///./node_modules/js-cookie/dist/js.cookie.mjs","webpack:///./node_modules/broadcast-channel/dist/esbrowser/util.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/methods/native.js","webpack:///./node_modules/oblivious-set/src/index.ts","webpack:///./node_modules/broadcast-channel/dist/esbrowser/options.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/methods/indexed-db.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/methods/localstorage.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/methods/simulate.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/method-chooser.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/broadcast-channel.js","webpack:///./node_modules/unload/dist/es/browser.js","webpack:///./node_modules/unload/dist/es/index.js","webpack:///./node_modules/broadcast-channel/dist/esbrowser/leader-election.js","webpack:///./node_modules/jsonpath-plus/dist/index-browser-esm.js"],"sourcesContent":["module.exports = false;\n\n","'use strict';\n\nclass CancelError extends Error {\n\tconstructor(reason) {\n\t\tsuper(reason || 'Promise was canceled');\n\t\tthis.name = 'CancelError';\n\t}\n\n\tget isCanceled() {\n\t\treturn true;\n\t}\n}\n\nclass PCancelable {\n\tstatic fn(userFn) {\n\t\treturn (...arguments_) => {\n\t\t\treturn new PCancelable((resolve, reject, onCancel) => {\n\t\t\t\targuments_.push(onCancel);\n\t\t\t\t// eslint-disable-next-line promise/prefer-await-to-then\n\t\t\t\tuserFn(...arguments_).then(resolve, reject);\n\t\t\t});\n\t\t};\n\t}\n\n\tconstructor(executor) {\n\t\tthis._cancelHandlers = [];\n\t\tthis._isPending = true;\n\t\tthis._isCanceled = false;\n\t\tthis._rejectOnCancel = true;\n\n\t\tthis._promise = new Promise((resolve, reject) => {\n\t\t\tthis._reject = reject;\n\n\t\t\tconst onResolve = value => {\n\t\t\t\tif (!this._isCanceled || !onCancel.shouldReject) {\n\t\t\t\t\tthis._isPending = false;\n\t\t\t\t\tresolve(value);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tconst onReject = error => {\n\t\t\t\tthis._isPending = false;\n\t\t\t\treject(error);\n\t\t\t};\n\n\t\t\tconst onCancel = handler => {\n\t\t\t\tif (!this._isPending) {\n\t\t\t\t\tthrow new Error('The `onCancel` handler was attached after the promise settled.');\n\t\t\t\t}\n\n\t\t\t\tthis._cancelHandlers.push(handler);\n\t\t\t};\n\n\t\t\tObject.defineProperties(onCancel, {\n\t\t\t\tshouldReject: {\n\t\t\t\t\tget: () => this._rejectOnCancel,\n\t\t\t\t\tset: boolean => {\n\t\t\t\t\t\tthis._rejectOnCancel = boolean;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\n\t\t\treturn executor(onResolve, onReject, onCancel);\n\t\t});\n\t}\n\n\tthen(onFulfilled, onRejected) {\n\t\t// eslint-disable-next-line promise/prefer-await-to-then\n\t\treturn this._promise.then(onFulfilled, onRejected);\n\t}\n\n\tcatch(onRejected) {\n\t\treturn this._promise.catch(onRejected);\n\t}\n\n\tfinally(onFinally) {\n\t\treturn this._promise.finally(onFinally);\n\t}\n\n\tcancel(reason) {\n\t\tif (!this._isPending || this._isCanceled) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis._isCanceled = true;\n\n\t\tif (this._cancelHandlers.length > 0) {\n\t\t\ttry {\n\t\t\t\tfor (const handler of this._cancelHandlers) {\n\t\t\t\t\thandler();\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tthis._reject(error);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\tif (this._rejectOnCancel) {\n\t\t\tthis._reject(new CancelError(reason));\n\t\t}\n\t}\n\n\tget isCanceled() {\n\t\treturn this._isCanceled;\n\t}\n}\n\nObject.setPrototypeOf(PCancelable.prototype, Promise.prototype);\n\nmodule.exports = PCancelable;\nmodule.exports.CancelError = CancelError;\n","function E () {\n  // Keep this empty so it's easier to inherit from\n  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)\n}\n\nE.prototype = {\n  on: function (name, callback, ctx) {\n    var e = this.e || (this.e = {});\n\n    (e[name] || (e[name] = [])).push({\n      fn: callback,\n      ctx: ctx\n    });\n\n    return this;\n  },\n\n  once: function (name, callback, ctx) {\n    var self = this;\n    function listener () {\n      self.off(name, listener);\n      callback.apply(ctx, arguments);\n    };\n\n    listener._ = callback\n    return this.on(name, listener, ctx);\n  },\n\n  emit: function (name) {\n    var data = [].slice.call(arguments, 1);\n    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();\n    var i = 0;\n    var len = evtArr.length;\n\n    for (i; i < len; i++) {\n      evtArr[i].fn.apply(evtArr[i].ctx, data);\n    }\n\n    return this;\n  },\n\n  off: function (name, callback) {\n    var e = this.e || (this.e = {});\n    var evts = e[name];\n    var liveEvents = [];\n\n    if (evts && callback) {\n      for (var i = 0, len = evts.length; i < len; i++) {\n        if (evts[i].fn !== callback && evts[i].fn._ !== callback)\n          liveEvents.push(evts[i]);\n      }\n    }\n\n    // Remove event from queue to prevent memory leak\n    // Suggested by https://github.com/lazd\n    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910\n\n    (liveEvents.length)\n      ? e[name] = liveEvents\n      : delete e[name];\n\n    return this;\n  }\n};\n\nmodule.exports = E;\n","/*! js-cookie v3.0.5 | MIT */\n/* eslint-disable no-var */\nfunction assign (target) {\n  for (var i = 1; i < arguments.length; i++) {\n    var source = arguments[i];\n    for (var key in source) {\n      target[key] = source[key];\n    }\n  }\n  return target\n}\n/* eslint-enable no-var */\n\n/* eslint-disable no-var */\nvar defaultConverter = {\n  read: function (value) {\n    if (value[0] === '\"') {\n      value = value.slice(1, -1);\n    }\n    return value.replace(/(%[\\dA-F]{2})+/gi, decodeURIComponent)\n  },\n  write: function (value) {\n    return encodeURIComponent(value).replace(\n      /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,\n      decodeURIComponent\n    )\n  }\n};\n/* eslint-enable no-var */\n\n/* eslint-disable no-var */\n\nfunction init (converter, defaultAttributes) {\n  function set (name, value, attributes) {\n    if (typeof document === 'undefined') {\n      return\n    }\n\n    attributes = assign({}, defaultAttributes, attributes);\n\n    if (typeof attributes.expires === 'number') {\n      attributes.expires = new Date(Date.now() + attributes.expires * 864e5);\n    }\n    if (attributes.expires) {\n      attributes.expires = attributes.expires.toUTCString();\n    }\n\n    name = encodeURIComponent(name)\n      .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)\n      .replace(/[()]/g, escape);\n\n    var stringifiedAttributes = '';\n    for (var attributeName in attributes) {\n      if (!attributes[attributeName]) {\n        continue\n      }\n\n      stringifiedAttributes += '; ' + attributeName;\n\n      if (attributes[attributeName] === true) {\n        continue\n      }\n\n      // Considers RFC 6265 section 5.2:\n      // ...\n      // 3.  If the remaining unparsed-attributes contains a %x3B (\";\")\n      //     character:\n      // Consume the characters of the unparsed-attributes up to,\n      // not including, the first %x3B (\";\") character.\n      // ...\n      stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];\n    }\n\n    return (document.cookie =\n      name + '=' + converter.write(value, name) + stringifiedAttributes)\n  }\n\n  function get (name) {\n    if (typeof document === 'undefined' || (arguments.length && !name)) {\n      return\n    }\n\n    // To prevent the for loop in the first place assign an empty array\n    // in case there are no cookies at all.\n    var cookies = document.cookie ? document.cookie.split('; ') : [];\n    var jar = {};\n    for (var i = 0; i < cookies.length; i++) {\n      var parts = cookies[i].split('=');\n      var value = parts.slice(1).join('=');\n\n      try {\n        var found = decodeURIComponent(parts[0]);\n        jar[found] = converter.read(value, found);\n\n        if (name === found) {\n          break\n        }\n      } catch (e) {}\n    }\n\n    return name ? jar[name] : jar\n  }\n\n  return Object.create(\n    {\n      set,\n      get,\n      remove: function (name, attributes) {\n        set(\n          name,\n          '',\n          assign({}, attributes, {\n            expires: -1\n          })\n        );\n      },\n      withAttributes: function (attributes) {\n        return init(this.converter, assign({}, this.attributes, attributes))\n      },\n      withConverter: function (converter) {\n        return init(assign({}, this.converter, converter), this.attributes)\n      }\n    },\n    {\n      attributes: { value: Object.freeze(defaultAttributes) },\n      converter: { value: Object.freeze(converter) }\n    }\n  )\n}\n\nvar api = init(defaultConverter, { path: '/' });\n/* eslint-enable no-var */\n\nexport { api as default };\n","/**\n * returns true if the given object is a promise\n */\nexport function isPromise(obj) {\n  if (obj && typeof obj.then === 'function') {\n    return true;\n  } else {\n    return false;\n  }\n}\nexport var PROMISE_RESOLVED_FALSE = Promise.resolve(false);\nexport var PROMISE_RESOLVED_TRUE = Promise.resolve(true);\nexport var PROMISE_RESOLVED_VOID = Promise.resolve();\nexport function sleep(time, resolveWith) {\n  if (!time) time = 0;\n  return new Promise(function (res) {\n    return setTimeout(function () {\n      return res(resolveWith);\n    }, time);\n  });\n}\nexport function randomInt(min, max) {\n  return Math.floor(Math.random() * (max - min + 1) + min);\n}\n/**\n * https://stackoverflow.com/a/8084248\n */\n\nexport function randomToken() {\n  return Math.random().toString(36).substring(2);\n}\nvar lastMs = 0;\nvar additional = 0;\n/**\n * returns the current time in micro-seconds,\n * WARNING: This is a pseudo-function\n * Performance.now is not reliable in webworkers, so we just make sure to never return the same time.\n * This is enough in browsers, and this function will not be used in nodejs.\n * The main reason for this hack is to ensure that BroadcastChannel behaves equal to production when it is used in fast-running unit tests.\n */\n\nexport function microSeconds() {\n  var ms = new Date().getTime();\n\n  if (ms === lastMs) {\n    additional++;\n    return ms * 1000 + additional;\n  } else {\n    lastMs = ms;\n    additional = 0;\n    return ms * 1000;\n  }\n}","import { microSeconds as micro, PROMISE_RESOLVED_VOID } from '../util.js';\nexport var microSeconds = micro;\nexport var type = 'native';\nexport function create(channelName) {\n  var state = {\n    messagesCallback: null,\n    bc: new BroadcastChannel(channelName),\n    subFns: [] // subscriberFunctions\n\n  };\n\n  state.bc.onmessage = function (msg) {\n    if (state.messagesCallback) {\n      state.messagesCallback(msg.data);\n    }\n  };\n\n  return state;\n}\nexport function close(channelState) {\n  channelState.bc.close();\n  channelState.subFns = [];\n}\nexport function postMessage(channelState, messageJson) {\n  try {\n    channelState.bc.postMessage(messageJson, false);\n    return PROMISE_RESOLVED_VOID;\n  } catch (err) {\n    return Promise.reject(err);\n  }\n}\nexport function onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\nexport function canBeUsed() {\n  if (typeof window === 'undefined') {\n    return false;\n  }\n\n  if (typeof BroadcastChannel === 'function') {\n    if (BroadcastChannel._pubkey) {\n      throw new Error('BroadcastChannel: Do not overwrite window.BroadcastChannel with this module, this is not a polyfill');\n    }\n\n    return true;\n  } else {\n    return false;\n  }\n}\nexport function averageResponseTime() {\n  return 150;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","\n/**\n * this is a set which automatically forgets\n * a given entry when a new entry is set and the ttl\n * of the old one is over\n */\nexport class ObliviousSet<T = any> {\n    public readonly map = new Map();\n\n    /**\n     * Creating calls to setTimeout() is expensive,\n     * so we only do that if there is not timeout already open.\n     */\n    public _to: boolean = false;\n    constructor(\n        public readonly ttl: number\n    ) { }\n\n    has(value: T): boolean {\n        return this.map.has(value);\n    }\n\n    add(value: T): void {\n        this.map.set(value, now());\n\n        /**\n         * When a new value is added,\n         * start the cleanup at the next tick\n         * to not block the cpu for more important stuff\n         * that might happen.\n         */\n        if (!this._to) {\n            this._to = true;\n            setTimeout(() => {\n                this._to = false;\n                removeTooOldValues(this);\n            }, 0);\n        }\n    }\n\n    clear() {\n        this.map.clear();\n    }\n}\n\n\n/**\n * Removes all entries from the set\n * where the TTL has expired\n */\nexport function removeTooOldValues(\n    obliviousSet: ObliviousSet\n) {\n    const olderThen = now() - obliviousSet.ttl;\n    const iterator = obliviousSet.map[Symbol.iterator]();\n\n    /**\n     * Because we can assume the new values are added at the bottom,\n     * we start from the top and stop as soon as we reach a non-too-old value.\n     */\n    while (true) {\n\n        const next = iterator.next().value;\n\n        if (!next) {\n            return; // no more elements\n        }\n        const value = next[0];\n        const time = next[1];\n        if (time < olderThen) {\n            obliviousSet.map.delete(value);\n        } else {\n            // We reached a value that is not old enough\n            return;\n        }\n    }\n}\n\nexport function now(): number {\n    return new Date().getTime();\n}\n\n\n","export function fillOptionsWithDefaults() {\n  var originalOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var options = JSON.parse(JSON.stringify(originalOptions)); // main\n\n  if (typeof options.webWorkerSupport === 'undefined') options.webWorkerSupport = true; // indexed-db\n\n  if (!options.idb) options.idb = {}; //  after this time the messages get deleted\n\n  if (!options.idb.ttl) options.idb.ttl = 1000 * 45;\n  if (!options.idb.fallbackInterval) options.idb.fallbackInterval = 150; //  handles abrupt db onclose events.\n\n  if (originalOptions.idb && typeof originalOptions.idb.onclose === 'function') options.idb.onclose = originalOptions.idb.onclose; // localstorage\n\n  if (!options.localstorage) options.localstorage = {};\n  if (!options.localstorage.removeTimeout) options.localstorage.removeTimeout = 1000 * 60; // custom methods\n\n  if (originalOptions.methods) options.methods = originalOptions.methods; // node\n\n  if (!options.node) options.node = {};\n  if (!options.node.ttl) options.node.ttl = 1000 * 60 * 2; // 2 minutes;\n\n  /**\n   * On linux use 'ulimit -Hn' to get the limit of open files.\n   * On ubuntu this was 4096 for me, so we use half of that as maxParallelWrites default.\n   */\n\n  if (!options.node.maxParallelWrites) options.node.maxParallelWrites = 2048;\n  if (typeof options.node.useFastPath === 'undefined') options.node.useFastPath = true;\n  return options;\n}","/**\n * this method uses indexeddb to store the messages\n * There is currently no observerAPI for idb\n * @link https://github.com/w3c/IndexedDB/issues/51\n * \n * When working on this, ensure to use these performance optimizations:\n * @link https://rxdb.info/slow-indexeddb.html\n */\nimport { sleep, randomInt, randomToken, microSeconds as micro, PROMISE_RESOLVED_VOID } from '../util.js';\nexport var microSeconds = micro;\nimport { ObliviousSet } from 'oblivious-set';\nimport { fillOptionsWithDefaults } from '../options.js';\nvar DB_PREFIX = 'pubkey.broadcast-channel-0-';\nvar OBJECT_STORE_ID = 'messages';\n/**\n * Use relaxed durability for faster performance on all transactions.\n * @link https://nolanlawson.com/2021/08/22/speeding-up-indexeddb-reads-and-writes/\n */\n\nexport var TRANSACTION_SETTINGS = {\n  durability: 'relaxed'\n};\nexport var type = 'idb';\nexport function getIdb() {\n  if (typeof indexedDB !== 'undefined') return indexedDB;\n\n  if (typeof window !== 'undefined') {\n    if (typeof window.mozIndexedDB !== 'undefined') return window.mozIndexedDB;\n    if (typeof window.webkitIndexedDB !== 'undefined') return window.webkitIndexedDB;\n    if (typeof window.msIndexedDB !== 'undefined') return window.msIndexedDB;\n  }\n\n  return false;\n}\n/**\n * If possible, we should explicitly commit IndexedDB transactions\n * for better performance.\n * @link https://nolanlawson.com/2021/08/22/speeding-up-indexeddb-reads-and-writes/\n */\n\nexport function commitIndexedDBTransaction(tx) {\n  if (tx.commit) {\n    tx.commit();\n  }\n}\nexport function createDatabase(channelName) {\n  var IndexedDB = getIdb(); // create table\n\n  var dbName = DB_PREFIX + channelName;\n  /**\n   * All IndexedDB databases are opened without version\n   * because it is a bit faster, especially on firefox\n   * @link http://nparashuram.com/IndexedDB/perf/#Open%20Database%20with%20version\n   */\n\n  var openRequest = IndexedDB.open(dbName);\n\n  openRequest.onupgradeneeded = function (ev) {\n    var db = ev.target.result;\n    db.createObjectStore(OBJECT_STORE_ID, {\n      keyPath: 'id',\n      autoIncrement: true\n    });\n  };\n\n  var dbPromise = new Promise(function (res, rej) {\n    openRequest.onerror = function (ev) {\n      return rej(ev);\n    };\n\n    openRequest.onsuccess = function () {\n      res(openRequest.result);\n    };\n  });\n  return dbPromise;\n}\n/**\n * writes the new message to the database\n * so other readers can find it\n */\n\nexport function writeMessage(db, readerUuid, messageJson) {\n  var time = new Date().getTime();\n  var writeObject = {\n    uuid: readerUuid,\n    time: time,\n    data: messageJson\n  };\n  var tx = db.transaction([OBJECT_STORE_ID], 'readwrite', TRANSACTION_SETTINGS);\n  return new Promise(function (res, rej) {\n    tx.oncomplete = function () {\n      return res();\n    };\n\n    tx.onerror = function (ev) {\n      return rej(ev);\n    };\n\n    var objectStore = tx.objectStore(OBJECT_STORE_ID);\n    objectStore.add(writeObject);\n    commitIndexedDBTransaction(tx);\n  });\n}\nexport function getAllMessages(db) {\n  var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  return new Promise(function (res) {\n    objectStore.openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\n      if (cursor) {\n        ret.push(cursor.value); //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n\n        cursor[\"continue\"]();\n      } else {\n        commitIndexedDBTransaction(tx);\n        res(ret);\n      }\n    };\n  });\n}\nexport function getMessagesHigherThan(db, lastCursorId) {\n  var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  var keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);\n  /**\n   * Optimization shortcut,\n   * if getAll() can be used, do not use a cursor.\n   * @link https://rxdb.info/slow-indexeddb.html\n   */\n\n  if (objectStore.getAll) {\n    var getAllRequest = objectStore.getAll(keyRangeValue);\n    return new Promise(function (res, rej) {\n      getAllRequest.onerror = function (err) {\n        return rej(err);\n      };\n\n      getAllRequest.onsuccess = function (e) {\n        res(e.target.result);\n      };\n    });\n  }\n\n  function openCursor() {\n    // Occasionally Safari will fail on IDBKeyRange.bound, this\n    // catches that error, having it open the cursor to the first\n    // item. When it gets data it will advance to the desired key.\n    try {\n      keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);\n      return objectStore.openCursor(keyRangeValue);\n    } catch (e) {\n      return objectStore.openCursor();\n    }\n  }\n\n  return new Promise(function (res, rej) {\n    var openCursorRequest = openCursor();\n\n    openCursorRequest.onerror = function (err) {\n      return rej(err);\n    };\n\n    openCursorRequest.onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\n      if (cursor) {\n        if (cursor.value.id < lastCursorId + 1) {\n          cursor[\"continue\"](lastCursorId + 1);\n        } else {\n          ret.push(cursor.value);\n          cursor[\"continue\"]();\n        }\n      } else {\n        commitIndexedDBTransaction(tx);\n        res(ret);\n      }\n    };\n  });\n}\nexport function removeMessagesById(db, ids) {\n  var tx = db.transaction([OBJECT_STORE_ID], 'readwrite', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  return Promise.all(ids.map(function (id) {\n    var deleteRequest = objectStore[\"delete\"](id);\n    return new Promise(function (res) {\n      deleteRequest.onsuccess = function () {\n        return res();\n      };\n    });\n  }));\n}\nexport function getOldMessages(db, ttl) {\n  var olderThen = new Date().getTime() - ttl;\n  var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  return new Promise(function (res) {\n    objectStore.openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\n      if (cursor) {\n        var msgObk = cursor.value;\n\n        if (msgObk.time < olderThen) {\n          ret.push(msgObk); //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n\n          cursor[\"continue\"]();\n        } else {\n          // no more old messages,\n          commitIndexedDBTransaction(tx);\n          res(ret);\n          return;\n        }\n      } else {\n        res(ret);\n      }\n    };\n  });\n}\nexport function cleanOldMessages(db, ttl) {\n  return getOldMessages(db, ttl).then(function (tooOld) {\n    return removeMessagesById(db, tooOld.map(function (msg) {\n      return msg.id;\n    }));\n  });\n}\nexport function create(channelName, options) {\n  options = fillOptionsWithDefaults(options);\n  return createDatabase(channelName).then(function (db) {\n    var state = {\n      closed: false,\n      lastCursorId: 0,\n      channelName: channelName,\n      options: options,\n      uuid: randomToken(),\n\n      /**\n       * emittedMessagesIds\n       * contains all messages that have been emitted before\n       * @type {ObliviousSet}\n       */\n      eMIs: new ObliviousSet(options.idb.ttl * 2),\n      // ensures we do not read messages in parrallel\n      writeBlockPromise: PROMISE_RESOLVED_VOID,\n      messagesCallback: null,\n      readQueuePromises: [],\n      db: db\n    };\n    /**\n     * Handle abrupt closes that do not originate from db.close().\n     * This could happen, for example, if the underlying storage is\n     * removed or if the user clears the database in the browser's\n     * history preferences.\n     */\n\n    db.onclose = function () {\n      state.closed = true;\n      if (options.idb.onclose) options.idb.onclose();\n    };\n    /**\n     * if service-workers are used,\n     * we have no 'storage'-event if they post a message,\n     * therefore we also have to set an interval\n     */\n\n\n    _readLoop(state);\n\n    return state;\n  });\n}\n\nfunction _readLoop(state) {\n  if (state.closed) return;\n  readNewMessages(state).then(function () {\n    return sleep(state.options.idb.fallbackInterval);\n  }).then(function () {\n    return _readLoop(state);\n  });\n}\n\nfunction _filterMessage(msgObj, state) {\n  if (msgObj.uuid === state.uuid) return false; // send by own\n\n  if (state.eMIs.has(msgObj.id)) return false; // already emitted\n\n  if (msgObj.data.time < state.messagesCallbackTime) return false; // older then onMessageCallback\n\n  return true;\n}\n/**\n * reads all new messages from the database and emits them\n */\n\n\nfunction readNewMessages(state) {\n  // channel already closed\n  if (state.closed) return PROMISE_RESOLVED_VOID; // if no one is listening, we do not need to scan for new messages\n\n  if (!state.messagesCallback) return PROMISE_RESOLVED_VOID;\n  return getMessagesHigherThan(state.db, state.lastCursorId).then(function (newerMessages) {\n    var useMessages = newerMessages\n    /**\n     * there is a bug in iOS where the msgObj can be undefined some times\n     * so we filter them out\n     * @link https://github.com/pubkey/broadcast-channel/issues/19\n     */\n    .filter(function (msgObj) {\n      return !!msgObj;\n    }).map(function (msgObj) {\n      if (msgObj.id > state.lastCursorId) {\n        state.lastCursorId = msgObj.id;\n      }\n\n      return msgObj;\n    }).filter(function (msgObj) {\n      return _filterMessage(msgObj, state);\n    }).sort(function (msgObjA, msgObjB) {\n      return msgObjA.time - msgObjB.time;\n    }); // sort by time\n\n    useMessages.forEach(function (msgObj) {\n      if (state.messagesCallback) {\n        state.eMIs.add(msgObj.id);\n        state.messagesCallback(msgObj.data);\n      }\n    });\n    return PROMISE_RESOLVED_VOID;\n  });\n}\n\nexport function close(channelState) {\n  channelState.closed = true;\n  channelState.db.close();\n}\nexport function postMessage(channelState, messageJson) {\n  channelState.writeBlockPromise = channelState.writeBlockPromise.then(function () {\n    return writeMessage(channelState.db, channelState.uuid, messageJson);\n  }).then(function () {\n    if (randomInt(0, 10) === 0) {\n      /* await (do not await) */\n      cleanOldMessages(channelState.db, channelState.options.idb.ttl);\n    }\n  });\n  return channelState.writeBlockPromise;\n}\nexport function onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n  readNewMessages(channelState);\n}\nexport function canBeUsed() {\n  var idb = getIdb();\n\n  if (!idb) {\n    return false;\n  }\n\n  return true;\n}\nexport function averageResponseTime(options) {\n  return options.idb.fallbackInterval * 2;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","/**\n * A localStorage-only method which uses localstorage and its 'storage'-event\n * This does not work inside of webworkers because they have no access to locastorage\n * This is basically implemented to support IE9 or your grandmothers toaster.\n * @link https://caniuse.com/#feat=namevalue-storage\n * @link https://caniuse.com/#feat=indexeddb\n */\nimport { ObliviousSet } from 'oblivious-set';\nimport { fillOptionsWithDefaults } from '../options.js';\nimport { sleep, randomToken, microSeconds as micro } from '../util.js';\nexport var microSeconds = micro;\nvar KEY_PREFIX = 'pubkey.broadcastChannel-';\nexport var type = 'localstorage';\n/**\n * copied from crosstab\n * @link https://github.com/tejacques/crosstab/blob/master/src/crosstab.js#L32\n */\n\nexport function getLocalStorage() {\n  var localStorage;\n  if (typeof window === 'undefined') return null;\n\n  try {\n    localStorage = window.localStorage;\n    localStorage = window['ie8-eventlistener/storage'] || window.localStorage;\n  } catch (e) {// New versions of Firefox throw a Security exception\n    // if cookies are disabled. See\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1028153\n  }\n\n  return localStorage;\n}\nexport function storageKey(channelName) {\n  return KEY_PREFIX + channelName;\n}\n/**\n* writes the new message to the storage\n* and fires the storage-event so other readers can find it\n*/\n\nexport function postMessage(channelState, messageJson) {\n  return new Promise(function (res) {\n    sleep().then(function () {\n      var key = storageKey(channelState.channelName);\n      var writeObj = {\n        token: randomToken(),\n        time: new Date().getTime(),\n        data: messageJson,\n        uuid: channelState.uuid\n      };\n      var value = JSON.stringify(writeObj);\n      getLocalStorage().setItem(key, value);\n      /**\n       * StorageEvent does not fire the 'storage' event\n       * in the window that changes the state of the local storage.\n       * So we fire it manually\n       */\n\n      var ev = document.createEvent('Event');\n      ev.initEvent('storage', true, true);\n      ev.key = key;\n      ev.newValue = value;\n      window.dispatchEvent(ev);\n      res();\n    });\n  });\n}\nexport function addStorageEventListener(channelName, fn) {\n  var key = storageKey(channelName);\n\n  var listener = function listener(ev) {\n    if (ev.key === key) {\n      fn(JSON.parse(ev.newValue));\n    }\n  };\n\n  window.addEventListener('storage', listener);\n  return listener;\n}\nexport function removeStorageEventListener(listener) {\n  window.removeEventListener('storage', listener);\n}\nexport function create(channelName, options) {\n  options = fillOptionsWithDefaults(options);\n\n  if (!canBeUsed()) {\n    throw new Error('BroadcastChannel: localstorage cannot be used');\n  }\n\n  var uuid = randomToken();\n  /**\n   * eMIs\n   * contains all messages that have been emitted before\n   * @type {ObliviousSet}\n   */\n\n  var eMIs = new ObliviousSet(options.localstorage.removeTimeout);\n  var state = {\n    channelName: channelName,\n    uuid: uuid,\n    eMIs: eMIs // emittedMessagesIds\n\n  };\n  state.listener = addStorageEventListener(channelName, function (msgObj) {\n    if (!state.messagesCallback) return; // no listener\n\n    if (msgObj.uuid === uuid) return; // own message\n\n    if (!msgObj.token || eMIs.has(msgObj.token)) return; // already emitted\n\n    if (msgObj.data.time && msgObj.data.time < state.messagesCallbackTime) return; // too old\n\n    eMIs.add(msgObj.token);\n    state.messagesCallback(msgObj.data);\n  });\n  return state;\n}\nexport function close(channelState) {\n  removeStorageEventListener(channelState.listener);\n}\nexport function onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n}\nexport function canBeUsed() {\n  var ls = getLocalStorage();\n  if (!ls) return false;\n\n  try {\n    var key = '__broadcastchannel_check';\n    ls.setItem(key, 'works');\n    ls.removeItem(key);\n  } catch (e) {\n    // Safari 10 in private mode will not allow write access to local\n    // storage and fail with a QuotaExceededError. See\n    // https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API#Private_Browsing_Incognito_modes\n    return false;\n  }\n\n  return true;\n}\nexport function averageResponseTime() {\n  var defaultTime = 120;\n  var userAgent = navigator.userAgent.toLowerCase();\n\n  if (userAgent.includes('safari') && !userAgent.includes('chrome')) {\n    // safari is much slower so this time is higher\n    return defaultTime * 2;\n  }\n\n  return defaultTime;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","import { microSeconds as micro } from '../util.js';\nexport var microSeconds = micro;\nexport var type = 'simulate';\nvar SIMULATE_CHANNELS = new Set();\nexport function create(channelName) {\n  var state = {\n    name: channelName,\n    messagesCallback: null\n  };\n  SIMULATE_CHANNELS.add(state);\n  return state;\n}\nexport function close(channelState) {\n  SIMULATE_CHANNELS[\"delete\"](channelState);\n}\nexport function postMessage(channelState, messageJson) {\n  return new Promise(function (res) {\n    return setTimeout(function () {\n      var channelArray = Array.from(SIMULATE_CHANNELS);\n      channelArray.filter(function (channel) {\n        return channel.name === channelState.name;\n      }).filter(function (channel) {\n        return channel !== channelState;\n      }).filter(function (channel) {\n        return !!channel.messagesCallback;\n      }).forEach(function (channel) {\n        return channel.messagesCallback(messageJson);\n      });\n      res();\n    }, 5);\n  });\n}\nexport function onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\nexport function canBeUsed() {\n  return true;\n}\nexport function averageResponseTime() {\n  return 5;\n}\nexport default {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};","import NativeMethod from './methods/native.js';\nimport IndexeDbMethod from './methods/indexed-db.js';\nimport LocalstorageMethod from './methods/localstorage.js';\nimport SimulateMethod from './methods/simulate.js'; // the line below will be removed from es5/browser builds\n\n\nvar METHODS = [NativeMethod, // fastest\nIndexeDbMethod, LocalstorageMethod];\nexport function chooseMethod(options) {\n  var chooseMethods = [].concat(options.methods, METHODS).filter(Boolean); // the line below will be removed from es5/browser builds\n\n\n  if (options.type) {\n    if (options.type === 'simulate') {\n      // only use simulate-method if directly chosen\n      return SimulateMethod;\n    }\n\n    var ret = chooseMethods.find(function (m) {\n      return m.type === options.type;\n    });\n    if (!ret) throw new Error('method-type ' + options.type + ' not found');else return ret;\n  }\n  /**\n   * if no webworker support is needed,\n   * remove idb from the list so that localstorage is been chosen\n   */\n\n\n  if (!options.webWorkerSupport) {\n    chooseMethods = chooseMethods.filter(function (m) {\n      return m.type !== 'idb';\n    });\n  }\n\n  var useMethod = chooseMethods.find(function (method) {\n    return method.canBeUsed();\n  });\n  if (!useMethod) throw new Error(\"No useable method found in \" + JSON.stringify(METHODS.map(function (m) {\n    return m.type;\n  })));else return useMethod;\n}","import { isPromise, PROMISE_RESOLVED_FALSE, PROMISE_RESOLVED_VOID } from './util.js';\nimport { chooseMethod } from './method-chooser.js';\nimport { fillOptionsWithDefaults } from './options.js';\n/**\n * Contains all open channels,\n * used in tests to ensure everything is closed.\n */\n\nexport var OPEN_BROADCAST_CHANNELS = new Set();\nvar lastId = 0;\nexport var BroadcastChannel = function BroadcastChannel(name, options) {\n  // identifier of the channel to debug stuff\n  this.id = lastId++;\n  OPEN_BROADCAST_CHANNELS.add(this);\n  this.name = name;\n\n  if (ENFORCED_OPTIONS) {\n    options = ENFORCED_OPTIONS;\n  }\n\n  this.options = fillOptionsWithDefaults(options);\n  this.method = chooseMethod(this.options); // isListening\n\n  this._iL = false;\n  /**\n   * _onMessageListener\n   * setting onmessage twice,\n   * will overwrite the first listener\n   */\n\n  this._onML = null;\n  /**\n   * _addEventListeners\n   */\n\n  this._addEL = {\n    message: [],\n    internal: []\n  };\n  /**\n   * Unsend message promises\n   * where the sending is still in progress\n   * @type {Set<Promise>}\n   */\n\n  this._uMP = new Set();\n  /**\n   * _beforeClose\n   * array of promises that will be awaited\n   * before the channel is closed\n   */\n\n  this._befC = [];\n  /**\n   * _preparePromise\n   */\n\n  this._prepP = null;\n\n  _prepareChannel(this);\n}; // STATICS\n\n/**\n * used to identify if someone overwrites\n * window.BroadcastChannel with this\n * See methods/native.js\n */\n\nBroadcastChannel._pubkey = true;\n/**\n * clears the tmp-folder if is node\n * @return {Promise<boolean>} true if has run, false if not node\n */\n\nexport function clearNodeFolder(options) {\n  options = fillOptionsWithDefaults(options);\n  var method = chooseMethod(options);\n\n  if (method.type === 'node') {\n    return method.clearNodeFolder().then(function () {\n      return true;\n    });\n  } else {\n    return PROMISE_RESOLVED_FALSE;\n  }\n}\n/**\n * if set, this method is enforced,\n * no mather what the options are\n */\n\nvar ENFORCED_OPTIONS;\nexport function enforceOptions(options) {\n  ENFORCED_OPTIONS = options;\n} // PROTOTYPE\n\nBroadcastChannel.prototype = {\n  postMessage: function postMessage(msg) {\n    if (this.closed) {\n      throw new Error('BroadcastChannel.postMessage(): ' + 'Cannot post message after channel has closed ' +\n      /**\n       * In the past when this error appeared, it was realy hard to debug.\n       * So now we log the msg together with the error so it at least\n       * gives some clue about where in your application this happens.\n       */\n      JSON.stringify(msg));\n    }\n\n    return _post(this, 'message', msg);\n  },\n  postInternal: function postInternal(msg) {\n    return _post(this, 'internal', msg);\n  },\n\n  set onmessage(fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n\n    _removeListenerObject(this, 'message', this._onML);\n\n    if (fn && typeof fn === 'function') {\n      this._onML = listenObj;\n\n      _addListenerObject(this, 'message', listenObj);\n    } else {\n      this._onML = null;\n    }\n  },\n\n  addEventListener: function addEventListener(type, fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n\n    _addListenerObject(this, type, listenObj);\n  },\n  removeEventListener: function removeEventListener(type, fn) {\n    var obj = this._addEL[type].find(function (obj) {\n      return obj.fn === fn;\n    });\n\n    _removeListenerObject(this, type, obj);\n  },\n  close: function close() {\n    var _this = this;\n\n    if (this.closed) {\n      return;\n    }\n\n    OPEN_BROADCAST_CHANNELS[\"delete\"](this);\n    this.closed = true;\n    var awaitPrepare = this._prepP ? this._prepP : PROMISE_RESOLVED_VOID;\n    this._onML = null;\n    this._addEL.message = [];\n    return awaitPrepare // wait until all current sending are processed\n    .then(function () {\n      return Promise.all(Array.from(_this._uMP));\n    }) // run before-close hooks\n    .then(function () {\n      return Promise.all(_this._befC.map(function (fn) {\n        return fn();\n      }));\n    }) // close the channel\n    .then(function () {\n      return _this.method.close(_this._state);\n    });\n  },\n\n  get type() {\n    return this.method.type;\n  },\n\n  get isClosed() {\n    return this.closed;\n  }\n\n};\n/**\n * Post a message over the channel\n * @returns {Promise} that resolved when the message sending is done\n */\n\nfunction _post(broadcastChannel, type, msg) {\n  var time = broadcastChannel.method.microSeconds();\n  var msgObj = {\n    time: time,\n    type: type,\n    data: msg\n  };\n  var awaitPrepare = broadcastChannel._prepP ? broadcastChannel._prepP : PROMISE_RESOLVED_VOID;\n  return awaitPrepare.then(function () {\n    var sendPromise = broadcastChannel.method.postMessage(broadcastChannel._state, msgObj); // add/remove to unsend messages list\n\n    broadcastChannel._uMP.add(sendPromise);\n\n    sendPromise[\"catch\"]().then(function () {\n      return broadcastChannel._uMP[\"delete\"](sendPromise);\n    });\n    return sendPromise;\n  });\n}\n\nfunction _prepareChannel(channel) {\n  var maybePromise = channel.method.create(channel.name, channel.options);\n\n  if (isPromise(maybePromise)) {\n    channel._prepP = maybePromise;\n    maybePromise.then(function (s) {\n      // used in tests to simulate slow runtime\n\n      /*if (channel.options.prepareDelay) {\n           await new Promise(res => setTimeout(res, this.options.prepareDelay));\n      }*/\n      channel._state = s;\n    });\n  } else {\n    channel._state = maybePromise;\n  }\n}\n\nfunction _hasMessageListeners(channel) {\n  if (channel._addEL.message.length > 0) return true;\n  if (channel._addEL.internal.length > 0) return true;\n  return false;\n}\n\nfunction _addListenerObject(channel, type, obj) {\n  channel._addEL[type].push(obj);\n\n  _startListening(channel);\n}\n\nfunction _removeListenerObject(channel, type, obj) {\n  channel._addEL[type] = channel._addEL[type].filter(function (o) {\n    return o !== obj;\n  });\n\n  _stopListening(channel);\n}\n\nfunction _startListening(channel) {\n  if (!channel._iL && _hasMessageListeners(channel)) {\n    // someone is listening, start subscribing\n    var listenerFn = function listenerFn(msgObj) {\n      channel._addEL[msgObj.type].forEach(function (listenerObject) {\n        /**\n         * Getting the current time in JavaScript has no good precision.\n         * So instead of only listening to events that happend 'after' the listener\n         * was added, we also listen to events that happended 100ms before it.\n         * This ensures that when another process, like a WebWorker, sends events\n         * we do not miss them out because their timestamp is a bit off compared to the main process.\n         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.\n         * @link https://johnresig.com/blog/accuracy-of-javascript-time/\n         */\n        var hundredMsInMicro = 100 * 1000;\n        var minMessageTime = listenerObject.time - hundredMsInMicro;\n\n        if (msgObj.time >= minMessageTime) {\n          listenerObject.fn(msgObj.data);\n        }\n      });\n    };\n\n    var time = channel.method.microSeconds();\n\n    if (channel._prepP) {\n      channel._prepP.then(function () {\n        channel._iL = true;\n        channel.method.onMessage(channel._state, listenerFn, time);\n      });\n    } else {\n      channel._iL = true;\n      channel.method.onMessage(channel._state, listenerFn, time);\n    }\n  }\n}\n\nfunction _stopListening(channel) {\n  if (channel._iL && !_hasMessageListeners(channel)) {\n    // noone is listening, stop subscribing\n    channel._iL = false;\n    var time = channel.method.microSeconds();\n    channel.method.onMessage(channel._state, null, time);\n  }\n}","/* global WorkerGlobalScope */\nfunction add(fn) {\n  if (typeof WorkerGlobalScope === 'function' && self instanceof WorkerGlobalScope) {// this is run inside of a webworker\n  } else {\n    /**\n     * if we are on react-native, there is no window.addEventListener\n     * @link https://github.com/pubkey/unload/issues/6\n     */\n    if (typeof window.addEventListener !== 'function') return;\n    /**\n     * for normal browser-windows, we use the beforeunload-event\n     */\n\n    window.addEventListener('beforeunload', function () {\n      fn();\n    }, true);\n    /**\n     * for iframes, we have to use the unload-event\n     * @link https://stackoverflow.com/q/47533670/3443137\n     */\n\n    window.addEventListener('unload', function () {\n      fn();\n    }, true);\n  }\n  /**\n   * TODO add fallback for safari-mobile\n   * @link https://stackoverflow.com/a/26193516/3443137\n   */\n\n}\n\nexport default {\n  add: add\n};","import isNode from 'detect-node';\nimport BrowserMethod from './browser.js';\nimport NodeMethod from './node.js';\nvar USE_METHOD = isNode ? NodeMethod : BrowserMethod;\nvar LISTENERS = new Set();\nvar startedListening = false;\n\nfunction startListening() {\n  if (startedListening) return;\n  startedListening = true;\n  USE_METHOD.add(runAll);\n}\n\nexport function add(fn) {\n  startListening();\n  if (typeof fn !== 'function') throw new Error('Listener is no function');\n  LISTENERS.add(fn);\n  var addReturn = {\n    remove: function remove() {\n      return LISTENERS[\"delete\"](fn);\n    },\n    run: function run() {\n      LISTENERS[\"delete\"](fn);\n      return fn();\n    }\n  };\n  return addReturn;\n}\nexport function runAll() {\n  var promises = [];\n  LISTENERS.forEach(function (fn) {\n    promises.push(fn());\n    LISTENERS[\"delete\"](fn);\n  });\n  return Promise.all(promises);\n}\nexport function removeAll() {\n  LISTENERS.clear();\n}\nexport function getSize() {\n  return LISTENERS.size;\n}","import { sleep, randomToken, PROMISE_RESOLVED_VOID, PROMISE_RESOLVED_TRUE } from './util.js';\nimport { add as unloadAdd } from 'unload';\n\nvar LeaderElection = function LeaderElection(broadcastChannel, options) {\n  var _this = this;\n\n  this.broadcastChannel = broadcastChannel;\n  this._options = options;\n  this.isLeader = false;\n  this.hasLeader = false;\n  this.isDead = false;\n  this.token = randomToken();\n  /**\n   * Apply Queue,\n   * used to ensure we do not run applyOnce()\n   * in parallel.\n   */\n\n  this._aplQ = PROMISE_RESOLVED_VOID; // amount of unfinished applyOnce() calls\n\n  this._aplQC = 0; // things to clean up\n\n  this._unl = []; // _unloads\n\n  this._lstns = []; // _listeners\n\n  this._dpL = function () {}; // onduplicate listener\n\n\n  this._dpLC = false; // true when onduplicate called\n\n  /**\n   * Even when the own instance is not applying,\n   * we still listen to messages to ensure the hasLeader flag\n   * is set correctly.\n   */\n\n  var hasLeaderListener = function hasLeaderListener(msg) {\n    if (msg.context === 'leader') {\n      if (msg.action === 'death') {\n        _this.hasLeader = false;\n      }\n\n      if (msg.action === 'tell') {\n        _this.hasLeader = true;\n      }\n    }\n  };\n\n  this.broadcastChannel.addEventListener('internal', hasLeaderListener);\n\n  this._lstns.push(hasLeaderListener);\n};\n\nLeaderElection.prototype = {\n  /**\n   * Returns true if the instance is leader,\n   * false if not.\n   * @async\n   */\n  applyOnce: function applyOnce( // true if the applyOnce() call came from the fallbackInterval cycle\n  isFromFallbackInterval) {\n    var _this2 = this;\n\n    if (this.isLeader) {\n      return sleep(0, true);\n    }\n\n    if (this.isDead) {\n      return sleep(0, false);\n    }\n    /**\n     * Already applying more then once,\n     * -> wait for the apply queue to be finished.\n     */\n\n\n    if (this._aplQC > 1) {\n      return this._aplQ;\n    }\n    /**\n     * Add a new apply-run\n     */\n\n\n    var applyRun = function applyRun() {\n      /**\n       * Optimization shortcuts.\n       * Directly return if a previous run\n       * has already elected a leader.\n       */\n      if (_this2.isLeader) {\n        return PROMISE_RESOLVED_TRUE;\n      }\n\n      var stopCriteria = false;\n      var stopCriteriaPromiseResolve;\n      /**\n       * Resolves when a stop criteria is reached.\n       * Uses as a performance shortcut so we do not\n       * have to await the responseTime when it is already clear\n       * that the election failed.\n       */\n\n      var stopCriteriaPromise = new Promise(function (res) {\n        stopCriteriaPromiseResolve = function stopCriteriaPromiseResolve() {\n          stopCriteria = true;\n          res();\n        };\n      });\n      var recieved = [];\n\n      var handleMessage = function handleMessage(msg) {\n        if (msg.context === 'leader' && msg.token != _this2.token) {\n          recieved.push(msg);\n\n          if (msg.action === 'apply') {\n            // other is applying\n            if (msg.token > _this2.token) {\n              /**\n               * other has higher token\n               * -> stop applying and let other become leader.\n               */\n              stopCriteriaPromiseResolve();\n            }\n          }\n\n          if (msg.action === 'tell') {\n            // other is already leader\n            stopCriteriaPromiseResolve();\n            _this2.hasLeader = true;\n          }\n        }\n      };\n\n      _this2.broadcastChannel.addEventListener('internal', handleMessage);\n      /**\n       * If the applyOnce() call came from the fallbackInterval,\n       * we can assume that the election runs in the background and\n       * not critical process is waiting for it.\n       * When this is true, we give the other intances\n       * more time to answer to messages in the election cycle.\n       * This makes it less likely to elect duplicate leaders.\n       * But also it takes longer which is not a problem because we anyway\n       * run in the background.\n       */\n\n\n      var waitForAnswerTime = isFromFallbackInterval ? _this2._options.responseTime * 4 : _this2._options.responseTime;\n\n      var applyPromise = _sendMessage(_this2, 'apply') // send out that this one is applying\n      .then(function () {\n        return Promise.race([sleep(waitForAnswerTime), stopCriteriaPromise.then(function () {\n          return Promise.reject(new Error());\n        })]);\n      }) // send again in case another instance was just created\n      .then(function () {\n        return _sendMessage(_this2, 'apply');\n      }) // let others time to respond\n      .then(function () {\n        return Promise.race([sleep(waitForAnswerTime), stopCriteriaPromise.then(function () {\n          return Promise.reject(new Error());\n        })]);\n      })[\"catch\"](function () {}).then(function () {\n        _this2.broadcastChannel.removeEventListener('internal', handleMessage);\n\n        if (!stopCriteria) {\n          // no stop criteria -> own is leader\n          return beLeader(_this2).then(function () {\n            return true;\n          });\n        } else {\n          // other is leader\n          return false;\n        }\n      });\n\n      return applyPromise;\n    };\n\n    this._aplQC = this._aplQC + 1;\n    this._aplQ = this._aplQ.then(function () {\n      return applyRun();\n    }).then(function () {\n      _this2._aplQC = _this2._aplQC - 1;\n    });\n    return this._aplQ.then(function () {\n      return _this2.isLeader;\n    });\n  },\n  awaitLeadership: function awaitLeadership() {\n    if (\n    /* _awaitLeadershipPromise */\n    !this._aLP) {\n      this._aLP = _awaitLeadershipOnce(this);\n    }\n\n    return this._aLP;\n  },\n\n  set onduplicate(fn) {\n    this._dpL = fn;\n  },\n\n  die: function die() {\n    var _this3 = this;\n\n    this._lstns.forEach(function (listener) {\n      return _this3.broadcastChannel.removeEventListener('internal', listener);\n    });\n\n    this._lstns = [];\n\n    this._unl.forEach(function (uFn) {\n      return uFn.remove();\n    });\n\n    this._unl = [];\n\n    if (this.isLeader) {\n      this.hasLeader = false;\n      this.isLeader = false;\n    }\n\n    this.isDead = true;\n    return _sendMessage(this, 'death');\n  }\n};\n/**\n * @param leaderElector {LeaderElector}\n */\n\nfunction _awaitLeadershipOnce(leaderElector) {\n  if (leaderElector.isLeader) {\n    return PROMISE_RESOLVED_VOID;\n  }\n\n  return new Promise(function (res) {\n    var resolved = false;\n\n    function finish() {\n      if (resolved) {\n        return;\n      }\n\n      resolved = true;\n      leaderElector.broadcastChannel.removeEventListener('internal', whenDeathListener);\n      res(true);\n    } // try once now\n\n\n    leaderElector.applyOnce().then(function () {\n      if (leaderElector.isLeader) {\n        finish();\n      }\n    });\n    /**\n     * Try on fallbackInterval\n     * @recursive\n     */\n\n    var tryOnFallBack = function tryOnFallBack() {\n      return sleep(leaderElector._options.fallbackInterval).then(function () {\n        if (leaderElector.isDead || resolved) {\n          return;\n        }\n\n        if (leaderElector.isLeader) {\n          finish();\n        } else {\n          return leaderElector.applyOnce(true).then(function () {\n            if (leaderElector.isLeader) {\n              finish();\n            } else {\n              tryOnFallBack();\n            }\n          });\n        }\n      });\n    };\n\n    tryOnFallBack(); // try when other leader dies\n\n    var whenDeathListener = function whenDeathListener(msg) {\n      if (msg.context === 'leader' && msg.action === 'death') {\n        leaderElector.hasLeader = false;\n        leaderElector.applyOnce().then(function () {\n          if (leaderElector.isLeader) {\n            finish();\n          }\n        });\n      }\n    };\n\n    leaderElector.broadcastChannel.addEventListener('internal', whenDeathListener);\n\n    leaderElector._lstns.push(whenDeathListener);\n  });\n}\n/**\n * sends and internal message over the broadcast-channel\n */\n\n\nfunction _sendMessage(leaderElector, action) {\n  var msgJson = {\n    context: 'leader',\n    action: action,\n    token: leaderElector.token\n  };\n  return leaderElector.broadcastChannel.postInternal(msgJson);\n}\n\nexport function beLeader(leaderElector) {\n  leaderElector.isLeader = true;\n  leaderElector.hasLeader = true;\n  var unloadFn = unloadAdd(function () {\n    return leaderElector.die();\n  });\n\n  leaderElector._unl.push(unloadFn);\n\n  var isLeaderListener = function isLeaderListener(msg) {\n    if (msg.context === 'leader' && msg.action === 'apply') {\n      _sendMessage(leaderElector, 'tell');\n    }\n\n    if (msg.context === 'leader' && msg.action === 'tell' && !leaderElector._dpLC) {\n      /**\n       * another instance is also leader!\n       * This can happen on rare events\n       * like when the CPU is at 100% for long time\n       * or the tabs are open very long and the browser throttles them.\n       * @link https://github.com/pubkey/broadcast-channel/issues/414\n       * @link https://github.com/pubkey/broadcast-channel/issues/385\n       */\n      leaderElector._dpLC = true;\n\n      leaderElector._dpL(); // message the lib user so the app can handle the problem\n\n\n      _sendMessage(leaderElector, 'tell'); // ensure other leader also knows the problem\n\n    }\n  };\n\n  leaderElector.broadcastChannel.addEventListener('internal', isLeaderListener);\n\n  leaderElector._lstns.push(isLeaderListener);\n\n  return _sendMessage(leaderElector, 'tell');\n}\n\nfunction fillOptionsWithDefaults(options, channel) {\n  if (!options) options = {};\n  options = JSON.parse(JSON.stringify(options));\n\n  if (!options.fallbackInterval) {\n    options.fallbackInterval = 3000;\n  }\n\n  if (!options.responseTime) {\n    options.responseTime = channel.method.averageResponseTime(channel.options);\n  }\n\n  return options;\n}\n\nexport function createLeaderElection(channel, options) {\n  if (channel._leaderElector) {\n    throw new Error('BroadcastChannel already has a leader-elector');\n  }\n\n  options = fillOptionsWithDefaults(options, channel);\n  var elector = new LeaderElection(channel, options);\n\n  channel._befC.push(function () {\n    return elector.die();\n  });\n\n  channel._leaderElector = elector;\n  return elector;\n}","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction _construct(Parent, args, Class) {\n  if (_isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) _setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nfunction _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\n\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !_isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n    }\n\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return _setPrototypeOf(Wrapper, Class);\n  };\n\n  return _wrapNativeSuper(Class);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n  return function _createSuperInternal() {\n    var Super = _getPrototypeOf(Derived),\n        result;\n\n    if (hasNativeReflectConstruct) {\n      var NewTarget = _getPrototypeOf(this).constructor;\n\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n\n    return _possibleConstructorReturn(this, result);\n  };\n}\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\n\nfunction _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n\n  if (!it) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function () {};\n\n      return {\n        s: F,\n        n: function () {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function (e) {\n          throw e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function () {\n      it = it.call(o);\n    },\n    n: function () {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function (e) {\n      didErr = true;\n      err = e;\n    },\n    f: function () {\n      try {\n        if (!normalCompletion && it.return != null) it.return();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\n\nvar hasOwnProp = Object.prototype.hasOwnProperty;\n/**\n* @typedef {null|boolean|number|string|PlainObject|GenericArray} JSONObject\n*/\n\n/**\n * Copies array and then pushes item into it.\n * @param {GenericArray} arr Array to copy and into which to push\n * @param {any} item Array item to add (to end)\n * @returns {GenericArray} Copy of the original array\n */\n\nfunction push(arr, item) {\n  arr = arr.slice();\n  arr.push(item);\n  return arr;\n}\n/**\n * Copies array and then unshifts item into it.\n * @param {any} item Array item to add (to beginning)\n * @param {GenericArray} arr Array to copy and into which to unshift\n * @returns {GenericArray} Copy of the original array\n */\n\n\nfunction unshift(item, arr) {\n  arr = arr.slice();\n  arr.unshift(item);\n  return arr;\n}\n/**\n * Caught when JSONPath is used without `new` but rethrown if with `new`\n * @extends Error\n */\n\n\nvar NewError = /*#__PURE__*/function (_Error) {\n  _inherits(NewError, _Error);\n\n  var _super = _createSuper(NewError);\n\n  /**\n   * @param {any} value The evaluated scalar value\n   */\n  function NewError(value) {\n    var _this;\n\n    _classCallCheck(this, NewError);\n\n    _this = _super.call(this, 'JSONPath should not be called with \"new\" (it prevents return ' + 'of (unwrapped) scalar values)');\n    _this.avoidNew = true;\n    _this.value = value;\n    _this.name = 'NewError';\n    return _this;\n  }\n\n  return NewError;\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n/**\n* @typedef {PlainObject} ReturnObject\n* @property {string} path\n* @property {JSONObject} value\n* @property {PlainObject|GenericArray} parent\n* @property {string} parentProperty\n*/\n\n/**\n* @callback JSONPathCallback\n* @param {string|PlainObject} preferredOutput\n* @param {\"value\"|\"property\"} type\n* @param {ReturnObject} fullRetObj\n* @returns {void}\n*/\n\n/**\n* @callback OtherTypeCallback\n* @param {JSONObject} val\n* @param {string} path\n* @param {PlainObject|GenericArray} parent\n* @param {string} parentPropName\n* @returns {boolean}\n*/\n\n/* eslint-disable max-len -- Can make multiline type after https://github.com/syavorsky/comment-parser/issues/109 */\n\n/**\n * @typedef {PlainObject} JSONPathOptions\n * @property {JSON} json\n * @property {string|string[]} path\n * @property {\"value\"|\"path\"|\"pointer\"|\"parent\"|\"parentProperty\"|\"all\"} [resultType=\"value\"]\n * @property {boolean} [flatten=false]\n * @property {boolean} [wrap=true]\n * @property {PlainObject} [sandbox={}]\n * @property {boolean} [preventEval=false]\n * @property {PlainObject|GenericArray|null} [parent=null]\n * @property {string|null} [parentProperty=null]\n * @property {JSONPathCallback} [callback]\n * @property {OtherTypeCallback} [otherTypeCallback] Defaults to\n *   function which throws on encountering `@other`\n * @property {boolean} [autostart=true]\n */\n\n/* eslint-enable max-len -- Can make multiline type after https://github.com/syavorsky/comment-parser/issues/109 */\n\n/**\n * @param {string|JSONPathOptions} opts If a string, will be treated as `expr`\n * @param {string} [expr] JSON path to evaluate\n * @param {JSON} [obj] JSON object to evaluate against\n * @param {JSONPathCallback} [callback] Passed 3 arguments: 1) desired payload\n *     per `resultType`, 2) `\"value\"|\"property\"`, 3) Full returned object with\n *     all payloads\n * @param {OtherTypeCallback} [otherTypeCallback] If `@other()` is at the end\n *   of one's query, this will be invoked with the value of the item, its\n *   path, its parent, and its parent's property name, and it should return\n *   a boolean indicating whether the supplied value belongs to the \"other\"\n *   type or not (or it may handle transformations and return `false`).\n * @returns {JSONPath}\n * @class\n */\n\n\nfunction JSONPath(opts, expr, obj, callback, otherTypeCallback) {\n  // eslint-disable-next-line no-restricted-syntax\n  if (!(this instanceof JSONPath)) {\n    try {\n      return new JSONPath(opts, expr, obj, callback, otherTypeCallback);\n    } catch (e) {\n      if (!e.avoidNew) {\n        throw e;\n      }\n\n      return e.value;\n    }\n  }\n\n  if (typeof opts === 'string') {\n    otherTypeCallback = callback;\n    callback = obj;\n    obj = expr;\n    expr = opts;\n    opts = null;\n  }\n\n  var optObj = opts && _typeof(opts) === 'object';\n  opts = opts || {};\n  this.json = opts.json || obj;\n  this.path = opts.path || expr;\n  this.resultType = opts.resultType || 'value';\n  this.flatten = opts.flatten || false;\n  this.wrap = hasOwnProp.call(opts, 'wrap') ? opts.wrap : true;\n  this.sandbox = opts.sandbox || {};\n  this.preventEval = opts.preventEval || false;\n  this.parent = opts.parent || null;\n  this.parentProperty = opts.parentProperty || null;\n  this.callback = opts.callback || callback || null;\n\n  this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function () {\n    throw new TypeError('You must supply an otherTypeCallback callback option ' + 'with the @other() operator.');\n  };\n\n  if (opts.autostart !== false) {\n    var args = {\n      path: optObj ? opts.path : expr\n    };\n\n    if (!optObj) {\n      args.json = obj;\n    } else if ('json' in opts) {\n      args.json = opts.json;\n    }\n\n    var ret = this.evaluate(args);\n\n    if (!ret || _typeof(ret) !== 'object') {\n      throw new NewError(ret);\n    }\n\n    return ret;\n  }\n} // PUBLIC METHODS\n\n\nJSONPath.prototype.evaluate = function (expr, json, callback, otherTypeCallback) {\n  var _this2 = this;\n\n  var currParent = this.parent,\n      currParentProperty = this.parentProperty;\n  var flatten = this.flatten,\n      wrap = this.wrap;\n  this.currResultType = this.resultType;\n  this.currPreventEval = this.preventEval;\n  this.currSandbox = this.sandbox;\n  callback = callback || this.callback;\n  this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback;\n  json = json || this.json;\n  expr = expr || this.path;\n\n  if (expr && _typeof(expr) === 'object' && !Array.isArray(expr)) {\n    if (!expr.path && expr.path !== '') {\n      throw new TypeError('You must supply a \"path\" property when providing an object ' + 'argument to JSONPath.evaluate().');\n    }\n\n    if (!hasOwnProp.call(expr, 'json')) {\n      throw new TypeError('You must supply a \"json\" property when providing an object ' + 'argument to JSONPath.evaluate().');\n    }\n\n    var _expr = expr;\n    json = _expr.json;\n    flatten = hasOwnProp.call(expr, 'flatten') ? expr.flatten : flatten;\n    this.currResultType = hasOwnProp.call(expr, 'resultType') ? expr.resultType : this.currResultType;\n    this.currSandbox = hasOwnProp.call(expr, 'sandbox') ? expr.sandbox : this.currSandbox;\n    wrap = hasOwnProp.call(expr, 'wrap') ? expr.wrap : wrap;\n    this.currPreventEval = hasOwnProp.call(expr, 'preventEval') ? expr.preventEval : this.currPreventEval;\n    callback = hasOwnProp.call(expr, 'callback') ? expr.callback : callback;\n    this.currOtherTypeCallback = hasOwnProp.call(expr, 'otherTypeCallback') ? expr.otherTypeCallback : this.currOtherTypeCallback;\n    currParent = hasOwnProp.call(expr, 'parent') ? expr.parent : currParent;\n    currParentProperty = hasOwnProp.call(expr, 'parentProperty') ? expr.parentProperty : currParentProperty;\n    expr = expr.path;\n  }\n\n  currParent = currParent || null;\n  currParentProperty = currParentProperty || null;\n\n  if (Array.isArray(expr)) {\n    expr = JSONPath.toPathString(expr);\n  }\n\n  if (!expr && expr !== '' || !json) {\n    return undefined;\n  }\n\n  var exprList = JSONPath.toPathArray(expr);\n\n  if (exprList[0] === '$' && exprList.length > 1) {\n    exprList.shift();\n  }\n\n  this._hasParentSelector = null;\n\n  var result = this._trace(exprList, json, ['$'], currParent, currParentProperty, callback).filter(function (ea) {\n    return ea && !ea.isParentSelector;\n  });\n\n  if (!result.length) {\n    return wrap ? [] : undefined;\n  }\n\n  if (!wrap && result.length === 1 && !result[0].hasArrExpr) {\n    return this._getPreferredOutput(result[0]);\n  }\n\n  return result.reduce(function (rslt, ea) {\n    var valOrPath = _this2._getPreferredOutput(ea);\n\n    if (flatten && Array.isArray(valOrPath)) {\n      rslt = rslt.concat(valOrPath);\n    } else {\n      rslt.push(valOrPath);\n    }\n\n    return rslt;\n  }, []);\n}; // PRIVATE METHODS\n\n\nJSONPath.prototype._getPreferredOutput = function (ea) {\n  var resultType = this.currResultType;\n\n  switch (resultType) {\n    case 'all':\n      {\n        var path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);\n        ea.pointer = JSONPath.toPointer(path);\n        ea.path = typeof ea.path === 'string' ? ea.path : JSONPath.toPathString(ea.path);\n        return ea;\n      }\n\n    case 'value':\n    case 'parent':\n    case 'parentProperty':\n      return ea[resultType];\n\n    case 'path':\n      return JSONPath.toPathString(ea[resultType]);\n\n    case 'pointer':\n      return JSONPath.toPointer(ea.path);\n\n    default:\n      throw new TypeError('Unknown result type');\n  }\n};\n\nJSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {\n  if (callback) {\n    var preferredOutput = this._getPreferredOutput(fullRetObj);\n\n    fullRetObj.path = typeof fullRetObj.path === 'string' ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path); // eslint-disable-next-line node/callback-return\n\n    callback(preferredOutput, type, fullRetObj);\n  }\n};\n/**\n *\n * @param {string} expr\n * @param {JSONObject} val\n * @param {string} path\n * @param {PlainObject|GenericArray} parent\n * @param {string} parentPropName\n * @param {JSONPathCallback} callback\n * @param {boolean} hasArrExpr\n * @param {boolean} literalPriority\n * @returns {ReturnObject|ReturnObject[]}\n */\n\n\nJSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {\n  var _this3 = this;\n\n  // No expr to follow? return path and value as the result of\n  //  this trace branch\n  var retObj;\n\n  if (!expr.length) {\n    retObj = {\n      path: path,\n      value: val,\n      parent: parent,\n      parentProperty: parentPropName,\n      hasArrExpr: hasArrExpr\n    };\n\n    this._handleCallback(retObj, callback, 'value');\n\n    return retObj;\n  }\n\n  var loc = expr[0],\n      x = expr.slice(1); // We need to gather the return value of recursive trace calls in order to\n  // do the parent sel computation.\n\n  var ret = [];\n  /**\n   *\n   * @param {ReturnObject|ReturnObject[]} elems\n   * @returns {void}\n   */\n\n  function addRet(elems) {\n    if (Array.isArray(elems)) {\n      // This was causing excessive stack size in Node (with or\n      //  without Babel) against our performance test:\n      //  `ret.push(...elems);`\n      elems.forEach(function (t) {\n        ret.push(t);\n      });\n    } else {\n      ret.push(elems);\n    }\n  }\n\n  if ((typeof loc !== 'string' || literalPriority) && val && hasOwnProp.call(val, loc)) {\n    // simple case--directly follow property\n    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr)); // eslint-disable-next-line unicorn/prefer-switch -- Part of larger `if`\n  } else if (loc === '*') {\n    // all child properties\n    this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, _x, v, p, par, pr, cb) {\n      addRet(_this3._trace(unshift(m, _x), v, p, par, pr, cb, true, true));\n    });\n  } else if (loc === '..') {\n    // all descendent parent properties\n    // Check remaining expression with val's immediate children\n    addRet(this._trace(x, val, path, parent, parentPropName, callback, hasArrExpr));\n\n    this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, _x, v, p, par, pr, cb) {\n      // We don't join m and x here because we only want parents,\n      //   not scalar values\n      if (_typeof(v[m]) === 'object') {\n        // Keep going with recursive descent on val's\n        //   object children\n        addRet(_this3._trace(unshift(l, _x), v[m], push(p, m), v, m, cb, true));\n      }\n    }); // The parent sel computation is handled in the frame above using the\n    // ancestor object of val\n\n  } else if (loc === '^') {\n    // This is not a final endpoint, so we do not invoke the callback here\n    this._hasParentSelector = true;\n    return {\n      path: path.slice(0, -1),\n      expr: x,\n      isParentSelector: true\n    };\n  } else if (loc === '~') {\n    // property name\n    retObj = {\n      path: push(path, loc),\n      value: parentPropName,\n      parent: parent,\n      parentProperty: null\n    };\n\n    this._handleCallback(retObj, callback, 'property');\n\n    return retObj;\n  } else if (loc === '$') {\n    // root only\n    addRet(this._trace(x, val, path, null, null, callback, hasArrExpr));\n  } else if (/^(\\x2D?[0-9]*):(\\x2D?[0-9]*):?([0-9]*)$/.test(loc)) {\n    // [start:end:step]  Python slice syntax\n    addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));\n  } else if (loc.indexOf('?(') === 0) {\n    // [?(expr)] (filtering)\n    if (this.currPreventEval) {\n      throw new Error('Eval [?(expr)] prevented in JSONPath expression.');\n    }\n\n    this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, _x, v, p, par, pr, cb) {\n      if (_this3._eval(l.replace(/^\\?\\(((?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?)\\)$/, '$1'), v[m], m, p, par, pr)) {\n        addRet(_this3._trace(unshift(m, _x), v, p, par, pr, cb, true));\n      }\n    });\n  } else if (loc[0] === '(') {\n    // [(expr)] (dynamic property/index)\n    if (this.currPreventEval) {\n      throw new Error('Eval [(expr)] prevented in JSONPath expression.');\n    } // As this will resolve to a property name (but we don't know it\n    //  yet), property and parent information is relative to the\n    //  parent of the property to which this expression will resolve\n\n\n    addRet(this._trace(unshift(this._eval(loc, val, path[path.length - 1], path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));\n  } else if (loc[0] === '@') {\n    // value type: @boolean(), etc.\n    var addType = false;\n    var valueType = loc.slice(1, -2);\n\n    switch (valueType) {\n      case 'scalar':\n        if (!val || !['object', 'function'].includes(_typeof(val))) {\n          addType = true;\n        }\n\n        break;\n\n      case 'boolean':\n      case 'string':\n      case 'undefined':\n      case 'function':\n        // eslint-disable-next-line valid-typeof\n        if (_typeof(val) === valueType) {\n          addType = true;\n        }\n\n        break;\n\n      case 'integer':\n        if (Number.isFinite(val) && !(val % 1)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'number':\n        if (Number.isFinite(val)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'nonFinite':\n        if (typeof val === 'number' && !Number.isFinite(val)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'object':\n        // eslint-disable-next-line valid-typeof\n        if (val && _typeof(val) === valueType) {\n          addType = true;\n        }\n\n        break;\n\n      case 'array':\n        if (Array.isArray(val)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'other':\n        addType = this.currOtherTypeCallback(val, path, parent, parentPropName);\n        break;\n\n      case 'null':\n        if (val === null) {\n          addType = true;\n        }\n\n        break;\n\n      /* c8 ignore next 2 */\n\n      default:\n        throw new TypeError('Unknown value type ' + valueType);\n    }\n\n    if (addType) {\n      retObj = {\n        path: path,\n        value: val,\n        parent: parent,\n        parentProperty: parentPropName\n      };\n\n      this._handleCallback(retObj, callback, 'value');\n\n      return retObj;\n    } // `-escaped property\n\n  } else if (loc[0] === '`' && val && hasOwnProp.call(val, loc.slice(1))) {\n    var locProp = loc.slice(1);\n    addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, hasArrExpr, true));\n  } else if (loc.includes(',')) {\n    // [name1,name2,...]\n    var parts = loc.split(',');\n\n    var _iterator = _createForOfIteratorHelper(parts),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var part = _step.value;\n        addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));\n      } // simple case--directly follow property\n\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  } else if (!literalPriority && val && hasOwnProp.call(val, loc)) {\n    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr, true));\n  } // We check the resulting values for parent selections. For parent\n  // selections we discard the value object and continue the trace with the\n  // current val object\n\n\n  if (this._hasParentSelector) {\n    for (var t = 0; t < ret.length; t++) {\n      var rett = ret[t];\n\n      if (rett && rett.isParentSelector) {\n        var tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr);\n\n        if (Array.isArray(tmp)) {\n          ret[t] = tmp[0];\n          var tl = tmp.length;\n\n          for (var tt = 1; tt < tl; tt++) {\n            t++;\n            ret.splice(t, 0, tmp[tt]);\n          }\n        } else {\n          ret[t] = tmp;\n        }\n      }\n    }\n  }\n\n  return ret;\n};\n\nJSONPath.prototype._walk = function (loc, expr, val, path, parent, parentPropName, callback, f) {\n  if (Array.isArray(val)) {\n    var n = val.length;\n\n    for (var i = 0; i < n; i++) {\n      f(i, loc, expr, val, path, parent, parentPropName, callback);\n    }\n  } else if (val && _typeof(val) === 'object') {\n    Object.keys(val).forEach(function (m) {\n      f(m, loc, expr, val, path, parent, parentPropName, callback);\n    });\n  }\n};\n\nJSONPath.prototype._slice = function (loc, expr, val, path, parent, parentPropName, callback) {\n  if (!Array.isArray(val)) {\n    return undefined;\n  }\n\n  var len = val.length,\n      parts = loc.split(':'),\n      step = parts[2] && Number.parseInt(parts[2]) || 1;\n  var start = parts[0] && Number.parseInt(parts[0]) || 0,\n      end = parts[1] && Number.parseInt(parts[1]) || len;\n  start = start < 0 ? Math.max(0, start + len) : Math.min(len, start);\n  end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);\n  var ret = [];\n\n  for (var i = start; i < end; i += step) {\n    var tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback, true); // Should only be possible to be an array here since first part of\n    //   ``unshift(i, expr)` passed in above would not be empty, nor `~`,\n    //     nor begin with `@` (as could return objects)\n    // This was causing excessive stack size in Node (with or\n    //  without Babel) against our performance test: `ret.push(...tmp);`\n\n\n    tmp.forEach(function (t) {\n      ret.push(t);\n    });\n  }\n\n  return ret;\n};\n\nJSONPath.prototype._eval = function (code, _v, _vname, path, parent, parentPropName) {\n  if (code.includes('@parentProperty')) {\n    this.currSandbox._$_parentProperty = parentPropName;\n    code = code.replace(/@parentProperty/g, '_$_parentProperty');\n  }\n\n  if (code.includes('@parent')) {\n    this.currSandbox._$_parent = parent;\n    code = code.replace(/@parent/g, '_$_parent');\n  }\n\n  if (code.includes('@property')) {\n    this.currSandbox._$_property = _vname;\n    code = code.replace(/@property/g, '_$_property');\n  }\n\n  if (code.includes('@path')) {\n    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));\n    code = code.replace(/@path/g, '_$_path');\n  }\n\n  if (code.includes('@root')) {\n    this.currSandbox._$_root = this.json;\n    code = code.replace(/@root/g, '_$_root');\n  }\n\n  if (/@([\\t-\\r \\)\\.\\[\\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF])/.test(code)) {\n    this.currSandbox._$_v = _v;\n    code = code.replace(/@([\\t-\\r \\)\\.\\[\\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF])/g, '_$_v$1');\n  }\n\n  try {\n    return this.vm.runInNewContext(code, this.currSandbox);\n  } catch (e) {\n    // eslint-disable-next-line no-console\n    console.log(e);\n    throw new Error('jsonPath: ' + e.message + ': ' + code);\n  }\n}; // PUBLIC CLASS PROPERTIES AND METHODS\n// Could store the cache object itself\n\n\nJSONPath.cache = {};\n/**\n * @param {string[]} pathArr Array to convert\n * @returns {string} The path string\n */\n\nJSONPath.toPathString = function (pathArr) {\n  var x = pathArr,\n      n = x.length;\n  var p = '$';\n\n  for (var i = 1; i < n; i++) {\n    if (!/^(~|\\^|@(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?\\(\\))$/.test(x[i])) {\n      p += /^[\\*0-9]+$/.test(x[i]) ? '[' + x[i] + ']' : \"['\" + x[i] + \"']\";\n    }\n  }\n\n  return p;\n};\n/**\n * @param {string} pointer JSON Path\n * @returns {string} JSON Pointer\n */\n\n\nJSONPath.toPointer = function (pointer) {\n  var x = pointer,\n      n = x.length;\n  var p = '';\n\n  for (var i = 1; i < n; i++) {\n    if (!/^(~|\\^|@(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?\\(\\))$/.test(x[i])) {\n      p += '/' + x[i].toString().replace(/~/g, '~0').replace(/\\//g, '~1');\n    }\n  }\n\n  return p;\n};\n/**\n * @param {string} expr Expression to convert\n * @returns {string[]}\n */\n\n\nJSONPath.toPathArray = function (expr) {\n  var cache = JSONPath.cache;\n\n  if (cache[expr]) {\n    return cache[expr].concat();\n  }\n\n  var subx = [];\n  var normalized = expr // Properties\n  .replace(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\\(\\)/g, ';$&;') // Parenthetical evaluations (filtering and otherwise), directly\n  //   within brackets or single quotes\n  .replace(/['\\[](\\??\\((?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?\\))['\\]]/g, function ($0, $1) {\n    return '[#' + (subx.push($1) - 1) + ']';\n  }) // Escape periods and tildes within properties\n  .replace(/\\[[\"']((?:(?!['\\]])[\\s\\S])*)[\"']\\]/g, function ($0, prop) {\n    return \"['\" + prop.replace(/\\./g, '%@%').replace(/~/g, '%%@@%%') + \"']\";\n  }) // Properties operator\n  .replace(/~/g, ';~;') // Split by property boundaries\n  .replace(/[\"']?\\.[\"']?(?!(?:(?!\\[)[\\s\\S])*\\])|\\[[\"']?/g, ';') // Reinsert periods within properties\n  .replace(/%@%/g, '.') // Reinsert tildes within properties\n  .replace(/%%@@%%/g, '~') // Parent\n  .replace(/(?:;)?(\\^+)(?:;)?/g, function ($0, ups) {\n    return ';' + ups.split('').join(';') + ';';\n  }) // Descendents\n  .replace(/;;;|;;/g, ';..;') // Remove trailing\n  .replace(/;$|'?\\]|'$/g, '');\n  var exprList = normalized.split(';').map(function (exp) {\n    var match = exp.match(/#([0-9]+)/);\n    return !match || !match[1] ? exp : subx[match[1]];\n  });\n  cache[expr] = exprList;\n  return cache[expr].concat();\n};\n\n/**\n* @callback ConditionCallback\n* @param {any} item\n* @returns {boolean}\n*/\n\n/**\n * Copy items out of one array into another.\n * @param {GenericArray} source Array with items to copy\n * @param {GenericArray} target Array to which to copy\n * @param {ConditionCallback} conditionCb Callback passed the current item;\n *     will move item if evaluates to `true`\n * @returns {void}\n */\n\nvar moveToAnotherArray = function moveToAnotherArray(source, target, conditionCb) {\n  var il = source.length;\n\n  for (var i = 0; i < il; i++) {\n    var item = source[i];\n\n    if (conditionCb(item)) {\n      target.push(source.splice(i--, 1)[0]);\n    }\n  }\n};\n\nJSONPath.prototype.vm = {\n  /**\n   * @param {string} expr Expression to evaluate\n   * @param {PlainObject} context Object whose items will be added\n   *   to evaluation\n   * @returns {any} Result of evaluated code\n   */\n  runInNewContext: function runInNewContext(expr, context) {\n    var keys = Object.keys(context);\n    var funcs = [];\n    moveToAnotherArray(keys, funcs, function (key) {\n      return typeof context[key] === 'function';\n    });\n    var values = keys.map(function (vr, i) {\n      return context[vr];\n    });\n    var funcString = funcs.reduce(function (s, func) {\n      var fString = context[func].toString();\n\n      if (!/function/.test(fString)) {\n        fString = 'function ' + fString;\n      }\n\n      return 'var ' + func + '=' + fString + ';' + s;\n    }, '');\n    expr = funcString + expr; // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function\n\n    if (!/([\"'])use strict\\1/.test(expr) && !keys.includes('arguments')) {\n      expr = 'var arguments = undefined;' + expr;\n    } // Remove last semi so `return` will be inserted before\n    //  the previous one instead, allowing for the return\n    //  of a bare ending expression\n\n\n    expr = expr.replace(/;[\\t-\\r \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]*$/, ''); // Insert `return`\n\n    var lastStatementEnd = expr.lastIndexOf(';');\n    var code = lastStatementEnd > -1 ? expr.slice(0, lastStatementEnd + 1) + ' return ' + expr.slice(lastStatementEnd + 1) : ' return ' + expr; // eslint-disable-next-line no-new-func\n\n    return _construct(Function, _toConsumableArray(keys).concat([code])).apply(void 0, _toConsumableArray(values));\n  }\n};\n\nexport { JSONPath };\n"],"names":["module","exports","CancelError","Error","constructor","reason","super","this","name","isCanceled","PCancelable","fn","userFn","arguments_","resolve","reject","onCancel","push","then","executor","_cancelHandlers","_isPending","_isCanceled","_rejectOnCancel","_promise","Promise","_reject","handler","Object","defineProperties","shouldReject","get","set","boolean","value","error","onFulfilled","onRejected","catch","onFinally","finally","cancel","length","setPrototypeOf","prototype","E","on","callback","ctx","e","once","self","listener","off","apply","arguments","_","emit","data","slice","call","evtArr","i","len","evts","liveEvents","assign","target","source","key","api","init","converter","defaultAttributes","attributes","document","expires","Date","now","toUTCString","encodeURIComponent","replace","decodeURIComponent","escape","stringifiedAttributes","attributeName","split","cookie","write","create","cookies","jar","parts","join","found","read","remove","withAttributes","withConverter","freeze","path","PROMISE_RESOLVED_TRUE","PROMISE_RESOLVED_VOID","sleep","time","resolveWith","res","setTimeout","randomToken","Math","random","toString","substring","lastMs","additional","microSeconds","ms","getTime","channelName","state","messagesCallback","bc","BroadcastChannel","subFns","onmessage","msg","close","channelState","onMessage","postMessage","messageJson","err","canBeUsed","window","_pubkey","type","averageResponseTime","ttl","map","Map","_to","has","add","obliviousSet","olderThen","iterator","Symbol","next","delete","removeTooOldValues","clear","originalOptions","undefined","options","JSON","parse","stringify","webWorkerSupport","idb","fallbackInterval","onclose","localstorage","removeTimeout","methods","node","maxParallelWrites","useFastPath","OBJECT_STORE_ID","TRANSACTION_SETTINGS","durability","getIdb","indexedDB","mozIndexedDB","webkitIndexedDB","msIndexedDB","commitIndexedDBTransaction","tx","commit","_readLoop","closed","readNewMessages","db","lastCursorId","transaction","objectStore","ret","keyRangeValue","IDBKeyRange","bound","Infinity","getAll","getAllRequest","rej","onerror","onsuccess","result","openCursorRequest","openCursor","ev","cursor","id","getMessagesHigherThan","newerMessages","useMessages","filter","msgObj","uuid","eMIs","messagesCallbackTime","_filterMessage","sort","msgObjA","msgObjB","forEach","dbName","openRequest","open","onupgradeneeded","createObjectStore","keyPath","autoIncrement","createDatabase","ObliviousSet","writeBlockPromise","readQueuePromises","readerUuid","writeObject","oncomplete","writeMessage","floor","msgObk","getOldMessages","tooOld","ids","all","deleteRequest","removeMessagesById","getLocalStorage","localStorage","storageKey","ls","setItem","removeItem","newValue","token","addEventListener","addStorageEventListener","removeEventListener","writeObj","createEvent","initEvent","dispatchEvent","userAgent","navigator","toLowerCase","includes","defaultTime","SIMULATE_CHANNELS","Set","Array","from","channel","METHODS","OPEN_BROADCAST_CHANNELS","lastId","maybePromise","obj","method","chooseMethods","concat","Boolean","find","m","useMethod","_iL","_onML","_addEL","message","internal","_uMP","_befC","_prepP","s","_state","_post","broadcastChannel","sendPromise","_hasMessageListeners","_addListenerObject","listenerFn","listenerObject","minMessageTime","_startListening","_removeListenerObject","o","_stopListening","postInternal","listenObj","_this","awaitPrepare","isClosed","WorkerGlobalScope","USE_METHOD","LISTENERS","startedListening","runAll","promises","LeaderElection","_options","isLeader","hasLeader","isDead","_aplQ","_aplQC","_unl","_lstns","_dpL","_dpLC","hasLeaderListener","context","action","_sendMessage","leaderElector","msgJson","createLeaderElection","_leaderElector","responseTime","elector","die","applyOnce","isFromFallbackInterval","_this2","applyRun","stopCriteriaPromiseResolve","stopCriteria","stopCriteriaPromise","recieved","handleMessage","waitForAnswerTime","race","unloadFn","run","isLeaderListener","beLeader","awaitLeadership","_aLP","resolved","finish","whenDeathListener","tryOnFallBack","onduplicate","_this3","uFn","_typeof","_getPrototypeOf","getPrototypeOf","__proto__","_setPrototypeOf","p","_isNativeReflectConstruct","Reflect","construct","sham","Proxy","valueOf","_construct","Parent","args","Class","a","instance","Function","bind","_wrapNativeSuper","_cache","indexOf","TypeError","Wrapper","enumerable","writable","configurable","_toConsumableArray","arr","isArray","_arrayLikeToArray","_arrayWithoutHoles","iter","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","minLen","n","test","arr2","hasOwnProp","hasOwnProperty","item","unshift","NewError","_Error","subClass","superClass","_inherits","Derived","hasNativeReflectConstruct","_super","Super","NewTarget","ReferenceError","_assertThisInitialized","_possibleConstructorReturn","Constructor","_classCallCheck","avoidNew","JSONPath","opts","expr","otherTypeCallback","optObj","json","resultType","flatten","wrap","sandbox","preventEval","parent","parentProperty","autostart","evaluate","currParent","currParentProperty","currResultType","currPreventEval","currSandbox","currOtherTypeCallback","toPathString","exprList","toPathArray","shift","_hasParentSelector","_trace","ea","isParentSelector","hasArrExpr","reduce","rslt","valOrPath","_getPreferredOutput","pointer","toPointer","_handleCallback","fullRetObj","preferredOutput","val","parentPropName","literalPriority","retObj","loc","x","addRet","elems","t","_walk","l","_x","v","par","pr","cb","_slice","_eval","addType","valueType","Number","isFinite","locProp","_step","_iterator","allowArrayLike","it","F","done","f","normalCompletion","didErr","step","return","_createForOfIteratorHelper","part","rett","tmp","tl","tt","splice","keys","parseInt","start","end","max","min","code","_v","_vname","_$_parentProperty","_$_parent","_$_property","_$_path","_$_root","_$_v","vm","runInNewContext","console","log","cache","pathArr","subx","$0","$1","prop","ups","exp","match","funcs","conditionCb","il","moveToAnotherArray","values","vr","funcString","func","fString","lastStatementEnd","lastIndexOf"],"sourceRoot":""}