@moyodb/sdk 0.0.0-alpha.1

package/dist/moyodb-sdk.js

@@ -0,0 +1,1988 @@
+function v(t) {
+  return t !== null && typeof t == "object";
+}
+function L(t, e) {
+  return t < e ? -1 : t > e ? 1 : 0;
+}
+function j(t, e, r) {
+  return new Promise((n) => {
+    const o = setTimeout(() => n(r), e);
+    t.then(
+      (s) => {
+        clearTimeout(o), n(s);
+      },
+      () => {
+        clearTimeout(o), n(r);
+      }
+    );
+  });
+}
+const K = 1, Be = "moyodb:worker-protocol:ready", qe = "moyodb:worker-protocol:request", Le = "moyodb:worker-protocol:response", Ce = [
+  "open",
+  "close",
+  "destroy",
+  "deleteDB",
+  "begin",
+  "commit",
+  "rollback",
+  "createStore",
+  "dropStore",
+  "clearStore",
+  "get",
+  "getMany",
+  "has",
+  "put",
+  "putMany",
+  "delete",
+  "deleteMany",
+  "applyBatch",
+  "scan",
+  "getByIndex",
+  "scanByIndex",
+  "getIndexes",
+  "reconcileIndexes",
+  "listStores",
+  "getVersion",
+  "changesSince",
+  "setSchemaVersion",
+  "exportSnapshot",
+  "importSnapshot",
+  "reset",
+  "compact",
+  "rebuild",
+  "stats",
+  "storageInfo",
+  "requestPersistence",
+  "setFailpoint"
+], de = "moyodb:packed-binary-list:v1", Ne = "moyodb:packed-nullable-binary-list:v1", Ue = "moyodb:packed-scan-rows:v1", De = "moyodb:packed-batch-ops:v1", We = 0, ze = 1, T = 4294967295, $e = [];
+new Set(Ce);
+function Fe(t) {
+  return v(t) && t.type === Be && t.version === K;
+}
+function Ve(t) {
+  return v(t) && t.type === Le && t.version === K && typeof t.id == "number" && Number.isSafeInteger(t.id) && typeof t.ok == "boolean";
+}
+function je(t) {
+  const e = new Error(t.message);
+  return e.name = t.name || t.code || "Error", t.stack && (e.stack = t.stack), t.code && Object.defineProperty(e, "code", {
+    value: t.code,
+    enumerable: !0,
+    configurable: !0
+  }), e;
+}
+function y(t, e, r = t) {
+  const n = new Error(e);
+  return n.name = t, Object.defineProperty(n, "code", {
+    value: r,
+    enumerable: !0,
+    configurable: !0
+  }), n;
+}
+function Ke(t, e) {
+  if (t === "importSnapshot") {
+    const r = e[0];
+    if (r instanceof Uint8Array) {
+      const n = tt(r);
+      return {
+        args: [n],
+        transfer: [n.buffer]
+      };
+    }
+  }
+  if (t === "getMany" || t === "deleteMany") {
+    const [r, n, o] = e;
+    if (Array.isArray(o) && o.length > 0) {
+      const s = Je(o);
+      return {
+        args: [r, n, s],
+        transfer: [s.bytes.buffer]
+      };
+    }
+  }
+  if (t === "putMany") {
+    const [r, n, o, s] = e;
+    if (Array.isArray(o) && o.length > 0) {
+      const i = Ye(o);
+      return {
+        args: [r, n, i, s],
+        transfer: [i.bytes.buffer]
+      };
+    }
+  }
+  if (t === "applyBatch") {
+    const [r, n, o] = e;
+    if (Array.isArray(o) && o.length > 0) {
+      const s = Qe(o);
+      return {
+        args: [r, n, s],
+        transfer: [s.bytes.buffer]
+      };
+    }
+  }
+  return { args: e, transfer: $e };
+}
+function He(t, e) {
+  return t === "getMany" && Ze(e) ? Ge(e) : (t === "scan" || t === "scanByIndex") && et(e) ? Xe(e) : e;
+}
+function Ye(t) {
+  const e = t.length, r = I(e * 2, "packed putMany item count"), n = R(r, 4, "packed putMany metadata");
+  let o = 0;
+  for (let c = 0; c < e; c += 1) {
+    const h = t[c], g = h[0], E = h[1];
+    if (!(g instanceof Uint8Array) || !(E instanceof Uint8Array))
+      throw y("WorkerProtocolError", "putMany entry key/value is not a Uint8Array");
+    const B = I(g.byteLength, "putMany key length"), q = I(E.byteLength, "putMany value length");
+    if (o += B + q, o > T)
+      throw y("WorkerProtocolError", "packed putMany payload exceeds 32-bit payload limit");
+  }
+  const s = A(4, n, "packed putMany header"), i = A(s, o, "packed putMany total"), d = new Uint8Array(i), u = new DataView(d.buffer);
+  u.setUint32(0, r, !0);
+  let l = 4, a = s;
+  for (let c = 0; c < e; c += 1) {
+    const h = t[c], g = h[0], E = h[1], B = g.byteLength, q = E.byteLength;
+    u.setUint32(l, B, !0), l += 4, u.setUint32(l, q, !0), l += 4, d.set(g, a), a += B, d.set(E, a), a += q;
+  }
+  return {
+    __moyodbPacked: de,
+    bytes: d
+  };
+}
+function Je(t) {
+  const e = t.length, r = R(e, 4, "packed binary-list metadata");
+  let n = 0;
+  for (let a = 0; a < e; a += 1) {
+    const c = t[a];
+    if (!(c instanceof Uint8Array))
+      throw y("WorkerProtocolError", "binary-list payload item is not a Uint8Array");
+    const h = I(c.byteLength, "binary-list item length");
+    if (n += h, n > T)
+      throw y("WorkerProtocolError", "packed binary-list payload exceeds 32-bit payload limit");
+  }
+  const o = A(4, r, "packed binary-list header"), s = A(o, n, "packed binary-list total"), i = new Uint8Array(s), d = new DataView(i.buffer);
+  d.setUint32(0, e, !0);
+  let u = 4, l = o;
+  for (let a = 0; a < e; a += 1) {
+    const c = t[a], h = c.byteLength;
+    d.setUint32(u, h, !0), u += 4, i.set(c, l), l += h;
+  }
+  return {
+    __moyodbPacked: de,
+    bytes: i
+  };
+}
+function Ge(t) {
+  const e = t.bytes;
+  if (!(e instanceof Uint8Array) || e.byteLength < 4)
+    throw y("WorkerProtocolError", "invalid packed nullable binary-list payload");
+  const r = new DataView(e.buffer, e.byteOffset, e.byteLength), n = r.getUint32(0, !0), o = R(n, 5, "packed nullable binary-list metadata"), s = A(4, o, "packed nullable binary-list header");
+  if (s > e.byteLength)
+    throw y("WorkerProtocolError", "packed nullable binary-list metadata exceeds payload length");
+  const i = new Array(n);
+  let d = 4, u = s;
+  for (let l = 0; l < n; l += 1) {
+    const a = r.getUint8(d), c = r.getUint32(d + 1, !0);
+    if (d += 5, a === 0) {
+      if (c !== 0)
+        throw y(
+          "WorkerProtocolError",
+          "packed nullable binary-list null item has a payload length"
+        );
+      i[l] = null;
+      continue;
+    }
+    if (a !== 1)
+      throw y(
+        "WorkerProtocolError",
+        `packed nullable binary-list item has invalid presence byte: ${a}`
+      );
+    const h = u + c;
+    if (h > T || h > e.byteLength)
+      throw y("WorkerProtocolError", "packed nullable binary-list item exceeds payload length");
+    i[l] = e.subarray(u, h), u = h;
+  }
+  if (u !== e.byteLength)
+    throw y("WorkerProtocolError", "packed nullable binary-list payload has trailing bytes");
+  return i;
+}
+function Xe(t) {
+  const e = t.bytes;
+  if (!(e instanceof Uint8Array) || e.byteLength < 4)
+    throw y("WorkerProtocolError", "invalid packed scan row payload");
+  const r = new DataView(e.buffer, e.byteOffset, e.byteLength), n = r.getUint32(0, !0), o = R(n, 8, "packed scan row metadata"), s = A(4, o, "packed scan row header");
+  if (s > e.byteLength)
+    throw y("WorkerProtocolError", "packed scan row metadata exceeds payload length");
+  const i = new Array(n);
+  let d = 4, u = s;
+  for (let l = 0; l < n; l += 1) {
+    const a = r.getUint32(d, !0), c = r.getUint32(d + 4, !0);
+    d += 8;
+    const h = u + a;
+    if (h > T || h > e.byteLength)
+      throw y("WorkerProtocolError", "packed scan row key exceeds payload length");
+    const g = h + c;
+    if (g > T || g > e.byteLength)
+      throw y("WorkerProtocolError", "packed scan row value exceeds payload length");
+    i[l] = {
+      key: e.subarray(u, h),
+      value: e.subarray(h, g)
+    }, u = g;
+  }
+  if (u !== e.byteLength)
+    throw y("WorkerProtocolError", "packed scan row payload has trailing bytes");
+  return i;
+}
+function Qe(t) {
+  const e = t.length, r = R(e, 9, "packed batch metadata");
+  let n = 0;
+  for (let a = 0; a < e; a += 1) {
+    const c = t[a];
+    if (c.kind !== "put" && c.kind !== "delete")
+      throw y(
+        "WorkerProtocolError",
+        `unknown batch operation kind: ${String(c.kind)}`
+      );
+    if (!(c.key instanceof Uint8Array))
+      throw y("WorkerProtocolError", "batch operation key is not a Uint8Array");
+    const h = I(c.key.byteLength, "batch operation key length");
+    if (n += h, n > T)
+      throw y("WorkerProtocolError", "packed batch payload exceeds 32-bit payload limit");
+    if (c.kind === "put") {
+      if (!(c.value instanceof Uint8Array))
+        throw y("WorkerProtocolError", "batch put value is not a Uint8Array");
+      const g = I(c.value.byteLength, "batch put value length");
+      if (n += g, n > T)
+        throw y("WorkerProtocolError", "packed batch payload exceeds 32-bit payload limit");
+    }
+  }
+  const o = A(4, r, "packed batch header"), s = A(o, n, "packed batch total"), i = new Uint8Array(s), d = new DataView(i.buffer);
+  d.setUint32(0, e, !0);
+  let u = 4, l = o;
+  for (let a = 0; a < e; a += 1) {
+    const c = t[a], h = c.key, g = h.byteLength, E = c.kind === "put" ? c.value.byteLength : 0;
+    d.setUint8(u, c.kind === "put" ? ze : We), d.setUint32(u + 1, g, !0), d.setUint32(u + 5, E, !0), u += 9, i.set(h, l), l += g, c.kind === "put" && (i.set(c.value, l), l += E);
+  }
+  return {
+    __moyodbPacked: De,
+    bytes: i
+  };
+}
+function Ze(t) {
+  return v(t) && t.__moyodbPacked === Ne && t.bytes instanceof Uint8Array;
+}
+function et(t) {
+  return v(t) && t.__moyodbPacked === Ue && t.bytes instanceof Uint8Array;
+}
+function R(t, e, r) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw y("WorkerProtocolError", `${r} count is invalid: ${t}`);
+  return I(t * e, r);
+}
+function A(t, e, r) {
+  const n = t + e;
+  return I(n, r);
+}
+function I(t, e) {
+  if (!Number.isSafeInteger(t) || t < 0 || t > T)
+    throw y("WorkerProtocolError", `${e} exceeds 32-bit payload limit`);
+  return t;
+}
+function tt(t) {
+  const e = new Uint8Array(t.byteLength);
+  return e.set(t), e;
+}
+function W(t) {
+  t.timeout && clearTimeout(t.timeout);
+}
+class rt {
+  constructor(e, r = {}) {
+    this.worker = e, this.requestTimeoutMs = r.requestTimeoutMs ?? 0, this.ready = new Promise((n, o) => {
+      this.readyResolve = n, this.readyReject = o;
+    }), this.worker.addEventListener("message", this.handleMessage), this.worker.addEventListener("messageerror", this.handleMessageError), this.worker.addEventListener("error", this.handleError);
+  }
+  worker;
+  nextRequestId = 1;
+  pending = /* @__PURE__ */ new Map();
+  closed = !1;
+  readyResolved = !1;
+  readyResolve = null;
+  readyReject = null;
+  ready;
+  requestTimeoutMs;
+  fatalHandler = null;
+  closeReason = null;
+  setFatalHandler(e) {
+    this.fatalHandler = e;
+  }
+  whenReady() {
+    return this.ready;
+  }
+  dispose(e = y("WorkerTerminatedError", "worker transport was closed")) {
+    this.disposeInternal(e, !1);
+  }
+  open(e) {
+    return this.request("open", [e]);
+  }
+  close() {
+    return this.request("close", []);
+  }
+  destroy() {
+    return this.request("destroy", []);
+  }
+  deleteDB(e) {
+    return this.request("deleteDB", [e]);
+  }
+  begin(e) {
+    return this.request("begin", [e]);
+  }
+  commit(e) {
+    return this.request("commit", [e]);
+  }
+  rollback(e) {
+    return this.request("rollback", [e]);
+  }
+  createStore(e, r, n) {
+    return this.request("createStore", [e, r, n]);
+  }
+  dropStore(e, r) {
+    return this.request("dropStore", [e, r]);
+  }
+  clearStore(e, r) {
+    return this.request("clearStore", [e, r]);
+  }
+  get(e, r, n) {
+    return this.request("get", [e, r, n]);
+  }
+  getMany(e, r, n) {
+    return this.request("getMany", [e, r, n]);
+  }
+  has(e, r, n) {
+    return this.request("has", [e, r, n]);
+  }
+  put(e, r, n, o, s) {
+    return this.request("put", [e, r, n, o, s]);
+  }
+  putMany(e, r, n, o) {
+    return this.request("putMany", [e, r, n, o]);
+  }
+  delete(e, r, n) {
+    return this.request("delete", [e, r, n]);
+  }
+  deleteMany(e, r, n) {
+    return this.request("deleteMany", [e, r, n]);
+  }
+  applyBatch(e, r, n) {
+    return this.request("applyBatch", [e, r, n]);
+  }
+  scan(e, r, n) {
+    return this.request("scan", [e, r, n]);
+  }
+  getByIndex(e, r, n, o) {
+    return this.request("getByIndex", [e, r, n, o]);
+  }
+  scanByIndex(e, r, n, o) {
+    return this.request("scanByIndex", [e, r, n, o]);
+  }
+  getIndexes() {
+    return this.request("getIndexes", []);
+  }
+  reconcileIndexes(e, r) {
+    return this.request("reconcileIndexes", [e, r]);
+  }
+  listStores() {
+    return this.request("listStores", []);
+  }
+  getVersion() {
+    return this.request("getVersion", []);
+  }
+  changesSince(e, r) {
+    return this.request("changesSince", [e, r]);
+  }
+  setSchemaVersion(e, r) {
+    return this.request("setSchemaVersion", [e, r]);
+  }
+  exportSnapshot(e) {
+    return this.request("exportSnapshot", [e]);
+  }
+  importSnapshot(e) {
+    return this.request("importSnapshot", [e]);
+  }
+  reset() {
+    return this.request("reset", []);
+  }
+  compact() {
+    return this.request("compact", []);
+  }
+  rebuild() {
+    return this.request("rebuild", []);
+  }
+  stats() {
+    return this.request("stats", []);
+  }
+  storageInfo() {
+    return this.request("storageInfo", []);
+  }
+  requestPersistence() {
+    return this.request("requestPersistence", []);
+  }
+  setFailpoint(e) {
+    return this.request("setFailpoint", [e]);
+  }
+  async request(e, r) {
+    this.ensureOpen(), await this.ready, this.ensureOpen();
+    const n = this.nextRequestId;
+    this.nextRequestId += 1;
+    const o = Ke(e, r), s = {
+      type: qe,
+      version: K,
+      id: n,
+      command: e,
+      args: o.args
+    };
+    return await new Promise((i, d) => {
+      const u = this.requestTimeoutMs > 0 ? setTimeout(() => {
+        this.pending.delete(n), d(
+          y(
+            "WorkerRequestTimeoutError",
+            `worker command ${e} timed out after ${this.requestTimeoutMs}ms`
+          )
+        );
+      }, this.requestTimeoutMs) : null;
+      this.pending.set(n, {
+        command: e,
+        resolve: (l) => i(l),
+        reject: d,
+        timeout: u
+      });
+      try {
+        o.transfer.length > 0 ? this.worker.postMessage(s, o.transfer) : this.worker.postMessage(s);
+      } catch (l) {
+        this.rejectPending(n, l instanceof Error ? l : new Error(String(l)));
+      }
+    });
+  }
+  ensureOpen() {
+    if (this.closed)
+      throw this.closeReason ?? y("WorkerTerminatedError", "worker transport is closed");
+  }
+  handleMessage = (e) => {
+    const r = e.data;
+    if (Fe(r)) {
+      this.readyResolved = !0, this.readyResolve?.(), this.readyResolve = null, this.readyReject = null;
+      return;
+    }
+    if (!Ve(r))
+      return;
+    const n = this.pending.get(r.id);
+    if (n) {
+      if (this.pending.delete(r.id), W(n), r.ok) {
+        n.resolve(He(n.command, r.result));
+        return;
+      }
+      n.reject(je(r.error));
+    }
+  };
+  handleMessageError = () => {
+    this.disposeInternal(
+      y("WorkerMessageError", "worker message could not be deserialized"),
+      !0
+    );
+  };
+  handleError = (e) => {
+    const r = e.error instanceof Error ? e.error : y("WorkerError", e.message || "worker runtime failed");
+    this.disposeInternal(r, !0);
+  };
+  rejectPending(e, r) {
+    const n = this.pending.get(e);
+    n && (this.pending.delete(e), W(n), n.reject(r));
+  }
+  disposeInternal(e, r) {
+    if (!this.closed) {
+      this.closed = !0, this.closeReason = e, this.worker.removeEventListener("message", this.handleMessage), this.worker.removeEventListener("messageerror", this.handleMessageError), this.worker.removeEventListener("error", this.handleError), this.readyResolved || this.readyReject?.(e), this.readyResolve = null, this.readyReject = null;
+      for (const n of this.pending.values())
+        W(n), n.reject(e);
+      this.pending.clear(), r && this.fatalHandler?.(e);
+    }
+  }
+}
+class p extends Error {
+  constructor(e, r) {
+    super(r), this.name = e, Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+class O extends p {
+  constructor(e) {
+    super("UnsupportedPlatformError", e);
+  }
+}
+class he extends p {
+  constructor(e) {
+    super("DatabaseBusyError", e);
+  }
+}
+class nt extends p {
+  constructor(e) {
+    super("CorruptionError", e);
+  }
+}
+class ot extends p {
+  constructor(e) {
+    super("StoreExistsError", e);
+  }
+}
+class st extends p {
+  constructor(e) {
+    super("StoreNotFoundError", e);
+  }
+}
+class it extends p {
+  constructor(e) {
+    super("IndexNotFoundError", e);
+  }
+}
+class fe extends p {
+  constructor(e) {
+    super("ConstraintError", e);
+  }
+}
+class at extends fe {
+  constructor(e) {
+    super(e), this.name = "UniqueIndexConstraintError";
+  }
+}
+class ct extends p {
+  constructor(e = "write transaction already open") {
+    super("WriteTransactionAlreadyOpenError", e);
+  }
+}
+class ut extends p {
+  constructor(e = "readonly transaction cannot perform this operation") {
+    super("ReadonlyTransactionError", e);
+  }
+}
+class z extends p {
+  constructor(e = "transaction is already closed") {
+    super("TransactionClosedError", e);
+  }
+}
+class H extends p {
+  constructor(e = "database handle is closed") {
+    super("DatabaseClosedError", e);
+  }
+}
+class lt extends p {
+  constructor(e) {
+    super("ValueTooLargeError", e);
+  }
+}
+class dt extends p {
+  constructor(e) {
+    super("KeyTooLargeError", e);
+  }
+}
+class ht extends p {
+  constructor(e) {
+    super("StoreNameTooLongError", e);
+  }
+}
+class ye extends p {
+  constructor(e) {
+    super("ReservedStoreNameError", e);
+  }
+}
+class ft extends p {
+  constructor(e) {
+    super("InvalidRangeError", e);
+  }
+}
+class yt extends p {
+  constructor(e) {
+    super("StorageError", e);
+  }
+}
+class _ extends p {
+  constructor(e) {
+    super("SerializationError", e);
+  }
+}
+class pt extends p {
+  constructor(e) {
+    super("InjectedFailureError", e);
+  }
+}
+class bt extends p {
+  constructor(e) {
+    super("ChangeFeedCompactedError", e);
+  }
+}
+class wt extends p {
+  constructor(e) {
+    super("InternalError", e);
+  }
+}
+class b extends p {
+  constructor(e) {
+    super("InvalidOpenOptionsError", e);
+  }
+}
+class C extends p {
+  constructor(e) {
+    super("VersionError", e);
+  }
+}
+const gt = {
+  UnsupportedPlatformError: O,
+  DatabaseBusyError: he,
+  CorruptionError: nt,
+  StoreExistsError: ot,
+  StoreNotFoundError: st,
+  IndexNotFoundError: it,
+  ConstraintError: fe,
+  UniqueIndexConstraintError: at,
+  WriteTransactionAlreadyOpenError: ct,
+  ReadonlyTransactionError: ut,
+  TransactionClosedError: z,
+  DatabaseClosedError: H,
+  ValueTooLargeError: lt,
+  KeyTooLargeError: dt,
+  StoreNameTooLongError: ht,
+  ReservedStoreNameError: ye,
+  InvalidRangeError: ft,
+  StorageError: yt,
+  SerializationError: _,
+  InjectedFailureError: pt,
+  ChangeFeedCompactedError: bt,
+  InternalError: wt,
+  InvalidOpenOptionsError: b,
+  VersionError: C
+};
+function Z(t, e) {
+  const r = gt[t];
+  if (r)
+    return new r(e);
+  const n = new Error(e);
+  return n.name = t, n;
+}
+function x(t) {
+  if (t instanceof p)
+    return t;
+  if (t instanceof Error)
+    return t.name === "Error" ? t : Z(t.name, t.message);
+  const e = t, r = e?.code ?? e?.name ?? "Error", n = e?.message ?? String(t);
+  return Z(r, n);
+}
+const ee = /* @__PURE__ */ new Set([
+  "after_wal_flush",
+  "after_main_flush",
+  "before_superblock_flush"
+]), mt = "moyodb:persistence-bridge:init", kt = "moyodb:persistence-bridge:request", xt = "moyodb:persistence-bridge:response", k = /* @__PURE__ */ new Map();
+function Et(t) {
+  if (t === null || typeof t != "object" || Array.isArray(t))
+    throw new b("open options must be an object");
+}
+function te(t, e, r) {
+  if (t === void 0)
+    return r;
+  if (typeof t != "boolean")
+    throw new b(`${e} must be a boolean`);
+  return t;
+}
+function pe(t, e, r) {
+  if (t === void 0)
+    return r;
+  if (typeof t != "number" || !Number.isSafeInteger(t) || t < 0)
+    throw new b(`${e} must be a non-negative safe integer`);
+  return t;
+}
+function St(t) {
+  return Math.max(1, pe(t, "cachePages", 256));
+}
+function It(t) {
+  if (t == null)
+    return null;
+  if (typeof t != "string" || !ee.has(t))
+    throw new b(`debugFailpoint must be one of: ${Array.from(ee).join(", ")}`);
+  return t;
+}
+function Pt(t = {}) {
+  return Et(t), {
+    createIfMissing: te(t.createIfMissing, "createIfMissing", !0),
+    ownerWaitMs: pe(t.ownerWaitMs, "ownerWaitMs", 0),
+    requestPersistence: te(t.requestPersistence, "requestPersistence", !0),
+    cachePages: St(t.cachePages),
+    debugFailpoint: It(t.debugFailpoint)
+  };
+}
+function Tt(t, e, r) {
+  if (e.cachePages !== r.cachePages)
+    throw new b(
+      `database ${t} is already open in this tab with cachePages=${e.cachePages}; requested cachePages=${r.cachePages}`
+    );
+}
+async function At() {
+  const t = globalThis.navigator?.storage;
+  return typeof t?.persisted != "function" ? !1 : await j(t.persisted(), 1e3, !1);
+}
+async function Ot() {
+  const t = globalThis.navigator?.storage;
+  return typeof t?.persist != "function" ? !1 : await j(t.persist(), 1e3, !1);
+}
+async function vt(t, e) {
+  const r = e.op === "persist" ? await Ot() : await At(), n = {
+    type: xt,
+    id: e.id,
+    granted: r
+  };
+  t.postMessage(n);
+}
+function Mt(t) {
+  const e = new MessageChannel(), r = e.port1;
+  return r.addEventListener("message", (n) => {
+    const o = n.data;
+    !o || o.type !== kt || vt(r, o);
+  }), r.start(), t.postMessage({ type: mt }, [e.port2]), {
+    close() {
+      r.close();
+    }
+  };
+}
+function be() {
+  const t = new Worker(new URL(
+    /* @vite-ignore */
+    "/assets/worker-CaOzbBz1.js",
+    import.meta.url
+  ), { type: "module" }), e = new rt(t), r = Mt(t);
+  return { worker: t, proxy: e, persistenceBridge: r };
+}
+function Rt(t, e, r, n, o) {
+  const s = {
+    dbName: t,
+    refs: 1,
+    worker: e,
+    proxy: r,
+    persistenceBridge: n,
+    options: o,
+    invalidated: !1,
+    txInvalidationListeners: /* @__PURE__ */ new Set(),
+    handleInvalidationListeners: /* @__PURE__ */ new Set()
+  };
+  return r.setFatalHandler(() => {
+    k.get(t) !== s || s.invalidated || (k.delete(t), s.refs = 0, Y(s), s.persistenceBridge.close(), s.worker.terminate());
+  }), s;
+}
+function we(t) {
+  for (const e of Array.from(t))
+    e();
+}
+function _t(t, e) {
+  return t.txInvalidationListeners.add(e), () => {
+    t.txInvalidationListeners.delete(e);
+  };
+}
+function Bt(t, e) {
+  return t.handleInvalidationListeners.add(e), () => {
+    t.handleInvalidationListeners.delete(e);
+  };
+}
+function N(t) {
+  we(t.txInvalidationListeners);
+}
+function Y(t) {
+  t.invalidated || (t.invalidated = !0, N(t), we(t.handleInvalidationListeners));
+}
+function qt(t) {
+  const e = k.get(t);
+  return e ? (k.delete(t), Y(e), e.refs = 0, e.persistenceBridge.close(), e.proxy.dispose(new Error("worker was terminated by unsafeDebugCrashWorker")), e.worker.terminate(), !0) : !1;
+}
+async function Lt(t, e = {}) {
+  const r = Pt(e), n = k.get(t);
+  if (n)
+    if (n.invalidated)
+      k.delete(t);
+    else {
+      if (Tt(t, n.options, r), r.debugFailpoint !== null)
+        try {
+          await n.proxy.setFailpoint(r.debugFailpoint);
+        } catch (u) {
+          throw x(u);
+        }
+      return n.refs += 1, n;
+    }
+  const { worker: o, proxy: s, persistenceBridge: i } = be(), d = Rt(t, o, s, i, r);
+  try {
+    return await s.open({
+      dbName: t,
+      options: r
+    }), k.set(t, d), d;
+  } catch (u) {
+    throw i.close(), s.dispose(new Error("worker open failed")), o.terminate(), x(u);
+  }
+}
+async function Ct(t) {
+  if (t.invalidated)
+    return;
+  const e = k.get(t.dbName);
+  if (e && (e.refs -= 1, !(e.refs > 0))) {
+    k.delete(t.dbName);
+    try {
+      await e.proxy.close();
+    } finally {
+      e.persistenceBridge.close(), e.proxy.dispose(new Error("worker was released")), e.worker.terminate();
+    }
+  }
+}
+async function ge(t) {
+  const e = k.get(t.dbName) ?? t;
+  k.delete(t.dbName), Y(e), e.refs = 0;
+  try {
+    await e.proxy.destroy();
+  } catch (r) {
+    throw x(r);
+  } finally {
+    e.persistenceBridge.close(), e.proxy.dispose(new Error("worker was released")), e.worker.terminate();
+  }
+}
+async function Nt(t) {
+  const e = k.get(t);
+  if (e) {
+    await ge(e);
+    return;
+  }
+  const { worker: r, proxy: n, persistenceBridge: o } = be();
+  try {
+    await n.deleteDB(t);
+  } catch (s) {
+    throw x(s);
+  } finally {
+    o.close(), n.dispose(new Error("temporary worker was terminated")), r.terminate();
+  }
+}
+const Ut = new TextEncoder(), Dt = new TextDecoder(), Wt = 16, zt = 32, $t = 33, Ft = 48, Vt = 64, jt = 80, M = 0, me = 255, $ = 0, Kt = 0xffffffffffffffffn;
+function P(t) {
+  return Ut.encode(t);
+}
+function Ht(t) {
+  return Dt.decode(t);
+}
+function Mr(t) {
+  return P(JSON.stringify(t));
+}
+function Rr(t) {
+  return JSON.parse(Ht(t));
+}
+function _r(t) {
+  const e = typeof t == "bigint" ? t : BigInt(t);
+  if (e < 0n)
+    throw new RangeError("u64Key only accepts non-negative values");
+  const r = new ArrayBuffer(8);
+  return new DataView(r).setBigUint64(0, e, !1), new Uint8Array(r);
+}
+function Br(t) {
+  return Array.isArray(t) ? ke(...t) : J(t);
+}
+function ke(...t) {
+  return Ee(t.map((e) => J(e)));
+}
+function re(t) {
+  return J(t);
+}
+function S(t) {
+  return Ee(t);
+}
+function Yt(t) {
+  const e = [], r = [];
+  for (let n = 0; n < t.length; n += 1) {
+    const o = t[n];
+    if (o !== M) {
+      r.push(o);
+      continue;
+    }
+    const s = t[n + 1];
+    if (s === me) {
+      r.push(M), n += 1;
+      continue;
+    }
+    if (s === $) {
+      e.push(Uint8Array.from(r)), r.length = 0, n += 1;
+      continue;
+    }
+    throw new TypeError("invalid compound key encoding");
+  }
+  if (r.length !== 0)
+    throw new TypeError("compound key terminated unexpectedly");
+  return e;
+}
+function F(t) {
+  const e = t.slice();
+  for (let r = e.length - 1; r >= 0; r -= 1)
+    if (e[r] !== 255)
+      return e[r] += 1, e.subarray(0, r + 1);
+  return null;
+}
+function xe(t) {
+  const e = F(t);
+  return e ? { gte: t, lt: e } : { gte: t };
+}
+function qr(...t) {
+  return xe(ke(...t));
+}
+function J(t) {
+  if (t === null)
+    return Uint8Array.of(Wt);
+  if (typeof t == "boolean")
+    return Uint8Array.of(t ? $t : zt);
+  if (typeof t == "number")
+    return Jt(t);
+  if (typeof t == "string") {
+    const e = P(t), r = new Uint8Array(1 + e.length);
+    return r[0] = Vt, r.set(e, 1), r;
+  }
+  if (t instanceof Uint8Array) {
+    const e = new Uint8Array(1 + t.length);
+    return e[0] = jt, e.set(t, 1), e;
+  }
+  throw new TypeError("compound key parts must be string, number, boolean, null, or Uint8Array");
+}
+function Ee(t) {
+  let e = 0;
+  for (const o of t) {
+    for (const s of o)
+      e += s === M ? 2 : 1;
+    e += 2;
+  }
+  const r = new Uint8Array(e);
+  let n = 0;
+  for (const o of t) {
+    for (const s of o)
+      s === M ? (r[n] = M, r[n + 1] = me, n += 2) : (r[n] = s, n += 1);
+    r[n] = $, r[n + 1] = $, n += 2;
+  }
+  return r;
+}
+function Jt(t) {
+  if (!Number.isFinite(t))
+    throw new TypeError("compound key number parts must be finite");
+  const e = Object.is(t, -0) ? 0 : t, r = new ArrayBuffer(9), n = new DataView(r);
+  n.setUint8(0, Ft), n.setFloat64(1, e, !1);
+  let o = n.getBigUint64(1, !1);
+  return o = (o & 1n << 63n) !== 0n ? ~o & Kt : o ^ 1n << 63n, n.setBigUint64(1, o, !1), new Uint8Array(r);
+}
+const Gt = new TextEncoder(), Se = new TextDecoder("utf-8", { fatal: !0 }), U = /* @__PURE__ */ Symbol("moyodb.indexing.missing"), Xt = 0xcbf29ce484222325n, Qt = 0x100000001b3n, Zt = 0xffffffffffffffffn, er = "__browserdb:", ne = "__browserdb:index:", Lr = "__browserdb:indexes";
+function tr(t) {
+  return t.startsWith(er);
+}
+function w(t) {
+  if (tr(t))
+    throw new ye(`reserved store name: ${t}`);
+}
+function G(t) {
+  if (t === void 0)
+    return [];
+  if (!Array.isArray(t))
+    throw new b("indexes must be an array");
+  const e = [], r = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map();
+  for (const o of t) {
+    if (o === null || typeof o != "object" || Array.isArray(o))
+      throw new b("each index definition must be an object");
+    const { store: s, name: i, keyPath: d, unique: u } = o;
+    if (typeof s != "string" || s.length === 0)
+      throw new b("index store must be a non-empty string");
+    if (typeof i != "string" || i.length === 0)
+      throw new b("index name must be a non-empty string");
+    w(s);
+    const l = nr(d);
+    if (u !== void 0 && typeof u != "boolean")
+      throw new b("index unique must be a boolean");
+    const a = {
+      store: s,
+      name: i,
+      keyPath: l.paths,
+      compound: l.compound,
+      unique: u ?? !1,
+      internalStore: or(s, i)
+    }, c = Ie(a.store, a.name);
+    if (r.has(c))
+      throw new b(`duplicate index definition ${a.store}.${a.name}`);
+    r.add(c);
+    const h = n.get(a.internalStore);
+    if (h && h !== c)
+      throw new b(
+        `index definitions ${h} and ${c} map to the same internal store ${a.internalStore}`
+      );
+    n.set(a.internalStore, c), e.push(a);
+  }
+  return e.sort(rr), e;
+}
+function rr(t, e) {
+  const r = L(t.store, e.store);
+  if (r !== 0)
+    return r;
+  const n = L(t.name, e.name);
+  if (n !== 0)
+    return n;
+  const o = Number(t.unique) - Number(e.unique);
+  return o !== 0 ? o : L(ie(t), ie(e));
+}
+function Ie(t, e) {
+  return `${t}\0${e}`;
+}
+function Cr(t, e, r) {
+  return t.find((n) => n.store === e && n.name === r) ?? null;
+}
+function Nr(t, e) {
+  return t.filter((r) => r.store === e);
+}
+function Ur(t, e) {
+  return S([P(t), P(e)]);
+}
+function Dr(t) {
+  return P(JSON.stringify(Te(t)));
+}
+function Wr(t) {
+  let e;
+  try {
+    e = JSON.parse(Se.decode(t));
+  } catch (n) {
+    throw new _(`invalid persisted index metadata: ${String(n)}`);
+  }
+  const [r] = G([e]);
+  return r;
+}
+function zr(t, e) {
+  return S([t, e]);
+}
+function $r(t) {
+  const e = Yt(t);
+  if (e.length !== 2)
+    throw new _("invalid index entry key encoding");
+  return {
+    logicalKey: e[0],
+    primaryKey: e[1]
+  };
+}
+function Fr(t) {
+  return xe(S([t]));
+}
+function Vr(t = {}) {
+  cr(t);
+  const e = {};
+  if (t.reverse !== void 0 && (e.reverse = t.reverse), t.limit !== void 0 && (e.limit = t.limit), t.gte && (e.gte = S([t.gte])), t.gt) {
+    const r = F(S([t.gt]));
+    r && (e.gte = r);
+  }
+  if (t.lt && (e.lt = S([t.lt])), t.lte) {
+    const r = F(S([t.lte]));
+    r && (e.lt = r);
+  }
+  return e;
+}
+function jr(t, e) {
+  const r = ir(e);
+  if (t.compound) {
+    const o = [];
+    for (const s of t.keyPath) {
+      const i = ce(r, s);
+      if (i === U)
+        return null;
+      o.push(ue(i));
+    }
+    return S(o);
+  }
+  const n = ce(r, t.keyPath[0]);
+  return n === U ? null : ue(n);
+}
+function oe(t) {
+  return JSON.stringify(Pe(t));
+}
+function Kr(t) {
+  return t.map((e) => ({
+    store: e.store,
+    name: e.name,
+    keyPath: [...e.keyPath],
+    compound: e.compound,
+    unique: e.unique,
+    internalStore: e.internalStore
+  }));
+}
+function Pe(t) {
+  return t.map(Te);
+}
+function Te(t) {
+  return {
+    store: t.store,
+    name: t.name,
+    keyPath: t.compound ? [...t.keyPath] : t.keyPath[0],
+    unique: t.unique
+  };
+}
+function nr(t) {
+  if (typeof t == "string")
+    return se(t), { paths: [t], compound: !1 };
+  if (!Array.isArray(t) || t.length === 0 || t.some((e) => typeof e != "string"))
+    throw new b("index keyPath must be a non-empty string or non-empty string[]");
+  for (const e of t)
+    se(e);
+  return { paths: [...t], compound: !0 };
+}
+function se(t) {
+  if (t.length === 0)
+    throw new b("index keyPath strings must be non-empty");
+  if (t.startsWith(".") || t.endsWith(".") || t.includes(".."))
+    throw new b(`invalid index keyPath: ${t}`);
+}
+function ie(t) {
+  return t.compound ? `[${t.keyPath.join(",")}]` : t.keyPath[0];
+}
+function or(t, e) {
+  const r = ae(P(t)), n = ae(P(e)), o = `${ne}${r}:${n}`;
+  if (Gt.encode(o).length <= 255)
+    return o;
+  const s = P(Ie(t, e));
+  return `${ne}h:${sr(s)}`;
+}
+function ae(t) {
+  let e = "";
+  for (const r of t)
+    e += String.fromCharCode(r);
+  return btoa(e).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/u, "");
+}
+function sr(t) {
+  let e = Xt;
+  for (const r of t)
+    e ^= BigInt(r), e = e * Qt & Zt;
+  return e.toString(16).padStart(16, "0");
+}
+function ir(t) {
+  try {
+    return JSON.parse(Se.decode(t));
+  } catch (e) {
+    throw new _(`indexed values must be valid UTF-8 JSON: ${String(e)}`);
+  }
+}
+function ce(t, e) {
+  let r = t;
+  for (const n of e.split(".")) {
+    if (r == null)
+      return U;
+    const o = Object(r);
+    if (!(n in o))
+      return U;
+    r = Reflect.get(o, n);
+  }
+  return r;
+}
+function ue(t) {
+  if (t instanceof Uint8Array || t === null || typeof t == "string" || typeof t == "number" || typeof t == "boolean")
+    return re(t);
+  throw new _(
+    `indexed keyPath values must resolve to string, number, boolean, null, or Uint8Array; got ${ar(t)}`
+  );
+}
+function ar(t) {
+  return Array.isArray(t) ? "array" : t === null ? "null" : typeof t;
+}
+function cr(t) {
+  if (t.gt !== void 0 && t.gte !== void 0)
+    throw new TypeError("index range cannot specify both gt and gte");
+  if (t.lt !== void 0 && t.lte !== void 0)
+    throw new TypeError("index range cannot specify both lt and lte");
+}
+function ur(t) {
+  return v(t) && t.key instanceof Uint8Array && (t.kind === "put" || t.kind === "delete");
+}
+function lr(t) {
+  return v(t) && typeof t.store == "string" && Array.isArray(t.changes) && t.changes.every(ur);
+}
+function dr(t) {
+  return v(t) && t.type === "commit_applied" && typeof t.dbName == "string" && typeof t.txid == "number" && Array.isArray(t.stores) && t.stores.every(lr);
+}
+function le(t) {
+  return t.map((e) => ({
+    key: e.key.slice(),
+    kind: e.kind
+  }));
+}
+function hr(t, e) {
+  if (e.byteLength > t.byteLength)
+    return !1;
+  for (let r = 0; r < e.byteLength; r += 1)
+    if (t[r] !== e[r])
+      return !1;
+  return !0;
+}
+function fr(t, e, r) {
+  if (typeof t == "function") {
+    if (e !== void 0 || r !== void 0)
+      throw new TypeError("subscribe(callback) accepts exactly one callback argument");
+    return {
+      store: null,
+      keyPrefix: null,
+      callback: t
+    };
+  }
+  if (typeof t != "string")
+    throw new TypeError("subscribe() storeName must be a string");
+  if (w(t), typeof e == "function") {
+    if (r !== void 0)
+      throw new TypeError("subscribe(storeName, callback) accepts exactly two arguments");
+    return {
+      store: t,
+      keyPrefix: null,
+      callback: e
+    };
+  }
+  if (e instanceof Uint8Array && typeof r == "function")
+    return {
+      store: t,
+      keyPrefix: e.slice(),
+      callback: r
+    };
+  throw new TypeError(
+    "subscribe() expects one of: (callback), (storeName, callback), (storeName, keyPrefix, callback)"
+  );
+}
+class yr {
+  #e;
+  #t = null;
+  #n = /* @__PURE__ */ new Set();
+  #s = !1;
+  constructor(e) {
+    this.#e = e;
+  }
+  subscribe(e, r, n) {
+    if (this.#s)
+      throw new H();
+    const o = fr(e, r, n), s = {
+      active: !0,
+      store: o.store,
+      keyPrefix: o.keyPrefix,
+      callback: o.callback
+    };
+    return this.#r(), this.#n.add(s), () => {
+      s.active && (s.active = !1, this.#n.delete(s), this.#n.size === 0 && this.#i());
+    };
+  }
+  close() {
+    this.#s || (this.#s = !0, this.#n.clear(), this.#i());
+  }
+  #r() {
+    if (this.#t !== null || this.#s)
+      return;
+    const e = new BroadcastChannel(`db:${this.#e}:events`);
+    e.onmessage = (r) => {
+      this.#c(r.data);
+    }, this.#t = e;
+  }
+  #i() {
+    this.#t?.close(), this.#t = null;
+  }
+  #c(e) {
+    if (!dr(e) || e.dbName !== this.#e || this.#n.size === 0)
+      return;
+    const r = Array.from(this.#n);
+    for (const n of e.stores)
+      for (const o of r) {
+        if (!o.active || o.store !== null && o.store !== n.store)
+          continue;
+        let s;
+        if (o.keyPrefix === null)
+          s = le(n.changes);
+        else if (s = le(
+          n.changes.filter((i) => hr(i.key, o.keyPrefix))
+        ), s.length === 0)
+          continue;
+        try {
+          o.callback(n.store, s, e.txid);
+        } catch (i) {
+          queueMicrotask(() => {
+            throw i;
+          });
+        }
+      }
+  }
+}
+async function f(t) {
+  try {
+    return await t();
+  } catch (e) {
+    throw x(e);
+  }
+}
+class pr {
+  mode;
+  #e;
+  #t;
+  #n = !1;
+  #s;
+  constructor(e, r, n, o) {
+    this.#e = e, this.#t = r, this.mode = n, this.#s = o;
+  }
+  async get(e, r) {
+    return this.#r(), w(e), f(() => this.#e.proxy.get(this.#t, e, r));
+  }
+  async getMany(e, r) {
+    return this.#r(), w(e), f(() => this.#e.proxy.getMany(this.#t, e, r));
+  }
+  async has(e, r) {
+    return this.#r(), w(e), f(() => this.#e.proxy.has(this.#t, e, r));
+  }
+  async put(e, r, n, o = {}) {
+    return this.#r(), w(e), f(() => this.#e.proxy.put(this.#t, e, r, n, V(o)));
+  }
+  async putMany(e, r, n = {}) {
+    return this.#r(), w(e), f(() => this.#e.proxy.putMany(this.#t, e, r, V(n)));
+  }
+  async delete(e, r) {
+    return this.#r(), w(e), f(() => this.#e.proxy.delete(this.#t, e, r));
+  }
+  async deleteMany(e, r) {
+    return this.#r(), w(e), f(() => this.#e.proxy.deleteMany(this.#t, e, r));
+  }
+  async applyBatch(e, r) {
+    return this.#r(), w(e), f(() => this.#e.proxy.applyBatch(this.#t, e, r));
+  }
+  async scan(e, r = {}) {
+    return this.#r(), w(e), f(() => this.#e.proxy.scan(this.#t, e, r));
+  }
+  async getByIndex(e, r, n) {
+    return this.#r(), w(e), f(() => this.#e.proxy.getByIndex(this.#t, e, r, n));
+  }
+  async *scanByIndex(e, r, n = {}) {
+    this.#r(), w(e);
+    const o = await f(() => this.#e.proxy.scanByIndex(this.#t, e, r, n));
+    for (const s of o)
+      yield [s.key, s.value];
+  }
+  async createStore(e, r = {}) {
+    return this.#r(), w(e), f(() => this.#e.proxy.createStore(this.#t, e, Re(r)));
+  }
+  async dropStore(e) {
+    return this.#r(), w(e), f(() => this.#e.proxy.dropStore(this.#t, e));
+  }
+  async clearStore(e) {
+    return this.#r(), w(e), f(() => this.#e.proxy.clearStore(this.#t, e));
+  }
+  async commit() {
+    this.#r();
+    try {
+      await f(() => this.#e.proxy.commit(this.#t));
+    } finally {
+      this.#i();
+    }
+  }
+  async rollback() {
+    this.#r();
+    try {
+      await f(() => this.#e.proxy.rollback(this.#t));
+    } finally {
+      this.#i();
+    }
+  }
+  async rollbackIfOpen() {
+    if (!this.#n) {
+      if (this.#e.invalidated) {
+        this.#i();
+        return;
+      }
+      try {
+        await this.#e.proxy.rollback(this.#t);
+      } catch (e) {
+        const r = x(e);
+        if (!(r instanceof z))
+          throw r;
+      } finally {
+        this.#i();
+      }
+    }
+  }
+  forceClose() {
+    this.#i();
+  }
+  internalId() {
+    return this.#t;
+  }
+  #r() {
+    if (this.#n || this.#e.invalidated)
+      throw new z();
+  }
+  #i() {
+    this.#n || (this.#n = !0, this.#s());
+  }
+}
+class br {
+  #e;
+  #t = !1;
+  #n = /* @__PURE__ */ new Set();
+  #s;
+  #r = null;
+  #i = null;
+  constructor(e) {
+    this.#e = e, this.#s = new yr(e.dbName), this.#r = _t(e, () => {
+      this.#l();
+    }), this.#i = Bt(e, () => {
+      this.#d();
+    });
+  }
+  async begin(e = "readonly") {
+    return this.#c(e);
+  }
+  async runSchemaMigration(e, r, n, o) {
+    this.#o();
+    const s = await this.#c("readwrite"), i = new wr(), d = new gr(s, i), u = new mr(this, d, i);
+    try {
+      await this.#e.proxy.reconcileIndexes(s.internalId(), o), await n({
+        db: u,
+        oldVersion: e,
+        newVersion: r,
+        transaction: d
+      }), await this.#e.proxy.setSchemaVersion(s.internalId(), r), await s.commit();
+    } catch (l) {
+      try {
+        await s.rollbackIfOpen();
+      } catch {
+      }
+      throw l;
+    }
+  }
+  async listStores() {
+    return this.#o(), f(() => this.#e.proxy.listStores());
+  }
+  async getVersion() {
+    return this.#o(), f(() => this.#e.proxy.getVersion());
+  }
+  async changesSince(e, r = {}) {
+    return this.#o(), f(
+      () => this.#e.proxy.changesSince(Sr(e), Ir(r))
+    );
+  }
+  async #c(e) {
+    return this.#o(), f(async () => {
+      const r = await this.#e.proxy.begin(e);
+      let n;
+      return n = new pr(this.#e, r, e, () => {
+        this.#n.delete(n);
+      }), this.#n.add(n), n;
+    });
+  }
+  async createStore(e, r = {}) {
+    await this.#a("readwrite", async (n) => {
+      await n.createStore(e, Re(r));
+    });
+  }
+  async dropStore(e) {
+    await this.#a("readwrite", async (r) => {
+      await r.dropStore(e);
+    });
+  }
+  async clearStore(e) {
+    await this.#a("readwrite", async (r) => {
+      await r.clearStore(e);
+    });
+  }
+  async get(e, r) {
+    return this.#a("readonly", (n) => n.get(e, r));
+  }
+  async getMany(e, r) {
+    return this.#a("readonly", (n) => n.getMany(e, r));
+  }
+  async has(e, r) {
+    return this.#a("readonly", (n) => n.has(e, r));
+  }
+  async put(e, r, n, o = {}) {
+    await this.#a("readwrite", async (s) => {
+      await s.put(e, r, n, V(o));
+    });
+  }
+  async delete(e, r) {
+    return this.#a("readwrite", (n) => n.delete(e, r));
+  }
+  async scan(e, r = {}) {
+    return this.#a("readonly", (n) => n.scan(e, r));
+  }
+  async exportSnapshot(e = {}) {
+    return this.#o(), f(async () => {
+      const r = await this.#e.proxy.exportSnapshot(Er(e));
+      return r instanceof Uint8Array ? r : new Uint8Array(r);
+    });
+  }
+  async importSnapshot(e) {
+    return this.#o(), f(() => {
+      const r = e instanceof Uint8Array ? e : new Uint8Array(e);
+      return this.#e.proxy.importSnapshot(r);
+    });
+  }
+  async reset() {
+    return this.#o(), N(this.#e), f(() => this.#e.proxy.reset());
+  }
+  async compact() {
+    return this.#o(), N(this.#e), f(() => this.#e.proxy.compact());
+  }
+  async rebuild() {
+    return this.#o(), N(this.#e), f(() => this.#e.proxy.rebuild());
+  }
+  async stats() {
+    return this.#o(), f(() => this.#e.proxy.stats());
+  }
+  async storageInfo() {
+    return this.#o(), f(() => this.#e.proxy.storageInfo());
+  }
+  async requestPersistence() {
+    return this.#o(), f(() => this.#e.proxy.requestPersistence());
+  }
+  async destroy() {
+    return this.#o(), f(() => ge(this.#e));
+  }
+  async setFailpoint(e) {
+    return this.#o(), f(() => this.#e.proxy.setFailpoint(e));
+  }
+  subscribe(e, r, n) {
+    if (this.#o(), typeof e == "function")
+      return this.#s.subscribe(e);
+    if (typeof r == "function")
+      return this.#s.subscribe(e, r);
+    if (r instanceof Uint8Array && typeof n == "function")
+      return this.#s.subscribe(e, r, n);
+    throw new TypeError(
+      "subscribe() expects one of: (callback), (storeName, callback), (storeName, keyPrefix, callback)"
+    );
+  }
+  watch(e, r, n) {
+    if (typeof e == "function")
+      return this.subscribe(e);
+    if (typeof r == "function")
+      return this.subscribe(e, r);
+    if (r instanceof Uint8Array && typeof n == "function")
+      return this.subscribe(e, r, n);
+    throw new TypeError(
+      "watch() expects one of: (callback), (storeName, callback), (storeName, keyPrefix, callback)"
+    );
+  }
+  async close() {
+    if (this.#t)
+      return;
+    this.#t = !0, this.#u(), this.#s.close();
+    let e = null;
+    const r = Array.from(this.#n);
+    if (r.length > 0) {
+      const n = await Promise.allSettled(r.map((o) => o.rollbackIfOpen()));
+      for (const o of n)
+        o.status === "rejected" && e === null && (e = x(o.reason));
+    }
+    try {
+      await Ct(this.#e);
+    } catch (n) {
+      throw x(n);
+    }
+    if (e)
+      throw e;
+  }
+  async #a(e, r) {
+    const n = await this.begin(e);
+    try {
+      const o = await r(n);
+      return e === "readwrite" ? await n.commit() : await n.rollback(), o;
+    } catch (o) {
+      try {
+        await n.rollback();
+      } catch {
+      }
+      throw o;
+    }
+  }
+  #u() {
+    this.#r?.(), this.#r = null, this.#i?.(), this.#i = null;
+  }
+  #l() {
+    for (const e of Array.from(this.#n))
+      e.forceClose();
+  }
+  #d() {
+    this.#t || (this.#t = !0, this.#u(), this.#l(), this.#s.close());
+  }
+  #o() {
+    if (this.#t || this.#e.invalidated)
+      throw new H();
+  }
+}
+class wr {
+  #e = /* @__PURE__ */ new Set();
+  #t = /* @__PURE__ */ new Set();
+  recordCreate(e) {
+    this.#t.delete(e), this.#e.add(e);
+  }
+  recordDrop(e) {
+    this.#e.delete(e) || this.#t.add(e);
+  }
+  apply(e) {
+    const r = new Set(e);
+    for (const n of this.#e)
+      r.add(n);
+    for (const n of this.#t)
+      r.delete(n);
+    return Array.from(r).sort(L);
+  }
+}
+class gr {
+  #e;
+  #t;
+  constructor(e, r) {
+    this.#e = e, this.#t = r;
+  }
+  get mode() {
+    return this.#e.mode;
+  }
+  async get(e, r) {
+    return this.#e.get(e, r);
+  }
+  async getMany(e, r) {
+    return this.#e.getMany(e, r);
+  }
+  async has(e, r) {
+    return this.#e.has(e, r);
+  }
+  async put(e, r, n, o = {}) {
+    await this.#e.put(e, r, n, o);
+  }
+  async putMany(e, r, n = {}) {
+    await this.#e.putMany(e, r, n);
+  }
+  async delete(e, r) {
+    return this.#e.delete(e, r);
+  }
+  async deleteMany(e, r) {
+    await this.#e.deleteMany(e, r);
+  }
+  async applyBatch(e, r) {
+    await this.#e.applyBatch(e, r);
+  }
+  async scan(e, r = {}) {
+    return this.#e.scan(e, r);
+  }
+  async getByIndex(e, r, n) {
+    return this.#e.getByIndex(e, r, n);
+  }
+  scanByIndex(e, r, n = {}) {
+    return this.#e.scanByIndex(e, r, n);
+  }
+  async createStore(e, r = {}) {
+    await this.#e.createStore(e, r), this.#t.recordCreate(e);
+  }
+  async dropStore(e) {
+    await this.#e.dropStore(e), this.#t.recordDrop(e);
+  }
+  async clearStore(e) {
+    await this.#e.clearStore(e);
+  }
+  async commit() {
+    throw m("transaction.commit");
+  }
+  async rollback() {
+    throw m("transaction.rollback");
+  }
+}
+class mr {
+  #e;
+  #t;
+  #n;
+  constructor(e, r, n) {
+    this.#e = e, this.#t = r, this.#n = n;
+  }
+  async begin(e = "readonly") {
+    throw m("db.begin");
+  }
+  async createStore(e, r = {}) {
+    await this.#t.createStore(e, r);
+  }
+  async dropStore(e) {
+    await this.#t.dropStore(e);
+  }
+  async clearStore(e) {
+    await this.#t.clearStore(e);
+  }
+  async listStores() {
+    return this.#n.apply(await this.#e.listStores());
+  }
+  async getVersion() {
+    return this.#e.getVersion();
+  }
+  async changesSince(e, r = {}) {
+    throw m("db.changesSince");
+  }
+  async get(e, r) {
+    return this.#t.get(e, r);
+  }
+  async getMany(e, r) {
+    return this.#t.getMany(e, r);
+  }
+  async has(e, r) {
+    return this.#t.has(e, r);
+  }
+  async put(e, r, n, o = {}) {
+    await this.#t.put(e, r, n, o);
+  }
+  async delete(e, r) {
+    return this.#t.delete(e, r);
+  }
+  async scan(e, r = {}) {
+    return this.#t.scan(e, r);
+  }
+  async exportSnapshot(e = {}) {
+    throw m("db.exportSnapshot");
+  }
+  async importSnapshot(e) {
+    throw m("db.importSnapshot");
+  }
+  async reset() {
+    throw m("db.reset");
+  }
+  async compact() {
+    throw m("db.compact");
+  }
+  async rebuild() {
+    throw m("db.rebuild");
+  }
+  async stats() {
+    return this.#e.stats();
+  }
+  async storageInfo() {
+    return this.#e.storageInfo();
+  }
+  async requestPersistence() {
+    return this.#e.requestPersistence();
+  }
+  async close() {
+    throw m("db.close");
+  }
+  async destroy() {
+    throw m("db.destroy");
+  }
+  async setFailpoint(e) {
+    throw m("db.setFailpoint");
+  }
+  subscribe(e, r, n) {
+    throw m("db.subscribe");
+  }
+  watch(e, r, n) {
+    throw m("db.watch");
+  }
+}
+function m(t) {
+  const e = new Error(
+    `${t}() is not available inside openDB() migrations; use the provided migration transaction and wait for openDB() to resolve`
+  );
+  return e.name = "InvalidStateError", e;
+}
+function X(t, e) {
+  if (typeof t != "string" || t.length === 0)
+    throw new TypeError(`${e}() database name must be a non-empty string`);
+  return t;
+}
+const Ae = (t) => new TypeError(t), Oe = (t) => new b(t);
+function D(t, e, r = Ae) {
+  if (t === void 0)
+    return {};
+  if (t === null || typeof t != "object" || Array.isArray(t))
+    throw r(e);
+  return t;
+}
+function ve(t, e, r = Ae) {
+  if (typeof t != "number" || !Number.isSafeInteger(t) || t < 0)
+    throw r(e);
+  return t;
+}
+function Q(t, e, r) {
+  return t === void 0 ? void 0 : ve(t, e, r);
+}
+function kr(t) {
+  return D(t, "open options must be an object", Oe);
+}
+function xr(t) {
+  return Q(
+    t,
+    "version must be a non-negative safe integer",
+    Oe
+  );
+}
+function V(t) {
+  const { ttl: e } = D(t, "put options must be an object"), r = Q(e, "ttl must be a non-negative safe integer");
+  return r === void 0 ? {} : { ttl: r };
+}
+function Me(t, e) {
+  const { compression: r } = D(t, e);
+  if (r === void 0)
+    return {};
+  if (r !== !1 && r !== "gzip" && r !== "deflate")
+    throw new TypeError('compression must be "gzip", "deflate", or false');
+  return { compression: r };
+}
+function Re(t) {
+  return Me(t, "createStore options must be an object");
+}
+function Er(t) {
+  return Me(t, "exportSnapshot options must be an object");
+}
+function Sr(t) {
+  return ve(t, "txid must be a non-negative safe integer");
+}
+function Ir(t) {
+  const { stores: e, limit: r } = D(t, "change feed options must be an object"), n = {};
+  if (e !== void 0) {
+    if (!Array.isArray(e) || e.some((s) => typeof s != "string"))
+      throw new TypeError("stores must be an array of strings");
+    for (const s of e)
+      w(s);
+    n.stores = [...e];
+  }
+  const o = Q(r, "limit must be a non-negative safe integer");
+  return o !== void 0 && (n.limit = o), n;
+}
+function Pr(t) {
+  if (t !== void 0) {
+    if (typeof t != "function")
+      throw new b("migrate must be a function");
+    return t;
+  }
+}
+function Tr(t) {
+  if (t !== void 0)
+    return G(t);
+}
+function Ar(t, e) {
+  return oe(t) === oe(e);
+}
+async function Or(t) {
+  return G(await t.proxy.getIndexes());
+}
+function _e() {
+  if (!globalThis.isSecureContext)
+    throw new O("moyodb requires a secure context (HTTPS)");
+  const t = globalThis.navigator;
+  if (!t?.storage)
+    throw new O("navigator.storage is unavailable");
+  if (typeof t.storage.getDirectory != "function")
+    throw new O("navigator.storage.getDirectory is unavailable");
+  if (typeof globalThis.Worker != "function")
+    throw new O("Worker is unavailable");
+  if (typeof globalThis.BroadcastChannel > "u")
+    throw new O("BroadcastChannel is unavailable");
+  if (!t.locks)
+    throw new O("navigator.locks is unavailable");
+}
+async function vr(t) {
+  const e = globalThis.navigator;
+  (t.requestPersistence ?? !0) && typeof e?.storage?.persist == "function" && await j(e.storage.persist(), 1e3, !1);
+}
+async function Hr(t, e = {}) {
+  const r = X(t, "openDB"), n = kr(e), o = xr(n.version), s = Pr(n.migrate), i = Tr(n.indexes);
+  if (o === void 0 && s !== void 0)
+    throw new b("migrate requires version");
+  if (o === void 0 && i !== void 0)
+    throw new b("indexes requires version");
+  _e(), await vr(n);
+  const d = await Lt(r, n), u = new br(d);
+  let l = !1;
+  try {
+    if (o === void 0)
+      return l = !0, u;
+    const [a, c] = await Promise.all([u.getVersion(), Or(d)]);
+    if (o < a)
+      throw new C(
+        `cannot open database ${r} at schema version ${o}; current schema version is ${a}`
+      );
+    if (o === a) {
+      if (i !== void 0 && !Ar(i, c))
+        throw new C(
+          `database ${r} is already at schema version ${a}, but the requested index catalog does not match the committed schema`
+        );
+      return l = !0, u;
+    }
+    if (d.refs > 1)
+      throw new he(
+        `database ${r} is already open in this tab; close existing handles before migrating from version ${a} to ${o}`
+      );
+    if (!s)
+      throw new C(
+        `database ${r} requires migration from version ${a} to ${o}, but no migrate hook was provided`
+      );
+    const h = i ?? c;
+    return await u.runSchemaMigration(a, o, s, Pe(h)), l = !0, u;
+  } catch (a) {
+    if (!l)
+      try {
+        await u.close();
+      } catch {
+      }
+    throw x(a);
+  }
+}
+async function Yr(t) {
+  const e = X(t, "deleteDB");
+  _e(), await Nt(e);
+}
+function Jr(t) {
+  const e = X(t, "unsafeDebugCrashWorker");
+  return qt(e);
+}
+export {
+  bt as ChangeFeedCompactedError,
+  fe as ConstraintError,
+  nt as CorruptionError,
+  he as DatabaseBusyError,
+  H as DatabaseClosedError,
+  Lr as INDEX_METADATA_STORE,
+  it as IndexNotFoundError,
+  pt as InjectedFailureError,
+  wt as InternalError,
+  b as InvalidOpenOptionsError,
+  ft as InvalidRangeError,
+  dt as KeyTooLargeError,
+  p as MoyoDbError,
+  ut as ReadonlyTransactionError,
+  ye as ReservedStoreNameError,
+  _ as SerializationError,
+  yt as StorageError,
+  ot as StoreExistsError,
+  ht as StoreNameTooLongError,
+  st as StoreNotFoundError,
+  z as TransactionClosedError,
+  at as UniqueIndexConstraintError,
+  O as UnsupportedPlatformError,
+  lt as ValueTooLargeError,
+  C as VersionError,
+  ct as WriteTransactionAlreadyOpenError,
+  w as assertPublicStoreName,
+  Kr as cloneNormalizedIndexDefinitions,
+  rr as compareNormalizedIndexDefinitions,
+  ke as compoundKey,
+  qr as compoundKeyRange,
+  $r as decodeIndexEntryKey,
+  Wr as decodeIndexMetadataValue,
+  Yr as deleteDB,
+  S as encodeCompoundKeyParts,
+  zr as encodeIndexEntryKey,
+  Ur as encodeIndexMetadataKey,
+  Dr as encodeIndexMetadataValue,
+  re as encodeIndexScalar,
+  jr as extractLogicalIndexKey,
+  Cr as findIndexDefinition,
+  Ie as indexDefinitionIdentity,
+  Br as indexKey,
+  Fr as indexKeyExactRange,
+  Vr as indexRangeToPhysicalRange,
+  Nr as indexesForStore,
+  tr as isInternalStoreName,
+  Rr as jsonDecode,
+  Mr as jsonEncode,
+  x as normalizeError,
+  G as normalizeIndexDefinitions,
+  Hr as openDB,
+  xe as prefixRange,
+  F as prefixSuccessor,
+  oe as serializeNormalizedIndexDefinitions,
+  Yt as splitCompoundKey,
+  Pe as toPublicIndexDefinitions,
+  _r as u64Key,
+  Jr as unsafeDebugCrashWorker,
+  Ht as utf8Decode,
+  P as utf8Encode
+};
+//# sourceMappingURL=moyodb-sdk.js.map