buzzcasting-storage 1.0.3

package/dist/buzzcasting-storage.js

@@ -0,0 +1,3274 @@
+var lr = Object.defineProperty;
+var ur = (t, e, n) => e in t ? lr(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n;
+var k = (t, e, n) => (ur(t, typeof e != "symbol" ? e + "" : e, n), n);
+class hr {
+  constructor(e) {
+    k(this, "options");
+    k(this, "url");
+    k(this, "csrf", () => {
+      var e, n;
+      if ((e = this.options) != null && e.csrf)
+        return {
+          headers: new Headers({
+            "X-Csrf-Token": (n = this.options) == null ? void 0 : n.csrf
+          })
+        };
+    });
+    this.options = e, this.url = `https://${e.app}.buzzcasting.net`;
+  }
+  auth() {
+    var n;
+    if (!((n = this.options) != null && n.token))
+      return;
+    let e = "";
+    switch (this.options.token) {
+      case "meta":
+        e = "Bearer " + this.options.bearer;
+        break;
+    }
+    return {
+      headers: new Headers({
+        Authorization: e
+        //'X-Session-Key': localStorage.getItem('guid') || 'invalid',
+      })
+    };
+  }
+  async get(e) {
+    let n;
+    const r = this.auth(), s = this.csrf();
+    n = { ...r, ...s };
+    let i = Object.assign({}, e);
+    delete i.type;
+    const o = Object.keys(i).length > 0 ? "?" + new URLSearchParams(i).toString() : "";
+    return await fetch(
+      [this.url, "api", this.options.version, e.type].join("/") + o,
+      { ...n, method: "get" }
+    ).then((a) => {
+      if (!a.ok)
+        throw Error(a.statusText);
+      return a;
+    }).then((a) => a.json()).then((a) => (a.query = e, a)).catch((a) => ({ succes: !1, message: a, data: [] }));
+  }
+  async hideMessage(e) {
+    const { app: n, version: r } = this.options, s = this.auth(), i = "?action=visible";
+    return console.log(
+      [n, "api", r, e.type, e.id].join("/") + i,
+      { ...s, method: "put" }
+    ), await fetch(
+      [n, "api", r, e.type, e.id].join("/") + i,
+      { ...s, method: "put" }
+    ).then((o) => {
+      if (!o.ok)
+        throw Error(o.statusText);
+      return o;
+    }).then((o) => o.json()).catch((o) => ({ succes: !1, message: o, data: [] }));
+  }
+}
+const Oe = "messages", Kn = "cloud", Dt = "series", dr = "topics", fr = "keyval", pr = "local", mr = "session", yr = "dexie", gr = "window", D = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : global, R = Object.keys, L = Array.isArray;
+function z(t, e) {
+  return typeof e != "object" || R(e).forEach(function(n) {
+    t[n] = e[n];
+  }), t;
+}
+typeof Promise > "u" || D.Promise || (D.Promise = Promise);
+const $e = Object.getPrototypeOf, br = {}.hasOwnProperty;
+function H(t, e) {
+  return br.call(t, e);
+}
+function Ce(t, e) {
+  typeof e == "function" && (e = e($e(t))), (typeof Reflect > "u" ? R : Reflect.ownKeys)(e).forEach((n) => {
+    te(t, n, e[n]);
+  });
+}
+const An = Object.defineProperty;
+function te(t, e, n, r) {
+  An(t, e, z(n && H(n, "get") && typeof n.get == "function" ? { get: n.get, set: n.set, configurable: !0 } : { value: n, configurable: !0, writable: !0 }, r));
+}
+function Se(t) {
+  return { from: function(e) {
+    return t.prototype = Object.create(e.prototype), te(t.prototype, "constructor", t), { extend: Ce.bind(null, t.prototype) };
+  } };
+}
+const vr = Object.getOwnPropertyDescriptor;
+function sn(t, e) {
+  let n;
+  return vr(t, e) || (n = $e(t)) && sn(n, e);
+}
+const wr = [].slice;
+function ht(t, e, n) {
+  return wr.call(t, e, n);
+}
+function Dn(t, e) {
+  return e(t);
+}
+function Ie(t) {
+  if (!t)
+    throw new Error("Assertion Failed");
+}
+function In(t) {
+  D.setImmediate ? setImmediate(t) : setTimeout(t, 0);
+}
+function Bn(t, e) {
+  return t.reduce((n, r, s) => {
+    var i = e(r, s);
+    return i && (n[i[0]] = i[1]), n;
+  }, {});
+}
+function ne(t, e) {
+  if (typeof e == "string" && H(t, e))
+    return t[e];
+  if (!e)
+    return t;
+  if (typeof e != "string") {
+    for (var n = [], r = 0, s = e.length; r < s; ++r) {
+      var i = ne(t, e[r]);
+      n.push(i);
+    }
+    return n;
+  }
+  var o = e.indexOf(".");
+  if (o !== -1) {
+    var a = t[e.substr(0, o)];
+    return a === void 0 ? void 0 : ne(a, e.substr(o + 1));
+  }
+}
+function Y(t, e, n) {
+  if (t && e !== void 0 && (!("isFrozen" in Object) || !Object.isFrozen(t)))
+    if (typeof e != "string" && "length" in e) {
+      Ie(typeof n != "string" && "length" in n);
+      for (var r = 0, s = e.length; r < s; ++r)
+        Y(t, e[r], n[r]);
+    } else {
+      var i = e.indexOf(".");
+      if (i !== -1) {
+        var o = e.substr(0, i), a = e.substr(i + 1);
+        if (a === "")
+          n === void 0 ? L(t) && !isNaN(parseInt(o)) ? t.splice(o, 1) : delete t[o] : t[o] = n;
+        else {
+          var c = t[o];
+          c && H(t, o) || (c = t[o] = {}), Y(c, a, n);
+        }
+      } else
+        n === void 0 ? L(t) && !isNaN(parseInt(e)) ? t.splice(e, 1) : delete t[e] : t[e] = n;
+    }
+}
+function Tn(t) {
+  var e = {};
+  for (var n in t)
+    H(t, n) && (e[n] = t[n]);
+  return e;
+}
+const _r = [].concat;
+function Mn(t) {
+  return _r.apply([], t);
+}
+const Rn = "BigUint64Array,BigInt64Array,Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey".split(",").concat(Mn([8, 16, 32, 64].map((t) => ["Int", "Uint", "Float"].map((e) => e + t + "Array")))).filter((t) => D[t]), kr = Rn.map((t) => D[t]);
+Bn(Rn, (t) => [t, !0]);
+let ie = null;
+function He(t) {
+  ie = typeof WeakMap < "u" && /* @__PURE__ */ new WeakMap();
+  const e = It(t);
+  return ie = null, e;
+}
+function It(t) {
+  if (!t || typeof t != "object")
+    return t;
+  let e = ie && ie.get(t);
+  if (e)
+    return e;
+  if (L(t)) {
+    e = [], ie && ie.set(t, e);
+    for (var n = 0, r = t.length; n < r; ++n)
+      e.push(It(t[n]));
+  } else if (kr.indexOf(t.constructor) >= 0)
+    e = t;
+  else {
+    const i = $e(t);
+    for (var s in e = i === Object.prototype ? {} : Object.create(i), ie && ie.set(t, e), t)
+      H(t, s) && (e[s] = It(t[s]));
+  }
+  return e;
+}
+const { toString: xr } = {};
+function Bt(t) {
+  return xr.call(t).slice(8, -1);
+}
+const Tt = typeof Symbol < "u" ? Symbol.iterator : "@@iterator", Sr = typeof Tt == "symbol" ? function(t) {
+  var e;
+  return t != null && (e = t[Tt]) && e.apply(t);
+} : function() {
+  return null;
+}, xe = {};
+function q(t) {
+  var e, n, r, s;
+  if (arguments.length === 1) {
+    if (L(t))
+      return t.slice();
+    if (this === xe && typeof t == "string")
+      return [t];
+    if (s = Sr(t)) {
+      for (n = []; !(r = s.next()).done; )
+        n.push(r.value);
+      return n;
+    }
+    if (t == null)
+      return [t];
+    if (typeof (e = t.length) == "number") {
+      for (n = new Array(e); e--; )
+        n[e] = t[e];
+      return n;
+    }
+    return [t];
+  }
+  for (e = arguments.length, n = new Array(e); e--; )
+    n[e] = arguments[e];
+  return n;
+}
+const on = typeof Symbol < "u" ? (t) => t[Symbol.toStringTag] === "AsyncFunction" : () => !1;
+var J = typeof location < "u" && /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href);
+function Fn(t, e) {
+  J = t, Nn = e;
+}
+var Nn = () => !0;
+const Er = !new Error("").stack;
+function be() {
+  if (Er)
+    try {
+      throw be.arguments, new Error();
+    } catch (t) {
+      return t;
+    }
+  return new Error();
+}
+function Mt(t, e) {
+  var n = t.stack;
+  return n ? (e = e || 0, n.indexOf(t.name) === 0 && (e += (t.name + t.message).split(`
+`).length), n.split(`
+`).slice(e).filter(Nn).map((r) => `
+` + r).join("")) : "";
+}
+var $n = ["Unknown", "Constraint", "Data", "TransactionInactive", "ReadOnly", "Version", "NotFound", "InvalidState", "InvalidAccess", "Abort", "Timeout", "QuotaExceeded", "Syntax", "DataClone"], an = ["Modify", "Bulk", "OpenFailed", "VersionChange", "Schema", "Upgrade", "InvalidTable", "MissingAPI", "NoSuchDatabase", "InvalidArgument", "SubTransaction", "Unsupported", "Internal", "DatabaseClosed", "PrematureCommit", "ForeignAwait"].concat($n), Pr = { VersionChanged: "Database version changed by other database connection", DatabaseClosed: "Database has been closed", Abort: "Transaction aborted", TransactionInactive: "Transaction has already completed or failed", MissingAPI: "IndexedDB API missing. Please visit https://tinyurl.com/y2uuvskb" };
+function Ee(t, e) {
+  this._e = be(), this.name = t, this.message = e;
+}
+function Ln(t, e) {
+  return t + ". Errors: " + Object.keys(e).map((n) => e[n].toString()).filter((n, r, s) => s.indexOf(n) === r).join(`
+`);
+}
+function dt(t, e, n, r) {
+  this._e = be(), this.failures = e, this.failedKeys = r, this.successCount = n, this.message = Ln(t, e);
+}
+function Te(t, e) {
+  this._e = be(), this.name = "BulkError", this.failures = Object.keys(e).map((n) => e[n]), this.failuresByPos = e, this.message = Ln(t, e);
+}
+Se(Ee).from(Error).extend({ stack: { get: function() {
+  return this._stack || (this._stack = this.name + ": " + this.message + Mt(this._e, 2));
+} }, toString: function() {
+  return this.name + ": " + this.message;
+} }), Se(dt).from(Ee), Se(Te).from(Ee);
+var cn = an.reduce((t, e) => (t[e] = e + "Error", t), {});
+const Or = Ee;
+var C = an.reduce((t, e) => {
+  var n = e + "Error";
+  function r(s, i) {
+    this._e = be(), this.name = n, s ? typeof s == "string" ? (this.message = `${s}${i ? `
+ ` + i : ""}`, this.inner = i || null) : typeof s == "object" && (this.message = `${s.name} ${s.message}`, this.inner = s) : (this.message = Pr[e] || n, this.inner = null);
+  }
+  return Se(r).from(Or), t[e] = r, t;
+}, {});
+C.Syntax = SyntaxError, C.Type = TypeError, C.Range = RangeError;
+var bn = $n.reduce((t, e) => (t[e + "Error"] = C[e], t), {}), st = an.reduce((t, e) => (["Syntax", "Type", "Range"].indexOf(e) === -1 && (t[e + "Error"] = C[e]), t), {});
+function A() {
+}
+function Le(t) {
+  return t;
+}
+function Cr(t, e) {
+  return t == null || t === Le ? e : function(n) {
+    return e(t(n));
+  };
+}
+function ye(t, e) {
+  return function() {
+    t.apply(this, arguments), e.apply(this, arguments);
+  };
+}
+function jr(t, e) {
+  return t === A ? e : function() {
+    var n = t.apply(this, arguments);
+    n !== void 0 && (arguments[0] = n);
+    var r = this.onsuccess, s = this.onerror;
+    this.onsuccess = null, this.onerror = null;
+    var i = e.apply(this, arguments);
+    return r && (this.onsuccess = this.onsuccess ? ye(r, this.onsuccess) : r), s && (this.onerror = this.onerror ? ye(s, this.onerror) : s), i !== void 0 ? i : n;
+  };
+}
+function Kr(t, e) {
+  return t === A ? e : function() {
+    t.apply(this, arguments);
+    var n = this.onsuccess, r = this.onerror;
+    this.onsuccess = this.onerror = null, e.apply(this, arguments), n && (this.onsuccess = this.onsuccess ? ye(n, this.onsuccess) : n), r && (this.onerror = this.onerror ? ye(r, this.onerror) : r);
+  };
+}
+function Ar(t, e) {
+  return t === A ? e : function(n) {
+    var r = t.apply(this, arguments);
+    z(n, r);
+    var s = this.onsuccess, i = this.onerror;
+    this.onsuccess = null, this.onerror = null;
+    var o = e.apply(this, arguments);
+    return s && (this.onsuccess = this.onsuccess ? ye(s, this.onsuccess) : s), i && (this.onerror = this.onerror ? ye(i, this.onerror) : i), r === void 0 ? o === void 0 ? void 0 : o : z(r, o);
+  };
+}
+function Dr(t, e) {
+  return t === A ? e : function() {
+    return e.apply(this, arguments) !== !1 && t.apply(this, arguments);
+  };
+}
+function ln(t, e) {
+  return t === A ? e : function() {
+    var n = t.apply(this, arguments);
+    if (n && typeof n.then == "function") {
+      for (var r = this, s = arguments.length, i = new Array(s); s--; )
+        i[s] = arguments[s];
+      return n.then(function() {
+        return e.apply(r, i);
+      });
+    }
+    return e.apply(this, arguments);
+  };
+}
+st.ModifyError = dt, st.DexieError = Ee, st.BulkError = Te;
+var Ue = {};
+const Un = 100, [Rt, ft, Ft] = typeof Promise > "u" ? [] : (() => {
+  let t = Promise.resolve();
+  if (typeof crypto > "u" || !crypto.subtle)
+    return [t, $e(t), t];
+  const e = crypto.subtle.digest("SHA-512", new Uint8Array([0]));
+  return [e, $e(e), t];
+})(), Wn = ft && ft.then, it = Rt && Rt.constructor, un = !!Ft;
+var Nt = !1, Ir = Ft ? () => {
+  Ft.then(Xe);
+} : D.setImmediate ? setImmediate.bind(null, Xe) : D.MutationObserver ? () => {
+  var t = document.createElement("div");
+  new MutationObserver(() => {
+    Xe(), t = null;
+  }).observe(t, { attributes: !0 }), t.setAttribute("i", "1");
+} : () => {
+  setTimeout(Xe, 0);
+}, Me = function(t, e) {
+  Be.push([t, e]), pt && (Ir(), pt = !1);
+}, $t = !0, pt = !0, fe = [], ot = [], Lt = null, Ut = Le, Pe = { id: "global", global: !0, ref: 0, unhandleds: [], onunhandled: _n, pgp: !1, env: {}, finalize: function() {
+  this.unhandleds.forEach((t) => {
+    try {
+      _n(t[0], t[1]);
+    } catch {
+    }
+  });
+} }, O = Pe, Be = [], pe = 0, at = [];
+function E(t) {
+  if (typeof this != "object")
+    throw new TypeError("Promises must be constructed via new");
+  this._listeners = [], this.onuncatched = A, this._lib = !1;
+  var e = this._PSD = O;
+  if (J && (this._stackHolder = be(), this._prev = null, this._numPrev = 0), typeof t != "function") {
+    if (t !== Ue)
+      throw new TypeError("Not a function");
+    return this._state = arguments[1], this._value = arguments[2], void (this._state === !1 && zt(this, this._value));
+  }
+  this._state = null, this._value = null, ++e.ref, Vn(this, t);
+}
+const Wt = { get: function() {
+  var t = O, e = mt;
+  function n(r, s) {
+    var i = !t.global && (t !== O || e !== mt);
+    const o = i && !re();
+    var a = new E((c, l) => {
+      hn(this, new zn(yt(r, t, i, o), yt(s, t, i, o), c, l, t));
+    });
+    return J && Yn(a, this), a;
+  }
+  return n.prototype = Ue, n;
+}, set: function(t) {
+  te(this, "then", t && t.prototype === Ue ? Wt : { get: function() {
+    return t;
+  }, set: Wt.set });
+} };
+function zn(t, e, n, r, s) {
+  this.onFulfilled = typeof t == "function" ? t : null, this.onRejected = typeof e == "function" ? e : null, this.resolve = n, this.reject = r, this.psd = s;
+}
+function Vn(t, e) {
+  try {
+    e((n) => {
+      if (t._state === null) {
+        if (n === t)
+          throw new TypeError("A promise cannot be resolved with itself.");
+        var r = t._lib && Ye();
+        n && typeof n.then == "function" ? Vn(t, (s, i) => {
+          n instanceof E ? n._then(s, i) : n.then(s, i);
+        }) : (t._state = !0, t._value = n, Gn(t)), r && Qe();
+      }
+    }, zt.bind(null, t));
+  } catch (n) {
+    zt(t, n);
+  }
+}
+function zt(t, e) {
+  if (ot.push(e), t._state === null) {
+    var n = t._lib && Ye();
+    e = Ut(e), t._state = !1, t._value = e, J && e !== null && typeof e == "object" && !e._promise && function(r, s, i) {
+      try {
+        r.apply(null, i);
+      } catch (o) {
+        s && s(o);
+      }
+    }(() => {
+      var r = sn(e, "stack");
+      e._promise = t, te(e, "stack", { get: () => Nt ? r && (r.get ? r.get.apply(e) : r.value) : t.stack });
+    }), function(r) {
+      fe.some((s) => s._value === r._value) || fe.push(r);
+    }(t), Gn(t), n && Qe();
+  }
+}
+function Gn(t) {
+  var e = t._listeners;
+  t._listeners = [];
+  for (var n = 0, r = e.length; n < r; ++n)
+    hn(t, e[n]);
+  var s = t._PSD;
+  --s.ref || s.finalize(), pe === 0 && (++pe, Me(() => {
+    --pe == 0 && dn();
+  }, []));
+}
+function hn(t, e) {
+  if (t._state !== null) {
+    var n = t._state ? e.onFulfilled : e.onRejected;
+    if (n === null)
+      return (t._state ? e.resolve : e.reject)(t._value);
+    ++e.psd.ref, ++pe, Me(Br, [n, t, e]);
+  } else
+    t._listeners.push(e);
+}
+function Br(t, e, n) {
+  try {
+    Lt = e;
+    var r, s = e._value;
+    e._state ? r = t(s) : (ot.length && (ot = []), r = t(s), ot.indexOf(s) === -1 && function(i) {
+      for (var o = fe.length; o; )
+        if (fe[--o]._value === i._value)
+          return void fe.splice(o, 1);
+    }(e)), n.resolve(r);
+  } catch (i) {
+    n.reject(i);
+  } finally {
+    Lt = null, --pe == 0 && dn(), --n.psd.ref || n.psd.finalize();
+  }
+}
+function Hn(t, e, n) {
+  if (e.length === n)
+    return e;
+  var r = "";
+  if (t._state === !1) {
+    var s, i, o = t._value;
+    o != null ? (s = o.name || "Error", i = o.message || o, r = Mt(o, 0)) : (s = o, i = ""), e.push(s + (i ? ": " + i : "") + r);
+  }
+  return J && ((r = Mt(t._stackHolder, 2)) && e.indexOf(r) === -1 && e.push(r), t._prev && Hn(t._prev, e, n)), e;
+}
+function Yn(t, e) {
+  var n = e ? e._numPrev + 1 : 0;
+  n < 100 && (t._prev = e, t._numPrev = n);
+}
+function Xe() {
+  Ye() && Qe();
+}
+function Ye() {
+  var t = $t;
+  return $t = !1, pt = !1, t;
+}
+function Qe() {
+  var t, e, n;
+  do
+    for (; Be.length > 0; )
+      for (t = Be, Be = [], n = t.length, e = 0; e < n; ++e) {
+        var r = t[e];
+        r[0].apply(null, r[1]);
+      }
+  while (Be.length > 0);
+  $t = !0, pt = !0;
+}
+function dn() {
+  var t = fe;
+  fe = [], t.forEach((r) => {
+    r._PSD.onunhandled.call(null, r._value, r);
+  });
+  for (var e = at.slice(0), n = e.length; n; )
+    e[--n]();
+}
+function Ze(t) {
+  return new E(Ue, !1, t);
+}
+function I(t, e) {
+  var n = O;
+  return function() {
+    var r = Ye(), s = O;
+    try {
+      return ce(n, !0), t.apply(this, arguments);
+    } catch (i) {
+      e && e(i);
+    } finally {
+      ce(s, !1), r && Qe();
+    }
+  };
+}
+Ce(E.prototype, { then: Wt, _then: function(t, e) {
+  hn(this, new zn(null, null, t, e, O));
+}, catch: function(t) {
+  if (arguments.length === 1)
+    return this.then(null, t);
+  var e = arguments[0], n = arguments[1];
+  return typeof e == "function" ? this.then(null, (r) => r instanceof e ? n(r) : Ze(r)) : this.then(null, (r) => r && r.name === e ? n(r) : Ze(r));
+}, finally: function(t) {
+  return this.then((e) => (t(), e), (e) => (t(), Ze(e)));
+}, stack: { get: function() {
+  if (this._stack)
+    return this._stack;
+  try {
+    Nt = !0;
+    var t = Hn(this, [], 20).join(`
+From previous: `);
+    return this._state !== null && (this._stack = t), t;
+  } finally {
+    Nt = !1;
+  }
+} }, timeout: function(t, e) {
+  return t < 1 / 0 ? new E((n, r) => {
+    var s = setTimeout(() => r(new C.Timeout(e)), t);
+    this.then(n, r).finally(clearTimeout.bind(null, s));
+  }) : this;
+} }), typeof Symbol < "u" && Symbol.toStringTag && te(E.prototype, Symbol.toStringTag, "Dexie.Promise"), Pe.env = Qn(), Ce(E, { all: function() {
+  var t = q.apply(null, arguments).map(qe);
+  return new E(function(e, n) {
+    t.length === 0 && e([]);
+    var r = t.length;
+    t.forEach((s, i) => E.resolve(s).then((o) => {
+      t[i] = o, --r || e(t);
+    }, n));
+  });
+}, resolve: (t) => {
+  if (t instanceof E)
+    return t;
+  if (t && typeof t.then == "function")
+    return new E((n, r) => {
+      t.then(n, r);
+    });
+  var e = new E(Ue, !0, t);
+  return Yn(e, Lt), e;
+}, reject: Ze, race: function() {
+  var t = q.apply(null, arguments).map(qe);
+  return new E((e, n) => {
+    t.map((r) => E.resolve(r).then(e, n));
+  });
+}, PSD: { get: () => O, set: (t) => O = t }, totalEchoes: { get: () => mt }, newPSD: ae, usePSD: Ke, scheduler: { get: () => Me, set: (t) => {
+  Me = t;
+} }, rejectionMapper: { get: () => Ut, set: (t) => {
+  Ut = t;
+} }, follow: (t, e) => new E((n, r) => ae((s, i) => {
+  var o = O;
+  o.unhandleds = [], o.onunhandled = i, o.finalize = ye(function() {
+    (function(a) {
+      function c() {
+        a(), at.splice(at.indexOf(c), 1);
+      }
+      at.push(c), ++pe, Me(() => {
+        --pe == 0 && dn();
+      }, []);
+    })(() => {
+      this.unhandleds.length === 0 ? s() : i(this.unhandleds[0]);
+    });
+  }, o.finalize), t();
+}, e, n, r)) }), it && (it.allSettled && te(E, "allSettled", function() {
+  const t = q.apply(null, arguments).map(qe);
+  return new E((e) => {
+    t.length === 0 && e([]);
+    let n = t.length;
+    const r = new Array(n);
+    t.forEach((s, i) => E.resolve(s).then((o) => r[i] = { status: "fulfilled", value: o }, (o) => r[i] = { status: "rejected", reason: o }).then(() => --n || e(r)));
+  });
+}), it.any && typeof AggregateError < "u" && te(E, "any", function() {
+  const t = q.apply(null, arguments).map(qe);
+  return new E((e, n) => {
+    t.length === 0 && n(new AggregateError([]));
+    let r = t.length;
+    const s = new Array(r);
+    t.forEach((i, o) => E.resolve(i).then((a) => e(a), (a) => {
+      s[o] = a, --r || n(new AggregateError(s));
+    }));
+  });
+}));
+const $ = { awaits: 0, echoes: 0, id: 0 };
+var Tr = 0, ct = [], kt = 0, mt = 0, Mr = 0;
+function ae(t, e, n, r) {
+  var s = O, i = Object.create(s);
+  i.parent = s, i.ref = 0, i.global = !1, i.id = ++Mr;
+  var o = Pe.env;
+  i.env = un ? { Promise: E, PromiseProp: { value: E, configurable: !0, writable: !0 }, all: E.all, race: E.race, allSettled: E.allSettled, any: E.any, resolve: E.resolve, reject: E.reject, nthen: vn(o.nthen, i), gthen: vn(o.gthen, i) } : {}, e && z(i, e), ++s.ref, i.finalize = function() {
+    --this.parent.ref || this.parent.finalize();
+  };
+  var a = Ke(i, t, n, r);
+  return i.ref === 0 && i.finalize(), a;
+}
+function je() {
+  return $.id || ($.id = ++Tr), ++$.awaits, $.echoes += Un, $.id;
+}
+function re() {
+  return !!$.awaits && (--$.awaits == 0 && ($.id = 0), $.echoes = $.awaits * Un, !0);
+}
+function qe(t) {
+  return $.echoes && t && t.constructor === it ? (je(), t.then((e) => (re(), e), (e) => (re(), F(e)))) : t;
+}
+function Rr(t) {
+  ++mt, $.echoes && --$.echoes != 0 || ($.echoes = $.id = 0), ct.push(O), ce(t, !0);
+}
+function Fr() {
+  var t = ct[ct.length - 1];
+  ct.pop(), ce(t, !1);
+}
+function ce(t, e) {
+  var n = O;
+  if ((e ? !$.echoes || kt++ && t === O : !kt || --kt && t === O) || Jn(e ? Rr.bind(null, t) : Fr), t !== O && (O = t, n === Pe && (Pe.env = Qn()), un)) {
+    var r = Pe.env.Promise, s = t.env;
+    ft.then = s.nthen, r.prototype.then = s.gthen, (n.global || t.global) && (Object.defineProperty(D, "Promise", s.PromiseProp), r.all = s.all, r.race = s.race, r.resolve = s.resolve, r.reject = s.reject, s.allSettled && (r.allSettled = s.allSettled), s.any && (r.any = s.any));
+  }
+}
+function Qn() {
+  var t = D.Promise;
+  return un ? { Promise: t, PromiseProp: Object.getOwnPropertyDescriptor(D, "Promise"), all: t.all, race: t.race, allSettled: t.allSettled, any: t.any, resolve: t.resolve, reject: t.reject, nthen: ft.then, gthen: t.prototype.then } : {};
+}
+function Ke(t, e, n, r, s) {
+  var i = O;
+  try {
+    return ce(t, !0), e(n, r, s);
+  } finally {
+    ce(i, !1);
+  }
+}
+function Jn(t) {
+  Wn.call(Rt, t);
+}
+function yt(t, e, n, r) {
+  return typeof t != "function" ? t : function() {
+    var s = O;
+    n && je(), ce(e, !0);
+    try {
+      return t.apply(this, arguments);
+    } finally {
+      ce(s, !1), r && Jn(re);
+    }
+  };
+}
+function vn(t, e) {
+  return function(n, r) {
+    return t.call(this, yt(n, e), yt(r, e));
+  };
+}
+("" + Wn).indexOf("[native code]") === -1 && (je = re = A);
+const wn = "unhandledrejection";
+function _n(t, e) {
+  var n;
+  try {
+    n = e.onuncatched(t);
+  } catch {
+  }
+  if (n !== !1)
+    try {
+      var r, s = { promise: e, reason: t };
+      if (D.document && document.createEvent ? ((r = document.createEvent("Event")).initEvent(wn, !0, !0), z(r, s)) : D.CustomEvent && z(r = new CustomEvent(wn, { detail: s }), s), r && D.dispatchEvent && (dispatchEvent(r), !D.PromiseRejectionEvent && D.onunhandledrejection))
+        try {
+          D.onunhandledrejection(r);
+        } catch {
+        }
+      J && r && !r.defaultPrevented && console.warn(`Unhandled rejection: ${t.stack || t}`);
+    } catch {
+    }
+}
+var F = E.reject;
+function Vt(t, e, n, r) {
+  if (t.idbdb && (t._state.openComplete || O.letThrough || t._vip)) {
+    var s = t._createTransaction(e, n, t._dbSchema);
+    try {
+      s.create(), t._state.PR1398_maxLoop = 3;
+    } catch (i) {
+      return i.name === cn.InvalidState && t.isOpen() && --t._state.PR1398_maxLoop > 0 ? (console.warn("Dexie: Need to reopen db"), t._close(), t.open().then(() => Vt(t, e, n, r))) : F(i);
+    }
+    return s._promise(e, (i, o) => ae(() => (O.trans = s, r(i, o, s)))).then((i) => s._completion.then(() => i));
+  }
+  if (t._state.openComplete)
+    return F(new C.DatabaseClosed(t._state.dbOpenError));
+  if (!t._state.isBeingOpened) {
+    if (!t._options.autoOpen)
+      return F(new C.DatabaseClosed());
+    t.open().catch(A);
+  }
+  return t._state.dbReadyPromise.then(() => Vt(t, e, n, r));
+}
+const kn = "3.2.5", de = "￿", Gt = -1 / 0, X = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.", Xn = "String expected.", Re = [], vt = typeof navigator < "u" && /(MSIE|Trident|Edge)/.test(navigator.userAgent), Nr = vt, $r = vt, Zn = (t) => !/(dexie\.js|dexie\.min\.js)/.test(t), wt = "__dbnames", xt = "readonly", St = "readwrite";
+function ge(t, e) {
+  return t ? e ? function() {
+    return t.apply(this, arguments) && e.apply(this, arguments);
+  } : t : e;
+}
+const qn = { type: 3, lower: -1 / 0, lowerOpen: !1, upper: [[]], upperOpen: !1 };
+function et(t) {
+  return typeof t != "string" || /\./.test(t) ? (e) => e : (e) => (e[t] === void 0 && t in e && delete (e = He(e))[t], e);
+}
+class Lr {
+  _trans(e, n, r) {
+    const s = this._tx || O.trans, i = this.name;
+    function o(c, l, u) {
+      if (!u.schema[i])
+        throw new C.NotFound("Table " + i + " not part of transaction");
+      return n(u.idbtrans, u);
+    }
+    const a = Ye();
+    try {
+      return s && s.db === this.db ? s === O.trans ? s._promise(e, o, r) : ae(() => s._promise(e, o, r), { trans: s, transless: O.transless || O }) : Vt(this.db, e, [this.name], o);
+    } finally {
+      a && Qe();
+    }
+  }
+  get(e, n) {
+    return e && e.constructor === Object ? this.where(e).first(n) : this._trans("readonly", (r) => this.core.get({ trans: r, key: e }).then((s) => this.hook.reading.fire(s))).then(n);
+  }
+  where(e) {
+    if (typeof e == "string")
+      return new this.db.WhereClause(this, e);
+    if (L(e))
+      return new this.db.WhereClause(this, `[${e.join("+")}]`);
+    const n = R(e);
+    if (n.length === 1)
+      return this.where(n[0]).equals(e[n[0]]);
+    const r = this.schema.indexes.concat(this.schema.primKey).filter((l) => {
+      if (l.compound && n.every((u) => l.keyPath.indexOf(u) >= 0)) {
+        for (let u = 0; u < n.length; ++u)
+          if (n.indexOf(l.keyPath[u]) === -1)
+            return !1;
+        return !0;
+      }
+      return !1;
+    }).sort((l, u) => l.keyPath.length - u.keyPath.length)[0];
+    if (r && this.db._maxKey !== de) {
+      const l = r.keyPath.slice(0, n.length);
+      return this.where(l).equals(l.map((u) => e[u]));
+    }
+    !r && J && console.warn(`The query ${JSON.stringify(e)} on ${this.name} would benefit of a compound index [${n.join("+")}]`);
+    const { idxByName: s } = this.schema, i = this.db._deps.indexedDB;
+    function o(l, u) {
+      try {
+        return i.cmp(l, u) === 0;
+      } catch {
+        return !1;
+      }
+    }
+    const [a, c] = n.reduce(([l, u], d) => {
+      const h = s[d], p = e[d];
+      return [l || h, l || !h ? ge(u, h && h.multi ? (g) => {
+        const y = ne(g, d);
+        return L(y) && y.some((b) => o(p, b));
+      } : (g) => o(p, ne(g, d))) : u];
+    }, [null, null]);
+    return a ? this.where(a.name).equals(e[a.keyPath]).filter(c) : r ? this.filter(c) : this.where(n).equals("");
+  }
+  filter(e) {
+    return this.toCollection().and(e);
+  }
+  count(e) {
+    return this.toCollection().count(e);
+  }
+  offset(e) {
+    return this.toCollection().offset(e);
+  }
+  limit(e) {
+    return this.toCollection().limit(e);
+  }
+  each(e) {
+    return this.toCollection().each(e);
+  }
+  toArray(e) {
+    return this.toCollection().toArray(e);
+  }
+  toCollection() {
+    return new this.db.Collection(new this.db.WhereClause(this));
+  }
+  orderBy(e) {
+    return new this.db.Collection(new this.db.WhereClause(this, L(e) ? `[${e.join("+")}]` : e));
+  }
+  reverse() {
+    return this.toCollection().reverse();
+  }
+  mapToClass(e) {
+    this.schema.mappedClass = e;
+    const n = (r) => {
+      if (!r)
+        return r;
+      const s = Object.create(e.prototype);
+      for (var i in r)
+        if (H(r, i))
+          try {
+            s[i] = r[i];
+          } catch {
+          }
+      return s;
+    };
+    return this.schema.readHook && this.hook.reading.unsubscribe(this.schema.readHook), this.schema.readHook = n, this.hook("reading", n), e;
+  }
+  defineClass() {
+    return this.mapToClass(function(e) {
+      z(this, e);
+    });
+  }
+  add(e, n) {
+    const { auto: r, keyPath: s } = this.schema.primKey;
+    let i = e;
+    return s && r && (i = et(s)(e)), this._trans("readwrite", (o) => this.core.mutate({ trans: o, type: "add", keys: n != null ? [n] : null, values: [i] })).then((o) => o.numFailures ? E.reject(o.failures[0]) : o.lastResult).then((o) => {
+      if (s)
+        try {
+          Y(e, s, o);
+        } catch {
+        }
+      return o;
+    });
+  }
+  update(e, n) {
+    if (typeof e != "object" || L(e))
+      return this.where(":id").equals(e).modify(n);
+    {
+      const r = ne(e, this.schema.primKey.keyPath);
+      if (r === void 0)
+        return F(new C.InvalidArgument("Given object does not contain its primary key"));
+      try {
+        typeof n != "function" ? R(n).forEach((s) => {
+          Y(e, s, n[s]);
+        }) : n(e, { value: e, primKey: r });
+      } catch {
+      }
+      return this.where(":id").equals(r).modify(n);
+    }
+  }
+  put(e, n) {
+    const { auto: r, keyPath: s } = this.schema.primKey;
+    let i = e;
+    return s && r && (i = et(s)(e)), this._trans("readwrite", (o) => this.core.mutate({ trans: o, type: "put", values: [i], keys: n != null ? [n] : null })).then((o) => o.numFailures ? E.reject(o.failures[0]) : o.lastResult).then((o) => {
+      if (s)
+        try {
+          Y(e, s, o);
+        } catch {
+        }
+      return o;
+    });
+  }
+  delete(e) {
+    return this._trans("readwrite", (n) => this.core.mutate({ trans: n, type: "delete", keys: [e] })).then((n) => n.numFailures ? E.reject(n.failures[0]) : void 0);
+  }
+  clear() {
+    return this._trans("readwrite", (e) => this.core.mutate({ trans: e, type: "deleteRange", range: qn })).then((e) => e.numFailures ? E.reject(e.failures[0]) : void 0);
+  }
+  bulkGet(e) {
+    return this._trans("readonly", (n) => this.core.getMany({ keys: e, trans: n }).then((r) => r.map((s) => this.hook.reading.fire(s))));
+  }
+  bulkAdd(e, n, r) {
+    const s = Array.isArray(n) ? n : void 0, i = (r = r || (s ? void 0 : n)) ? r.allKeys : void 0;
+    return this._trans("readwrite", (o) => {
+      const { auto: a, keyPath: c } = this.schema.primKey;
+      if (c && s)
+        throw new C.InvalidArgument("bulkAdd(): keys argument invalid on tables with inbound keys");
+      if (s && s.length !== e.length)
+        throw new C.InvalidArgument("Arguments objects and keys must have the same length");
+      const l = e.length;
+      let u = c && a ? e.map(et(c)) : e;
+      return this.core.mutate({ trans: o, type: "add", keys: s, values: u, wantResults: i }).then(({ numFailures: d, results: h, lastResult: p, failures: g }) => {
+        if (d === 0)
+          return i ? h : p;
+        throw new Te(`${this.name}.bulkAdd(): ${d} of ${l} operations failed`, g);
+      });
+    });
+  }
+  bulkPut(e, n, r) {
+    const s = Array.isArray(n) ? n : void 0, i = (r = r || (s ? void 0 : n)) ? r.allKeys : void 0;
+    return this._trans("readwrite", (o) => {
+      const { auto: a, keyPath: c } = this.schema.primKey;
+      if (c && s)
+        throw new C.InvalidArgument("bulkPut(): keys argument invalid on tables with inbound keys");
+      if (s && s.length !== e.length)
+        throw new C.InvalidArgument("Arguments objects and keys must have the same length");
+      const l = e.length;
+      let u = c && a ? e.map(et(c)) : e;
+      return this.core.mutate({ trans: o, type: "put", keys: s, values: u, wantResults: i }).then(({ numFailures: d, results: h, lastResult: p, failures: g }) => {
+        if (d === 0)
+          return i ? h : p;
+        throw new Te(`${this.name}.bulkPut(): ${d} of ${l} operations failed`, g);
+      });
+    });
+  }
+  bulkDelete(e) {
+    const n = e.length;
+    return this._trans("readwrite", (r) => this.core.mutate({ trans: r, type: "delete", keys: e })).then(({ numFailures: r, lastResult: s, failures: i }) => {
+      if (r === 0)
+        return s;
+      throw new Te(`${this.name}.bulkDelete(): ${r} of ${n} operations failed`, i);
+    });
+  }
+}
+function Fe(t) {
+  var e = {}, n = function(o, a) {
+    if (a) {
+      for (var c = arguments.length, l = new Array(c - 1); --c; )
+        l[c - 1] = arguments[c];
+      return e[o].subscribe.apply(null, l), t;
+    }
+    if (typeof o == "string")
+      return e[o];
+  };
+  n.addEventType = i;
+  for (var r = 1, s = arguments.length; r < s; ++r)
+    i(arguments[r]);
+  return n;
+  function i(o, a, c) {
+    if (typeof o != "object") {
+      var l;
+      a || (a = Dr), c || (c = A);
+      var u = { subscribers: [], fire: c, subscribe: function(d) {
+        u.subscribers.indexOf(d) === -1 && (u.subscribers.push(d), u.fire = a(u.fire, d));
+      }, unsubscribe: function(d) {
+        u.subscribers = u.subscribers.filter(function(h) {
+          return h !== d;
+        }), u.fire = u.subscribers.reduce(a, c);
+      } };
+      return e[o] = n[o] = u, u;
+    }
+    R(l = o).forEach(function(d) {
+      var h = l[d];
+      if (L(h))
+        i(d, l[d][0], l[d][1]);
+      else {
+        if (h !== "asap")
+          throw new C.InvalidArgument("Invalid event config");
+        var p = i(d, Le, function() {
+          for (var g = arguments.length, y = new Array(g); g--; )
+            y[g] = arguments[g];
+          p.subscribers.forEach(function(b) {
+            In(function() {
+              b.apply(null, y);
+            });
+          });
+        });
+      }
+    });
+  }
+}
+function De(t, e) {
+  return Se(e).from({ prototype: t }), e;
+}
+function _e(t, e) {
+  return !(t.filter || t.algorithm || t.or) && (e ? t.justLimit : !t.replayFilter);
+}
+function Et(t, e) {
+  t.filter = ge(t.filter, e);
+}
+function Pt(t, e, n) {
+  var r = t.replayFilter;
+  t.replayFilter = r ? () => ge(r(), e()) : e, t.justLimit = n && !r;
+}
+function lt(t, e) {
+  if (t.isPrimKey)
+    return e.primaryKey;
+  const n = e.getIndexByKeyPath(t.index);
+  if (!n)
+    throw new C.Schema("KeyPath " + t.index + " on object store " + e.name + " is not indexed");
+  return n;
+}
+function xn(t, e, n) {
+  const r = lt(t, e.schema);
+  return e.openCursor({ trans: n, values: !t.keysOnly, reverse: t.dir === "prev", unique: !!t.unique, query: { index: r, range: t.range } });
+}
+function tt(t, e, n, r) {
+  const s = t.replayFilter ? ge(t.filter, t.replayFilter()) : t.filter;
+  if (t.or) {
+    const i = {}, o = (a, c, l) => {
+      if (!s || s(c, l, (h) => c.stop(h), (h) => c.fail(h))) {
+        var u = c.primaryKey, d = "" + u;
+        d === "[object ArrayBuffer]" && (d = "" + new Uint8Array(u)), H(i, d) || (i[d] = !0, e(a, c, l));
+      }
+    };
+    return Promise.all([t.or._iterate(o, n), Sn(xn(t, r, n), t.algorithm, o, !t.keysOnly && t.valueMapper)]);
+  }
+  return Sn(xn(t, r, n), ge(t.algorithm, s), e, !t.keysOnly && t.valueMapper);
+}
+function Sn(t, e, n, r) {
+  var s = I(r ? (i, o, a) => n(r(i), o, a) : n);
+  return t.then((i) => {
+    if (i)
+      return i.start(() => {
+        var o = () => i.continue();
+        e && !e(i, (a) => o = a, (a) => {
+          i.stop(a), o = A;
+        }, (a) => {
+          i.fail(a), o = A;
+        }) || s(i.value, i, (a) => o = a), o();
+      });
+  });
+}
+function W(t, e) {
+  try {
+    const n = En(t), r = En(e);
+    if (n !== r)
+      return n === "Array" ? 1 : r === "Array" ? -1 : n === "binary" ? 1 : r === "binary" ? -1 : n === "string" ? 1 : r === "string" ? -1 : n === "Date" ? 1 : r !== "Date" ? NaN : -1;
+    switch (n) {
+      case "number":
+      case "Date":
+      case "string":
+        return t > e ? 1 : t < e ? -1 : 0;
+      case "binary":
+        return function(s, i) {
+          const o = s.length, a = i.length, c = o < a ? o : a;
+          for (let l = 0; l < c; ++l)
+            if (s[l] !== i[l])
+              return s[l] < i[l] ? -1 : 1;
+          return o === a ? 0 : o < a ? -1 : 1;
+        }(Pn(t), Pn(e));
+      case "Array":
+        return function(s, i) {
+          const o = s.length, a = i.length, c = o < a ? o : a;
+          for (let l = 0; l < c; ++l) {
+            const u = W(s[l], i[l]);
+            if (u !== 0)
+              return u;
+          }
+          return o === a ? 0 : o < a ? -1 : 1;
+        }(t, e);
+    }
+  } catch {
+  }
+  return NaN;
+}
+function En(t) {
+  const e = typeof t;
+  if (e !== "object")
+    return e;
+  if (ArrayBuffer.isView(t))
+    return "binary";
+  const n = Bt(t);
+  return n === "ArrayBuffer" ? "binary" : n;
+}
+function Pn(t) {
+  return t instanceof Uint8Array ? t : ArrayBuffer.isView(t) ? new Uint8Array(t.buffer, t.byteOffset, t.byteLength) : new Uint8Array(t);
+}
+class Ur {
+  _read(e, n) {
+    var r = this._ctx;
+    return r.error ? r.table._trans(null, F.bind(null, r.error)) : r.table._trans("readonly", e).then(n);
+  }
+  _write(e) {
+    var n = this._ctx;
+    return n.error ? n.table._trans(null, F.bind(null, n.error)) : n.table._trans("readwrite", e, "locked");
+  }
+  _addAlgorithm(e) {
+    var n = this._ctx;
+    n.algorithm = ge(n.algorithm, e);
+  }
+  _iterate(e, n) {
+    return tt(this._ctx, e, n, this._ctx.table.core);
+  }
+  clone(e) {
+    var n = Object.create(this.constructor.prototype), r = Object.create(this._ctx);
+    return e && z(r, e), n._ctx = r, n;
+  }
+  raw() {
+    return this._ctx.valueMapper = null, this;
+  }
+  each(e) {
+    var n = this._ctx;
+    return this._read((r) => tt(n, e, r, n.table.core));
+  }
+  count(e) {
+    return this._read((n) => {
+      const r = this._ctx, s = r.table.core;
+      if (_e(r, !0))
+        return s.count({ trans: n, query: { index: lt(r, s.schema), range: r.range } }).then((o) => Math.min(o, r.limit));
+      var i = 0;
+      return tt(r, () => (++i, !1), n, s).then(() => i);
+    }).then(e);
+  }
+  sortBy(e, n) {
+    const r = e.split(".").reverse(), s = r[0], i = r.length - 1;
+    function o(l, u) {
+      return u ? o(l[r[u]], u - 1) : l[s];
+    }
+    var a = this._ctx.dir === "next" ? 1 : -1;
+    function c(l, u) {
+      var d = o(l, i), h = o(u, i);
+      return d < h ? -a : d > h ? a : 0;
+    }
+    return this.toArray(function(l) {
+      return l.sort(c);
+    }).then(n);
+  }
+  toArray(e) {
+    return this._read((n) => {
+      var r = this._ctx;
+      if (r.dir === "next" && _e(r, !0) && r.limit > 0) {
+        const { valueMapper: s } = r, i = lt(r, r.table.core.schema);
+        return r.table.core.query({ trans: n, limit: r.limit, values: !0, query: { index: i, range: r.range } }).then(({ result: o }) => s ? o.map(s) : o);
+      }
+      {
+        const s = [];
+        return tt(r, (i) => s.push(i), n, r.table.core).then(() => s);
+      }
+    }, e);
+  }
+  offset(e) {
+    var n = this._ctx;
+    return e <= 0 || (n.offset += e, _e(n) ? Pt(n, () => {
+      var r = e;
+      return (s, i) => r === 0 || (r === 1 ? (--r, !1) : (i(() => {
+        s.advance(r), r = 0;
+      }), !1));
+    }) : Pt(n, () => {
+      var r = e;
+      return () => --r < 0;
+    })), this;
+  }
+  limit(e) {
+    return this._ctx.limit = Math.min(this._ctx.limit, e), Pt(this._ctx, () => {
+      var n = e;
+      return function(r, s, i) {
+        return --n <= 0 && s(i), n >= 0;
+      };
+    }, !0), this;
+  }
+  until(e, n) {
+    return Et(this._ctx, function(r, s, i) {
+      return !e(r.value) || (s(i), n);
+    }), this;
+  }
+  first(e) {
+    return this.limit(1).toArray(function(n) {
+      return n[0];
+    }).then(e);
+  }
+  last(e) {
+    return this.reverse().first(e);
+  }
+  filter(e) {
+    var n, r;
+    return Et(this._ctx, function(s) {
+      return e(s.value);
+    }), n = this._ctx, r = e, n.isMatch = ge(n.isMatch, r), this;
+  }
+  and(e) {
+    return this.filter(e);
+  }
+  or(e) {
+    return new this.db.WhereClause(this._ctx.table, e, this);
+  }
+  reverse() {
+    return this._ctx.dir = this._ctx.dir === "prev" ? "next" : "prev", this._ondirectionchange && this._ondirectionchange(this._ctx.dir), this;
+  }
+  desc() {
+    return this.reverse();
+  }
+  eachKey(e) {
+    var n = this._ctx;
+    return n.keysOnly = !n.isMatch, this.each(function(r, s) {
+      e(s.key, s);
+    });
+  }
+  eachUniqueKey(e) {
+    return this._ctx.unique = "unique", this.eachKey(e);
+  }
+  eachPrimaryKey(e) {
+    var n = this._ctx;
+    return n.keysOnly = !n.isMatch, this.each(function(r, s) {
+      e(s.primaryKey, s);
+    });
+  }
+  keys(e) {
+    var n = this._ctx;
+    n.keysOnly = !n.isMatch;
+    var r = [];
+    return this.each(function(s, i) {
+      r.push(i.key);
+    }).then(function() {
+      return r;
+    }).then(e);
+  }
+  primaryKeys(e) {
+    var n = this._ctx;
+    if (n.dir === "next" && _e(n, !0) && n.limit > 0)
+      return this._read((s) => {
+        var i = lt(n, n.table.core.schema);
+        return n.table.core.query({ trans: s, values: !1, limit: n.limit, query: { index: i, range: n.range } });
+      }).then(({ result: s }) => s).then(e);
+    n.keysOnly = !n.isMatch;
+    var r = [];
+    return this.each(function(s, i) {
+      r.push(i.primaryKey);
+    }).then(function() {
+      return r;
+    }).then(e);
+  }
+  uniqueKeys(e) {
+    return this._ctx.unique = "unique", this.keys(e);
+  }
+  firstKey(e) {
+    return this.limit(1).keys(function(n) {
+      return n[0];
+    }).then(e);
+  }
+  lastKey(e) {
+    return this.reverse().firstKey(e);
+  }
+  distinct() {
+    var e = this._ctx, n = e.index && e.table.schema.idxByName[e.index];
+    if (!n || !n.multi)
+      return this;
+    var r = {};
+    return Et(this._ctx, function(s) {
+      var i = s.primaryKey.toString(), o = H(r, i);
+      return r[i] = !0, !o;
+    }), this;
+  }
+  modify(e) {
+    var n = this._ctx;
+    return this._write((r) => {
+      var s;
+      if (typeof e == "function")
+        s = e;
+      else {
+        var i = R(e), o = i.length;
+        s = function(y) {
+          for (var b = !1, m = 0; m < o; ++m) {
+            var f = i[m], w = e[f];
+            ne(y, f) !== w && (Y(y, f, w), b = !0);
+          }
+          return b;
+        };
+      }
+      const a = n.table.core, { outbound: c, extractKey: l } = a.schema.primaryKey, u = this.db._options.modifyChunkSize || 200, d = [];
+      let h = 0;
+      const p = [], g = (y, b) => {
+        const { failures: m, numFailures: f } = b;
+        h += y - f;
+        for (let w of R(m))
+          d.push(m[w]);
+      };
+      return this.clone().primaryKeys().then((y) => {
+        const b = (m) => {
+          const f = Math.min(u, y.length - m);
+          return a.getMany({ trans: r, keys: y.slice(m, m + f), cache: "immutable" }).then((w) => {
+            const S = [], P = [], x = c ? [] : null, v = [];
+            for (let _ = 0; _ < f; ++_) {
+              const T = w[_], K = { value: He(T), primKey: y[m + _] };
+              s.call(K, K.value, K) !== !1 && (K.value == null ? v.push(y[m + _]) : c || W(l(T), l(K.value)) === 0 ? (P.push(K.value), c && x.push(y[m + _])) : (v.push(y[m + _]), S.push(K.value)));
+            }
+            const j = _e(n) && n.limit === 1 / 0 && (typeof e != "function" || e === Ot) && { index: n.index, range: n.range };
+            return Promise.resolve(S.length > 0 && a.mutate({ trans: r, type: "add", values: S }).then((_) => {
+              for (let T in _.failures)
+                v.splice(parseInt(T), 1);
+              g(S.length, _);
+            })).then(() => (P.length > 0 || j && typeof e == "object") && a.mutate({ trans: r, type: "put", keys: x, values: P, criteria: j, changeSpec: typeof e != "function" && e }).then((_) => g(P.length, _))).then(() => (v.length > 0 || j && e === Ot) && a.mutate({ trans: r, type: "delete", keys: v, criteria: j }).then((_) => g(v.length, _))).then(() => y.length > m + f && b(m + u));
+          });
+        };
+        return b(0).then(() => {
+          if (d.length > 0)
+            throw new dt("Error modifying one or more objects", d, h, p);
+          return y.length;
+        });
+      });
+    });
+  }
+  delete() {
+    var e = this._ctx, n = e.range;
+    return _e(e) && (e.isPrimKey && !$r || n.type === 3) ? this._write((r) => {
+      const { primaryKey: s } = e.table.core.schema, i = n;
+      return e.table.core.count({ trans: r, query: { index: s, range: i } }).then((o) => e.table.core.mutate({ trans: r, type: "deleteRange", range: i }).then(({ failures: a, lastResult: c, results: l, numFailures: u }) => {
+        if (u)
+          throw new dt("Could not delete some values", Object.keys(a).map((d) => a[d]), o - u);
+        return o - u;
+      }));
+    }) : this.modify(Ot);
+  }
+}
+const Ot = (t, e) => e.value = null;
+function Wr(t, e) {
+  return t < e ? -1 : t === e ? 0 : 1;
+}
+function zr(t, e) {
+  return t > e ? -1 : t === e ? 0 : 1;
+}
+function G(t, e, n) {
+  var r = t instanceof tr ? new t.Collection(t) : t;
+  return r._ctx.error = n ? new n(e) : new TypeError(e), r;
+}
+function ke(t) {
+  return new t.Collection(t, () => er("")).limit(0);
+}
+function Vr(t, e, n, r, s, i) {
+  for (var o = Math.min(t.length, r.length), a = -1, c = 0; c < o; ++c) {
+    var l = e[c];
+    if (l !== r[c])
+      return s(t[c], n[c]) < 0 ? t.substr(0, c) + n[c] + n.substr(c + 1) : s(t[c], r[c]) < 0 ? t.substr(0, c) + r[c] + n.substr(c + 1) : a >= 0 ? t.substr(0, a) + e[a] + n.substr(a + 1) : null;
+    s(t[c], l) < 0 && (a = c);
+  }
+  return o < r.length && i === "next" ? t + n.substr(t.length) : o < t.length && i === "prev" ? t.substr(0, n.length) : a < 0 ? null : t.substr(0, a) + r[a] + n.substr(a + 1);
+}
+function nt(t, e, n, r) {
+  var s, i, o, a, c, l, u, d = n.length;
+  if (!n.every((y) => typeof y == "string"))
+    return G(t, Xn);
+  function h(y) {
+    s = /* @__PURE__ */ function(m) {
+      return m === "next" ? (f) => f.toUpperCase() : (f) => f.toLowerCase();
+    }(y), i = /* @__PURE__ */ function(m) {
+      return m === "next" ? (f) => f.toLowerCase() : (f) => f.toUpperCase();
+    }(y), o = y === "next" ? Wr : zr;
+    var b = n.map(function(m) {
+      return { lower: i(m), upper: s(m) };
+    }).sort(function(m, f) {
+      return o(m.lower, f.lower);
+    });
+    a = b.map(function(m) {
+      return m.upper;
+    }), c = b.map(function(m) {
+      return m.lower;
+    }), l = y, u = y === "next" ? "" : r;
+  }
+  h("next");
+  var p = new t.Collection(t, () => se(a[0], c[d - 1] + r));
+  p._ondirectionchange = function(y) {
+    h(y);
+  };
+  var g = 0;
+  return p._addAlgorithm(function(y, b, m) {
+    var f = y.key;
+    if (typeof f != "string")
+      return !1;
+    var w = i(f);
+    if (e(w, c, g))
+      return !0;
+    for (var S = null, P = g; P < d; ++P) {
+      var x = Vr(f, w, a[P], c[P], o, l);
+      x === null && S === null ? g = P + 1 : (S === null || o(S, x) > 0) && (S = x);
+    }
+    return b(S !== null ? function() {
+      y.continue(S + u);
+    } : m), !1;
+  }), p;
+}
+function se(t, e, n, r) {
+  return { type: 2, lower: t, upper: e, lowerOpen: n, upperOpen: r };
+}
+function er(t) {
+  return { type: 1, lower: t, upper: t };
+}
+class tr {
+  get Collection() {
+    return this._ctx.table.db.Collection;
+  }
+  between(e, n, r, s) {
+    r = r !== !1, s = s === !0;
+    try {
+      return this._cmp(e, n) > 0 || this._cmp(e, n) === 0 && (r || s) && (!r || !s) ? ke(this) : new this.Collection(this, () => se(e, n, !r, !s));
+    } catch {
+      return G(this, X);
+    }
+  }
+  equals(e) {
+    return e == null ? G(this, X) : new this.Collection(this, () => er(e));
+  }
+  above(e) {
+    return e == null ? G(this, X) : new this.Collection(this, () => se(e, void 0, !0));
+  }
+  aboveOrEqual(e) {
+    return e == null ? G(this, X) : new this.Collection(this, () => se(e, void 0, !1));
+  }
+  below(e) {
+    return e == null ? G(this, X) : new this.Collection(this, () => se(void 0, e, !1, !0));
+  }
+  belowOrEqual(e) {
+    return e == null ? G(this, X) : new this.Collection(this, () => se(void 0, e));
+  }
+  startsWith(e) {
+    return typeof e != "string" ? G(this, Xn) : this.between(e, e + de, !0, !0);
+  }
+  startsWithIgnoreCase(e) {
+    return e === "" ? this.startsWith(e) : nt(this, (n, r) => n.indexOf(r[0]) === 0, [e], de);
+  }
+  equalsIgnoreCase(e) {
+    return nt(this, (n, r) => n === r[0], [e], "");
+  }
+  anyOfIgnoreCase() {
+    var e = q.apply(xe, arguments);
+    return e.length === 0 ? ke(this) : nt(this, (n, r) => r.indexOf(n) !== -1, e, "");
+  }
+  startsWithAnyOfIgnoreCase() {
+    var e = q.apply(xe, arguments);
+    return e.length === 0 ? ke(this) : nt(this, (n, r) => r.some((s) => n.indexOf(s) === 0), e, de);
+  }
+  anyOf() {
+    const e = q.apply(xe, arguments);
+    let n = this._cmp;
+    try {
+      e.sort(n);
+    } catch {
+      return G(this, X);
+    }
+    if (e.length === 0)
+      return ke(this);
+    const r = new this.Collection(this, () => se(e[0], e[e.length - 1]));
+    r._ondirectionchange = (i) => {
+      n = i === "next" ? this._ascending : this._descending, e.sort(n);
+    };
+    let s = 0;
+    return r._addAlgorithm((i, o, a) => {
+      const c = i.key;
+      for (; n(c, e[s]) > 0; )
+        if (++s, s === e.length)
+          return o(a), !1;
+      return n(c, e[s]) === 0 || (o(() => {
+        i.continue(e[s]);
+      }), !1);
+    }), r;
+  }
+  notEqual(e) {
+    return this.inAnyRange([[Gt, e], [e, this.db._maxKey]], { includeLowers: !1, includeUppers: !1 });
+  }
+  noneOf() {
+    const e = q.apply(xe, arguments);
+    if (e.length === 0)
+      return new this.Collection(this);
+    try {
+      e.sort(this._ascending);
+    } catch {
+      return G(this, X);
+    }
+    const n = e.reduce((r, s) => r ? r.concat([[r[r.length - 1][1], s]]) : [[Gt, s]], null);
+    return n.push([e[e.length - 1], this.db._maxKey]), this.inAnyRange(n, { includeLowers: !1, includeUppers: !1 });
+  }
+  inAnyRange(e, n) {
+    const r = this._cmp, s = this._ascending, i = this._descending, o = this._min, a = this._max;
+    if (e.length === 0)
+      return ke(this);
+    if (!e.every((f) => f[0] !== void 0 && f[1] !== void 0 && s(f[0], f[1]) <= 0))
+      return G(this, "First argument to inAnyRange() must be an Array of two-value Arrays [lower,upper] where upper must not be lower than lower", C.InvalidArgument);
+    const c = !n || n.includeLowers !== !1, l = n && n.includeUppers === !0;
+    let u, d = s;
+    function h(f, w) {
+      return d(f[0], w[0]);
+    }
+    try {
+      u = e.reduce(function(f, w) {
+        let S = 0, P = f.length;
+        for (; S < P; ++S) {
+          const x = f[S];
+          if (r(w[0], x[1]) < 0 && r(w[1], x[0]) > 0) {
+            x[0] = o(x[0], w[0]), x[1] = a(x[1], w[1]);
+            break;
+          }
+        }
+        return S === P && f.push(w), f;
+      }, []), u.sort(h);
+    } catch {
+      return G(this, X);
+    }
+    let p = 0;
+    const g = l ? (f) => s(f, u[p][1]) > 0 : (f) => s(f, u[p][1]) >= 0, y = c ? (f) => i(f, u[p][0]) > 0 : (f) => i(f, u[p][0]) >= 0;
+    let b = g;
+    const m = new this.Collection(this, () => se(u[0][0], u[u.length - 1][1], !c, !l));
+    return m._ondirectionchange = (f) => {
+      f === "next" ? (b = g, d = s) : (b = y, d = i), u.sort(h);
+    }, m._addAlgorithm((f, w, S) => {
+      for (var P = f.key; b(P); )
+        if (++p, p === u.length)
+          return w(S), !1;
+      return !!function(x) {
+        return !g(x) && !y(x);
+      }(P) || (this._cmp(P, u[p][1]) === 0 || this._cmp(P, u[p][0]) === 0 || w(() => {
+        d === s ? f.continue(u[p][0]) : f.continue(u[p][1]);
+      }), !1);
+    }), m;
+  }
+  startsWithAnyOf() {
+    const e = q.apply(xe, arguments);
+    return e.every((n) => typeof n == "string") ? e.length === 0 ? ke(this) : this.inAnyRange(e.map((n) => [n, n + de])) : G(this, "startsWithAnyOf() only works with strings");
+  }
+}
+function Q(t) {
+  return I(function(e) {
+    return We(e), t(e.target.error), !1;
+  });
+}
+function We(t) {
+  t.stopPropagation && t.stopPropagation(), t.preventDefault && t.preventDefault();
+}
+const ze = "storagemutated", oe = "x-storagemutated-1", le = Fe(null, ze);
+class Gr {
+  _lock() {
+    return Ie(!O.global), ++this._reculock, this._reculock !== 1 || O.global || (O.lockOwnerFor = this), this;
+  }
+  _unlock() {
+    if (Ie(!O.global), --this._reculock == 0)
+      for (O.global || (O.lockOwnerFor = null); this._blockedFuncs.length > 0 && !this._locked(); ) {
+        var e = this._blockedFuncs.shift();
+        try {
+          Ke(e[1], e[0]);
+        } catch {
+        }
+      }
+    return this;
+  }
+  _locked() {
+    return this._reculock && O.lockOwnerFor !== this;
+  }
+  create(e) {
+    if (!this.mode)
+      return this;
+    const n = this.db.idbdb, r = this.db._state.dbOpenError;
+    if (Ie(!this.idbtrans), !e && !n)
+      switch (r && r.name) {
+        case "DatabaseClosedError":
+          throw new C.DatabaseClosed(r);
+        case "MissingAPIError":
+          throw new C.MissingAPI(r.message, r);
+        default:
+          throw new C.OpenFailed(r);
+      }
+    if (!this.active)
+      throw new C.TransactionInactive();
+    return Ie(this._completion._state === null), (e = this.idbtrans = e || (this.db.core ? this.db.core.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }) : n.transaction(this.storeNames, this.mode, { durability: this.chromeTransactionDurability }))).onerror = I((s) => {
+      We(s), this._reject(e.error);
+    }), e.onabort = I((s) => {
+      We(s), this.active && this._reject(new C.Abort(e.error)), this.active = !1, this.on("abort").fire(s);
+    }), e.oncomplete = I(() => {
+      this.active = !1, this._resolve(), "mutatedParts" in e && le.storagemutated.fire(e.mutatedParts);
+    }), this;
+  }
+  _promise(e, n, r) {
+    if (e === "readwrite" && this.mode !== "readwrite")
+      return F(new C.ReadOnly("Transaction is readonly"));
+    if (!this.active)
+      return F(new C.TransactionInactive());
+    if (this._locked())
+      return new E((i, o) => {
+        this._blockedFuncs.push([() => {
+          this._promise(e, n, r).then(i, o);
+        }, O]);
+      });
+    if (r)
+      return ae(() => {
+        var i = new E((o, a) => {
+          this._lock();
+          const c = n(o, a, this);
+          c && c.then && c.then(o, a);
+        });
+        return i.finally(() => this._unlock()), i._lib = !0, i;
+      });
+    var s = new E((i, o) => {
+      var a = n(i, o, this);
+      a && a.then && a.then(i, o);
+    });
+    return s._lib = !0, s;
+  }
+  _root() {
+    return this.parent ? this.parent._root() : this;
+  }
+  waitFor(e) {
+    var n = this._root();
+    const r = E.resolve(e);
+    if (n._waitingFor)
+      n._waitingFor = n._waitingFor.then(() => r);
+    else {
+      n._waitingFor = r, n._waitingQueue = [];
+      var s = n.idbtrans.objectStore(n.storeNames[0]);
+      (function o() {
+        for (++n._spinCount; n._waitingQueue.length; )
+          n._waitingQueue.shift()();
+        n._waitingFor && (s.get(-1 / 0).onsuccess = o);
+      })();
+    }
+    var i = n._waitingFor;
+    return new E((o, a) => {
+      r.then((c) => n._waitingQueue.push(I(o.bind(null, c))), (c) => n._waitingQueue.push(I(a.bind(null, c)))).finally(() => {
+        n._waitingFor === i && (n._waitingFor = null);
+      });
+    });
+  }
+  abort() {
+    this.active && (this.active = !1, this.idbtrans && this.idbtrans.abort(), this._reject(new C.Abort()));
+  }
+  table(e) {
+    const n = this._memoizedTables || (this._memoizedTables = {});
+    if (H(n, e))
+      return n[e];
+    const r = this.schema[e];
+    if (!r)
+      throw new C.NotFound("Table " + e + " not part of transaction");
+    const s = new this.db.Table(e, r, this);
+    return s.core = this.db.core.table(e), n[e] = s, s;
+  }
+}
+function Ht(t, e, n, r, s, i, o) {
+  return { name: t, keyPath: e, unique: n, multi: r, auto: s, compound: i, src: (n && !o ? "&" : "") + (r ? "*" : "") + (s ? "++" : "") + nr(e) };
+}
+function nr(t) {
+  return typeof t == "string" ? t : t ? "[" + [].join.call(t, "+") + "]" : "";
+}
+function rr(t, e, n) {
+  return { name: t, primKey: e, indexes: n, mappedClass: null, idxByName: Bn(n, (r) => [r.name, r]) };
+}
+let Ve = (t) => {
+  try {
+    return t.only([[]]), Ve = () => [[]], [[]];
+  } catch {
+    return Ve = () => de, de;
+  }
+};
+function Yt(t) {
+  return t == null ? () => {
+  } : typeof t == "string" ? function(e) {
+    return e.split(".").length === 1 ? (r) => r[e] : (r) => ne(r, e);
+  }(t) : (e) => ne(e, t);
+}
+function On(t) {
+  return [].slice.call(t);
+}
+let Hr = 0;
+function Ne(t) {
+  return t == null ? ":id" : typeof t == "string" ? t : `[${t.join("+")}]`;
+}
+function Yr(t, e, n) {
+  function r(c) {
+    if (c.type === 3)
+      return null;
+    if (c.type === 4)
+      throw new Error("Cannot convert never type to IDBKeyRange");
+    const { lower: l, upper: u, lowerOpen: d, upperOpen: h } = c;
+    return l === void 0 ? u === void 0 ? null : e.upperBound(u, !!h) : u === void 0 ? e.lowerBound(l, !!d) : e.bound(l, u, !!d, !!h);
+  }
+  const { schema: s, hasGetAll: i } = function(c, l) {
+    const u = On(c.objectStoreNames);
+    return { schema: { name: c.name, tables: u.map((d) => l.objectStore(d)).map((d) => {
+      const { keyPath: h, autoIncrement: p } = d, g = L(h), y = h == null, b = {}, m = { name: d.name, primaryKey: { name: null, isPrimaryKey: !0, outbound: y, compound: g, keyPath: h, autoIncrement: p, unique: !0, extractKey: Yt(h) }, indexes: On(d.indexNames).map((f) => d.index(f)).map((f) => {
+        const { name: w, unique: S, multiEntry: P, keyPath: x } = f, v = { name: w, compound: L(x), keyPath: x, unique: S, multiEntry: P, extractKey: Yt(x) };
+        return b[Ne(x)] = v, v;
+      }), getIndexByKeyPath: (f) => b[Ne(f)] };
+      return b[":id"] = m.primaryKey, h != null && (b[Ne(h)] = m.primaryKey), m;
+    }) }, hasGetAll: u.length > 0 && "getAll" in l.objectStore(u[0]) && !(typeof navigator < "u" && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604) };
+  }(t, n), o = s.tables.map((c) => function(l) {
+    const u = l.name;
+    return { name: u, schema: l, mutate: function({ trans: d, type: h, keys: p, values: g, range: y }) {
+      return new Promise((b, m) => {
+        b = I(b);
+        const f = d.objectStore(u), w = f.keyPath == null, S = h === "put" || h === "add";
+        if (!S && h !== "delete" && h !== "deleteRange")
+          throw new Error("Invalid operation type: " + h);
+        const { length: P } = p || g || { length: 1 };
+        if (p && g && p.length !== g.length)
+          throw new Error("Given keys array must have same length as given values array.");
+        if (P === 0)
+          return b({ numFailures: 0, failures: {}, results: [], lastResult: void 0 });
+        let x;
+        const v = [], j = [];
+        let _ = 0;
+        const T = (U) => {
+          ++_, We(U);
+        };
+        if (h === "deleteRange") {
+          if (y.type === 4)
+            return b({ numFailures: _, failures: j, results: [], lastResult: void 0 });
+          y.type === 3 ? v.push(x = f.clear()) : v.push(x = f.delete(r(y)));
+        } else {
+          const [U, N] = S ? w ? [g, p] : [g, null] : [p, null];
+          if (S)
+            for (let M = 0; M < P; ++M)
+              v.push(x = N && N[M] !== void 0 ? f[h](U[M], N[M]) : f[h](U[M])), x.onerror = T;
+          else
+            for (let M = 0; M < P; ++M)
+              v.push(x = f[h](U[M])), x.onerror = T;
+        }
+        const K = (U) => {
+          const N = U.target.result;
+          v.forEach((M, ve) => M.error != null && (j[ve] = M.error)), b({ numFailures: _, failures: j, results: h === "delete" ? p : v.map((M) => M.result), lastResult: N });
+        };
+        x.onerror = (U) => {
+          T(U), K(U);
+        }, x.onsuccess = K;
+      });
+    }, getMany: ({ trans: d, keys: h }) => new Promise((p, g) => {
+      p = I(p);
+      const y = d.objectStore(u), b = h.length, m = new Array(b);
+      let f, w = 0, S = 0;
+      const P = (v) => {
+        const j = v.target;
+        m[j._pos] = j.result, ++S === w && p(m);
+      }, x = Q(g);
+      for (let v = 0; v < b; ++v)
+        h[v] != null && (f = y.get(h[v]), f._pos = v, f.onsuccess = P, f.onerror = x, ++w);
+      w === 0 && p(m);
+    }), get: ({ trans: d, key: h }) => new Promise((p, g) => {
+      p = I(p);
+      const y = d.objectStore(u).get(h);
+      y.onsuccess = (b) => p(b.target.result), y.onerror = Q(g);
+    }), query: /* @__PURE__ */ function(d) {
+      return (h) => new Promise((p, g) => {
+        p = I(p);
+        const { trans: y, values: b, limit: m, query: f } = h, w = m === 1 / 0 ? void 0 : m, { index: S, range: P } = f, x = y.objectStore(u), v = S.isPrimaryKey ? x : x.index(S.name), j = r(P);
+        if (m === 0)
+          return p({ result: [] });
+        if (d) {
+          const _ = b ? v.getAll(j, w) : v.getAllKeys(j, w);
+          _.onsuccess = (T) => p({ result: T.target.result }), _.onerror = Q(g);
+        } else {
+          let _ = 0;
+          const T = b || !("openKeyCursor" in v) ? v.openCursor(j) : v.openKeyCursor(j), K = [];
+          T.onsuccess = (U) => {
+            const N = T.result;
+            return N ? (K.push(b ? N.value : N.primaryKey), ++_ === m ? p({ result: K }) : void N.continue()) : p({ result: K });
+          }, T.onerror = Q(g);
+        }
+      });
+    }(i), openCursor: function({ trans: d, values: h, query: p, reverse: g, unique: y }) {
+      return new Promise((b, m) => {
+        b = I(b);
+        const { index: f, range: w } = p, S = d.objectStore(u), P = f.isPrimaryKey ? S : S.index(f.name), x = g ? y ? "prevunique" : "prev" : y ? "nextunique" : "next", v = h || !("openKeyCursor" in P) ? P.openCursor(r(w), x) : P.openKeyCursor(r(w), x);
+        v.onerror = Q(m), v.onsuccess = I((j) => {
+          const _ = v.result;
+          if (!_)
+            return void b(null);
+          _.___id = ++Hr, _.done = !1;
+          const T = _.continue.bind(_);
+          let K = _.continuePrimaryKey;
+          K && (K = K.bind(_));
+          const U = _.advance.bind(_), N = () => {
+            throw new Error("Cursor not stopped");
+          };
+          _.trans = d, _.stop = _.continue = _.continuePrimaryKey = _.advance = () => {
+            throw new Error("Cursor not started");
+          }, _.fail = I(m), _.next = function() {
+            let M = 1;
+            return this.start(() => M-- ? this.continue() : this.stop()).then(() => this);
+          }, _.start = (M) => {
+            const ve = new Promise((V, ue) => {
+              V = I(V), v.onerror = Q(ue), _.fail = ue, _.stop = (Ae) => {
+                _.stop = _.continue = _.continuePrimaryKey = _.advance = N, V(Ae);
+              };
+            }), we = () => {
+              if (v.result)
+                try {
+                  M();
+                } catch (V) {
+                  _.fail(V);
+                }
+              else
+                _.done = !0, _.start = () => {
+                  throw new Error("Cursor behind last entry");
+                }, _.stop();
+            };
+            return v.onsuccess = I((V) => {
+              v.onsuccess = we, we();
+            }), _.continue = T, _.continuePrimaryKey = K, _.advance = U, we(), ve;
+          }, b(_);
+        }, m);
+      });
+    }, count({ query: d, trans: h }) {
+      const { index: p, range: g } = d;
+      return new Promise((y, b) => {
+        const m = h.objectStore(u), f = p.isPrimaryKey ? m : m.index(p.name), w = r(g), S = w ? f.count(w) : f.count();
+        S.onsuccess = I((P) => y(P.target.result)), S.onerror = Q(b);
+      });
+    } };
+  }(c)), a = {};
+  return o.forEach((c) => a[c.name] = c), { stack: "dbcore", transaction: t.transaction.bind(t), table(c) {
+    if (!a[c])
+      throw new Error(`Table '${c}' not found`);
+    return a[c];
+  }, MIN_KEY: -1 / 0, MAX_KEY: Ve(e), schema: s };
+}
+function Qt({ _novip: t }, e) {
+  const n = e.db, r = function(s, i, { IDBKeyRange: o, indexedDB: a }, c) {
+    return { dbcore: function(u, d) {
+      return d.reduce((h, { create: p }) => ({ ...h, ...p(h) }), u);
+    }(Yr(i, o, c), s.dbcore) };
+  }(t._middlewares, n, t._deps, e);
+  t.core = r.dbcore, t.tables.forEach((s) => {
+    const i = s.name;
+    t.core.schema.tables.some((o) => o.name === i) && (s.core = t.core.table(i), t[i] instanceof t.Table && (t[i].core = s.core));
+  });
+}
+function gt({ _novip: t }, e, n, r) {
+  n.forEach((s) => {
+    const i = r[s];
+    e.forEach((o) => {
+      const a = sn(o, s);
+      (!a || "value" in a && a.value === void 0) && (o === t.Transaction.prototype || o instanceof t.Transaction ? te(o, s, { get() {
+        return this.table(s);
+      }, set(c) {
+        An(this, s, { value: c, writable: !0, configurable: !0, enumerable: !0 });
+      } }) : o[s] = new t.Table(s, i));
+    });
+  });
+}
+function Jt({ _novip: t }, e) {
+  e.forEach((n) => {
+    for (let r in n)
+      n[r] instanceof t.Table && delete n[r];
+  });
+}
+function Qr(t, e) {
+  return t._cfg.version - e._cfg.version;
+}
+function Jr(t, e, n, r) {
+  const s = t._dbSchema, i = t._createTransaction("readwrite", t._storeNames, s);
+  i.create(n), i._completion.catch(r);
+  const o = i._reject.bind(i), a = O.transless || O;
+  ae(() => {
+    O.trans = i, O.transless = a, e === 0 ? (R(s).forEach((c) => {
+      Ct(n, c, s[c].primKey, s[c].indexes);
+    }), Qt(t, n), E.follow(() => t.on.populate.fire(i)).catch(o)) : function({ _novip: c }, l, u, d) {
+      const h = [], p = c._versions;
+      let g = c._dbSchema = Zt(c, c.idbdb, d), y = !1;
+      const b = p.filter((f) => f._cfg.version >= l);
+      function m() {
+        return h.length ? E.resolve(h.shift()(u.idbtrans)).then(m) : E.resolve();
+      }
+      return b.forEach((f) => {
+        h.push(() => {
+          const w = g, S = f._cfg.dbschema;
+          qt(c, w, d), qt(c, S, d), g = c._dbSchema = S;
+          const P = sr(w, S);
+          P.add.forEach((v) => {
+            Ct(d, v[0], v[1].primKey, v[1].indexes);
+          }), P.change.forEach((v) => {
+            if (v.recreate)
+              throw new C.Upgrade("Not yet support for changing primary key");
+            {
+              const j = d.objectStore(v.name);
+              v.add.forEach((_) => Xt(j, _)), v.change.forEach((_) => {
+                j.deleteIndex(_.name), Xt(j, _);
+              }), v.del.forEach((_) => j.deleteIndex(_));
+            }
+          });
+          const x = f._cfg.contentUpgrade;
+          if (x && f._cfg.version > l) {
+            Qt(c, d), u._memoizedTables = {}, y = !0;
+            let v = Tn(S);
+            P.del.forEach((K) => {
+              v[K] = w[K];
+            }), Jt(c, [c.Transaction.prototype]), gt(c, [c.Transaction.prototype], R(v), v), u.schema = v;
+            const j = on(x);
+            let _;
+            j && je();
+            const T = E.follow(() => {
+              if (_ = x(u), _ && j) {
+                var K = re.bind(null, null);
+                _.then(K, K);
+              }
+            });
+            return _ && typeof _.then == "function" ? E.resolve(_) : T.then(() => _);
+          }
+        }), h.push((w) => {
+          (!y || !Nr) && function(S, P) {
+            [].slice.call(P.db.objectStoreNames).forEach((x) => S[x] == null && P.db.deleteObjectStore(x));
+          }(f._cfg.dbschema, w), Jt(c, [c.Transaction.prototype]), gt(c, [c.Transaction.prototype], c._storeNames, c._dbSchema), u.schema = c._dbSchema;
+        });
+      }), m().then(() => {
+        var f, w;
+        w = d, R(f = g).forEach((S) => {
+          w.db.objectStoreNames.contains(S) || Ct(w, S, f[S].primKey, f[S].indexes);
+        });
+      });
+    }(t, e, i, n).catch(o);
+  });
+}
+function sr(t, e) {
+  const n = { del: [], add: [], change: [] };
+  let r;
+  for (r in t)
+    e[r] || n.del.push(r);
+  for (r in e) {
+    const s = t[r], i = e[r];
+    if (s) {
+      const o = { name: r, def: i, recreate: !1, del: [], add: [], change: [] };
+      if ("" + (s.primKey.keyPath || "") != "" + (i.primKey.keyPath || "") || s.primKey.auto !== i.primKey.auto && !vt)
+        o.recreate = !0, n.change.push(o);
+      else {
+        const a = s.idxByName, c = i.idxByName;
+        let l;
+        for (l in a)
+          c[l] || o.del.push(l);
+        for (l in c) {
+          const u = a[l], d = c[l];
+          u ? u.src !== d.src && o.change.push(d) : o.add.push(d);
+        }
+        (o.del.length > 0 || o.add.length > 0 || o.change.length > 0) && n.change.push(o);
+      }
+    } else
+      n.add.push([r, i]);
+  }
+  return n;
+}
+function Ct(t, e, n, r) {
+  const s = t.db.createObjectStore(e, n.keyPath ? { keyPath: n.keyPath, autoIncrement: n.auto } : { autoIncrement: n.auto });
+  return r.forEach((i) => Xt(s, i)), s;
+}
+function Xt(t, e) {
+  t.createIndex(e.name, e.keyPath, { unique: e.unique, multiEntry: e.multi });
+}
+function Zt(t, e, n) {
+  const r = {};
+  return ht(e.objectStoreNames, 0).forEach((s) => {
+    const i = n.objectStore(s);
+    let o = i.keyPath;
+    const a = Ht(nr(o), o || "", !1, !1, !!i.autoIncrement, o && typeof o != "string", !0), c = [];
+    for (let u = 0; u < i.indexNames.length; ++u) {
+      const d = i.index(i.indexNames[u]);
+      o = d.keyPath;
+      var l = Ht(d.name, o, !!d.unique, !!d.multiEntry, !1, o && typeof o != "string", !1);
+      c.push(l);
+    }
+    r[s] = rr(s, a, c);
+  }), r;
+}
+function qt({ _novip: t }, e, n) {
+  const r = n.db.objectStoreNames;
+  for (let s = 0; s < r.length; ++s) {
+    const i = r[s], o = n.objectStore(i);
+    t._hasGetAll = "getAll" in o;
+    for (let a = 0; a < o.indexNames.length; ++a) {
+      const c = o.indexNames[a], l = o.index(c).keyPath, u = typeof l == "string" ? l : "[" + ht(l).join("+") + "]";
+      if (e[i]) {
+        const d = e[i].idxByName[u];
+        d && (d.name = c, delete e[i].idxByName[u], e[i].idxByName[c] = d);
+      }
+    }
+  }
+  typeof navigator < "u" && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && D.WorkerGlobalScope && D instanceof D.WorkerGlobalScope && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604 && (t._hasGetAll = !1);
+}
+class Xr {
+  _parseStoresSpec(e, n) {
+    R(e).forEach((r) => {
+      if (e[r] !== null) {
+        var s = e[r].split(",").map((o, a) => {
+          const c = (o = o.trim()).replace(/([&*]|\+\+)/g, ""), l = /^\[/.test(c) ? c.match(/^\[(.*)\]$/)[1].split("+") : c;
+          return Ht(c, l || null, /\&/.test(o), /\*/.test(o), /\+\+/.test(o), L(l), a === 0);
+        }), i = s.shift();
+        if (i.multi)
+          throw new C.Schema("Primary key cannot be multi-valued");
+        s.forEach((o) => {
+          if (o.auto)
+            throw new C.Schema("Only primary key can be marked as autoIncrement (++)");
+          if (!o.keyPath)
+            throw new C.Schema("Index must have a name and cannot be an empty string");
+        }), n[r] = rr(r, i, s);
+      }
+    });
+  }
+  stores(e) {
+    const n = this.db;
+    this._cfg.storesSource = this._cfg.storesSource ? z(this._cfg.storesSource, e) : e;
+    const r = n._versions, s = {};
+    let i = {};
+    return r.forEach((o) => {
+      z(s, o._cfg.storesSource), i = o._cfg.dbschema = {}, o._parseStoresSpec(s, i);
+    }), n._dbSchema = i, Jt(n, [n._allTables, n, n.Transaction.prototype]), gt(n, [n._allTables, n, n.Transaction.prototype, this._cfg.tables], R(i), i), n._storeNames = R(i), this;
+  }
+  upgrade(e) {
+    return this._cfg.contentUpgrade = ln(this._cfg.contentUpgrade || A, e), this;
+  }
+}
+function fn(t, e) {
+  let n = t._dbNamesDB;
+  return n || (n = t._dbNamesDB = new me(wt, { addons: [], indexedDB: t, IDBKeyRange: e }), n.version(1).stores({ dbnames: "name" })), n.table("dbnames");
+}
+function pn(t) {
+  return t && typeof t.databases == "function";
+}
+function en(t) {
+  return ae(function() {
+    return O.letThrough = !0, t();
+  });
+}
+function Zr() {
+  var t;
+  return !navigator.userAgentData && /Safari\//.test(navigator.userAgent) && !/Chrom(e|ium)\//.test(navigator.userAgent) && indexedDB.databases ? new Promise(function(e) {
+    var n = function() {
+      return indexedDB.databases().finally(e);
+    };
+    t = setInterval(n, 100), n();
+  }).finally(function() {
+    return clearInterval(t);
+  }) : Promise.resolve();
+}
+function qr(t) {
+  const e = t._state, { indexedDB: n } = t._deps;
+  if (e.isBeingOpened || t.idbdb)
+    return e.dbReadyPromise.then(() => e.dbOpenError ? F(e.dbOpenError) : t);
+  J && (e.openCanceller._stackHolder = be()), e.isBeingOpened = !0, e.dbOpenError = null, e.openComplete = !1;
+  const r = e.openCanceller;
+  function s() {
+    if (e.openCanceller !== r)
+      throw new C.DatabaseClosed("db.open() was cancelled");
+  }
+  let i = e.dbReadyResolve, o = null, a = !1;
+  const c = () => new E((l, u) => {
+    if (s(), !n)
+      throw new C.MissingAPI();
+    const d = t.name, h = e.autoSchema ? n.open(d) : n.open(d, Math.round(10 * t.verno));
+    if (!h)
+      throw new C.MissingAPI();
+    h.onerror = Q(u), h.onblocked = I(t._fireOnBlocked), h.onupgradeneeded = I((p) => {
+      if (o = h.transaction, e.autoSchema && !t._options.allowEmptyDB) {
+        h.onerror = We, o.abort(), h.result.close();
+        const y = n.deleteDatabase(d);
+        y.onsuccess = y.onerror = I(() => {
+          u(new C.NoSuchDatabase(`Database ${d} doesnt exist`));
+        });
+      } else {
+        o.onerror = Q(u);
+        var g = p.oldVersion > Math.pow(2, 62) ? 0 : p.oldVersion;
+        a = g < 1, t._novip.idbdb = h.result, Jr(t, g / 10, o, u);
+      }
+    }, u), h.onsuccess = I(() => {
+      o = null;
+      const p = t._novip.idbdb = h.result, g = ht(p.objectStoreNames);
+      if (g.length > 0)
+        try {
+          const b = p.transaction((y = g).length === 1 ? y[0] : y, "readonly");
+          e.autoSchema ? function({ _novip: m }, f, w) {
+            m.verno = f.version / 10;
+            const S = m._dbSchema = Zt(0, f, w);
+            m._storeNames = ht(f.objectStoreNames, 0), gt(m, [m._allTables], R(S), S);
+          }(t, p, b) : (qt(t, t._dbSchema, b), function(m, f) {
+            const w = sr(Zt(0, m.idbdb, f), m._dbSchema);
+            return !(w.add.length || w.change.some((S) => S.add.length || S.change.length));
+          }(t, b) || console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail.")), Qt(t, b);
+        } catch {
+        }
+      var y;
+      Re.push(t), p.onversionchange = I((b) => {
+        e.vcFired = !0, t.on("versionchange").fire(b);
+      }), p.onclose = I((b) => {
+        t.on("close").fire(b);
+      }), a && function({ indexedDB: b, IDBKeyRange: m }, f) {
+        !pn(b) && f !== wt && fn(b, m).put({ name: f }).catch(A);
+      }(t._deps, d), l();
+    }, u);
+  }).catch((l) => l && l.name === "UnknownError" && e.PR1398_maxLoop > 0 ? (e.PR1398_maxLoop--, console.warn("Dexie: Workaround for Chrome UnknownError on open()"), c()) : E.reject(l));
+  return E.race([r, (typeof navigator > "u" ? E.resolve() : Zr()).then(c)]).then(() => (s(), e.onReadyBeingFired = [], E.resolve(en(() => t.on.ready.fire(t.vip))).then(function l() {
+    if (e.onReadyBeingFired.length > 0) {
+      let u = e.onReadyBeingFired.reduce(ln, A);
+      return e.onReadyBeingFired = [], E.resolve(en(() => u(t.vip))).then(l);
+    }
+  }))).finally(() => {
+    e.onReadyBeingFired = null, e.isBeingOpened = !1;
+  }).then(() => t).catch((l) => {
+    e.dbOpenError = l;
+    try {
+      o && o.abort();
+    } catch {
+    }
+    return r === e.openCanceller && t._close(), F(l);
+  }).finally(() => {
+    e.openComplete = !0, i();
+  });
+}
+function tn(t) {
+  var e = (i) => t.next(i), n = s(e), r = s((i) => t.throw(i));
+  function s(i) {
+    return (o) => {
+      var a = i(o), c = a.value;
+      return a.done ? c : c && typeof c.then == "function" ? c.then(n, r) : L(c) ? Promise.all(c).then(n, r) : n(c);
+    };
+  }
+  return s(e)();
+}
+function es(t, e, n) {
+  var r = arguments.length;
+  if (r < 2)
+    throw new C.InvalidArgument("Too few arguments");
+  for (var s = new Array(r - 1); --r; )
+    s[r - 1] = arguments[r];
+  return n = s.pop(), [t, Mn(s), n];
+}
+function ir(t, e, n, r, s) {
+  return E.resolve().then(() => {
+    const i = O.transless || O, o = t._createTransaction(e, n, t._dbSchema, r), a = { trans: o, transless: i };
+    if (r)
+      o.idbtrans = r.idbtrans;
+    else
+      try {
+        o.create(), t._state.PR1398_maxLoop = 3;
+      } catch (d) {
+        return d.name === cn.InvalidState && t.isOpen() && --t._state.PR1398_maxLoop > 0 ? (console.warn("Dexie: Need to reopen db"), t._close(), t.open().then(() => ir(t, e, n, null, s))) : F(d);
+      }
+    const c = on(s);
+    let l;
+    c && je();
+    const u = E.follow(() => {
+      if (l = s.call(o, o), l)
+        if (c) {
+          var d = re.bind(null, null);
+          l.then(d, d);
+        } else
+          typeof l.next == "function" && typeof l.throw == "function" && (l = tn(l));
+    }, a);
+    return (l && typeof l.then == "function" ? E.resolve(l).then((d) => o.active ? d : F(new C.PrematureCommit("Transaction committed too early. See http://bit.ly/2kdckMn"))) : u.then(() => l)).then((d) => (r && o._resolve(), o._completion.then(() => d))).catch((d) => (o._reject(d), F(d)));
+  });
+}
+function rt(t, e, n) {
+  const r = L(t) ? t.slice() : [t];
+  for (let s = 0; s < n; ++s)
+    r.push(e);
+  return r;
+}
+const ts = { stack: "dbcore", name: "VirtualIndexMiddleware", level: 1, create: function(t) {
+  return { ...t, table(e) {
+    const n = t.table(e), { schema: r } = n, s = {}, i = [];
+    function o(u, d, h) {
+      const p = Ne(u), g = s[p] = s[p] || [], y = u == null ? 0 : typeof u == "string" ? 1 : u.length, b = d > 0, m = { ...h, isVirtual: b, keyTail: d, keyLength: y, extractKey: Yt(u), unique: !b && h.unique };
+      return g.push(m), m.isPrimaryKey || i.push(m), y > 1 && o(y === 2 ? u[0] : u.slice(0, y - 1), d + 1, h), g.sort((f, w) => f.keyTail - w.keyTail), m;
+    }
+    const a = o(r.primaryKey.keyPath, 0, r.primaryKey);
+    s[":id"] = [a];
+    for (const u of r.indexes)
+      o(u.keyPath, 0, u);
+    function c(u) {
+      const d = u.query.index;
+      return d.isVirtual ? { ...u, query: { index: d, range: (h = u.query.range, p = d.keyTail, { type: h.type === 1 ? 2 : h.type, lower: rt(h.lower, h.lowerOpen ? t.MAX_KEY : t.MIN_KEY, p), lowerOpen: !0, upper: rt(h.upper, h.upperOpen ? t.MIN_KEY : t.MAX_KEY, p), upperOpen: !0 }) } } : u;
+      var h, p;
+    }
+    return { ...n, schema: { ...r, primaryKey: a, indexes: i, getIndexByKeyPath: function(u) {
+      const d = s[Ne(u)];
+      return d && d[0];
+    } }, count: (u) => n.count(c(u)), query: (u) => n.query(c(u)), openCursor(u) {
+      const { keyTail: d, isVirtual: h, keyLength: p } = u.query.index;
+      return h ? n.openCursor(c(u)).then((g) => g && function(y) {
+        return Object.create(y, { continue: { value: function(m) {
+          m != null ? y.continue(rt(m, u.reverse ? t.MAX_KEY : t.MIN_KEY, d)) : u.unique ? y.continue(y.key.slice(0, p).concat(u.reverse ? t.MIN_KEY : t.MAX_KEY, d)) : y.continue();
+        } }, continuePrimaryKey: { value(m, f) {
+          y.continuePrimaryKey(rt(m, t.MAX_KEY, d), f);
+        } }, primaryKey: { get: () => y.primaryKey }, key: { get() {
+          const m = y.key;
+          return p === 1 ? m[0] : m.slice(0, p);
+        } }, value: { get: () => y.value } });
+      }(g)) : n.openCursor(u);
+    } };
+  } };
+} };
+function mn(t, e, n, r) {
+  return n = n || {}, r = r || "", R(t).forEach((s) => {
+    if (H(e, s)) {
+      var i = t[s], o = e[s];
+      if (typeof i == "object" && typeof o == "object" && i && o) {
+        const a = Bt(i);
+        a !== Bt(o) ? n[r + s] = e[s] : a === "Object" ? mn(i, o, n, r + s + ".") : i !== o && (n[r + s] = e[s]);
+      } else
+        i !== o && (n[r + s] = e[s]);
+    } else
+      n[r + s] = void 0;
+  }), R(e).forEach((s) => {
+    H(t, s) || (n[r + s] = e[s]);
+  }), n;
+}
+const ns = { stack: "dbcore", name: "HooksMiddleware", level: 2, create: (t) => ({ ...t, table(e) {
+  const n = t.table(e), { primaryKey: r } = n.schema;
+  return { ...n, mutate(i) {
+    const o = O.trans, { deleting: a, creating: c, updating: l } = o.table(e).hook;
+    switch (i.type) {
+      case "add":
+        if (c.fire === A)
+          break;
+        return o._promise("readwrite", () => u(i), !0);
+      case "put":
+        if (c.fire === A && l.fire === A)
+          break;
+        return o._promise("readwrite", () => u(i), !0);
+      case "delete":
+        if (a.fire === A)
+          break;
+        return o._promise("readwrite", () => u(i), !0);
+      case "deleteRange":
+        if (a.fire === A)
+          break;
+        return o._promise("readwrite", () => function(h) {
+          return d(h.trans, h.range, 1e4);
+        }(i), !0);
+    }
+    return n.mutate(i);
+    function u(h) {
+      const p = O.trans, g = h.keys || function(y, b) {
+        return b.type === "delete" ? b.keys : b.keys || b.values.map(y.extractKey);
+      }(r, h);
+      if (!g)
+        throw new Error("Keys missing");
+      return (h = h.type === "add" || h.type === "put" ? { ...h, keys: g } : { ...h }).type !== "delete" && (h.values = [...h.values]), h.keys && (h.keys = [...h.keys]), function(y, b, m) {
+        return b.type === "add" ? Promise.resolve([]) : y.getMany({ trans: b.trans, keys: m, cache: "immutable" });
+      }(n, h, g).then((y) => {
+        const b = g.map((m, f) => {
+          const w = y[f], S = { onerror: null, onsuccess: null };
+          if (h.type === "delete")
+            a.fire.call(S, m, w, p);
+          else if (h.type === "add" || w === void 0) {
+            const P = c.fire.call(S, m, h.values[f], p);
+            m == null && P != null && (m = P, h.keys[f] = m, r.outbound || Y(h.values[f], r.keyPath, m));
+          } else {
+            const P = mn(w, h.values[f]), x = l.fire.call(S, P, m, w, p);
+            if (x) {
+              const v = h.values[f];
+              Object.keys(x).forEach((j) => {
+                H(v, j) ? v[j] = x[j] : Y(v, j, x[j]);
+              });
+            }
+          }
+          return S;
+        });
+        return n.mutate(h).then(({ failures: m, results: f, numFailures: w, lastResult: S }) => {
+          for (let P = 0; P < g.length; ++P) {
+            const x = f ? f[P] : g[P], v = b[P];
+            x == null ? v.onerror && v.onerror(m[P]) : v.onsuccess && v.onsuccess(h.type === "put" && y[P] ? h.values[P] : x);
+          }
+          return { failures: m, results: f, numFailures: w, lastResult: S };
+        }).catch((m) => (b.forEach((f) => f.onerror && f.onerror(m)), Promise.reject(m)));
+      });
+    }
+    function d(h, p, g) {
+      return n.query({ trans: h, values: !1, query: { index: r, range: p }, limit: g }).then(({ result: y }) => u({ type: "delete", keys: y, trans: h }).then((b) => b.numFailures > 0 ? Promise.reject(b.failures[0]) : y.length < g ? { failures: [], numFailures: 0, lastResult: void 0 } : d(h, { ...p, lower: y[y.length - 1], lowerOpen: !0 }, g)));
+    }
+  } };
+} }) };
+function or(t, e, n) {
+  try {
+    if (!e || e.keys.length < t.length)
+      return null;
+    const r = [];
+    for (let s = 0, i = 0; s < e.keys.length && i < t.length; ++s)
+      W(e.keys[s], t[i]) === 0 && (r.push(n ? He(e.values[s]) : e.values[s]), ++i);
+    return r.length === t.length ? r : null;
+  } catch {
+    return null;
+  }
+}
+const rs = { stack: "dbcore", level: -1, create: (t) => ({ table: (e) => {
+  const n = t.table(e);
+  return { ...n, getMany: (r) => {
+    if (!r.cache)
+      return n.getMany(r);
+    const s = or(r.keys, r.trans._cache, r.cache === "clone");
+    return s ? E.resolve(s) : n.getMany(r).then((i) => (r.trans._cache = { keys: r.keys, values: r.cache === "clone" ? He(i) : i }, i));
+  }, mutate: (r) => (r.type !== "add" && (r.trans._cache = null), n.mutate(r)) };
+} }) };
+function yn(t) {
+  return !("from" in t);
+}
+const Z = function(t, e) {
+  if (!this) {
+    const n = new Z();
+    return t && "d" in t && z(n, t), n;
+  }
+  z(this, arguments.length ? { d: 1, from: t, to: arguments.length > 1 ? e : t } : { d: 0 });
+};
+function Ge(t, e, n) {
+  const r = W(e, n);
+  if (isNaN(r))
+    return;
+  if (r > 0)
+    throw RangeError();
+  if (yn(t))
+    return z(t, { from: e, to: n, d: 1 });
+  const s = t.l, i = t.r;
+  if (W(n, t.from) < 0)
+    return s ? Ge(s, e, n) : t.l = { from: e, to: n, d: 1, l: null, r: null }, Cn(t);
+  if (W(e, t.to) > 0)
+    return i ? Ge(i, e, n) : t.r = { from: e, to: n, d: 1, l: null, r: null }, Cn(t);
+  W(e, t.from) < 0 && (t.from = e, t.l = null, t.d = i ? i.d + 1 : 1), W(n, t.to) > 0 && (t.to = n, t.r = null, t.d = t.l ? t.l.d + 1 : 1);
+  const o = !t.r;
+  s && !t.l && bt(t, s), i && o && bt(t, i);
+}
+function bt(t, e) {
+  yn(e) || function n(r, { from: s, to: i, l: o, r: a }) {
+    Ge(r, s, i), o && n(r, o), a && n(r, a);
+  }(t, e);
+}
+function ss(t, e) {
+  const n = nn(e);
+  let r = n.next();
+  if (r.done)
+    return !1;
+  let s = r.value;
+  const i = nn(t);
+  let o = i.next(s.from), a = o.value;
+  for (; !r.done && !o.done; ) {
+    if (W(a.from, s.to) <= 0 && W(a.to, s.from) >= 0)
+      return !0;
+    W(s.from, a.from) < 0 ? s = (r = n.next(a.from)).value : a = (o = i.next(s.from)).value;
+  }
+  return !1;
+}
+function nn(t) {
+  let e = yn(t) ? null : { s: 0, n: t };
+  return { next(n) {
+    const r = arguments.length > 0;
+    for (; e; )
+      switch (e.s) {
+        case 0:
+          if (e.s = 1, r)
+            for (; e.n.l && W(n, e.n.from) < 0; )
+              e = { up: e, n: e.n.l, s: 1 };
+          else
+            for (; e.n.l; )
+              e = { up: e, n: e.n.l, s: 1 };
+        case 1:
+          if (e.s = 2, !r || W(n, e.n.to) <= 0)
+            return { value: e.n, done: !1 };
+        case 2:
+          if (e.n.r) {
+            e.s = 3, e = { up: e, n: e.n.r, s: 0 };
+            continue;
+          }
+        case 3:
+          e = e.up;
+      }
+    return { done: !0 };
+  } };
+}
+function Cn(t) {
+  var e, n;
+  const r = (((e = t.r) === null || e === void 0 ? void 0 : e.d) || 0) - (((n = t.l) === null || n === void 0 ? void 0 : n.d) || 0), s = r > 1 ? "r" : r < -1 ? "l" : "";
+  if (s) {
+    const i = s === "r" ? "l" : "r", o = { ...t }, a = t[s];
+    t.from = a.from, t.to = a.to, t[s] = a[s], o[s] = a[i], t[i] = o, o.d = jn(o);
+  }
+  t.d = jn(t);
+}
+function jn({ r: t, l: e }) {
+  return (t ? e ? Math.max(t.d, e.d) : t.d : e ? e.d : 0) + 1;
+}
+Ce(Z.prototype, { add(t) {
+  return bt(this, t), this;
+}, addKey(t) {
+  return Ge(this, t, t), this;
+}, addKeys(t) {
+  return t.forEach((e) => Ge(this, e, e)), this;
+}, [Tt]() {
+  return nn(this);
+} });
+const is = { stack: "dbcore", level: 0, create: (t) => {
+  const e = t.schema.name, n = new Z(t.MIN_KEY, t.MAX_KEY);
+  return { ...t, table: (r) => {
+    const s = t.table(r), { schema: i } = s, { primaryKey: o } = i, { extractKey: a, outbound: c } = o, l = { ...s, mutate: (h) => {
+      const p = h.trans, g = p.mutatedParts || (p.mutatedParts = {}), y = (x) => {
+        const v = `idb://${e}/${r}/${x}`;
+        return g[v] || (g[v] = new Z());
+      }, b = y(""), m = y(":dels"), { type: f } = h;
+      let [w, S] = h.type === "deleteRange" ? [h.range] : h.type === "delete" ? [h.keys] : h.values.length < 50 ? [[], h.values] : [];
+      const P = h.trans._cache;
+      return s.mutate(h).then((x) => {
+        if (L(w)) {
+          f !== "delete" && (w = x.results), b.addKeys(w);
+          const v = or(w, P);
+          v || f === "add" || m.addKeys(w), (v || S) && function(j, _, T, K) {
+            function U(N) {
+              const M = j(N.name || "");
+              function ve(V) {
+                return V != null ? N.extractKey(V) : null;
+              }
+              const we = (V) => N.multiEntry && L(V) ? V.forEach((ue) => M.addKey(ue)) : M.addKey(V);
+              (T || K).forEach((V, ue) => {
+                const Ae = T && ve(T[ue]), _t = K && ve(K[ue]);
+                W(Ae, _t) !== 0 && (Ae != null && we(Ae), _t != null && we(_t));
+              });
+            }
+            _.indexes.forEach(U);
+          }(y, i, v, S);
+        } else if (w) {
+          const v = { from: w.lower, to: w.upper };
+          m.add(v), b.add(v);
+        } else
+          b.add(n), m.add(n), i.indexes.forEach((v) => y(v.name).add(n));
+        return x;
+      });
+    } }, u = ({ query: { index: h, range: p } }) => {
+      var g, y;
+      return [h, new Z((g = p.lower) !== null && g !== void 0 ? g : t.MIN_KEY, (y = p.upper) !== null && y !== void 0 ? y : t.MAX_KEY)];
+    }, d = { get: (h) => [o, new Z(h.key)], getMany: (h) => [o, new Z().addKeys(h.keys)], count: u, query: u, openCursor: u };
+    return R(d).forEach((h) => {
+      l[h] = function(p) {
+        const { subscr: g } = O;
+        if (g) {
+          const y = (S) => {
+            const P = `idb://${e}/${r}/${S}`;
+            return g[P] || (g[P] = new Z());
+          }, b = y(""), m = y(":dels"), [f, w] = d[h](p);
+          if (y(f.name || "").add(w), !f.isPrimaryKey) {
+            if (h !== "count") {
+              const S = h === "query" && c && p.values && s.query({ ...p, values: !1 });
+              return s[h].apply(this, arguments).then((P) => {
+                if (h === "query") {
+                  if (c && p.values)
+                    return S.then(({ result: v }) => (b.addKeys(v), P));
+                  const x = p.values ? P.result.map(a) : P.result;
+                  p.values ? b.addKeys(x) : m.addKeys(x);
+                } else if (h === "openCursor") {
+                  const x = P, v = p.values;
+                  return x && Object.create(x, { key: { get: () => (m.addKey(x.primaryKey), x.key) }, primaryKey: { get() {
+                    const j = x.primaryKey;
+                    return m.addKey(j), j;
+                  } }, value: { get: () => (v && b.addKey(x.primaryKey), x.value) } });
+                }
+                return P;
+              });
+            }
+            m.add(n);
+          }
+        }
+        return s[h].apply(this, arguments);
+      };
+    }), l;
+  } };
+} };
+class me {
+  constructor(e, n) {
+    this._middlewares = {}, this.verno = 0;
+    const r = me.dependencies;
+    this._options = n = { addons: me.addons, autoOpen: !0, indexedDB: r.indexedDB, IDBKeyRange: r.IDBKeyRange, ...n }, this._deps = { indexedDB: n.indexedDB, IDBKeyRange: n.IDBKeyRange };
+    const { addons: s } = n;
+    this._dbSchema = {}, this._versions = [], this._storeNames = [], this._allTables = {}, this.idbdb = null, this._novip = this;
+    const i = { dbOpenError: null, isBeingOpened: !1, onReadyBeingFired: null, openComplete: !1, dbReadyResolve: A, dbReadyPromise: null, cancelOpen: A, openCanceller: null, autoSchema: !0, PR1398_maxLoop: 3 };
+    var o;
+    i.dbReadyPromise = new E((a) => {
+      i.dbReadyResolve = a;
+    }), i.openCanceller = new E((a, c) => {
+      i.cancelOpen = c;
+    }), this._state = i, this.name = e, this.on = Fe(this, "populate", "blocked", "versionchange", "close", { ready: [ln, A] }), this.on.ready.subscribe = Dn(this.on.ready.subscribe, (a) => (c, l) => {
+      me.vip(() => {
+        const u = this._state;
+        if (u.openComplete)
+          u.dbOpenError || E.resolve().then(c), l && a(c);
+        else if (u.onReadyBeingFired)
+          u.onReadyBeingFired.push(c), l && a(c);
+        else {
+          a(c);
+          const d = this;
+          l || a(function h() {
+            d.on.ready.unsubscribe(c), d.on.ready.unsubscribe(h);
+          });
+        }
+      });
+    }), this.Collection = (o = this, De(Ur.prototype, function(a, c) {
+      this.db = o;
+      let l = qn, u = null;
+      if (c)
+        try {
+          l = c();
+        } catch (g) {
+          u = g;
+        }
+      const d = a._ctx, h = d.table, p = h.hook.reading.fire;
+      this._ctx = { table: h, index: d.index, isPrimKey: !d.index || h.schema.primKey.keyPath && d.index === h.schema.primKey.name, range: l, keysOnly: !1, dir: "next", unique: "", algorithm: null, filter: null, replayFilter: null, justLimit: !0, isMatch: null, offset: 0, limit: 1 / 0, error: u, or: d.or, valueMapper: p !== Le ? p : null };
+    })), this.Table = function(a) {
+      return De(Lr.prototype, function(c, l, u) {
+        this.db = a, this._tx = u, this.name = c, this.schema = l, this.hook = a._allTables[c] ? a._allTables[c].hook : Fe(null, { creating: [jr, A], reading: [Cr, Le], updating: [Ar, A], deleting: [Kr, A] });
+      });
+    }(this), this.Transaction = function(a) {
+      return De(Gr.prototype, function(c, l, u, d, h) {
+        this.db = a, this.mode = c, this.storeNames = l, this.schema = u, this.chromeTransactionDurability = d, this.idbtrans = null, this.on = Fe(this, "complete", "error", "abort"), this.parent = h || null, this.active = !0, this._reculock = 0, this._blockedFuncs = [], this._resolve = null, this._reject = null, this._waitingFor = null, this._waitingQueue = null, this._spinCount = 0, this._completion = new E((p, g) => {
+          this._resolve = p, this._reject = g;
+        }), this._completion.then(() => {
+          this.active = !1, this.on.complete.fire();
+        }, (p) => {
+          var g = this.active;
+          return this.active = !1, this.on.error.fire(p), this.parent ? this.parent._reject(p) : g && this.idbtrans && this.idbtrans.abort(), F(p);
+        });
+      });
+    }(this), this.Version = function(a) {
+      return De(Xr.prototype, function(c) {
+        this.db = a, this._cfg = { version: c, storesSource: null, dbschema: {}, tables: {}, contentUpgrade: null };
+      });
+    }(this), this.WhereClause = function(a) {
+      return De(tr.prototype, function(c, l, u) {
+        this.db = a, this._ctx = { table: c, index: l === ":id" ? null : l, or: u };
+        const d = a._deps.indexedDB;
+        if (!d)
+          throw new C.MissingAPI();
+        this._cmp = this._ascending = d.cmp.bind(d), this._descending = (h, p) => d.cmp(p, h), this._max = (h, p) => d.cmp(h, p) > 0 ? h : p, this._min = (h, p) => d.cmp(h, p) < 0 ? h : p, this._IDBKeyRange = a._deps.IDBKeyRange;
+      });
+    }(this), this.on("versionchange", (a) => {
+      a.newVersion > 0 ? console.warn(`Another connection wants to upgrade database '${this.name}'. Closing db now to resume the upgrade.`) : console.warn(`Another connection wants to delete database '${this.name}'. Closing db now to resume the delete request.`), this.close();
+    }), this.on("blocked", (a) => {
+      !a.newVersion || a.newVersion < a.oldVersion ? console.warn(`Dexie.delete('${this.name}') was blocked`) : console.warn(`Upgrade '${this.name}' blocked by other connection holding version ${a.oldVersion / 10}`);
+    }), this._maxKey = Ve(n.IDBKeyRange), this._createTransaction = (a, c, l, u) => new this.Transaction(a, c, l, this._options.chromeTransactionDurability, u), this._fireOnBlocked = (a) => {
+      this.on("blocked").fire(a), Re.filter((c) => c.name === this.name && c !== this && !c._state.vcFired).map((c) => c.on("versionchange").fire(a));
+    }, this.use(ts), this.use(ns), this.use(is), this.use(rs), this.vip = Object.create(this, { _vip: { value: !0 } }), s.forEach((a) => a(this));
+  }
+  version(e) {
+    if (isNaN(e) || e < 0.1)
+      throw new C.Type("Given version is not a positive number");
+    if (e = Math.round(10 * e) / 10, this.idbdb || this._state.isBeingOpened)
+      throw new C.Schema("Cannot add version when database is open");
+    this.verno = Math.max(this.verno, e);
+    const n = this._versions;
+    var r = n.filter((s) => s._cfg.version === e)[0];
+    return r || (r = new this.Version(e), n.push(r), n.sort(Qr), r.stores({}), this._state.autoSchema = !1, r);
+  }
+  _whenReady(e) {
+    return this.idbdb && (this._state.openComplete || O.letThrough || this._vip) ? e() : new E((n, r) => {
+      if (this._state.openComplete)
+        return r(new C.DatabaseClosed(this._state.dbOpenError));
+      if (!this._state.isBeingOpened) {
+        if (!this._options.autoOpen)
+          return void r(new C.DatabaseClosed());
+        this.open().catch(A);
+      }
+      this._state.dbReadyPromise.then(n, r);
+    }).then(e);
+  }
+  use({ stack: e, create: n, level: r, name: s }) {
+    s && this.unuse({ stack: e, name: s });
+    const i = this._middlewares[e] || (this._middlewares[e] = []);
+    return i.push({ stack: e, create: n, level: r ?? 10, name: s }), i.sort((o, a) => o.level - a.level), this;
+  }
+  unuse({ stack: e, name: n, create: r }) {
+    return e && this._middlewares[e] && (this._middlewares[e] = this._middlewares[e].filter((s) => r ? s.create !== r : !!n && s.name !== n)), this;
+  }
+  open() {
+    return qr(this);
+  }
+  _close() {
+    const e = this._state, n = Re.indexOf(this);
+    if (n >= 0 && Re.splice(n, 1), this.idbdb) {
+      try {
+        this.idbdb.close();
+      } catch {
+      }
+      this._novip.idbdb = null;
+    }
+    e.dbReadyPromise = new E((r) => {
+      e.dbReadyResolve = r;
+    }), e.openCanceller = new E((r, s) => {
+      e.cancelOpen = s;
+    });
+  }
+  close() {
+    this._close();
+    const e = this._state;
+    this._options.autoOpen = !1, e.dbOpenError = new C.DatabaseClosed(), e.isBeingOpened && e.cancelOpen(e.dbOpenError);
+  }
+  delete() {
+    const e = arguments.length > 0, n = this._state;
+    return new E((r, s) => {
+      const i = () => {
+        this.close();
+        var o = this._deps.indexedDB.deleteDatabase(this.name);
+        o.onsuccess = I(() => {
+          (function({ indexedDB: a, IDBKeyRange: c }, l) {
+            !pn(a) && l !== wt && fn(a, c).delete(l).catch(A);
+          })(this._deps, this.name), r();
+        }), o.onerror = Q(s), o.onblocked = this._fireOnBlocked;
+      };
+      if (e)
+        throw new C.InvalidArgument("Arguments not allowed in db.delete()");
+      n.isBeingOpened ? n.dbReadyPromise.then(i) : i();
+    });
+  }
+  backendDB() {
+    return this.idbdb;
+  }
+  isOpen() {
+    return this.idbdb !== null;
+  }
+  hasBeenClosed() {
+    const e = this._state.dbOpenError;
+    return e && e.name === "DatabaseClosed";
+  }
+  hasFailed() {
+    return this._state.dbOpenError !== null;
+  }
+  dynamicallyOpened() {
+    return this._state.autoSchema;
+  }
+  get tables() {
+    return R(this._allTables).map((e) => this._allTables[e]);
+  }
+  transaction() {
+    const e = es.apply(this, arguments);
+    return this._transaction.apply(this, e);
+  }
+  _transaction(e, n, r) {
+    let s = O.trans;
+    s && s.db === this && e.indexOf("!") === -1 || (s = null);
+    const i = e.indexOf("?") !== -1;
+    let o, a;
+    e = e.replace("!", "").replace("?", "");
+    try {
+      if (a = n.map((l) => {
+        var u = l instanceof this.Table ? l.name : l;
+        if (typeof u != "string")
+          throw new TypeError("Invalid table argument to Dexie.transaction(). Only Table or String are allowed");
+        return u;
+      }), e == "r" || e === xt)
+        o = xt;
+      else {
+        if (e != "rw" && e != St)
+          throw new C.InvalidArgument("Invalid transaction mode: " + e);
+        o = St;
+      }
+      if (s) {
+        if (s.mode === xt && o === St) {
+          if (!i)
+            throw new C.SubTransaction("Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY");
+          s = null;
+        }
+        s && a.forEach((l) => {
+          if (s && s.storeNames.indexOf(l) === -1) {
+            if (!i)
+              throw new C.SubTransaction("Table " + l + " not included in parent transaction.");
+            s = null;
+          }
+        }), i && s && !s.active && (s = null);
+      }
+    } catch (l) {
+      return s ? s._promise(null, (u, d) => {
+        d(l);
+      }) : F(l);
+    }
+    const c = ir.bind(null, this, o, a, s, r);
+    return s ? s._promise(o, c, "lock") : O.trans ? Ke(O.transless, () => this._whenReady(c)) : this._whenReady(c);
+  }
+  table(e) {
+    if (!H(this._allTables, e))
+      throw new C.InvalidTable(`Table ${e} does not exist`);
+    return this._allTables[e];
+  }
+}
+const os = typeof Symbol < "u" && "observable" in Symbol ? Symbol.observable : "@@observable";
+class as {
+  constructor(e) {
+    this._subscribe = e;
+  }
+  subscribe(e, n, r) {
+    return this._subscribe(e && typeof e != "function" ? e : { next: e, error: n, complete: r });
+  }
+  [os]() {
+    return this;
+  }
+}
+function ar(t, e) {
+  return R(e).forEach((n) => {
+    bt(t[n] || (t[n] = new Z()), e[n]);
+  }), t;
+}
+function cs(t) {
+  let e, n = !1;
+  const r = new as((s) => {
+    const i = on(t);
+    let o = !1, a = {}, c = {};
+    const l = { get closed() {
+      return o;
+    }, unsubscribe: () => {
+      o = !0, le.storagemutated.unsubscribe(p);
+    } };
+    s.start && s.start(l);
+    let u = !1, d = !1;
+    function h() {
+      return R(c).some((y) => a[y] && ss(a[y], c[y]));
+    }
+    const p = (y) => {
+      ar(a, y), h() && g();
+    }, g = () => {
+      if (u || o)
+        return;
+      a = {};
+      const y = {}, b = function(m) {
+        i && je();
+        const f = () => ae(t, { subscr: m, trans: null }), w = O.trans ? Ke(O.transless, f) : f();
+        return i && w.then(re, re), w;
+      }(y);
+      d || (le(ze, p), d = !0), u = !0, Promise.resolve(b).then((m) => {
+        n = !0, e = m, u = !1, o || (h() ? g() : (a = {}, c = y, s.next && s.next(m)));
+      }, (m) => {
+        u = !1, n = !1, s.error && s.error(m), l.unsubscribe();
+      });
+    };
+    return g(), l;
+  });
+  return r.hasValue = () => n, r.getValue = () => e, r;
+}
+let rn;
+try {
+  rn = { indexedDB: D.indexedDB || D.mozIndexedDB || D.webkitIndexedDB || D.msIndexedDB, IDBKeyRange: D.IDBKeyRange || D.webkitIDBKeyRange };
+} catch {
+  rn = { indexedDB: null, IDBKeyRange: null };
+}
+const he = me;
+function ut(t) {
+  let e = ee;
+  try {
+    ee = !0, le.storagemutated.fire(t);
+  } finally {
+    ee = e;
+  }
+}
+Ce(he, { ...st, delete: (t) => new he(t, { addons: [] }).delete(), exists: (t) => new he(t, { addons: [] }).open().then((e) => (e.close(), !0)).catch("NoSuchDatabaseError", () => !1), getDatabaseNames(t) {
+  try {
+    return function({ indexedDB: e, IDBKeyRange: n }) {
+      return pn(e) ? Promise.resolve(e.databases()).then((r) => r.map((s) => s.name).filter((s) => s !== wt)) : fn(e, n).toCollection().primaryKeys();
+    }(he.dependencies).then(t);
+  } catch {
+    return F(new C.MissingAPI());
+  }
+}, defineClass: () => function(t) {
+  z(this, t);
+}, ignoreTransaction: (t) => O.trans ? Ke(O.transless, t) : t(), vip: en, async: function(t) {
+  return function() {
+    try {
+      var e = tn(t.apply(this, arguments));
+      return e && typeof e.then == "function" ? e : E.resolve(e);
+    } catch (n) {
+      return F(n);
+    }
+  };
+}, spawn: function(t, e, n) {
+  try {
+    var r = tn(t.apply(n, e || []));
+    return r && typeof r.then == "function" ? r : E.resolve(r);
+  } catch (s) {
+    return F(s);
+  }
+}, currentTransaction: { get: () => O.trans || null }, waitFor: function(t, e) {
+  const n = E.resolve(typeof t == "function" ? he.ignoreTransaction(t) : t).timeout(e || 6e4);
+  return O.trans ? O.trans.waitFor(n) : n;
+}, Promise: E, debug: { get: () => J, set: (t) => {
+  Fn(t, t === "dexie" ? () => !0 : Zn);
+} }, derive: Se, extend: z, props: Ce, override: Dn, Events: Fe, on: le, liveQuery: cs, extendObservabilitySet: ar, getByKeyPath: ne, setByKeyPath: Y, delByKeyPath: function(t, e) {
+  typeof e == "string" ? Y(t, e, void 0) : "length" in e && [].map.call(e, function(n) {
+    Y(t, n, void 0);
+  });
+}, shallowClone: Tn, deepClone: He, getObjectDiff: mn, cmp: W, asap: In, minKey: Gt, addons: [], connections: Re, errnames: cn, dependencies: rn, semVer: kn, version: kn.split(".").map((t) => parseInt(t)).reduce((t, e, n) => t + e / Math.pow(10, 2 * n)) }), he.maxKey = Ve(he.dependencies.IDBKeyRange), typeof dispatchEvent < "u" && typeof addEventListener < "u" && (le(ze, (t) => {
+  if (!ee) {
+    let e;
+    vt ? (e = document.createEvent("CustomEvent"), e.initCustomEvent(oe, !0, !0, t)) : e = new CustomEvent(oe, { detail: t }), ee = !0, dispatchEvent(e), ee = !1;
+  }
+}), addEventListener(oe, ({ detail: t }) => {
+  ee || ut(t);
+}));
+let ee = !1;
+if (typeof BroadcastChannel < "u") {
+  const t = new BroadcastChannel(oe);
+  typeof t.unref == "function" && t.unref(), le(ze, (e) => {
+    ee || t.postMessage(e);
+  }), t.onmessage = (e) => {
+    e.data && ut(e.data);
+  };
+} else if (typeof self < "u" && typeof navigator < "u") {
+  le(ze, (e) => {
+    try {
+      ee || (typeof localStorage < "u" && localStorage.setItem(oe, JSON.stringify({ trig: Math.random(), changedParts: e })), typeof self.clients == "object" && [...self.clients.matchAll({ includeUncontrolled: !0 })].forEach((n) => n.postMessage({ type: oe, changedParts: e })));
+    } catch {
+    }
+  }), typeof addEventListener < "u" && addEventListener("storage", (e) => {
+    if (e.key === oe) {
+      const n = JSON.parse(e.newValue);
+      n && ut(n.changedParts);
+    }
+  });
+  const t = self.document && navigator.serviceWorker;
+  t && t.addEventListener("message", function({ data: e }) {
+    e && e.type === oe && ut(e.changedParts);
+  });
+}
+E.rejectionMapper = function(t, e) {
+  if (!t || t instanceof Ee || t instanceof TypeError || t instanceof SyntaxError || !t.name || !bn[t.name])
+    return t;
+  var n = new bn[t.name](e || t.message, t);
+  return "stack" in t && te(n, "stack", { get: function() {
+    return this.inner.stack;
+  } }), n;
+}, Fn(J, Zn);
+const B = (t) => {
+  let e = `${t.type}.${t.topics}`;
+  return t.hasOwnProperty("order") && (e += `.${t.order}`), t.hasOwnProperty("period") && (e += `.${t.period}`), e;
+};
+function Je(t, e) {
+  var n;
+  switch (t.moderation) {
+    case "before":
+      const r = /* @__PURE__ */ new Date(), s = (n = t.beforeTime) == null ? void 0 : n.split(":"), i = parseInt(s ? s[0] : "00"), o = parseInt(s ? s[1] : "00"), a = parseInt(s ? s[2] : "00");
+      e.before = r.setHours(i, o, a, 0) / 1e3, e.hasOwnProperty("period") || (e.period = r.getDay() === 1 ? 72 : 24);
+      break;
+    case "delayed":
+      t.delay && t.delay > 0 && (e.delay = `${t.delay}`);
+      break;
+    case "approved":
+      e.approved = "1";
+      break;
+    default:
+      t.period !== 0 && (e.period = t.period);
+  }
+  return e;
+}
+class ls {
+  constructor(e) {
+    k(this, "db");
+    k(this, "subscribers", []);
+    k(this, "options");
+    k(this, "setCloud", async (e, n) => {
+      n !== "" && await this.db.table("cloud").put({
+        id: e.widget,
+        dashboard_id: e.dashboard,
+        data: n
+      });
+    });
+    k(this, "getCloud", async (e) => {
+      const n = await this.db.table(Kn).where({ id: e.widget }).last();
+      return n.presentation = (e == null ? void 0 : e.presentation) || "not set", n.slide = (e == null ? void 0 : e.slide) || "not set", n ?? { data: null };
+    });
+    k(this, "setSeries", async (e, n) => {
+      n !== "" && await this.db.table(Dt).put({
+        id: e.widget,
+        dashboard_id: e.dashboard,
+        data: n.data
+      });
+    });
+    k(this, "getSeries", async (e) => {
+      const n = await this.db.table(Dt).where({ id: e.widget }).last();
+      return n.presentation = (e == null ? void 0 : e.presentation) || "not set", n.slide = (e == null ? void 0 : e.slide) || "not set", n ?? { data: null };
+    });
+    k(this, "setMessages", async (e, n) => {
+      const r = n.title;
+      n.messages.forEach((s) => {
+        var i, o, a;
+        this.db.table(Oe).put({ id: s.id, utc: s.utc, data: s }), this.db.table(dr).put({
+          widget_id: e.widget,
+          message_id: s.id,
+          dashboard_id: e.dashboard,
+          title: r,
+          engagement: (i = s.dynamics) == null ? void 0 : i.engagement,
+          impressions: (o = s.dynamics) == null ? void 0 : o.semrush_visits,
+          reach: (a = s.dynamics) == null ? void 0 : a.potential_reach,
+          sentiment: s.topics[0].sentiment,
+          utc: s.utc
+        });
+      });
+    });
+    k(this, "getMessages", async (e) => {
+      const n = (l) => l.widget_id === e.widget, r = (l) => l.utc > ((e == null ? void 0 : e.since) || 0), s = (l) => !l.hasOwnProperty("visible") || (l == null ? void 0 : l.visible) !== 0, i = await this.db.table("topics").orderBy("utc").reverse().filter(n).filter(r).filter(s).limit((e == null ? void 0 : e.limit) ?? 25).toArray(), o = i[0].title || "No results", a = i.map((l) => l.message_id), c = await this.db.table("messages").where("id").anyOf(a).toArray().then((l) => l.sort(function(u, d) {
+        return d.utc - u.utc;
+      }));
+      return {
+        data: {
+          presentation: (e == null ? void 0 : e.presentation) || "not set",
+          slide: (e == null ? void 0 : e.slide) || "not set",
+          messages: c.map((l) => l.data),
+          title: o,
+          topics: [e.dashboard, e.widget].join("-"),
+          query: e
+        }
+      };
+    });
+    k(this, "cleanMessages", async (e) => {
+      const n = Date.now() / 1e3, r = (s) => s.utc < e - n;
+      await this.db.table("topics").orderBy("utc").filter(r).modify((s, i) => {
+        delete i.value;
+      });
+    });
+    k(this, "subscribe", (e) => {
+      var r;
+      if (e.widget === void 0) {
+        const s = (r = e.topics) == null ? void 0 : r.split("-");
+        e.dashboard = s ? s[0] : "", e.widget = s ? s[1] : "";
+      }
+      this.subscribers.filter((s) => s.widget == e.widget).length > 0 || (e.type === Oe && (e = Je(this.options, e)), console.log("[storage] subscribe", e), this.subscribers.push(e));
+    });
+    this.options = e, this.db = new me(e.app), this.db.version(2).stores({
+      player: "id,title,name,location",
+      monitor: "id,player_id,cols,rows,order,width,height,physicalwidth,physicalheight,devicePixelRatio,screenLeft,screenTop,orientation,monitor",
+      display: "id,monitor_id,presentation_id,colstart,colend,rowstart,rowend",
+      channel: "id,slide_index",
+      presentation: "id,name,data",
+      cloud: "id,dashboard_id,data",
+      messages: "id,utc,visible,data",
+      series: "id,dashboard_id,data",
+      topics: "[widget_id+message_id],widget_id,dashboard_id,title,engagement,impressions,reach,sentiment,visible,utc",
+      widgets: "id,dashboard_id,type"
+    }), this.db.open();
+  }
+  getSubscribers() {
+    return this.subscribers;
+  }
+}
+function gn(t) {
+  return new Promise((e, n) => {
+    t.oncomplete = t.onsuccess = () => e(t.result), t.onabort = t.onerror = () => n(t.error);
+  });
+}
+function us(t, e) {
+  const n = indexedDB.open(t);
+  n.onupgradeneeded = () => n.result.createObjectStore(e);
+  const r = gn(n);
+  return (s, i) => r.then((o) => i(o.transaction(e, s).objectStore(e)));
+}
+let jt;
+function cr() {
+  return jt || (jt = us("keyval-store", "keyval")), jt;
+}
+function Kt(t, e = cr()) {
+  return e("readonly", (n) => gn(n.get(t)));
+}
+function At(t, e, n = cr()) {
+  return n("readwrite", (r) => (r.put(e, t), gn(r.transaction)));
+}
+class hs {
+  constructor(e) {
+    k(this, "subscribers", []);
+    k(this, "options");
+    k(this, "setCloud", async (e, n) => {
+      const r = B(e);
+      await At(r, n);
+    });
+    k(this, "getCloud", async (e) => {
+      const n = B(e);
+      return await Kt(n);
+    });
+    k(this, "setSeries", async (e, n) => {
+      const r = B(e);
+      await At(r, n);
+    });
+    k(this, "getSeries", async (e) => {
+      const n = B(e);
+      return await Kt(n);
+    });
+    k(this, "setMessages", async (e, n) => {
+      const r = B(e);
+      await At(r, n);
+    });
+    k(this, "getMessages", async (e) => {
+      const n = B(e);
+      return await Kt(n);
+    });
+    k(this, "cleanMessages", async (e) => {
+      console.log("cleanMessages not implemented for ", this.options.storage);
+    });
+    k(this, "subscribe", (e) => {
+      var r;
+      if (e.widget === void 0) {
+        const s = (r = e.topics) == null ? void 0 : r.split("-");
+        e.dashboard = s ? s[0] : "", e.widget = s ? s[1] : "";
+      }
+      e.type === "messages" && (e = Je(this.options, e)), !this.subscribers.filter((s) => s.widget == e.widget).length && this.subscribers.push(e);
+    });
+    this.options = e;
+  }
+  getSubscribers() {
+    return this.subscribers;
+  }
+}
+class ds {
+  constructor(e) {
+    k(this, "subscribers", []);
+    k(this, "options");
+    k(this, "setCloud", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.localStorage.setObject(r, n));
+      });
+    });
+    k(this, "getCloud", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.localStorage.getObject(n));
+      });
+    });
+    k(this, "setSeries", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.localStorage.setObject(r, n));
+      });
+    });
+    k(this, "getSeries", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.localStorage.getObject(n));
+      });
+    });
+    k(this, "setMessages", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.localStorage.setObject(r, n));
+      });
+    });
+    k(this, "getMessages", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.localStorage.getObject(n));
+      });
+    });
+    k(this, "cleanMessages", async (e) => {
+      console.log("cleanMessages not implemented for ", this.options.storage);
+    });
+    k(this, "setWidget", async (e) => {
+      let n = `widget.${e.widget}`;
+      return new Promise(async (r) => {
+        r(window.localStorage.setObject(n, e));
+      });
+    });
+    k(this, "subscribe", (e) => {
+      var r;
+      if (e.widget === void 0) {
+        const s = (r = e.topics) == null ? void 0 : r.split("-");
+        e.dashboard = s ? s[0] : "", e.widget = s ? s[1] : "";
+      }
+      e.type === Oe && (e = Je(this.options, e)), !this.subscribers.filter((s) => s.widget == e.widget).length && this.subscribers.push(e);
+    });
+    this.options = e, Storage.prototype.setObject = function(n, r) {
+      this.setItem(n, JSON.stringify(r));
+    }, Storage.prototype.getObject = function(n) {
+      const r = this.getItem(n);
+      return r && JSON.parse(r);
+    };
+  }
+  getSubscribers() {
+    return this.subscribers;
+  }
+}
+class fs {
+  constructor(e) {
+    k(this, "subscribers", []);
+    k(this, "options");
+    k(this, "setCloud", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.sessionStorage.setObject(r, n));
+      });
+    });
+    k(this, "getCloud", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.sessionStorage.getObject(n));
+      });
+    });
+    k(this, "setSeries", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.sessionStorage.setObject(r, n));
+      });
+    });
+    k(this, "getSeries", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.sessionStorage.getObject(n));
+      });
+    });
+    k(this, "setMessages", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.sessionStorage.setObject(r, n));
+      });
+    });
+    k(this, "getMessages", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.sessionStorage.getObject(n));
+      });
+    });
+    k(this, "cleanMessages", async (e) => {
+      console.log("cleanMessages not implemented for ", this.options.storage);
+    });
+    k(this, "setWidget", async (e) => {
+      let n = `widget.${e.widget}`;
+      return new Promise(async (r) => {
+        r(window.sessionStorage.setObject(n, e));
+      });
+    });
+    k(this, "subscribe", (e) => {
+      var r;
+      if (e.widget === void 0) {
+        const s = (r = e.topics) == null ? void 0 : r.split("-");
+        e.dashboard = s ? s[0] : "", e.widget = s ? s[1] : "";
+      }
+      e.type === Oe && (e = Je(this.options, e)), !this.subscribers.filter(
+        (s) => s.widget == e.widget
+      ).length && this.subscribers.push(e);
+    });
+    this.options = e, Storage.prototype.setObject = function(n, r) {
+      this.setItem(n, JSON.stringify(r));
+    }, Storage.prototype.getObject = function(n) {
+      const r = this.getItem(n);
+      return r && JSON.parse(r);
+    };
+  }
+  getSubscribers() {
+    return this.subscribers;
+  }
+}
+class ps {
+  constructor(e) {
+    k(this, "subscribers", []);
+    k(this, "options");
+    k(this, "setCloud", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.BuzzCasting.WidgetData[r] = n);
+      });
+    });
+    k(this, "getCloud", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.localStorage.getObject(n));
+      });
+    });
+    k(this, "setSeries", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.localStorage.setObject(r, n));
+      });
+    });
+    k(this, "getSeries", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.localStorage.getObject(n));
+      });
+    });
+    k(this, "setMessages", async (e, n) => {
+      const r = B(e);
+      return new Promise(async (s) => {
+        s(window.localStorage.setObject(r, n));
+      });
+    });
+    k(this, "getMessages", async (e) => {
+      const n = B(e);
+      return new Promise(async (r) => {
+        r(window.localStorage.getObject(n));
+      });
+    });
+    k(this, "cleanMessages", async (e) => {
+      console.log("cleanMessages not implemented for ", this.options.storage);
+    });
+    k(this, "setWidget", async (e) => {
+      let n = `widget.${e.widget}`;
+      return new Promise(async (r) => {
+        r(window.localStorage.setObject(n, e));
+      });
+    });
+    k(this, "subscribe", (e) => {
+      var r;
+      if (e.widget === void 0) {
+        const s = (r = e.topics) == null ? void 0 : r.split("-");
+        e.dashboard = s ? s[0] : "", e.widget = s ? s[1] : "";
+      }
+      e.type === Oe && (e = Je(this.options, e)), !this.subscribers.filter((s) => s.widget == e.widget).length && this.subscribers.push(e);
+    });
+    this.options = e, window.BuzzCasting.WidgetData = /* @__PURE__ */ new Set();
+  }
+  getSubscribers() {
+    return this.subscribers;
+  }
+}
+class ys {
+  //private options: IStorageManager
+  constructor(e) {
+    k(this, "sm");
+    k(this, "api");
+    k(this, "bc");
+    k(this, "options");
+    k(this, "update", async () => {
+      var r;
+      const e = (r = this.sm) == null ? void 0 : r.getSubscribers();
+      if ((e == null ? void 0 : e.length) === 0)
+        return;
+      const n = [];
+      e == null || e.forEach((s) => {
+        n.push(this.api.get(s));
+      }), await Promise.allSettled(n).then(
+        (s) => s.forEach((i) => {
+          var o, a, c;
+          if (i.status === "fulfilled") {
+            const l = i.value;
+            switch (l.query.type) {
+              case Oe:
+                (o = this.sm) == null || o.setMessages(l.query, l.data);
+                break;
+              case Kn:
+                (a = this.sm) == null || a.setCloud(l.query, l.data);
+                break;
+              case Dt:
+                (c = this.sm) == null || c.setSeries(l.query, l.data);
+                break;
+              default:
+                console.warn(`data type ${l.query.type} unknown`);
+            }
+            console.debug("[store]", l.data.title ?? l.query.widget), this.bc.postMessage({ event: "widget-update", data: l.query });
+          } else
+            console.warn("[store error]");
+        })
+      );
+    });
+    k(this, "hide", (e) => {
+      this.api.hideMessage(e);
+    });
+    k(this, "actions", async (e) => {
+      var n;
+      switch (e.data.event) {
+        case "subscribe":
+          (n = this.sm) == null || n.subscribe(e.data.data);
+          break;
+        case "update":
+          console.debug("[sm] update", e.data), await this.update();
+          break;
+      }
+    });
+    k(this, "getCloud", async (e) => {
+      var n;
+      return await ((n = this.sm) == null ? void 0 : n.getCloud(e));
+    });
+    k(this, "getSeries", async (e) => {
+      var n;
+      return await ((n = this.sm) == null ? void 0 : n.getSeries(e));
+    });
+    k(this, "getMessages", async (e) => {
+      var n;
+      return await ((n = this.sm) == null ? void 0 : n.getMessages(e));
+    });
+    k(this, "cleanMessages", async () => {
+      var n, r;
+      const e = ((n = this.options) == null ? void 0 : n.retention) || 345600;
+      return await ((r = this.sm) == null ? void 0 : r.cleanMessages(e));
+    });
+    k(this, "getSubscribers", async () => {
+      var e;
+      return await ((e = this.sm) == null ? void 0 : e.getSubscribers());
+    });
+    switch (this.options = e, this.bc = new BroadcastChannel(e.app), console.debug("[sm] broadcast channel", e.app), this.bc.onmessage = (n) => {
+      this.actions(n);
+    }, this.bc.postMessage({ event: "sm-init", data: {} }), this.api = new hr(e), e.storage) {
+      case yr:
+        this.sm = new ls(e);
+        break;
+      case pr:
+        this.sm = new fs(e);
+        break;
+      case mr:
+        this.sm = new ds(e);
+        break;
+      case fr:
+        this.sm = new hs(e);
+        break;
+      case gr:
+        this.sm = new ps(e);
+        break;
+      default:
+        this.sm = null;
+    }
+  }
+}
+export {
+  ys as default
+};