@nylas/react 1.0.0-prealpha1

package/dist/index-2b85580a-f9211f23.js

@@ -0,0 +1,3238 @@
+import { d as T, u as or, e as dn } from "./utils-5074a070-ce33ee6b.js";
+import { a as fn, f as pn } from "./index-4f65b6f9.js";
+class ar {
+  constructor(e, n, r = !0, s) {
+    this.automaticComponentRegistration = !0, this.registeredComponents = {}, this.propStateRegistrations = /* @__PURE__ */ new Map(), this.eventListenerRegistrations = /* @__PURE__ */ new Map(), this.host = e, this.stores = n, this.automaticComponentRegistration = r, this.eventOverrides = s, T(`[${this.hostTagName}] Initializing (abstract) provider.`, { eventOverrides: s }), this.registerComponent = this.registerComponent.bind(this), this.getStore = this.getStore.bind(this), Object.keys(this.stores).forEach((i) => {
+      this.propStateRegistrations.set(i, /* @__PURE__ */ new Map());
+    });
+  }
+  async componentWillLoad(e) {
+    T(`[${this.hostTagName}] Will load`), this.setupStoreListeners(), this.nylasConnector = e;
+    const n = Array.from(this.host.querySelectorAll("*")).filter((r) => r.tagName.toLowerCase().startsWith("nylas-"));
+    T(`[${this.hostTagName}] Found ${n.length} child component(s).`, { childComponents: n }), n.forEach((r) => {
+      const s = r;
+      if (!s) {
+        T(`[~${this.hostTagName}] Component ${s.tagName} does not have a name. Skipping.`);
+        return;
+      }
+      if (!s.registerNylasComponent) {
+        T(`[~${this.hostTagName}] Component ${s.tagName} is not a component that can be registered. Skipping.`, { component: s });
+        return;
+      }
+      const i = {
+        element: s,
+        name: s.tagName.toLowerCase(),
+        getStoresToProp: s.getStoresToProp,
+        storeToProps: s.storeToProps,
+        stateToProps: s.stateToProps,
+        authToProp: s.authToProp,
+        eventToProps: s.eventToProps,
+        connectorToProp: s.connectorToProp
+      };
+      this.registerComponent(i);
+    });
+  }
+  async componentDidLoad() {
+    T(`[${this.hostTagName}] Did load`);
+  }
+  async componentDisconnected() {
+    Object.values(this.stores).forEach((e) => {
+      e.dispose();
+    });
+  }
+  async registerComponentHandler(e) {
+    if (e.stopPropagation(), !this.automaticComponentRegistration) {
+      T(`[${this.hostTagName}] Automatic component registration disabled. Skipping registration of ${e.detail.name}.`);
+      return;
+    }
+    this.registerComponent(e.detail);
+  }
+  async unregisterComponentHandler(e) {
+    if (e.stopPropagation(), !this.automaticComponentRegistration) {
+      T(`[${this.hostTagName}] Automatic component registration disabled. Skipping unregistration of ${e.detail.name}.`);
+      return;
+    }
+    this.unregisterComponent(e.detail);
+  }
+  registerComponent(e) {
+    T(`[${this.hostTagName}] Registering component ${e.name}.`);
+    const n = e.element.dataset.nylasId;
+    if (n && this.registeredComponents[n]) {
+      T(`[${this.hostTagName}] Component ${e.name} already registered. Skipping.`);
+      return;
+    }
+    const { stateToProps: r, getStoresToProp: s, eventToProps: i, storeToProps: o, connectorToProp: u, element: a } = e;
+    a.dataset.nylasId = or(), this.registeredComponents[a.dataset.nylasId] = e;
+    const l = this.eventOverrides;
+    i == null || i.forEach((h, c) => {
+      var y;
+      const d = this.nylasConnector, m = async (g) => {
+        T(`[${this.hostTagName}] Handling "${e.name}" prop "${String(c)}" event.`, { eventOverrides: l }), c in l && (T(`[${this.hostTagName}] Found event override for "${String(c)}" event. Calling override.`), await l[c](g, d)), g.defaultPrevented || await h(g, d);
+      }, p = e.element.dataset.nylasId;
+      p && !this.eventListenerRegistrations.has(p) && this.eventListenerRegistrations.set(p, []), p && ((y = this.eventListenerRegistrations.get(p)) == null || y.push([a, c, m])), T(`[${this.hostTagName}] Setting "${e.name}" event "${String(c)}" to automcially call NylasConnector method.`);
+      const f = dn(c.toString());
+      T(`[${this.hostTagName}] Adding event listener for "${f}" on "${a.tagName}"`), a.addEventListener(f, m);
+    }), r == null || r.forEach((h, c) => {
+      var y, g, v, b;
+      const [d, m] = c.split("."), f = this.getStore(d).state[m];
+      if (!a.dataset.nylasId) {
+        T(`[${this.hostTagName}] Component "${e.name}" not registered. Skipping.`, { component: e });
+        return;
+      }
+      this.propStateRegistrations.has(d) || this.propStateRegistrations.set(d, /* @__PURE__ */ new Map()), (y = this.propStateRegistrations.get(d)) != null && y.has(m) ? (b = (v = this.propStateRegistrations.get(d)) == null ? void 0 : v.get(m)) == null || b.push({
+        elementId: a.dataset.nylasId,
+        propKey: h
+      }) : (g = this.propStateRegistrations.get(d)) == null || g.set(m, [
+        {
+          elementId: a.dataset.nylasId,
+          propKey: h
+        }
+      ]), a[h.toString()] = f, T(`[${this.hostTagName}] Setting "${e.name}" prop "${h.toString()}" to "${c}" value.`, { stateValue: f });
+    }), s && (a[s == null ? void 0 : s.toString()] = this.getStore, T(`[${this.hostTagName}] Setting "${e.name}" prop "${s.toString()}" to "getStore" method.`)), o == null || o.forEach((h, c) => {
+      const d = this.getStore(c);
+      a[h.toString()] = d, T(`[${this.hostTagName}] Setting "${e.name}" prop "${h.toString()}" to "${c}" store.`, { store: d });
+    }), u && (a[u == null ? void 0 : u.toString()] = this.nylasConnector, T(`[${this.hostTagName}] Setting "${e.name}" prop "${u.toString()}" to "nylasConnector" value.`, { connectorToProp: u })), T(`[${this.hostTagName}] Component ${e.name} registered.`);
+  }
+  unregisterComponent(e) {
+    T(`[${this.hostTagName}] Unregistering component ${e.name}.`);
+    const n = e.element.dataset.nylasId;
+    if (!n) {
+      T(`[${this.hostTagName}] Component ${e.name} not registered. Skipping.`);
+      return;
+    }
+    if (this.registeredComponents[n]) {
+      T(`[${this.hostTagName}] Component ${e.name} not registered. Skipping.`);
+      return;
+    }
+    this.propStateRegistrations.forEach((s, i) => {
+      s.forEach((o, u) => {
+        var h, c;
+        const a = (h = this.propStateRegistrations.get(i)) == null ? void 0 : h.get(u), l = a == null ? void 0 : a.filter((d) => d.elementId !== n);
+        l && ((c = this.propStateRegistrations.get(i)) == null || c.set(u, l));
+      });
+    });
+    const r = this.eventListenerRegistrations.get(n);
+    r == null || r.forEach(([s, i, o]) => {
+      const u = dn(i.toString());
+      T(`[${this.hostTagName}] Removing event listener for "${u}" on "${s.tagName}"`), s.removeEventListener(u, o);
+    }), delete this.registeredComponents[n];
+  }
+  getStore(e) {
+    const n = this.stores[e];
+    if (!n)
+      throw new Error(`[${this.hostTagName}] Store "${e.toString()}" not found.`);
+    return n;
+  }
+  async setupStoreListeners() {
+    const e = this;
+    Object.entries(this.stores).forEach(([n, r]) => {
+      T(`[${e.hostTagName}] Listening for changes in "${n}" store.`), r.use({
+        set(s, i, o) {
+          var l;
+          if (T(`[${e.hostTagName}] Store "${n}" state "${s.toString()}" changed`, { newValue: i, oldValue: o }), i === o) {
+            T(`[${e.hostTagName}] Store "${n}" state "${s.toString()}" unchanged. Skipping.`);
+            return;
+          }
+          const u = e.registeredComponents;
+          if (!u) {
+            T(`[${e.hostTagName}] No registered components found. Skipping.`);
+            return;
+          }
+          const a = ((l = e.propStateRegistrations.get(n)) == null ? void 0 : l.get(s.toString())) || [];
+          T(`[${e.hostTagName}] Found ${a.length} prop(s) registered for "${s.toString()}" store.`, {
+            props: a,
+            propStateRegistrations: e.propStateRegistrations
+          }), a.forEach(({ elementId: h, propKey: c }) => {
+            const d = u[h];
+            if (!d) {
+              T(`[${e.hostTagName}] Component "${h}" not found. Skipping.`, { component: d });
+              return;
+            }
+            const p = e.getStore(n).state[s];
+            d.element[c.toString()] = p, T(`[${e.hostTagName}] Setting "${d.name}" prop "${c.toString()}" to "${s.toString()}" value.`, { stateValue: p });
+          });
+        }
+      });
+    });
+  }
+  get hostTagName() {
+    var e, n;
+    return ((n = (e = this.host) == null ? void 0 : e.tagName) == null ? void 0 : n.toLowerCase()) ?? "nylas-provider";
+  }
+}
+class ds extends ar {
+}
+var ur = Object.defineProperty, cr = (t, e, n) => e in t ? ur(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, ut = (t, e, n) => (cr(t, typeof e != "symbol" ? e + "" : e, n), n), lr = /* @__PURE__ */ ((t) => (t.Error = "error", t.Warning = "warning", t.Info = "info", t.Success = "success", t))(lr || {});
+const fs = (t) => "error" in t;
+class ps extends Error {
+  constructor(e) {
+    super(e == null ? void 0 : e.message), ut(this, "apiError"), this.name = "NylasAPIError", this.stack = new Error().stack, this.apiError = e;
+  }
+}
+async function mn(t) {
+  const e = new TextEncoder().encode(t), n = await crypto.subtle.digest("SHA-256", e), r = Array.from(new Uint8Array(n)).map((s) => s.toString(16).padStart(2, "0")).join("");
+  return btoa(r).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+const K = typeof globalThis < "u" ? globalThis : typeof self < "u" ? self : typeof window < "u" ? window : global, $ = Object.keys, F = Array.isArray;
+function U(t, e) {
+  return typeof e != "object" || $(e).forEach(function(n) {
+    t[n] = e[n];
+  }), t;
+}
+typeof Promise > "u" || K.Promise || (K.Promise = Promise);
+const Be = Object.getPrototypeOf, hr = {}.hasOwnProperty;
+function z(t, e) {
+  return hr.call(t, e);
+}
+function Ee(t, e) {
+  typeof e == "function" && (e = e(Be(t))), (typeof Reflect > "u" ? $ : Reflect.ownKeys)(e).forEach((n) => {
+    ee(t, n, e[n]);
+  });
+}
+const An = Object.defineProperty;
+function ee(t, e, n, r) {
+  An(t, e, U(n && z(n, "get") && typeof n.get == "function" ? { get: n.get, set: n.set, configurable: !0 } : { value: n, configurable: !0, writable: !0 }, r));
+}
+function ke(t) {
+  return { from: function(e) {
+    return t.prototype = Object.create(e.prototype), ee(t.prototype, "constructor", t), { extend: Ee.bind(null, t.prototype) };
+  } };
+}
+const dr = Object.getOwnPropertyDescriptor;
+function Zt(t, e) {
+  let n;
+  return dr(t, e) || (n = Be(t)) && Zt(n, e);
+}
+const fr = [].slice;
+function ct(t, e, n) {
+  return fr.call(t, e, n);
+}
+function On(t, e) {
+  return e(t);
+}
+function Ie(t) {
+  if (!t)
+    throw new Error("Assertion Failed");
+}
+function In(t) {
+  K.setImmediate ? setImmediate(t) : setTimeout(t, 0);
+}
+function Kn(t, e) {
+  return t.reduce((n, r, s) => {
+    var i = e(r, s);
+    return i && (n[i[0]] = i[1]), n;
+  }, {});
+}
+function te(t, e) {
+  if (z(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 = te(t, e[r]);
+      n.push(i);
+    }
+    return n;
+  }
+  var o = e.indexOf(".");
+  if (o !== -1) {
+    var u = t[e.substr(0, o)];
+    return u === void 0 ? void 0 : te(u, e.substr(o + 1));
+  }
+}
+function H(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)
+        H(t, e[r], n[r]);
+    } else {
+      var i = e.indexOf(".");
+      if (i !== -1) {
+        var o = e.substr(0, i), u = e.substr(i + 1);
+        if (u === "")
+          n === void 0 ? F(t) && !isNaN(parseInt(o)) ? t.splice(o, 1) : delete t[o] : t[o] = n;
+        else {
+          var a = t[o];
+          a && z(t, o) || (a = t[o] = {}), H(a, u, n);
+        }
+      } else
+        n === void 0 ? F(t) && !isNaN(parseInt(e)) ? t.splice(e, 1) : delete t[e] : t[e] = n;
+    }
+}
+function Rn(t) {
+  var e = {};
+  for (var n in t)
+    z(t, n) && (e[n] = t[n]);
+  return e;
+}
+const pr = [].concat;
+function jn(t) {
+  return pr.apply([], t);
+}
+const Dn = "Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey".split(",").concat(jn([8, 16, 32, 64].map((t) => ["Int", "Uint", "Float"].map((e) => e + t + "Array")))).filter((t) => K[t]), mr = Dn.map((t) => K[t]);
+Kn(Dn, (t) => [t, !0]);
+let se = null;
+function We(t) {
+  se = typeof WeakMap < "u" && /* @__PURE__ */ new WeakMap();
+  const e = Tt(t);
+  return se = null, e;
+}
+function Tt(t) {
+  if (!t || typeof t != "object")
+    return t;
+  let e = se && se.get(t);
+  if (e)
+    return e;
+  if (F(t)) {
+    e = [], se && se.set(t, e);
+    for (var n = 0, r = t.length; n < r; ++n)
+      e.push(Tt(t[n]));
+  } else if (mr.indexOf(t.constructor) >= 0)
+    e = t;
+  else {
+    const i = Be(t);
+    for (var s in e = i === Object.prototype ? {} : Object.create(i), se && se.set(t, e), t)
+      z(t, s) && (e[s] = Tt(t[s]));
+  }
+  return e;
+}
+const { toString: gr } = {};
+function At(t) {
+  return gr.call(t).slice(8, -1);
+}
+const Ot = typeof Symbol < "u" ? Symbol.iterator : "@@iterator", yr = typeof Ot == "symbol" ? function(t) {
+  var e;
+  return t != null && (e = t[Ot]) && e.apply(t);
+} : function() {
+  return null;
+}, _e = {};
+function J(t) {
+  var e, n, r, s;
+  if (arguments.length === 1) {
+    if (F(t))
+      return t.slice();
+    if (this === _e && typeof t == "string")
+      return [t];
+    if (s = yr(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 en = typeof Symbol < "u" ? (t) => t[Symbol.toStringTag] === "AsyncFunction" : () => !1;
+var G = typeof location < "u" && /^(http|https):\/\/(localhost|127\.0\.0\.1)/.test(location.href);
+function $n(t, e) {
+  G = t, Nn = e;
+}
+var Nn = () => !0;
+const vr = !new Error("").stack;
+function Pe() {
+  if (vr)
+    try {
+      throw new Error();
+    } catch (t) {
+      return t;
+    }
+  return new Error();
+}
+function It(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 Bn = ["Unknown", "Constraint", "Data", "TransactionInactive", "ReadOnly", "Version", "NotFound", "InvalidState", "InvalidAccess", "Abort", "Timeout", "QuotaExceeded", "Syntax", "DataClone"], tn = ["Modify", "Bulk", "OpenFailed", "VersionChange", "Schema", "Upgrade", "InvalidTable", "MissingAPI", "NoSuchDatabase", "InvalidArgument", "SubTransaction", "Unsupported", "Internal", "DatabaseClosed", "PrematureCommit", "ForeignAwait"].concat(Bn), br = { 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 xe(t, e) {
+  this._e = Pe(), this.name = t, this.message = e;
+}
+function Mn(t, e) {
+  return t + ". Errors: " + Object.keys(e).map((n) => e[n].toString()).filter((n, r, s) => s.indexOf(n) === r).join(`
+`);
+}
+function lt(t, e, n, r) {
+  this._e = Pe(), this.failures = e, this.failedKeys = r, this.successCount = n, this.message = Mn(t, e);
+}
+function Re(t, e) {
+  this._e = Pe(), this.name = "BulkError", this.failures = Object.keys(e).map((n) => e[n]), this.failuresByPos = e, this.message = Mn(t, e);
+}
+ke(xe).from(Error).extend({ stack: { get: function() {
+  return this._stack || (this._stack = this.name + ": " + this.message + It(this._e, 2));
+} }, toString: function() {
+  return this.name + ": " + this.message;
+} }), ke(lt).from(xe), ke(Re).from(xe);
+var nn = tn.reduce((t, e) => (t[e] = e + "Error", t), {});
+const wr = xe;
+var C = tn.reduce((t, e) => {
+  var n = e + "Error";
+  function r(s, i) {
+    this._e = Pe(), 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 = br[e] || n, this.inner = null);
+  }
+  return ke(r).from(wr), t[e] = r, t;
+}, {});
+C.Syntax = SyntaxError, C.Type = TypeError, C.Range = RangeError;
+var gn = Bn.reduce((t, e) => (t[e + "Error"] = C[e], t), {}), tt = tn.reduce((t, e) => (["Syntax", "Type", "Range"].indexOf(e) === -1 && (t[e + "Error"] = C[e]), t), {});
+function I() {
+}
+function Me(t) {
+  return t;
+}
+function _r(t, e) {
+  return t == null || t === Me ? e : function(n) {
+    return e(t(n));
+  };
+}
+function me(t, e) {
+  return function() {
+    t.apply(this, arguments), e.apply(this, arguments);
+  };
+}
+function kr(t, e) {
+  return t === I ? 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 ? me(r, this.onsuccess) : r), s && (this.onerror = this.onerror ? me(s, this.onerror) : s), i !== void 0 ? i : n;
+  };
+}
+function xr(t, e) {
+  return t === I ? 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 ? me(n, this.onsuccess) : n), r && (this.onerror = this.onerror ? me(r, this.onerror) : r);
+  };
+}
+function Sr(t, e) {
+  return t === I ? e : function(n) {
+    var r = t.apply(this, arguments);
+    U(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 ? me(s, this.onsuccess) : s), i && (this.onerror = this.onerror ? me(i, this.onerror) : i), r === void 0 ? o === void 0 ? void 0 : o : U(r, o);
+  };
+}
+function Er(t, e) {
+  return t === I ? e : function() {
+    return e.apply(this, arguments) !== !1 && t.apply(this, arguments);
+  };
+}
+function rn(t, e) {
+  return t === I ? 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);
+  };
+}
+tt.ModifyError = lt, tt.DexieError = xe, tt.BulkError = Re;
+var Fe = {};
+const Fn = 100, [Kt, ht, Rt] = typeof Promise > "u" ? [] : (() => {
+  let t = Promise.resolve();
+  if (typeof crypto > "u" || !crypto.subtle)
+    return [t, Be(t), t];
+  const e = crypto.subtle.digest("SHA-512", new Uint8Array([0]));
+  return [e, Be(e), t];
+})(), qn = ht && ht.then, nt = Kt && Kt.constructor, sn = !!Rt;
+var jt = !1, Pr = Rt ? () => {
+  Rt.then(Ye);
+} : K.setImmediate ? setImmediate.bind(null, Ye) : K.MutationObserver ? () => {
+  var t = document.createElement("div");
+  new MutationObserver(() => {
+    Ye(), t = null;
+  }).observe(t, { attributes: !0 }), t.setAttribute("i", "1");
+} : () => {
+  setTimeout(Ye, 0);
+}, je = function(t, e) {
+  Ke.push([t, e]), dt && (Pr(), dt = !1);
+}, Dt = !0, dt = !0, de = [], rt = [], $t = null, Nt = Me, Se = { id: "global", global: !0, ref: 0, unhandleds: [], onunhandled: bn, pgp: !1, env: {}, finalize: function() {
+  this.unhandleds.forEach((t) => {
+    try {
+      bn(t[0], t[1]);
+    } catch {
+    }
+  });
+} }, P = Se, Ke = [], fe = 0, st = [];
+function S(t) {
+  if (typeof this != "object")
+    throw new TypeError("Promises must be constructed via new");
+  this._listeners = [], this.onuncatched = I, this._lib = !1;
+  var e = this._PSD = P;
+  if (G && (this._stackHolder = Pe(), this._prev = null, this._numPrev = 0), typeof t != "function") {
+    if (t !== Fe)
+      throw new TypeError("Not a function");
+    return this._state = arguments[1], this._value = arguments[2], void (this._state === !1 && Mt(this, this._value));
+  }
+  this._state = null, this._value = null, ++e.ref, Un(this, t);
+}
+const Bt = { get: function() {
+  var t = P, e = ft;
+  function n(r, s) {
+    var i = !t.global && (t !== P || e !== ft);
+    const o = i && !ne();
+    var u = new S((a, l) => {
+      on(this, new Ln(pt(r, t, i, o), pt(s, t, i, o), a, l, t));
+    });
+    return G && zn(u, this), u;
+  }
+  return n.prototype = Fe, n;
+}, set: function(t) {
+  ee(this, "then", t && t.prototype === Fe ? Bt : { get: function() {
+    return t;
+  }, set: Bt.set });
+} };
+function Ln(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 Un(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 && ze();
+        n && typeof n.then == "function" ? Un(t, (s, i) => {
+          n instanceof S ? n._then(s, i) : n.then(s, i);
+        }) : (t._state = !0, t._value = n, Vn(t)), r && He();
+      }
+    }, Mt.bind(null, t));
+  } catch (n) {
+    Mt(t, n);
+  }
+}
+function Mt(t, e) {
+  if (rt.push(e), t._state === null) {
+    var n = t._lib && ze();
+    e = Nt(e), t._state = !1, t._value = e, G && e !== null && typeof e == "object" && !e._promise && function(r, s, i) {
+      try {
+        r.apply(null, i);
+      } catch (o) {
+        s && s(o);
+      }
+    }(() => {
+      var r = Zt(e, "stack");
+      e._promise = t, ee(e, "stack", { get: () => jt ? r && (r.get ? r.get.apply(e) : r.value) : t.stack });
+    }), function(r) {
+      de.some((s) => s._value === r._value) || de.push(r);
+    }(t), Vn(t), n && He();
+  }
+}
+function Vn(t) {
+  var e = t._listeners;
+  t._listeners = [];
+  for (var n = 0, r = e.length; n < r; ++n)
+    on(t, e[n]);
+  var s = t._PSD;
+  --s.ref || s.finalize(), fe === 0 && (++fe, je(() => {
+    --fe == 0 && an();
+  }, []));
+}
+function on(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, ++fe, je(Cr, [n, t, e]);
+  } else
+    t._listeners.push(e);
+}
+function Cr(t, e, n) {
+  try {
+    $t = e;
+    var r, s = e._value;
+    e._state ? r = t(s) : (rt.length && (rt = []), r = t(s), rt.indexOf(s) === -1 && function(i) {
+      for (var o = de.length; o; )
+        if (de[--o]._value === i._value)
+          return void de.splice(o, 1);
+    }(e)), n.resolve(r);
+  } catch (i) {
+    n.reject(i);
+  } finally {
+    $t = null, --fe == 0 && an(), --n.psd.ref || n.psd.finalize();
+  }
+}
+function Wn(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 = It(o, 0)) : (s = o, i = ""), e.push(s + (i ? ": " + i : "") + r);
+  }
+  return G && ((r = It(t._stackHolder, 2)) && e.indexOf(r) === -1 && e.push(r), t._prev && Wn(t._prev, e, n)), e;
+}
+function zn(t, e) {
+  var n = e ? e._numPrev + 1 : 0;
+  n < 100 && (t._prev = e, t._numPrev = n);
+}
+function Ye() {
+  ze() && He();
+}
+function ze() {
+  var t = Dt;
+  return Dt = !1, dt = !1, t;
+}
+function He() {
+  var t, e, n;
+  do
+    for (; Ke.length > 0; )
+      for (t = Ke, Ke = [], n = t.length, e = 0; e < n; ++e) {
+        var r = t[e];
+        r[0].apply(null, r[1]);
+      }
+  while (Ke.length > 0);
+  Dt = !0, dt = !0;
+}
+function an() {
+  var t = de;
+  de = [], t.forEach((r) => {
+    r._PSD.onunhandled.call(null, r._value, r);
+  });
+  for (var e = st.slice(0), n = e.length; n; )
+    e[--n]();
+}
+function Ge(t) {
+  return new S(Fe, !1, t);
+}
+function R(t, e) {
+  var n = P;
+  return function() {
+    var r = ze(), s = P;
+    try {
+      return ae(n, !0), t.apply(this, arguments);
+    } catch (i) {
+      e && e(i);
+    } finally {
+      ae(s, !1), r && He();
+    }
+  };
+}
+Ee(S.prototype, { then: Bt, _then: function(t, e) {
+  on(this, new Ln(null, null, t, e, P));
+}, 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) : Ge(r)) : this.then(null, (r) => r && r.name === e ? n(r) : Ge(r));
+}, finally: function(t) {
+  return this.then((e) => (t(), e), (e) => (t(), Ge(e)));
+}, stack: { get: function() {
+  if (this._stack)
+    return this._stack;
+  try {
+    jt = !0;
+    var t = Wn(this, [], 20).join(`
+From previous: `);
+    return this._state !== null && (this._stack = t), t;
+  } finally {
+    jt = !1;
+  }
+} }, timeout: function(t, e) {
+  return t < 1 / 0 ? new S((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 && ee(S.prototype, Symbol.toStringTag, "Dexie.Promise"), Se.env = Hn(), Ee(S, { all: function() {
+  var t = J.apply(null, arguments).map(Xe);
+  return new S(function(e, n) {
+    t.length === 0 && e([]);
+    var r = t.length;
+    t.forEach((s, i) => S.resolve(s).then((o) => {
+      t[i] = o, --r || e(t);
+    }, n));
+  });
+}, resolve: (t) => {
+  if (t instanceof S)
+    return t;
+  if (t && typeof t.then == "function")
+    return new S((n, r) => {
+      t.then(n, r);
+    });
+  var e = new S(Fe, !0, t);
+  return zn(e, $t), e;
+}, reject: Ge, race: function() {
+  var t = J.apply(null, arguments).map(Xe);
+  return new S((e, n) => {
+    t.map((r) => S.resolve(r).then(e, n));
+  });
+}, PSD: { get: () => P, set: (t) => P = t }, totalEchoes: { get: () => ft }, newPSD: oe, usePSD: Te, scheduler: { get: () => je, set: (t) => {
+  je = t;
+} }, rejectionMapper: { get: () => Nt, set: (t) => {
+  Nt = t;
+} }, follow: (t, e) => new S((n, r) => oe((s, i) => {
+  var o = P;
+  o.unhandleds = [], o.onunhandled = i, o.finalize = me(function() {
+    (function(u) {
+      function a() {
+        u(), st.splice(st.indexOf(a), 1);
+      }
+      st.push(a), ++fe, je(() => {
+        --fe == 0 && an();
+      }, []);
+    })(() => {
+      this.unhandleds.length === 0 ? s() : i(this.unhandleds[0]);
+    });
+  }, o.finalize), t();
+}, e, n, r)) }), nt && (nt.allSettled && ee(S, "allSettled", function() {
+  const t = J.apply(null, arguments).map(Xe);
+  return new S((e) => {
+    t.length === 0 && e([]);
+    let n = t.length;
+    const r = new Array(n);
+    t.forEach((s, i) => S.resolve(s).then((o) => r[i] = { status: "fulfilled", value: o }, (o) => r[i] = { status: "rejected", reason: o }).then(() => --n || e(r)));
+  });
+}), nt.any && typeof AggregateError < "u" && ee(S, "any", function() {
+  const t = J.apply(null, arguments).map(Xe);
+  return new S((e, n) => {
+    t.length === 0 && n(new AggregateError([]));
+    let r = t.length;
+    const s = new Array(r);
+    t.forEach((i, o) => S.resolve(i).then((u) => e(u), (u) => {
+      s[o] = u, --r || n(new AggregateError(s));
+    }));
+  });
+}));
+const M = { awaits: 0, echoes: 0, id: 0 };
+var Tr = 0, it = [], wt = 0, ft = 0, Ar = 0;
+function oe(t, e, n, r) {
+  var s = P, i = Object.create(s);
+  i.parent = s, i.ref = 0, i.global = !1, i.id = ++Ar;
+  var o = Se.env;
+  i.env = sn ? { Promise: S, PromiseProp: { value: S, configurable: !0, writable: !0 }, all: S.all, race: S.race, allSettled: S.allSettled, any: S.any, resolve: S.resolve, reject: S.reject, nthen: yn(o.nthen, i), gthen: yn(o.gthen, i) } : {}, e && U(i, e), ++s.ref, i.finalize = function() {
+    --this.parent.ref || this.parent.finalize();
+  };
+  var u = Te(i, t, n, r);
+  return i.ref === 0 && i.finalize(), u;
+}
+function Ce() {
+  return M.id || (M.id = ++Tr), ++M.awaits, M.echoes += Fn, M.id;
+}
+function ne() {
+  return !!M.awaits && (--M.awaits == 0 && (M.id = 0), M.echoes = M.awaits * Fn, !0);
+}
+function Xe(t) {
+  return M.echoes && t && t.constructor === nt ? (Ce(), t.then((e) => (ne(), e), (e) => (ne(), N(e)))) : t;
+}
+function Or(t) {
+  ++ft, M.echoes && --M.echoes != 0 || (M.echoes = M.id = 0), it.push(P), ae(t, !0);
+}
+function Ir() {
+  var t = it[it.length - 1];
+  it.pop(), ae(t, !1);
+}
+function ae(t, e) {
+  var n = P;
+  if ((e ? !M.echoes || wt++ && t === P : !wt || --wt && t === P) || Yn(e ? Or.bind(null, t) : Ir), t !== P && (P = t, n === Se && (Se.env = Hn()), sn)) {
+    var r = Se.env.Promise, s = t.env;
+    ht.then = s.nthen, r.prototype.then = s.gthen, (n.global || t.global) && (Object.defineProperty(K, "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 Hn() {
+  var t = K.Promise;
+  return sn ? { Promise: t, PromiseProp: Object.getOwnPropertyDescriptor(K, "Promise"), all: t.all, race: t.race, allSettled: t.allSettled, any: t.any, resolve: t.resolve, reject: t.reject, nthen: ht.then, gthen: t.prototype.then } : {};
+}
+function Te(t, e, n, r, s) {
+  var i = P;
+  try {
+    return ae(t, !0), e(n, r, s);
+  } finally {
+    ae(i, !1);
+  }
+}
+function Yn(t) {
+  qn.call(Kt, t);
+}
+function pt(t, e, n, r) {
+  return typeof t != "function" ? t : function() {
+    var s = P;
+    n && Ce(), ae(e, !0);
+    try {
+      return t.apply(this, arguments);
+    } finally {
+      ae(s, !1), r && Yn(ne);
+    }
+  };
+}
+function yn(t, e) {
+  return function(n, r) {
+    return t.call(this, pt(n, e), pt(r, e));
+  };
+}
+("" + qn).indexOf("[native code]") === -1 && (Ce = ne = I);
+const vn = "unhandledrejection";
+function bn(t, e) {
+  var n;
+  try {
+    n = e.onuncatched(t);
+  } catch {
+  }
+  if (n !== !1)
+    try {
+      var r, s = { promise: e, reason: t };
+      if (K.document && document.createEvent ? ((r = document.createEvent("Event")).initEvent(vn, !0, !0), U(r, s)) : K.CustomEvent && U(r = new CustomEvent(vn, { detail: s }), s), r && K.dispatchEvent && (dispatchEvent(r), !K.PromiseRejectionEvent && K.onunhandledrejection))
+        try {
+          K.onunhandledrejection(r);
+        } catch {
+        }
+      G && r && !r.defaultPrevented && console.warn(`Unhandled rejection: ${t.stack || t}`);
+    } catch {
+    }
+}
+var N = S.reject;
+function Ft(t, e, n, r) {
+  if (t.idbdb && (t._state.openComplete || P.letThrough || t._vip)) {
+    var s = t._createTransaction(e, n, t._dbSchema);
+    try {
+      s.create(), t._state.PR1398_maxLoop = 3;
+    } catch (i) {
+      return i.name === nn.InvalidState && t.isOpen() && --t._state.PR1398_maxLoop > 0 ? (console.warn("Dexie: Need to reopen db"), t._close(), t.open().then(() => Ft(t, e, n, r))) : N(i);
+    }
+    return s._promise(e, (i, o) => oe(() => (P.trans = s, r(i, o, s)))).then((i) => s._completion.then(() => i));
+  }
+  if (t._state.openComplete)
+    return N(new C.DatabaseClosed(t._state.dbOpenError));
+  if (!t._state.isBeingOpened) {
+    if (!t._options.autoOpen)
+      return N(new C.DatabaseClosed());
+    t.open().catch(I);
+  }
+  return t._state.dbReadyPromise.then(() => Ft(t, e, n, r));
+}
+const wn = "3.2.4", he = String.fromCharCode(65535), qt = -1 / 0, X = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.", Gn = "String expected.", De = [], yt = typeof navigator < "u" && /(MSIE|Trident|Edge)/.test(navigator.userAgent), Kr = yt, Rr = yt, Xn = (t) => !/(dexie\.js|dexie\.min\.js)/.test(t), vt = "__dbnames", _t = "readonly", kt = "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 Qe(t) {
+  return typeof t != "string" || /\./.test(t) ? (e) => e : (e) => (e[t] === void 0 && t in e && delete (e = We(e))[t], e);
+}
+class jr {
+  _trans(e, n, r) {
+    const s = this._tx || P.trans, i = this.name;
+    function o(a, l, h) {
+      if (!h.schema[i])
+        throw new C.NotFound("Table " + i + " not part of transaction");
+      return n(h.idbtrans, h);
+    }
+    const u = ze();
+    try {
+      return s && s.db === this.db ? s === P.trans ? s._promise(e, o, r) : oe(() => s._promise(e, o, r), { trans: s, transless: P.transless || P }) : Ft(this.db, e, [this.name], o);
+    } finally {
+      u && He();
+    }
+  }
+  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 (F(e))
+      return new this.db.WhereClause(this, `[${e.join("+")}]`);
+    const n = $(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) => l.compound && n.every((h) => l.keyPath.indexOf(h) >= 0) && l.keyPath.every((h) => n.indexOf(h) >= 0))[0];
+    if (r && this.db._maxKey !== he)
+      return this.where(r.name).equals(r.keyPath.map((l) => e[l]));
+    !r && G && 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, h) {
+      try {
+        return i.cmp(l, h) === 0;
+      } catch {
+        return !1;
+      }
+    }
+    const [u, a] = n.reduce(([l, h], c) => {
+      const d = s[c], m = e[c];
+      return [l || d, l || !d ? ge(h, d && d.multi ? (p) => {
+        const f = te(p, c);
+        return F(f) && f.some((y) => o(m, y));
+      } : (p) => o(m, te(p, c))) : h];
+    }, [null, null]);
+    return u ? this.where(u.name).equals(e[u.keyPath]).filter(a) : r ? this.filter(a) : 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, F(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 (z(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) {
+      U(this, e);
+    });
+  }
+  add(e, n) {
+    const { auto: r, keyPath: s } = this.schema.primKey;
+    let i = e;
+    return s && r && (i = Qe(s)(e)), this._trans("readwrite", (o) => this.core.mutate({ trans: o, type: "add", keys: n != null ? [n] : null, values: [i] })).then((o) => o.numFailures ? S.reject(o.failures[0]) : o.lastResult).then((o) => {
+      if (s)
+        try {
+          H(e, s, o);
+        } catch {
+        }
+      return o;
+    });
+  }
+  update(e, n) {
+    if (typeof e != "object" || F(e))
+      return this.where(":id").equals(e).modify(n);
+    {
+      const r = te(e, this.schema.primKey.keyPath);
+      if (r === void 0)
+        return N(new C.InvalidArgument("Given object does not contain its primary key"));
+      try {
+        typeof n != "function" ? $(n).forEach((s) => {
+          H(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 = Qe(s)(e)), this._trans("readwrite", (o) => this.core.mutate({ trans: o, type: "put", values: [i], keys: n != null ? [n] : null })).then((o) => o.numFailures ? S.reject(o.failures[0]) : o.lastResult).then((o) => {
+      if (s)
+        try {
+          H(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 ? S.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 ? S.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: u, keyPath: a } = this.schema.primKey;
+      if (a && 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 h = a && u ? e.map(Qe(a)) : e;
+      return this.core.mutate({ trans: o, type: "add", keys: s, values: h, wantResults: i }).then(({ numFailures: c, results: d, lastResult: m, failures: p }) => {
+        if (c === 0)
+          return i ? d : m;
+        throw new Re(`${this.name}.bulkAdd(): ${c} of ${l} operations failed`, p);
+      });
+    });
+  }
+  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: u, keyPath: a } = this.schema.primKey;
+      if (a && 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 h = a && u ? e.map(Qe(a)) : e;
+      return this.core.mutate({ trans: o, type: "put", keys: s, values: h, wantResults: i }).then(({ numFailures: c, results: d, lastResult: m, failures: p }) => {
+        if (c === 0)
+          return i ? d : m;
+        throw new Re(`${this.name}.bulkPut(): ${c} of ${l} operations failed`, p);
+      });
+    });
+  }
+  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 Re(`${this.name}.bulkDelete(): ${r} of ${n} operations failed`, i);
+    });
+  }
+}
+function $e(t) {
+  var e = {}, n = function(o, u) {
+    if (u) {
+      for (var a = arguments.length, l = new Array(a - 1); --a; )
+        l[a - 1] = arguments[a];
+      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, u, a) {
+    if (typeof o != "object") {
+      var l;
+      u || (u = Er), a || (a = I);
+      var h = { subscribers: [], fire: a, subscribe: function(c) {
+        h.subscribers.indexOf(c) === -1 && (h.subscribers.push(c), h.fire = u(h.fire, c));
+      }, unsubscribe: function(c) {
+        h.subscribers = h.subscribers.filter(function(d) {
+          return d !== c;
+        }), h.fire = h.subscribers.reduce(u, a);
+      } };
+      return e[o] = n[o] = h, h;
+    }
+    $(l = o).forEach(function(c) {
+      var d = l[c];
+      if (F(d))
+        i(c, l[c][0], l[c][1]);
+      else {
+        if (d !== "asap")
+          throw new C.InvalidArgument("Invalid event config");
+        var m = i(c, Me, function() {
+          for (var p = arguments.length, f = new Array(p); p--; )
+            f[p] = arguments[p];
+          m.subscribers.forEach(function(y) {
+            In(function() {
+              y.apply(null, f);
+            });
+          });
+        });
+      }
+    });
+  }
+}
+function Oe(t, e) {
+  return ke(e).from({ prototype: t }), e;
+}
+function be(t, e) {
+  return !(t.filter || t.algorithm || t.or) && (e ? t.justLimit : !t.replayFilter);
+}
+function xt(t, e) {
+  t.filter = ge(t.filter, e);
+}
+function St(t, e, n) {
+  var r = t.replayFilter;
+  t.replayFilter = r ? () => ge(r(), e()) : e, t.justLimit = n && !r;
+}
+function ot(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 _n(t, e, n) {
+  const r = ot(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 Je(t, e, n, r) {
+  const s = t.replayFilter ? ge(t.filter, t.replayFilter()) : t.filter;
+  if (t.or) {
+    const i = {}, o = (u, a, l) => {
+      if (!s || s(a, l, (d) => a.stop(d), (d) => a.fail(d))) {
+        var h = a.primaryKey, c = "" + h;
+        c === "[object ArrayBuffer]" && (c = "" + new Uint8Array(h)), z(i, c) || (i[c] = !0, e(u, a, l));
+      }
+    };
+    return Promise.all([t.or._iterate(o, n), kn(_n(t, r, n), t.algorithm, o, !t.keysOnly && t.valueMapper)]);
+  }
+  return kn(_n(t, r, n), ge(t.algorithm, s), e, !t.keysOnly && t.valueMapper);
+}
+function kn(t, e, n, r) {
+  var s = R(r ? (i, o, u) => n(r(i), o, u) : n);
+  return t.then((i) => {
+    if (i)
+      return i.start(() => {
+        var o = () => i.continue();
+        e && !e(i, (u) => o = u, (u) => {
+          i.stop(u), o = I;
+        }, (u) => {
+          i.fail(u), o = I;
+        }) || s(i.value, i, (u) => o = u), o();
+      });
+  });
+}
+function L(t, e) {
+  try {
+    const n = xn(t), r = xn(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, u = i.length, a = o < u ? o : u;
+          for (let l = 0; l < a; ++l)
+            if (s[l] !== i[l])
+              return s[l] < i[l] ? -1 : 1;
+          return o === u ? 0 : o < u ? -1 : 1;
+        }(Sn(t), Sn(e));
+      case "Array":
+        return function(s, i) {
+          const o = s.length, u = i.length, a = o < u ? o : u;
+          for (let l = 0; l < a; ++l) {
+            const h = L(s[l], i[l]);
+            if (h !== 0)
+              return h;
+          }
+          return o === u ? 0 : o < u ? -1 : 1;
+        }(t, e);
+    }
+  } catch {
+  }
+  return NaN;
+}
+function xn(t) {
+  const e = typeof t;
+  if (e !== "object")
+    return e;
+  if (ArrayBuffer.isView(t))
+    return "binary";
+  const n = At(t);
+  return n === "ArrayBuffer" ? "binary" : n;
+}
+function Sn(t) {
+  return t instanceof Uint8Array ? t : ArrayBuffer.isView(t) ? new Uint8Array(t.buffer, t.byteOffset, t.byteLength) : new Uint8Array(t);
+}
+class Dr {
+  _read(e, n) {
+    var r = this._ctx;
+    return r.error ? r.table._trans(null, N.bind(null, r.error)) : r.table._trans("readonly", e).then(n);
+  }
+  _write(e) {
+    var n = this._ctx;
+    return n.error ? n.table._trans(null, N.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 Je(this._ctx, e, n, this._ctx.table.core);
+  }
+  clone(e) {
+    var n = Object.create(this.constructor.prototype), r = Object.create(this._ctx);
+    return e && U(r, e), n._ctx = r, n;
+  }
+  raw() {
+    return this._ctx.valueMapper = null, this;
+  }
+  each(e) {
+    var n = this._ctx;
+    return this._read((r) => Je(n, e, r, n.table.core));
+  }
+  count(e) {
+    return this._read((n) => {
+      const r = this._ctx, s = r.table.core;
+      if (be(r, !0))
+        return s.count({ trans: n, query: { index: ot(r, s.schema), range: r.range } }).then((o) => Math.min(o, r.limit));
+      var i = 0;
+      return Je(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, h) {
+      return h ? o(l[r[h]], h - 1) : l[s];
+    }
+    var u = this._ctx.dir === "next" ? 1 : -1;
+    function a(l, h) {
+      var c = o(l, i), d = o(h, i);
+      return c < d ? -u : c > d ? u : 0;
+    }
+    return this.toArray(function(l) {
+      return l.sort(a);
+    }).then(n);
+  }
+  toArray(e) {
+    return this._read((n) => {
+      var r = this._ctx;
+      if (r.dir === "next" && be(r, !0) && r.limit > 0) {
+        const { valueMapper: s } = r, i = ot(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 Je(r, (i) => s.push(i), n, r.table.core).then(() => s);
+      }
+    }, e);
+  }
+  offset(e) {
+    var n = this._ctx;
+    return e <= 0 || (n.offset += e, be(n) ? St(n, () => {
+      var r = e;
+      return (s, i) => r === 0 || (r === 1 ? (--r, !1) : (i(() => {
+        s.advance(r), r = 0;
+      }), !1));
+    }) : St(n, () => {
+      var r = e;
+      return () => --r < 0;
+    })), this;
+  }
+  limit(e) {
+    return this._ctx.limit = Math.min(this._ctx.limit, e), St(this._ctx, () => {
+      var n = e;
+      return function(r, s, i) {
+        return --n <= 0 && s(i), n >= 0;
+      };
+    }, !0), this;
+  }
+  until(e, n) {
+    return xt(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 xt(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" && be(n, !0) && n.limit > 0)
+      return this._read((s) => {
+        var i = ot(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 xt(this._ctx, function(s) {
+      var i = s.primaryKey.toString(), o = z(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 = $(e), o = i.length;
+        s = function(f) {
+          for (var y = !1, g = 0; g < o; ++g) {
+            var v = i[g], b = e[v];
+            te(f, v) !== b && (H(f, v, b), y = !0);
+          }
+          return y;
+        };
+      }
+      const u = n.table.core, { outbound: a, extractKey: l } = u.schema.primaryKey, h = this.db._options.modifyChunkSize || 200, c = [];
+      let d = 0;
+      const m = [], p = (f, y) => {
+        const { failures: g, numFailures: v } = y;
+        d += f - v;
+        for (let b of $(g))
+          c.push(g[b]);
+      };
+      return this.clone().primaryKeys().then((f) => {
+        const y = (g) => {
+          const v = Math.min(h, f.length - g);
+          return u.getMany({ trans: r, keys: f.slice(g, g + v), cache: "immutable" }).then((b) => {
+            const x = [], E = [], k = a ? [] : null, w = [];
+            for (let _ = 0; _ < v; ++_) {
+              const j = b[_], O = { value: We(j), primKey: f[g + _] };
+              s.call(O, O.value, O) !== !1 && (O.value == null ? w.push(f[g + _]) : a || L(l(j), l(O.value)) === 0 ? (E.push(O.value), a && k.push(f[g + _])) : (w.push(f[g + _]), x.push(O.value)));
+            }
+            const A = be(n) && n.limit === 1 / 0 && (typeof e != "function" || e === Et) && { index: n.index, range: n.range };
+            return Promise.resolve(x.length > 0 && u.mutate({ trans: r, type: "add", values: x }).then((_) => {
+              for (let j in _.failures)
+                w.splice(parseInt(j), 1);
+              p(x.length, _);
+            })).then(() => (E.length > 0 || A && typeof e == "object") && u.mutate({ trans: r, type: "put", keys: k, values: E, criteria: A, changeSpec: typeof e != "function" && e }).then((_) => p(E.length, _))).then(() => (w.length > 0 || A && e === Et) && u.mutate({ trans: r, type: "delete", keys: w, criteria: A }).then((_) => p(w.length, _))).then(() => f.length > g + v && y(g + h));
+          });
+        };
+        return y(0).then(() => {
+          if (c.length > 0)
+            throw new lt("Error modifying one or more objects", c, d, m);
+          return f.length;
+        });
+      });
+    });
+  }
+  delete() {
+    var e = this._ctx, n = e.range;
+    return be(e) && (e.isPrimKey && !Rr || 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: u, lastResult: a, results: l, numFailures: h }) => {
+        if (h)
+          throw new lt("Could not delete some values", Object.keys(u).map((c) => u[c]), o - h);
+        return o - h;
+      }));
+    }) : this.modify(Et);
+  }
+}
+const Et = (t, e) => e.value = null;
+function $r(t, e) {
+  return t < e ? -1 : t === e ? 0 : 1;
+}
+function Nr(t, e) {
+  return t > e ? -1 : t === e ? 0 : 1;
+}
+function W(t, e, n) {
+  var r = t instanceof Zn ? new t.Collection(t) : t;
+  return r._ctx.error = n ? new n(e) : new TypeError(e), r;
+}
+function we(t) {
+  return new t.Collection(t, () => Jn("")).limit(0);
+}
+function Br(t, e, n, r, s, i) {
+  for (var o = Math.min(t.length, r.length), u = -1, a = 0; a < o; ++a) {
+    var l = e[a];
+    if (l !== r[a])
+      return s(t[a], n[a]) < 0 ? t.substr(0, a) + n[a] + n.substr(a + 1) : s(t[a], r[a]) < 0 ? t.substr(0, a) + r[a] + n.substr(a + 1) : u >= 0 ? t.substr(0, u) + e[u] + n.substr(u + 1) : null;
+    s(t[a], l) < 0 && (u = a);
+  }
+  return o < r.length && i === "next" ? t + n.substr(t.length) : o < t.length && i === "prev" ? t.substr(0, n.length) : u < 0 ? null : t.substr(0, u) + r[u] + n.substr(u + 1);
+}
+function Ze(t, e, n, r) {
+  var s, i, o, u, a, l, h, c = n.length;
+  if (!n.every((f) => typeof f == "string"))
+    return W(t, Gn);
+  function d(f) {
+    s = function(g) {
+      return g === "next" ? (v) => v.toUpperCase() : (v) => v.toLowerCase();
+    }(f), i = function(g) {
+      return g === "next" ? (v) => v.toLowerCase() : (v) => v.toUpperCase();
+    }(f), o = f === "next" ? $r : Nr;
+    var y = n.map(function(g) {
+      return { lower: i(g), upper: s(g) };
+    }).sort(function(g, v) {
+      return o(g.lower, v.lower);
+    });
+    u = y.map(function(g) {
+      return g.upper;
+    }), a = y.map(function(g) {
+      return g.lower;
+    }), l = f, h = f === "next" ? "" : r;
+  }
+  d("next");
+  var m = new t.Collection(t, () => re(u[0], a[c - 1] + r));
+  m._ondirectionchange = function(f) {
+    d(f);
+  };
+  var p = 0;
+  return m._addAlgorithm(function(f, y, g) {
+    var v = f.key;
+    if (typeof v != "string")
+      return !1;
+    var b = i(v);
+    if (e(b, a, p))
+      return !0;
+    for (var x = null, E = p; E < c; ++E) {
+      var k = Br(v, b, u[E], a[E], o, l);
+      k === null && x === null ? p = E + 1 : (x === null || o(x, k) > 0) && (x = k);
+    }
+    return y(x !== null ? function() {
+      f.continue(x + h);
+    } : g), !1;
+  }), m;
+}
+function re(t, e, n, r) {
+  return { type: 2, lower: t, upper: e, lowerOpen: n, upperOpen: r };
+}
+function Jn(t) {
+  return { type: 1, lower: t, upper: t };
+}
+class Zn {
+  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) ? we(this) : new this.Collection(this, () => re(e, n, !r, !s));
+    } catch {
+      return W(this, X);
+    }
+  }
+  equals(e) {
+    return e == null ? W(this, X) : new this.Collection(this, () => Jn(e));
+  }
+  above(e) {
+    return e == null ? W(this, X) : new this.Collection(this, () => re(e, void 0, !0));
+  }
+  aboveOrEqual(e) {
+    return e == null ? W(this, X) : new this.Collection(this, () => re(e, void 0, !1));
+  }
+  below(e) {
+    return e == null ? W(this, X) : new this.Collection(this, () => re(void 0, e, !1, !0));
+  }
+  belowOrEqual(e) {
+    return e == null ? W(this, X) : new this.Collection(this, () => re(void 0, e));
+  }
+  startsWith(e) {
+    return typeof e != "string" ? W(this, Gn) : this.between(e, e + he, !0, !0);
+  }
+  startsWithIgnoreCase(e) {
+    return e === "" ? this.startsWith(e) : Ze(this, (n, r) => n.indexOf(r[0]) === 0, [e], he);
+  }
+  equalsIgnoreCase(e) {
+    return Ze(this, (n, r) => n === r[0], [e], "");
+  }
+  anyOfIgnoreCase() {
+    var e = J.apply(_e, arguments);
+    return e.length === 0 ? we(this) : Ze(this, (n, r) => r.indexOf(n) !== -1, e, "");
+  }
+  startsWithAnyOfIgnoreCase() {
+    var e = J.apply(_e, arguments);
+    return e.length === 0 ? we(this) : Ze(this, (n, r) => r.some((s) => n.indexOf(s) === 0), e, he);
+  }
+  anyOf() {
+    const e = J.apply(_e, arguments);
+    let n = this._cmp;
+    try {
+      e.sort(n);
+    } catch {
+      return W(this, X);
+    }
+    if (e.length === 0)
+      return we(this);
+    const r = new this.Collection(this, () => re(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, u) => {
+      const a = i.key;
+      for (; n(a, e[s]) > 0; )
+        if (++s, s === e.length)
+          return o(u), !1;
+      return n(a, e[s]) === 0 || (o(() => {
+        i.continue(e[s]);
+      }), !1);
+    }), r;
+  }
+  notEqual(e) {
+    return this.inAnyRange([[qt, e], [e, this.db._maxKey]], { includeLowers: !1, includeUppers: !1 });
+  }
+  noneOf() {
+    const e = J.apply(_e, arguments);
+    if (e.length === 0)
+      return new this.Collection(this);
+    try {
+      e.sort(this._ascending);
+    } catch {
+      return W(this, X);
+    }
+    const n = e.reduce((r, s) => r ? r.concat([[r[r.length - 1][1], s]]) : [[qt, 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, u = this._max;
+    if (e.length === 0)
+      return we(this);
+    if (!e.every((v) => v[0] !== void 0 && v[1] !== void 0 && s(v[0], v[1]) <= 0))
+      return W(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 a = !n || n.includeLowers !== !1, l = n && n.includeUppers === !0;
+    let h, c = s;
+    function d(v, b) {
+      return c(v[0], b[0]);
+    }
+    try {
+      h = e.reduce(function(v, b) {
+        let x = 0, E = v.length;
+        for (; x < E; ++x) {
+          const k = v[x];
+          if (r(b[0], k[1]) < 0 && r(b[1], k[0]) > 0) {
+            k[0] = o(k[0], b[0]), k[1] = u(k[1], b[1]);
+            break;
+          }
+        }
+        return x === E && v.push(b), v;
+      }, []), h.sort(d);
+    } catch {
+      return W(this, X);
+    }
+    let m = 0;
+    const p = l ? (v) => s(v, h[m][1]) > 0 : (v) => s(v, h[m][1]) >= 0, f = a ? (v) => i(v, h[m][0]) > 0 : (v) => i(v, h[m][0]) >= 0;
+    let y = p;
+    const g = new this.Collection(this, () => re(h[0][0], h[h.length - 1][1], !a, !l));
+    return g._ondirectionchange = (v) => {
+      v === "next" ? (y = p, c = s) : (y = f, c = i), h.sort(d);
+    }, g._addAlgorithm((v, b, x) => {
+      for (var E = v.key; y(E); )
+        if (++m, m === h.length)
+          return b(x), !1;
+      return !!function(k) {
+        return !p(k) && !f(k);
+      }(E) || (this._cmp(E, h[m][1]) === 0 || this._cmp(E, h[m][0]) === 0 || b(() => {
+        c === s ? v.continue(h[m][0]) : v.continue(h[m][1]);
+      }), !1);
+    }), g;
+  }
+  startsWithAnyOf() {
+    const e = J.apply(_e, arguments);
+    return e.every((n) => typeof n == "string") ? e.length === 0 ? we(this) : this.inAnyRange(e.map((n) => [n, n + he])) : W(this, "startsWithAnyOf() only works with strings");
+  }
+}
+function Y(t) {
+  return R(function(e) {
+    return qe(e), t(e.target.error), !1;
+  });
+}
+function qe(t) {
+  t.stopPropagation && t.stopPropagation(), t.preventDefault && t.preventDefault();
+}
+const Le = "storagemutated", ie = "x-storagemutated-1", ue = $e(null, Le);
+class Mr {
+  _lock() {
+    return Ie(!P.global), ++this._reculock, this._reculock !== 1 || P.global || (P.lockOwnerFor = this), this;
+  }
+  _unlock() {
+    if (Ie(!P.global), --this._reculock == 0)
+      for (P.global || (P.lockOwnerFor = null); this._blockedFuncs.length > 0 && !this._locked(); ) {
+        var e = this._blockedFuncs.shift();
+        try {
+          Te(e[1], e[0]);
+        } catch {
+        }
+      }
+    return this;
+  }
+  _locked() {
+    return this._reculock && P.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 = R((s) => {
+      qe(s), this._reject(e.error);
+    }), e.onabort = R((s) => {
+      qe(s), this.active && this._reject(new C.Abort(e.error)), this.active = !1, this.on("abort").fire(s);
+    }), e.oncomplete = R(() => {
+      this.active = !1, this._resolve(), "mutatedParts" in e && ue.storagemutated.fire(e.mutatedParts);
+    }), this;
+  }
+  _promise(e, n, r) {
+    if (e === "readwrite" && this.mode !== "readwrite")
+      return N(new C.ReadOnly("Transaction is readonly"));
+    if (!this.active)
+      return N(new C.TransactionInactive());
+    if (this._locked())
+      return new S((i, o) => {
+        this._blockedFuncs.push([() => {
+          this._promise(e, n, r).then(i, o);
+        }, P]);
+      });
+    if (r)
+      return oe(() => {
+        var i = new S((o, u) => {
+          this._lock();
+          const a = n(o, u, this);
+          a && a.then && a.then(o, u);
+        });
+        return i.finally(() => this._unlock()), i._lib = !0, i;
+      });
+    var s = new S((i, o) => {
+      var u = n(i, o, this);
+      u && u.then && u.then(i, o);
+    });
+    return s._lib = !0, s;
+  }
+  _root() {
+    return this.parent ? this.parent._root() : this;
+  }
+  waitFor(e) {
+    var n = this._root();
+    const r = S.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 S((o, u) => {
+      r.then((a) => n._waitingQueue.push(R(o.bind(null, a))), (a) => n._waitingQueue.push(R(u.bind(null, a)))).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 (z(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 Lt(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 ? "++" : "") + er(e) };
+}
+function er(t) {
+  return typeof t == "string" ? t : t ? "[" + [].join.call(t, "+") + "]" : "";
+}
+function tr(t, e, n) {
+  return { name: t, primKey: e, indexes: n, mappedClass: null, idxByName: Kn(n, (r) => [r.name, r]) };
+}
+let Ue = (t) => {
+  try {
+    return t.only([[]]), Ue = () => [[]], [[]];
+  } catch {
+    return Ue = () => he, he;
+  }
+};
+function Ut(t) {
+  return t == null ? () => {
+  } : typeof t == "string" ? function(e) {
+    return e.split(".").length === 1 ? (n) => n[e] : (n) => te(n, e);
+  }(t) : (e) => te(e, t);
+}
+function En(t) {
+  return [].slice.call(t);
+}
+let Fr = 0;
+function Ne(t) {
+  return t == null ? ":id" : typeof t == "string" ? t : `[${t.join("+")}]`;
+}
+function qr(t, e, n) {
+  function r(a) {
+    if (a.type === 3)
+      return null;
+    if (a.type === 4)
+      throw new Error("Cannot convert never type to IDBKeyRange");
+    const { lower: l, upper: h, lowerOpen: c, upperOpen: d } = a;
+    return l === void 0 ? h === void 0 ? null : e.upperBound(h, !!d) : h === void 0 ? e.lowerBound(l, !!c) : e.bound(l, h, !!c, !!d);
+  }
+  const { schema: s, hasGetAll: i } = function(a, l) {
+    const h = En(a.objectStoreNames);
+    return { schema: { name: a.name, tables: h.map((c) => l.objectStore(c)).map((c) => {
+      const { keyPath: d, autoIncrement: m } = c, p = F(d), f = d == null, y = {}, g = { name: c.name, primaryKey: { name: null, isPrimaryKey: !0, outbound: f, compound: p, keyPath: d, autoIncrement: m, unique: !0, extractKey: Ut(d) }, indexes: En(c.indexNames).map((v) => c.index(v)).map((v) => {
+        const { name: b, unique: x, multiEntry: E, keyPath: k } = v, w = { name: b, compound: F(k), keyPath: k, unique: x, multiEntry: E, extractKey: Ut(k) };
+        return y[Ne(k)] = w, w;
+      }), getIndexByKeyPath: (v) => y[Ne(v)] };
+      return y[":id"] = g.primaryKey, d != null && (y[Ne(d)] = g.primaryKey), g;
+    }) }, hasGetAll: h.length > 0 && "getAll" in l.objectStore(h[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((a) => function(l) {
+    const h = l.name;
+    return { name: h, schema: l, mutate: function({ trans: c, type: d, keys: m, values: p, range: f }) {
+      return new Promise((y, g) => {
+        y = R(y);
+        const v = c.objectStore(h), b = v.keyPath == null, x = d === "put" || d === "add";
+        if (!x && d !== "delete" && d !== "deleteRange")
+          throw new Error("Invalid operation type: " + d);
+        const { length: E } = m || p || { length: 1 };
+        if (m && p && m.length !== p.length)
+          throw new Error("Given keys array must have same length as given values array.");
+        if (E === 0)
+          return y({ numFailures: 0, failures: {}, results: [], lastResult: void 0 });
+        let k;
+        const w = [], A = [];
+        let _ = 0;
+        const j = (q) => {
+          ++_, qe(q);
+        };
+        if (d === "deleteRange") {
+          if (f.type === 4)
+            return y({ numFailures: _, failures: A, results: [], lastResult: void 0 });
+          f.type === 3 ? w.push(k = v.clear()) : w.push(k = v.delete(r(f)));
+        } else {
+          const [q, B] = x ? b ? [p, m] : [p, null] : [m, null];
+          if (x)
+            for (let D = 0; D < E; ++D)
+              w.push(k = B && B[D] !== void 0 ? v[d](q[D], B[D]) : v[d](q[D])), k.onerror = j;
+          else
+            for (let D = 0; D < E; ++D)
+              w.push(k = v[d](q[D])), k.onerror = j;
+        }
+        const O = (q) => {
+          const B = q.target.result;
+          w.forEach((D, ye) => D.error != null && (A[ye] = D.error)), y({ numFailures: _, failures: A, results: d === "delete" ? m : w.map((D) => D.result), lastResult: B });
+        };
+        k.onerror = (q) => {
+          j(q), O(q);
+        }, k.onsuccess = O;
+      });
+    }, getMany: ({ trans: c, keys: d }) => new Promise((m, p) => {
+      m = R(m);
+      const f = c.objectStore(h), y = d.length, g = new Array(y);
+      let v, b = 0, x = 0;
+      const E = (w) => {
+        const A = w.target;
+        g[A._pos] = A.result, ++x === b && m(g);
+      }, k = Y(p);
+      for (let w = 0; w < y; ++w)
+        d[w] != null && (v = f.get(d[w]), v._pos = w, v.onsuccess = E, v.onerror = k, ++b);
+      b === 0 && m(g);
+    }), get: ({ trans: c, key: d }) => new Promise((m, p) => {
+      m = R(m);
+      const f = c.objectStore(h).get(d);
+      f.onsuccess = (y) => m(y.target.result), f.onerror = Y(p);
+    }), query: function(c) {
+      return (d) => new Promise((m, p) => {
+        m = R(m);
+        const { trans: f, values: y, limit: g, query: v } = d, b = g === 1 / 0 ? void 0 : g, { index: x, range: E } = v, k = f.objectStore(h), w = x.isPrimaryKey ? k : k.index(x.name), A = r(E);
+        if (g === 0)
+          return m({ result: [] });
+        if (c) {
+          const _ = y ? w.getAll(A, b) : w.getAllKeys(A, b);
+          _.onsuccess = (j) => m({ result: j.target.result }), _.onerror = Y(p);
+        } else {
+          let _ = 0;
+          const j = y || !("openKeyCursor" in w) ? w.openCursor(A) : w.openKeyCursor(A), O = [];
+          j.onsuccess = (q) => {
+            const B = j.result;
+            return B ? (O.push(y ? B.value : B.primaryKey), ++_ === g ? m({ result: O }) : void B.continue()) : m({ result: O });
+          }, j.onerror = Y(p);
+        }
+      });
+    }(i), openCursor: function({ trans: c, values: d, query: m, reverse: p, unique: f }) {
+      return new Promise((y, g) => {
+        y = R(y);
+        const { index: v, range: b } = m, x = c.objectStore(h), E = v.isPrimaryKey ? x : x.index(v.name), k = p ? f ? "prevunique" : "prev" : f ? "nextunique" : "next", w = d || !("openKeyCursor" in E) ? E.openCursor(r(b), k) : E.openKeyCursor(r(b), k);
+        w.onerror = Y(g), w.onsuccess = R((A) => {
+          const _ = w.result;
+          if (!_)
+            return void y(null);
+          _.___id = ++Fr, _.done = !1;
+          const j = _.continue.bind(_);
+          let O = _.continuePrimaryKey;
+          O && (O = O.bind(_));
+          const q = _.advance.bind(_), B = () => {
+            throw new Error("Cursor not stopped");
+          };
+          _.trans = c, _.stop = _.continue = _.continuePrimaryKey = _.advance = () => {
+            throw new Error("Cursor not started");
+          }, _.fail = R(g), _.next = function() {
+            let D = 1;
+            return this.start(() => D-- ? this.continue() : this.stop()).then(() => this);
+          }, _.start = (D) => {
+            const ye = new Promise((V, ce) => {
+              V = R(V), w.onerror = Y(ce), _.fail = ce, _.stop = (Ae) => {
+                _.stop = _.continue = _.continuePrimaryKey = _.advance = B, V(Ae);
+              };
+            }), ve = () => {
+              if (w.result)
+                try {
+                  D();
+                } catch (V) {
+                  _.fail(V);
+                }
+              else
+                _.done = !0, _.start = () => {
+                  throw new Error("Cursor behind last entry");
+                }, _.stop();
+            };
+            return w.onsuccess = R((V) => {
+              w.onsuccess = ve, ve();
+            }), _.continue = j, _.continuePrimaryKey = O, _.advance = q, ve(), ye;
+          }, y(_);
+        }, g);
+      });
+    }, count({ query: c, trans: d }) {
+      const { index: m, range: p } = c;
+      return new Promise((f, y) => {
+        const g = d.objectStore(h), v = m.isPrimaryKey ? g : g.index(m.name), b = r(p), x = b ? v.count(b) : v.count();
+        x.onsuccess = R((E) => f(E.target.result)), x.onerror = Y(y);
+      });
+    } };
+  }(a)), u = {};
+  return o.forEach((a) => u[a.name] = a), { stack: "dbcore", transaction: t.transaction.bind(t), table(a) {
+    if (!u[a])
+      throw new Error(`Table '${a}' not found`);
+    return u[a];
+  }, MIN_KEY: -1 / 0, MAX_KEY: Ue(e), schema: s };
+}
+function Vt({ _novip: t }, e) {
+  const n = e.db, r = function(s, i, { IDBKeyRange: o, indexedDB: u }, a) {
+    return { dbcore: function(l, h) {
+      return h.reduce((c, { create: d }) => ({ ...c, ...d(c) }), l);
+    }(qr(i, o, a), 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 mt({ _novip: t }, e, n, r) {
+  n.forEach((s) => {
+    const i = r[s];
+    e.forEach((o) => {
+      const u = Zt(o, s);
+      (!u || "value" in u && u.value === void 0) && (o === t.Transaction.prototype || o instanceof t.Transaction ? ee(o, s, { get() {
+        return this.table(s);
+      }, set(a) {
+        An(this, s, { value: a, writable: !0, configurable: !0, enumerable: !0 });
+      } }) : o[s] = new t.Table(s, i));
+    });
+  });
+}
+function Wt({ _novip: t }, e) {
+  e.forEach((n) => {
+    for (let r in n)
+      n[r] instanceof t.Table && delete n[r];
+  });
+}
+function Lr(t, e) {
+  return t._cfg.version - e._cfg.version;
+}
+function Ur(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), u = P.transless || P;
+  oe(() => {
+    P.trans = i, P.transless = u, e === 0 ? ($(s).forEach((a) => {
+      Pt(n, a, s[a].primKey, s[a].indexes);
+    }), Vt(t, n), S.follow(() => t.on.populate.fire(i)).catch(o)) : function({ _novip: a }, l, h, c) {
+      const d = [], m = a._versions;
+      let p = a._dbSchema = Ht(a, a.idbdb, c), f = !1;
+      const y = m.filter((v) => v._cfg.version >= l);
+      function g() {
+        return d.length ? S.resolve(d.shift()(h.idbtrans)).then(g) : S.resolve();
+      }
+      return y.forEach((v) => {
+        d.push(() => {
+          const b = p, x = v._cfg.dbschema;
+          Yt(a, b, c), Yt(a, x, c), p = a._dbSchema = x;
+          const E = nr(b, x);
+          E.add.forEach((w) => {
+            Pt(c, w[0], w[1].primKey, w[1].indexes);
+          }), E.change.forEach((w) => {
+            if (w.recreate)
+              throw new C.Upgrade("Not yet support for changing primary key");
+            {
+              const A = c.objectStore(w.name);
+              w.add.forEach((_) => zt(A, _)), w.change.forEach((_) => {
+                A.deleteIndex(_.name), zt(A, _);
+              }), w.del.forEach((_) => A.deleteIndex(_));
+            }
+          });
+          const k = v._cfg.contentUpgrade;
+          if (k && v._cfg.version > l) {
+            Vt(a, c), h._memoizedTables = {}, f = !0;
+            let w = Rn(x);
+            E.del.forEach((O) => {
+              w[O] = b[O];
+            }), Wt(a, [a.Transaction.prototype]), mt(a, [a.Transaction.prototype], $(w), w), h.schema = w;
+            const A = en(k);
+            let _;
+            A && Ce();
+            const j = S.follow(() => {
+              if (_ = k(h), _ && A) {
+                var O = ne.bind(null, null);
+                _.then(O, O);
+              }
+            });
+            return _ && typeof _.then == "function" ? S.resolve(_) : j.then(() => _);
+          }
+        }), d.push((b) => {
+          (!f || !Kr) && function(x, E) {
+            [].slice.call(E.db.objectStoreNames).forEach((k) => x[k] == null && E.db.deleteObjectStore(k));
+          }(v._cfg.dbschema, b), Wt(a, [a.Transaction.prototype]), mt(a, [a.Transaction.prototype], a._storeNames, a._dbSchema), h.schema = a._dbSchema;
+        });
+      }), g().then(() => {
+        var v, b;
+        b = c, $(v = p).forEach((x) => {
+          b.db.objectStoreNames.contains(x) || Pt(b, x, v[x].primKey, v[x].indexes);
+        });
+      });
+    }(t, e, i, n).catch(o);
+  });
+}
+function nr(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 && !yt)
+        o.recreate = !0, n.change.push(o);
+      else {
+        const u = s.idxByName, a = i.idxByName;
+        let l;
+        for (l in u)
+          a[l] || o.del.push(l);
+        for (l in a) {
+          const h = u[l], c = a[l];
+          h ? h.src !== c.src && o.change.push(c) : o.add.push(c);
+        }
+        (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 Pt(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) => zt(s, i)), s;
+}
+function zt(t, e) {
+  t.createIndex(e.name, e.keyPath, { unique: e.unique, multiEntry: e.multi });
+}
+function Ht(t, e, n) {
+  const r = {};
+  return ct(e.objectStoreNames, 0).forEach((s) => {
+    const i = n.objectStore(s);
+    let o = i.keyPath;
+    const u = Lt(er(o), o || "", !1, !1, !!i.autoIncrement, o && typeof o != "string", !0), a = [];
+    for (let h = 0; h < i.indexNames.length; ++h) {
+      const c = i.index(i.indexNames[h]);
+      o = c.keyPath;
+      var l = Lt(c.name, o, !!c.unique, !!c.multiEntry, !1, o && typeof o != "string", !1);
+      a.push(l);
+    }
+    r[s] = tr(s, u, a);
+  }), r;
+}
+function Yt({ _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 u = 0; u < o.indexNames.length; ++u) {
+      const a = o.indexNames[u], l = o.index(a).keyPath, h = typeof l == "string" ? l : "[" + ct(l).join("+") + "]";
+      if (e[i]) {
+        const c = e[i].idxByName[h];
+        c && (c.name = a, delete e[i].idxByName[h], e[i].idxByName[a] = c);
+      }
+    }
+  }
+  typeof navigator < "u" && /Safari/.test(navigator.userAgent) && !/(Chrome\/|Edge\/)/.test(navigator.userAgent) && K.WorkerGlobalScope && K instanceof K.WorkerGlobalScope && [].concat(navigator.userAgent.match(/Safari\/(\d*)/))[1] < 604 && (t._hasGetAll = !1);
+}
+class Vr {
+  _parseStoresSpec(e, n) {
+    $(e).forEach((r) => {
+      if (e[r] !== null) {
+        var s = e[r].split(",").map((o, u) => {
+          const a = (o = o.trim()).replace(/([&*]|\+\+)/g, ""), l = /^\[/.test(a) ? a.match(/^\[(.*)\]$/)[1].split("+") : a;
+          return Lt(a, l || null, /\&/.test(o), /\*/.test(o), /\+\+/.test(o), F(l), u === 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] = tr(r, i, s);
+      }
+    });
+  }
+  stores(e) {
+    const n = this.db;
+    this._cfg.storesSource = this._cfg.storesSource ? U(this._cfg.storesSource, e) : e;
+    const r = n._versions, s = {};
+    let i = {};
+    return r.forEach((o) => {
+      U(s, o._cfg.storesSource), i = o._cfg.dbschema = {}, o._parseStoresSpec(s, i);
+    }), n._dbSchema = i, Wt(n, [n._allTables, n, n.Transaction.prototype]), mt(n, [n._allTables, n, n.Transaction.prototype, this._cfg.tables], $(i), i), n._storeNames = $(i), this;
+  }
+  upgrade(e) {
+    return this._cfg.contentUpgrade = rn(this._cfg.contentUpgrade || I, e), this;
+  }
+}
+function un(t, e) {
+  let n = t._dbNamesDB;
+  return n || (n = t._dbNamesDB = new pe(vt, { addons: [], indexedDB: t, IDBKeyRange: e }), n.version(1).stores({ dbnames: "name" })), n.table("dbnames");
+}
+function cn(t) {
+  return t && typeof t.databases == "function";
+}
+function Gt(t) {
+  return oe(function() {
+    return P.letThrough = !0, t();
+  });
+}
+function Wr() {
+  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 zr(t) {
+  const e = t._state, { indexedDB: n } = t._deps;
+  if (e.isBeingOpened || t.idbdb)
+    return e.dbReadyPromise.then(() => e.dbOpenError ? N(e.dbOpenError) : t);
+  G && (e.openCanceller._stackHolder = Pe()), 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, u = !1;
+  return S.race([r, (typeof navigator > "u" ? S.resolve() : Wr()).then(() => new S((a, l) => {
+    if (s(), !n)
+      throw new C.MissingAPI();
+    const h = t.name, c = e.autoSchema ? n.open(h) : n.open(h, Math.round(10 * t.verno));
+    if (!c)
+      throw new C.MissingAPI();
+    c.onerror = Y(l), c.onblocked = R(t._fireOnBlocked), c.onupgradeneeded = R((d) => {
+      if (o = c.transaction, e.autoSchema && !t._options.allowEmptyDB) {
+        c.onerror = qe, o.abort(), c.result.close();
+        const p = n.deleteDatabase(h);
+        p.onsuccess = p.onerror = R(() => {
+          l(new C.NoSuchDatabase(`Database ${h} doesnt exist`));
+        });
+      } else {
+        o.onerror = Y(l);
+        var m = d.oldVersion > Math.pow(2, 62) ? 0 : d.oldVersion;
+        u = m < 1, t._novip.idbdb = c.result, Ur(t, m / 10, o, l);
+      }
+    }, l), c.onsuccess = R(() => {
+      o = null;
+      const d = t._novip.idbdb = c.result, m = ct(d.objectStoreNames);
+      if (m.length > 0)
+        try {
+          const f = d.transaction((p = m).length === 1 ? p[0] : p, "readonly");
+          e.autoSchema ? function({ _novip: y }, g, v) {
+            y.verno = g.version / 10;
+            const b = y._dbSchema = Ht(0, g, v);
+            y._storeNames = ct(g.objectStoreNames, 0), mt(y, [y._allTables], $(b), b);
+          }(t, d, f) : (Yt(t, t._dbSchema, f), function(y, g) {
+            const v = nr(Ht(0, y.idbdb, g), y._dbSchema);
+            return !(v.add.length || v.change.some((b) => b.add.length || b.change.length));
+          }(t, f) || console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail.")), Vt(t, f);
+        } catch {
+        }
+      var p;
+      De.push(t), d.onversionchange = R((f) => {
+        e.vcFired = !0, t.on("versionchange").fire(f);
+      }), d.onclose = R((f) => {
+        t.on("close").fire(f);
+      }), u && function({ indexedDB: f, IDBKeyRange: y }, g) {
+        !cn(f) && g !== vt && un(f, y).put({ name: g }).catch(I);
+      }(t._deps, h), a();
+    }, l);
+  }))]).then(() => (s(), e.onReadyBeingFired = [], S.resolve(Gt(() => t.on.ready.fire(t.vip))).then(function a() {
+    if (e.onReadyBeingFired.length > 0) {
+      let l = e.onReadyBeingFired.reduce(rn, I);
+      return e.onReadyBeingFired = [], S.resolve(Gt(() => l(t.vip))).then(a);
+    }
+  }))).finally(() => {
+    e.onReadyBeingFired = null, e.isBeingOpened = !1;
+  }).then(() => t).catch((a) => {
+    e.dbOpenError = a;
+    try {
+      o && o.abort();
+    } catch {
+    }
+    return r === e.openCanceller && t._close(), N(a);
+  }).finally(() => {
+    e.openComplete = !0, i();
+  });
+}
+function Xt(t) {
+  var e = (i) => t.next(i), n = s(e), r = s((i) => t.throw(i));
+  function s(i) {
+    return (o) => {
+      var u = i(o), a = u.value;
+      return u.done ? a : a && typeof a.then == "function" ? a.then(n, r) : F(a) ? Promise.all(a).then(n, r) : n(a);
+    };
+  }
+  return s(e)();
+}
+function Hr(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, jn(s), n];
+}
+function rr(t, e, n, r, s) {
+  return S.resolve().then(() => {
+    const i = P.transless || P, o = t._createTransaction(e, n, t._dbSchema, r), u = { trans: o, transless: i };
+    if (r)
+      o.idbtrans = r.idbtrans;
+    else
+      try {
+        o.create(), t._state.PR1398_maxLoop = 3;
+      } catch (c) {
+        return c.name === nn.InvalidState && t.isOpen() && --t._state.PR1398_maxLoop > 0 ? (console.warn("Dexie: Need to reopen db"), t._close(), t.open().then(() => rr(t, e, n, null, s))) : N(c);
+      }
+    const a = en(s);
+    let l;
+    a && Ce();
+    const h = S.follow(() => {
+      if (l = s.call(o, o), l)
+        if (a) {
+          var c = ne.bind(null, null);
+          l.then(c, c);
+        } else
+          typeof l.next == "function" && typeof l.throw == "function" && (l = Xt(l));
+    }, u);
+    return (l && typeof l.then == "function" ? S.resolve(l).then((c) => o.active ? c : N(new C.PrematureCommit("Transaction committed too early. See http://bit.ly/2kdckMn"))) : h.then(() => l)).then((c) => (r && o._resolve(), o._completion.then(() => c))).catch((c) => (o._reject(c), N(c)));
+  });
+}
+function et(t, e, n) {
+  const r = F(t) ? t.slice() : [t];
+  for (let s = 0; s < n; ++s)
+    r.push(e);
+  return r;
+}
+const Yr = { 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(l, h, c) {
+      const d = Ne(l), m = s[d] = s[d] || [], p = l == null ? 0 : typeof l == "string" ? 1 : l.length, f = h > 0, y = { ...c, isVirtual: f, keyTail: h, keyLength: p, extractKey: Ut(l), unique: !f && c.unique };
+      return m.push(y), y.isPrimaryKey || i.push(y), p > 1 && o(p === 2 ? l[0] : l.slice(0, p - 1), h + 1, c), m.sort((g, v) => g.keyTail - v.keyTail), y;
+    }
+    const u = o(r.primaryKey.keyPath, 0, r.primaryKey);
+    s[":id"] = [u];
+    for (const l of r.indexes)
+      o(l.keyPath, 0, l);
+    function a(l) {
+      const h = l.query.index;
+      return h.isVirtual ? { ...l, query: { index: h, range: (c = l.query.range, d = h.keyTail, { type: c.type === 1 ? 2 : c.type, lower: et(c.lower, c.lowerOpen ? t.MAX_KEY : t.MIN_KEY, d), lowerOpen: !0, upper: et(c.upper, c.upperOpen ? t.MIN_KEY : t.MAX_KEY, d), upperOpen: !0 }) } } : l;
+      var c, d;
+    }
+    return { ...n, schema: { ...r, primaryKey: u, indexes: i, getIndexByKeyPath: function(l) {
+      const h = s[Ne(l)];
+      return h && h[0];
+    } }, count: (l) => n.count(a(l)), query: (l) => n.query(a(l)), openCursor(l) {
+      const { keyTail: h, isVirtual: c, keyLength: d } = l.query.index;
+      return c ? n.openCursor(a(l)).then((m) => m && function(p) {
+        return Object.create(p, { continue: { value: function(f) {
+          f != null ? p.continue(et(f, l.reverse ? t.MAX_KEY : t.MIN_KEY, h)) : l.unique ? p.continue(p.key.slice(0, d).concat(l.reverse ? t.MIN_KEY : t.MAX_KEY, h)) : p.continue();
+        } }, continuePrimaryKey: { value(f, y) {
+          p.continuePrimaryKey(et(f, t.MAX_KEY, h), y);
+        } }, primaryKey: { get: () => p.primaryKey }, key: { get() {
+          const f = p.key;
+          return d === 1 ? f[0] : f.slice(0, d);
+        } }, value: { get: () => p.value } });
+      }(m)) : n.openCursor(l);
+    } };
+  } };
+} };
+function ln(t, e, n, r) {
+  return n = n || {}, r = r || "", $(t).forEach((s) => {
+    if (z(e, s)) {
+      var i = t[s], o = e[s];
+      if (typeof i == "object" && typeof o == "object" && i && o) {
+        const u = At(i);
+        u !== At(o) ? n[r + s] = e[s] : u === "Object" ? ln(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;
+  }), $(e).forEach((s) => {
+    z(t, s) || (n[r + s] = e[s]);
+  }), n;
+}
+const Gr = { stack: "dbcore", name: "HooksMiddleware", level: 2, create: (t) => ({ ...t, table(e) {
+  const n = t.table(e), { primaryKey: r } = n.schema;
+  return { ...n, mutate(s) {
+    const i = P.trans, { deleting: o, creating: u, updating: a } = i.table(e).hook;
+    switch (s.type) {
+      case "add":
+        if (u.fire === I)
+          break;
+        return i._promise("readwrite", () => l(s), !0);
+      case "put":
+        if (u.fire === I && a.fire === I)
+          break;
+        return i._promise("readwrite", () => l(s), !0);
+      case "delete":
+        if (o.fire === I)
+          break;
+        return i._promise("readwrite", () => l(s), !0);
+      case "deleteRange":
+        if (o.fire === I)
+          break;
+        return i._promise("readwrite", () => function(c) {
+          return h(c.trans, c.range, 1e4);
+        }(s), !0);
+    }
+    return n.mutate(s);
+    function l(c) {
+      const d = P.trans, m = c.keys || function(p, f) {
+        return f.type === "delete" ? f.keys : f.keys || f.values.map(p.extractKey);
+      }(r, c);
+      if (!m)
+        throw new Error("Keys missing");
+      return (c = c.type === "add" || c.type === "put" ? { ...c, keys: m } : { ...c }).type !== "delete" && (c.values = [...c.values]), c.keys && (c.keys = [...c.keys]), function(p, f, y) {
+        return f.type === "add" ? Promise.resolve([]) : p.getMany({ trans: f.trans, keys: y, cache: "immutable" });
+      }(n, c, m).then((p) => {
+        const f = m.map((y, g) => {
+          const v = p[g], b = { onerror: null, onsuccess: null };
+          if (c.type === "delete")
+            o.fire.call(b, y, v, d);
+          else if (c.type === "add" || v === void 0) {
+            const x = u.fire.call(b, y, c.values[g], d);
+            y == null && x != null && (y = x, c.keys[g] = y, r.outbound || H(c.values[g], r.keyPath, y));
+          } else {
+            const x = ln(v, c.values[g]), E = a.fire.call(b, x, y, v, d);
+            if (E) {
+              const k = c.values[g];
+              Object.keys(E).forEach((w) => {
+                z(k, w) ? k[w] = E[w] : H(k, w, E[w]);
+              });
+            }
+          }
+          return b;
+        });
+        return n.mutate(c).then(({ failures: y, results: g, numFailures: v, lastResult: b }) => {
+          for (let x = 0; x < m.length; ++x) {
+            const E = g ? g[x] : m[x], k = f[x];
+            E == null ? k.onerror && k.onerror(y[x]) : k.onsuccess && k.onsuccess(c.type === "put" && p[x] ? c.values[x] : E);
+          }
+          return { failures: y, results: g, numFailures: v, lastResult: b };
+        }).catch((y) => (f.forEach((g) => g.onerror && g.onerror(y)), Promise.reject(y)));
+      });
+    }
+    function h(c, d, m) {
+      return n.query({ trans: c, values: !1, query: { index: r, range: d }, limit: m }).then(({ result: p }) => l({ type: "delete", keys: p, trans: c }).then((f) => f.numFailures > 0 ? Promise.reject(f.failures[0]) : p.length < m ? { failures: [], numFailures: 0, lastResult: void 0 } : h(c, { ...d, lower: p[p.length - 1], lowerOpen: !0 }, m)));
+    }
+  } };
+} }) };
+function sr(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)
+      L(e.keys[s], t[i]) === 0 && (r.push(n ? We(e.values[s]) : e.values[s]), ++i);
+    return r.length === t.length ? r : null;
+  } catch {
+    return null;
+  }
+}
+const Xr = { 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 = sr(r.keys, r.trans._cache, r.cache === "clone");
+    return s ? S.resolve(s) : n.getMany(r).then((i) => (r.trans._cache = { keys: r.keys, values: r.cache === "clone" ? We(i) : i }, i));
+  }, mutate: (r) => (r.type !== "add" && (r.trans._cache = null), n.mutate(r)) };
+} }) };
+function hn(t) {
+  return !("from" in t);
+}
+const Q = function(t, e) {
+  if (!this) {
+    const n = new Q();
+    return t && "d" in t && U(n, t), n;
+  }
+  U(this, arguments.length ? { d: 1, from: t, to: arguments.length > 1 ? e : t } : { d: 0 });
+};
+function Ve(t, e, n) {
+  const r = L(e, n);
+  if (isNaN(r))
+    return;
+  if (r > 0)
+    throw RangeError();
+  if (hn(t))
+    return U(t, { from: e, to: n, d: 1 });
+  const s = t.l, i = t.r;
+  if (L(n, t.from) < 0)
+    return s ? Ve(s, e, n) : t.l = { from: e, to: n, d: 1, l: null, r: null }, Pn(t);
+  if (L(e, t.to) > 0)
+    return i ? Ve(i, e, n) : t.r = { from: e, to: n, d: 1, l: null, r: null }, Pn(t);
+  L(e, t.from) < 0 && (t.from = e, t.l = null, t.d = i ? i.d + 1 : 1), L(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 && gt(t, s), i && o && gt(t, i);
+}
+function gt(t, e) {
+  hn(e) || function n(r, { from: s, to: i, l: o, r: u }) {
+    Ve(r, s, i), o && n(r, o), u && n(r, u);
+  }(t, e);
+}
+function Qr(t, e) {
+  const n = Qt(e);
+  let r = n.next();
+  if (r.done)
+    return !1;
+  let s = r.value;
+  const i = Qt(t);
+  let o = i.next(s.from), u = o.value;
+  for (; !r.done && !o.done; ) {
+    if (L(u.from, s.to) <= 0 && L(u.to, s.from) >= 0)
+      return !0;
+    L(s.from, u.from) < 0 ? s = (r = n.next(u.from)).value : u = (o = i.next(s.from)).value;
+  }
+  return !1;
+}
+function Qt(t) {
+  let e = hn(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 && L(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 || L(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 Pn(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 }, u = t[s];
+    t.from = u.from, t.to = u.to, t[s] = u[s], o[s] = u[i], t[i] = o, o.d = Cn(o);
+  }
+  t.d = Cn(t);
+}
+function Cn({ r: t, l: e }) {
+  return (t ? e ? Math.max(t.d, e.d) : t.d : e ? e.d : 0) + 1;
+}
+Ee(Q.prototype, { add(t) {
+  return gt(this, t), this;
+}, addKey(t) {
+  return Ve(this, t, t), this;
+}, addKeys(t) {
+  return t.forEach((e) => Ve(this, e, e)), this;
+}, [Ot]() {
+  return Qt(this);
+} });
+const Jr = { stack: "dbcore", level: 0, create: (t) => {
+  const e = t.schema.name, n = new Q(t.MIN_KEY, t.MAX_KEY);
+  return { ...t, table: (r) => {
+    const s = t.table(r), { schema: i } = s, { primaryKey: o } = i, { extractKey: u, outbound: a } = o, l = { ...s, mutate: (d) => {
+      const m = d.trans, p = m.mutatedParts || (m.mutatedParts = {}), f = (k) => {
+        const w = `idb://${e}/${r}/${k}`;
+        return p[w] || (p[w] = new Q());
+      }, y = f(""), g = f(":dels"), { type: v } = d;
+      let [b, x] = d.type === "deleteRange" ? [d.range] : d.type === "delete" ? [d.keys] : d.values.length < 50 ? [[], d.values] : [];
+      const E = d.trans._cache;
+      return s.mutate(d).then((k) => {
+        if (F(b)) {
+          v !== "delete" && (b = k.results), y.addKeys(b);
+          const w = sr(b, E);
+          w || v === "add" || g.addKeys(b), (w || x) && function(A, _, j, O) {
+            function q(B) {
+              const D = A(B.name || "");
+              function ye(V) {
+                return V != null ? B.extractKey(V) : null;
+              }
+              const ve = (V) => B.multiEntry && F(V) ? V.forEach((ce) => D.addKey(ce)) : D.addKey(V);
+              (j || O).forEach((V, ce) => {
+                const Ae = j && ye(j[ce]), bt = O && ye(O[ce]);
+                L(Ae, bt) !== 0 && (Ae != null && ve(Ae), bt != null && ve(bt));
+              });
+            }
+            _.indexes.forEach(q);
+          }(f, i, w, x);
+        } else if (b) {
+          const w = { from: b.lower, to: b.upper };
+          g.add(w), y.add(w);
+        } else
+          y.add(n), g.add(n), i.indexes.forEach((w) => f(w.name).add(n));
+        return k;
+      });
+    } }, h = ({ query: { index: d, range: m } }) => {
+      var p, f;
+      return [d, new Q((p = m.lower) !== null && p !== void 0 ? p : t.MIN_KEY, (f = m.upper) !== null && f !== void 0 ? f : t.MAX_KEY)];
+    }, c = { get: (d) => [o, new Q(d.key)], getMany: (d) => [o, new Q().addKeys(d.keys)], count: h, query: h, openCursor: h };
+    return $(c).forEach((d) => {
+      l[d] = function(m) {
+        const { subscr: p } = P;
+        if (p) {
+          const f = (x) => {
+            const E = `idb://${e}/${r}/${x}`;
+            return p[E] || (p[E] = new Q());
+          }, y = f(""), g = f(":dels"), [v, b] = c[d](m);
+          if (f(v.name || "").add(b), !v.isPrimaryKey) {
+            if (d !== "count") {
+              const x = d === "query" && a && m.values && s.query({ ...m, values: !1 });
+              return s[d].apply(this, arguments).then((E) => {
+                if (d === "query") {
+                  if (a && m.values)
+                    return x.then(({ result: w }) => (y.addKeys(w), E));
+                  const k = m.values ? E.result.map(u) : E.result;
+                  m.values ? y.addKeys(k) : g.addKeys(k);
+                } else if (d === "openCursor") {
+                  const k = E, w = m.values;
+                  return k && Object.create(k, { key: { get: () => (g.addKey(k.primaryKey), k.key) }, primaryKey: { get() {
+                    const A = k.primaryKey;
+                    return g.addKey(A), A;
+                  } }, value: { get: () => (w && y.addKey(k.primaryKey), k.value) } });
+                }
+                return E;
+              });
+            }
+            g.add(n);
+          }
+        }
+        return s[d].apply(this, arguments);
+      };
+    }), l;
+  } };
+} };
+class pe {
+  constructor(e, n) {
+    this._middlewares = {}, this.verno = 0;
+    const r = pe.dependencies;
+    this._options = n = { addons: pe.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: I, dbReadyPromise: null, cancelOpen: I, openCanceller: null, autoSchema: !0, PR1398_maxLoop: 3 };
+    var o;
+    i.dbReadyPromise = new S((u) => {
+      i.dbReadyResolve = u;
+    }), i.openCanceller = new S((u, a) => {
+      i.cancelOpen = a;
+    }), this._state = i, this.name = e, this.on = $e(this, "populate", "blocked", "versionchange", "close", { ready: [rn, I] }), this.on.ready.subscribe = On(this.on.ready.subscribe, (u) => (a, l) => {
+      pe.vip(() => {
+        const h = this._state;
+        if (h.openComplete)
+          h.dbOpenError || S.resolve().then(a), l && u(a);
+        else if (h.onReadyBeingFired)
+          h.onReadyBeingFired.push(a), l && u(a);
+        else {
+          u(a);
+          const c = this;
+          l || u(function d() {
+            c.on.ready.unsubscribe(a), c.on.ready.unsubscribe(d);
+          });
+        }
+      });
+    }), this.Collection = (o = this, Oe(Dr.prototype, function(u, a) {
+      this.db = o;
+      let l = Qn, h = null;
+      if (a)
+        try {
+          l = a();
+        } catch (p) {
+          h = p;
+        }
+      const c = u._ctx, d = c.table, m = d.hook.reading.fire;
+      this._ctx = { table: d, index: c.index, isPrimKey: !c.index || d.schema.primKey.keyPath && c.index === d.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: h, or: c.or, valueMapper: m !== Me ? m : null };
+    })), this.Table = function(u) {
+      return Oe(jr.prototype, function(a, l, h) {
+        this.db = u, this._tx = h, this.name = a, this.schema = l, this.hook = u._allTables[a] ? u._allTables[a].hook : $e(null, { creating: [kr, I], reading: [_r, Me], updating: [Sr, I], deleting: [xr, I] });
+      });
+    }(this), this.Transaction = function(u) {
+      return Oe(Mr.prototype, function(a, l, h, c, d) {
+        this.db = u, this.mode = a, this.storeNames = l, this.schema = h, this.chromeTransactionDurability = c, this.idbtrans = null, this.on = $e(this, "complete", "error", "abort"), this.parent = d || 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 S((m, p) => {
+          this._resolve = m, this._reject = p;
+        }), this._completion.then(() => {
+          this.active = !1, this.on.complete.fire();
+        }, (m) => {
+          var p = this.active;
+          return this.active = !1, this.on.error.fire(m), this.parent ? this.parent._reject(m) : p && this.idbtrans && this.idbtrans.abort(), N(m);
+        });
+      });
+    }(this), this.Version = function(u) {
+      return Oe(Vr.prototype, function(a) {
+        this.db = u, this._cfg = { version: a, storesSource: null, dbschema: {}, tables: {}, contentUpgrade: null };
+      });
+    }(this), this.WhereClause = function(u) {
+      return Oe(Zn.prototype, function(a, l, h) {
+        this.db = u, this._ctx = { table: a, index: l === ":id" ? null : l, or: h };
+        const c = u._deps.indexedDB;
+        if (!c)
+          throw new C.MissingAPI();
+        this._cmp = this._ascending = c.cmp.bind(c), this._descending = (d, m) => c.cmp(m, d), this._max = (d, m) => c.cmp(d, m) > 0 ? d : m, this._min = (d, m) => c.cmp(d, m) < 0 ? d : m, this._IDBKeyRange = u._deps.IDBKeyRange;
+      });
+    }(this), this.on("versionchange", (u) => {
+      u.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", (u) => {
+      !u.newVersion || u.newVersion < u.oldVersion ? console.warn(`Dexie.delete('${this.name}') was blocked`) : console.warn(`Upgrade '${this.name}' blocked by other connection holding version ${u.oldVersion / 10}`);
+    }), this._maxKey = Ue(n.IDBKeyRange), this._createTransaction = (u, a, l, h) => new this.Transaction(u, a, l, this._options.chromeTransactionDurability, h), this._fireOnBlocked = (u) => {
+      this.on("blocked").fire(u), De.filter((a) => a.name === this.name && a !== this && !a._state.vcFired).map((a) => a.on("versionchange").fire(u));
+    }, this.use(Yr), this.use(Gr), this.use(Jr), this.use(Xr), this.vip = Object.create(this, { _vip: { value: !0 } }), s.forEach((u) => u(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(Lr), r.stores({}), this._state.autoSchema = !1, r);
+  }
+  _whenReady(e) {
+    return this.idbdb && (this._state.openComplete || P.letThrough || this._vip) ? e() : new S((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(I);
+      }
+      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, u) => o.level - u.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 zr(this);
+  }
+  _close() {
+    const e = this._state, n = De.indexOf(this);
+    if (n >= 0 && De.splice(n, 1), this.idbdb) {
+      try {
+        this.idbdb.close();
+      } catch {
+      }
+      this._novip.idbdb = null;
+    }
+    e.dbReadyPromise = new S((r) => {
+      e.dbReadyResolve = r;
+    }), e.openCanceller = new S((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 S((r, s) => {
+      const i = () => {
+        this.close();
+        var o = this._deps.indexedDB.deleteDatabase(this.name);
+        o.onsuccess = R(() => {
+          (function({ indexedDB: u, IDBKeyRange: a }, l) {
+            !cn(u) && l !== vt && un(u, a).delete(l).catch(I);
+          })(this._deps, this.name), r();
+        }), o.onerror = Y(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 $(this._allTables).map((e) => this._allTables[e]);
+  }
+  transaction() {
+    const e = Hr.apply(this, arguments);
+    return this._transaction.apply(this, e);
+  }
+  _transaction(e, n, r) {
+    let s = P.trans;
+    s && s.db === this && e.indexOf("!") === -1 || (s = null);
+    const i = e.indexOf("?") !== -1;
+    let o, u;
+    e = e.replace("!", "").replace("?", "");
+    try {
+      if (u = n.map((l) => {
+        var h = l instanceof this.Table ? l.name : l;
+        if (typeof h != "string")
+          throw new TypeError("Invalid table argument to Dexie.transaction(). Only Table or String are allowed");
+        return h;
+      }), e == "r" || e === _t)
+        o = _t;
+      else {
+        if (e != "rw" && e != kt)
+          throw new C.InvalidArgument("Invalid transaction mode: " + e);
+        o = kt;
+      }
+      if (s) {
+        if (s.mode === _t && o === kt) {
+          if (!i)
+            throw new C.SubTransaction("Cannot enter a sub-transaction with READWRITE mode when parent transaction is READONLY");
+          s = null;
+        }
+        s && u.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, (h, c) => {
+        c(l);
+      }) : N(l);
+    }
+    const a = rr.bind(null, this, o, u, s, r);
+    return s ? s._promise(o, a, "lock") : P.trans ? Te(P.transless, () => this._whenReady(a)) : this._whenReady(a);
+  }
+  table(e) {
+    if (!z(this._allTables, e))
+      throw new C.InvalidTable(`Table ${e} does not exist`);
+    return this._allTables[e];
+  }
+}
+const Zr = typeof Symbol < "u" && "observable" in Symbol ? Symbol.observable : "@@observable";
+class es {
+  constructor(e) {
+    this._subscribe = e;
+  }
+  subscribe(e, n, r) {
+    return this._subscribe(e && typeof e != "function" ? e : { next: e, error: n, complete: r });
+  }
+  [Zr]() {
+    return this;
+  }
+}
+function ir(t, e) {
+  return $(e).forEach((n) => {
+    gt(t[n] || (t[n] = new Q()), e[n]);
+  }), t;
+}
+function ts(t) {
+  let e, n = !1;
+  const r = new es((s) => {
+    const i = en(t);
+    let o = !1, u = {}, a = {};
+    const l = { get closed() {
+      return o;
+    }, unsubscribe: () => {
+      o = !0, ue.storagemutated.unsubscribe(m);
+    } };
+    s.start && s.start(l);
+    let h = !1, c = !1;
+    function d() {
+      return $(a).some((f) => u[f] && Qr(u[f], a[f]));
+    }
+    const m = (f) => {
+      ir(u, f), d() && p();
+    }, p = () => {
+      if (h || o)
+        return;
+      u = {};
+      const f = {}, y = function(g) {
+        i && Ce();
+        const v = () => oe(t, { subscr: g, trans: null }), b = P.trans ? Te(P.transless, v) : v();
+        return i && b.then(ne, ne), b;
+      }(f);
+      c || (ue(Le, m), c = !0), h = !0, Promise.resolve(y).then((g) => {
+        n = !0, e = g, h = !1, o || (d() ? p() : (u = {}, a = f, s.next && s.next(g)));
+      }, (g) => {
+        h = !1, n = !1, s.error && s.error(g), l.unsubscribe();
+      });
+    };
+    return p(), l;
+  });
+  return r.hasValue = () => n, r.getValue = () => e, r;
+}
+let Jt;
+try {
+  Jt = { indexedDB: K.indexedDB || K.mozIndexedDB || K.webkitIndexedDB || K.msIndexedDB, IDBKeyRange: K.IDBKeyRange || K.webkitIDBKeyRange };
+} catch {
+  Jt = { indexedDB: null, IDBKeyRange: null };
+}
+const le = pe;
+function at(t) {
+  let e = Z;
+  try {
+    Z = !0, ue.storagemutated.fire(t);
+  } finally {
+    Z = e;
+  }
+}
+Ee(le, { ...tt, delete: (t) => new le(t, { addons: [] }).delete(), exists: (t) => new le(t, { addons: [] }).open().then((e) => (e.close(), !0)).catch("NoSuchDatabaseError", () => !1), getDatabaseNames(t) {
+  try {
+    return function({ indexedDB: e, IDBKeyRange: n }) {
+      return cn(e) ? Promise.resolve(e.databases()).then((r) => r.map((s) => s.name).filter((s) => s !== vt)) : un(e, n).toCollection().primaryKeys();
+    }(le.dependencies).then(t);
+  } catch {
+    return N(new C.MissingAPI());
+  }
+}, defineClass: () => function(t) {
+  U(this, t);
+}, ignoreTransaction: (t) => P.trans ? Te(P.transless, t) : t(), vip: Gt, async: function(t) {
+  return function() {
+    try {
+      var e = Xt(t.apply(this, arguments));
+      return e && typeof e.then == "function" ? e : S.resolve(e);
+    } catch (n) {
+      return N(n);
+    }
+  };
+}, spawn: function(t, e, n) {
+  try {
+    var r = Xt(t.apply(n, e || []));
+    return r && typeof r.then == "function" ? r : S.resolve(r);
+  } catch (s) {
+    return N(s);
+  }
+}, currentTransaction: { get: () => P.trans || null }, waitFor: function(t, e) {
+  const n = S.resolve(typeof t == "function" ? le.ignoreTransaction(t) : t).timeout(e || 6e4);
+  return P.trans ? P.trans.waitFor(n) : n;
+}, Promise: S, debug: { get: () => G, set: (t) => {
+  $n(t, t === "dexie" ? () => !0 : Xn);
+} }, derive: ke, extend: U, props: Ee, override: On, Events: $e, on: ue, liveQuery: ts, extendObservabilitySet: ir, getByKeyPath: te, setByKeyPath: H, delByKeyPath: function(t, e) {
+  typeof e == "string" ? H(t, e, void 0) : "length" in e && [].map.call(e, function(n) {
+    H(t, n, void 0);
+  });
+}, shallowClone: Rn, deepClone: We, getObjectDiff: ln, cmp: L, asap: In, minKey: qt, addons: [], connections: De, errnames: nn, dependencies: Jt, semVer: wn, version: wn.split(".").map((t) => parseInt(t)).reduce((t, e, n) => t + e / Math.pow(10, 2 * n)) }), le.maxKey = Ue(le.dependencies.IDBKeyRange), typeof dispatchEvent < "u" && typeof addEventListener < "u" && (ue(Le, (t) => {
+  if (!Z) {
+    let e;
+    yt ? (e = document.createEvent("CustomEvent"), e.initCustomEvent(ie, !0, !0, t)) : e = new CustomEvent(ie, { detail: t }), Z = !0, dispatchEvent(e), Z = !1;
+  }
+}), addEventListener(ie, ({ detail: t }) => {
+  Z || at(t);
+}));
+let Z = !1;
+if (typeof BroadcastChannel < "u") {
+  const t = new BroadcastChannel(ie);
+  typeof t.unref == "function" && t.unref(), ue(Le, (e) => {
+    Z || t.postMessage(e);
+  }), t.onmessage = (e) => {
+    e.data && at(e.data);
+  };
+} else if (typeof self < "u" && typeof navigator < "u") {
+  ue(Le, (e) => {
+    try {
+      Z || (typeof localStorage < "u" && localStorage.setItem(ie, JSON.stringify({ trig: Math.random(), changedParts: e })), typeof self.clients == "object" && [...self.clients.matchAll({ includeUncontrolled: !0 })].forEach((n) => n.postMessage({ type: ie, changedParts: e })));
+    } catch {
+    }
+  }), typeof addEventListener < "u" && addEventListener("storage", (e) => {
+    if (e.key === ie) {
+      const n = JSON.parse(e.newValue);
+      n && at(n.changedParts);
+    }
+  });
+  const t = self.document && navigator.serviceWorker;
+  t && t.addEventListener("message", function({ data: e }) {
+    e && e.type === ie && at(e.changedParts);
+  });
+}
+S.rejectionMapper = function(t, e) {
+  if (!t || t instanceof xe || t instanceof TypeError || t instanceof SyntaxError || !t.name || !gn[t.name])
+    return t;
+  var n = new gn[t.name](e || t.message, t);
+  return "stack" in t && ee(n, "stack", { get: function() {
+    return this.inner.stack;
+  } }), n;
+}, $n(G, Xn);
+class ns extends pe {
+  constructor() {
+    super("NylasAuthDatabase"), ut(this, "grant"), ut(this, "pkce"), this.version(1).stores({
+      grant: "++id,token",
+      pkce: "++id,codeVerifier"
+    }), this.grant = this.table("grant"), this.pkce = this.table("pkce");
+  }
+}
+class rs {
+  constructor() {
+    ut(this, "theDB"), this.theDB = new ns();
+  }
+  async setCodeVerifier(e) {
+    await this.theDB.pkce.put({ id: 1, codeVerifier: e }, 1);
+  }
+  async getCodeVerifier() {
+    const [e] = await this.theDB.pkce.toArray();
+    return e ? e.codeVerifier : null;
+  }
+  async getTokenInfo() {
+    const e = await this.theDB.grant.get(1);
+    return e ? e.token : null;
+  }
+  async setTokenInfo(e) {
+    await this.theDB.grant.put({ id: 1, token: e }, 1);
+  }
+  async reset() {
+    await this.theDB.grant.clear();
+  }
+}
+function ms(t) {
+  const e = "NylasAuth";
+  if (!t)
+    throw new Error("NylasAuth requires a config object");
+  let n = null;
+  if (t.storageType === "indexeddb" && (n = new rs()), !n)
+    throw new Error("NylasAuth requires a storage object");
+  const r = [
+    {
+      type: "read-only",
+      value: "https://www.googleapis.com/auth/gmail.readonly"
+    },
+    {
+      type: "modify",
+      value: "https://www.googleapis.com/auth/gmail.modify"
+    },
+    {
+      type: "compose",
+      value: "https://www.googleapis.com/auth/gmail.compose"
+    },
+    {
+      type: "insert",
+      value: "https://www.googleapis.com/auth/gmail.insert"
+    },
+    {
+      type: "labels",
+      value: "https://www.googleapis.com/auth/gmail.labels"
+    },
+    {
+      type: "metadata",
+      value: "https://www.googleapis.com/auth/gmail.metadata"
+    },
+    {
+      type: "settings.basic",
+      value: "https://www.googleapis.com/auth/gmail.settings.basic"
+    },
+    {
+      type: "settings.sharing",
+      value: "https://www.googleapis.com/auth/gmail.settings.sharing"
+    }
+  ], s = [
+    {
+      type: "read-only",
+      value: "https://outlook.office.com/mail.read"
+    },
+    {
+      type: "modify",
+      value: "https://outlook.office.com/mail.readwrite"
+    },
+    {
+      type: "send",
+      value: "https://outlook.office.com/mail.send"
+    },
+    {
+      type: "offline",
+      value: "offline_access"
+    }
+  ];
+  async function i(o, u, a, l = !0, h, c) {
+    const d = await (n == null ? void 0 : n.getTokenInfo()), m = new URL(o, h ?? t.apiUri), p = new Headers();
+    p.append("Accept", "application/json"), p.append("Content-Type", "application/json"), p.append("User-Agent", e), d && p.append("Authorization", `Bearer ${d.access_token}`);
+    const f = await fetch(m.toString(), {
+      method: u || "GET",
+      headers: p,
+      mode: "cors",
+      referrer: location.origin,
+      body: a ? JSON.stringify(a) : void 0,
+      ...c || {}
+    });
+    return l ? await f.json() : f.body;
+  }
+  return {
+    config: t,
+    /**
+     * This method will make a request to the Nylas API to exchange an authorization code for an access token.
+     * @param scopes The scopes that were used to generate the authorization code
+     * @param email The email that was used to generate the authorization code
+     * @param provider The provider that was used to generate the authorization code
+     * @returns A promise that resolves to a URL string that can be used to redirect the user to the Nylas API to complete the authorization flow
+     */
+    async getHostedAuthRedirectURL(o = t.defaultScopes, u, a) {
+      const l = await mn(Math.random().toString()), h = await mn(l);
+      await (n == null ? void 0 : n.setCodeVerifier(l));
+      const c = new URL(`${t.apiUri}/v3/connect/auth`);
+      return c.searchParams.set("client_id", t.clientId), c.searchParams.set("response_type", "code"), c.searchParams.set("scope", o.join(" ")), c.searchParams.set("redirect_uri", t.redirectURI), c.searchParams.set("access_type", "offline"), c.searchParams.set("code_challenge", h), c.searchParams.set("code_challenge_method", "S256"), c.searchParams.set("options", "rotate_refresh_token"), a && c.searchParams.set("provider", a), u && c.searchParams.set("login_hint", u), c.toString();
+    },
+    /**
+     * This method will make a request to the Nylas API to exchange an authorization code for an access token.
+     * @param path A path to the Nylas API, e.g. `/v3/grants/methreads`
+     * @param method GET, POST, PUT, DELETE, etc.
+     * @param body A JSON object to send as the body of the request
+     * @param domain The domain to use for the request, e.g. `api.us.nylas.com`
+     * @param parseJSON Whether to parse the response as JSON or return the raw response (default: true)
+     * @returns
+     */
+    nylasAPIRequest: i,
+    /**
+     * This method will make a request to the Nylas API to exchange an authorization code for an access token.
+     * @param code  The authorization code that was returned from the Nylas API
+     * @returns A promise that resolves to a TokenExchangeResponse object
+     */
+    async exchangeAuthCodeForTokenInfo(o) {
+      if (!o)
+        return null;
+      const u = await (n == null ? void 0 : n.getCodeVerifier()), a = await this.nylasAPIRequest("/v3/connect/token", "POST", {
+        code: o,
+        client_id: t.clientId,
+        grant_type: "authorization_code",
+        redirect_uri: t.redirectURI,
+        code_verifier: u
+      });
+      return "error" in a || await (n == null ? void 0 : n.setTokenInfo(a)), a;
+    },
+    /**
+     * This method will make a `application/octet-stream` request to the Nylas API to download a file.
+     */
+    async nylasDownloadFileRequest(o, u = "GET", a) {
+      const l = await (n == null ? void 0 : n.getTokenInfo()), h = new URL(o, t.apiUri), c = new Headers();
+      return c.append("Accept", "application/json"), c.append("Content-Type", "application/octet-stream"), c.append("User-Agent", e), l && c.append("Authorization", `Bearer ${l.access_token}`), (await fetch(h.toString(), {
+        method: u,
+        headers: c,
+        mode: "cors",
+        referrer: location.origin,
+        body: a ? JSON.stringify(a) : void 0
+      })).blob();
+    },
+    /**
+     * This methid will clear the access token from the storage object
+     */
+    async logout() {
+      const o = await (n == null ? void 0 : n.getTokenInfo());
+      o && await this.nylasAPIRequest(`/v3/connect/revoke?token=${o.access_token}`, "POST"), await (n == null ? void 0 : n.reset());
+    },
+    /**
+     * This method will make a request to the Nylas API to exchange an authorization code for an access token.
+     * @returns A promise that resolves to a boolean indicating whether the user is authenticated
+     */
+    async isAuthenticated() {
+      return !!await (n == null ? void 0 : n.getTokenInfo());
+    },
+    /**
+     * This method will return information about the current access token.
+     * @returns A promise with the token info
+     */
+    async getTokenInfo() {
+      const o = await (n == null ? void 0 : n.getTokenInfo());
+      if (!o)
+        return null;
+      const { access_token: u, ...a } = o;
+      return a;
+    },
+    /**
+     * This method will make a request to the Nylas API to validate if the current access token is valid.
+     * @returns A promise that resolves to a boolean indicating whether the current access token is valid
+     */
+    async isAccessTokenValid() {
+      const o = await (n == null ? void 0 : n.getTokenInfo());
+      return o ? "data" in await this.nylasAPIRequest(
+        `/v3/connect/tokeninfo?id_token=${o.id_token}`,
+        "GET"
+      ) : !1;
+    },
+    /**
+     * This method will make a request to the Nylas API to refresh the current access token.
+     * @returns A promise that resolves to a TokenExchangeResponse object
+     */
+    async refreshAccessToken() {
+      const o = await (n == null ? void 0 : n.getTokenInfo());
+      if (!o)
+        return null;
+      const u = await this.nylasAPIRequest("/v3/connect/token", "POST", {
+        client_id: t.clientId,
+        grant_type: "refresh_token",
+        refresh_token: o.refresh_token
+      });
+      return "error" in u || await (n == null ? void 0 : n.setTokenInfo(u)), u;
+    },
+    /**
+     * This method will return true if the current access token has the given scope
+     * based on the type of scope (e.g. 'read-only', 'modify', 'compose', 'insert', 'labels', 'metadata', 'settings.basic', or 'settings.sharing')
+     * @param type Either 'read-only', 'modify', 'compose', 'insert', 'labels', 'metadata', 'settings.basic', or 'settings.sharing'
+     */
+    async hasScopeByType(o = "email", u) {
+      const a = await (n == null ? void 0 : n.getTokenInfo());
+      if (!a)
+        return !1;
+      const l = a.scope.toLowerCase().split(" ");
+      let h = [];
+      const c = Array.isArray(u) ? u : [u];
+      return o === "email" && (h = [...s, ...r].filter(
+        (d) => c.includes(d.type)
+      )), h.every((d) => l.includes(d.value));
+    },
+    /**
+     * A helper method to check if the current access token has a given scope.
+     * @param scope The scope(s) to check for in the current access token  (e.g. https://www.googleapis.com/auth/gmail.modify)
+     * @returns boolean indicating whether the current access token has the given scope
+     */
+    async hasScope(o) {
+      const u = await (n == null ? void 0 : n.getTokenInfo());
+      if (!u)
+        return !1;
+      const a = u.scope.toLowerCase().split(" ");
+      return (Array.isArray(o) ? o : [o]).some((l) => a.includes(l.toLowerCase()));
+    }
+  };
+}
+const ss = (t, e, n) => {
+  const r = t.get(e);
+  r ? r.includes(n) || r.push(n) : t.set(e, [n]);
+}, is = (t, e) => {
+  let n;
+  return (...r) => {
+    n && clearTimeout(n), n = setTimeout(() => {
+      n = 0, t(...r);
+    }, e);
+  };
+}, os = (t) => !("isConnected" in t) || t.isConnected, Tn = is((t) => {
+  for (let e of t.keys())
+    t.set(e, t.get(e).filter(os));
+}, 2e3), as = () => {
+  if (typeof fn != "function")
+    return {};
+  const t = /* @__PURE__ */ new Map();
+  return {
+    dispose: () => t.clear(),
+    get: (e) => {
+      const n = fn();
+      n && ss(t, e, n);
+    },
+    set: (e) => {
+      const n = t.get(e);
+      n && t.set(e, n.filter(pn)), Tn(t);
+    },
+    reset: () => {
+      t.forEach((e) => e.forEach(pn)), Tn(t);
+    }
+  };
+}, Ct = (t) => typeof t == "function" ? t() : t, us = (t, e = (n, r) => n !== r) => {
+  const n = Ct(t);
+  let r = new Map(Object.entries(n ?? {}));
+  const s = {
+    dispose: [],
+    get: [],
+    set: [],
+    reset: []
+  }, i = () => {
+    var p;
+    r = new Map(Object.entries((p = Ct(t)) !== null && p !== void 0 ? p : {})), s.reset.forEach((f) => f());
+  }, o = () => {
+    s.dispose.forEach((p) => p()), i();
+  }, u = (p) => (s.get.forEach((f) => f(p)), r.get(p)), a = (p, f) => {
+    const y = r.get(p);
+    e(f, y, p) && (r.set(p, f), s.set.forEach((g) => g(p, f, y)));
+  }, l = typeof Proxy > "u" ? {} : new Proxy(n, {
+    get(p, f) {
+      return u(f);
+    },
+    ownKeys(p) {
+      return Array.from(r.keys());
+    },
+    getOwnPropertyDescriptor() {
+      return {
+        enumerable: !0,
+        configurable: !0
+      };
+    },
+    has(p, f) {
+      return r.has(f);
+    },
+    set(p, f, y) {
+      return a(f, y), !0;
+    }
+  }), h = (p, f) => (s[p].push(f), () => {
+    cs(s[p], f);
+  });
+  return {
+    state: l,
+    get: u,
+    set: a,
+    on: h,
+    onChange: (p, f) => {
+      const y = h("set", (v, b) => {
+        v === p && f(b);
+      }), g = h("reset", () => f(Ct(t)[p]));
+      return () => {
+        y(), g();
+      };
+    },
+    use: (...p) => {
+      const f = p.reduce((y, g) => (g.set && y.push(h("set", g.set)), g.get && y.push(h("get", g.get)), g.reset && y.push(h("reset", g.reset)), g.dispose && y.push(h("dispose", g.dispose)), y), []);
+      return () => f.forEach((y) => y());
+    },
+    dispose: o,
+    reset: i,
+    forceUpdate: (p) => {
+      const f = r.get(p);
+      s.set.forEach((y) => y(p, f, f));
+    }
+  };
+}, cs = (t, e) => {
+  const n = t.indexOf(e);
+  n >= 0 && (t[n] = t[t.length - 1], t.length--);
+}, gs = (t, e) => {
+  const n = us(t, e);
+  return n.use(as()), n;
+};
+export {
+  ds as N,
+  fs as X,
+  ps as Z,
+  gs as c,
+  ms as e,
+  lr as n
+};