@graphrefly/ts 0.0.0

package/dist/storage/browser.cjs

@@ -0,0 +1,777 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/storage/browser.ts
+var browser_exports = {};
+__export(browser_exports, {
+  indexedDbAppendLog: () => indexedDbAppendLog,
+  indexedDbBackend: () => indexedDbBackend,
+  indexedDbKv: () => indexedDbKv
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/storage/backend.ts
+var HEX_TABLE = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+function hasStoragePutIfAbsent(backend) {
+  return typeof backend.putIfAbsent === "function";
+}
+function hasStorageVersioned(backend) {
+  return typeof backend.getVersioned === "function" && typeof backend.setIfMatch === "function";
+}
+
+// src/json/codec.ts
+var JS_MIN_NORMAL_NUMBER = 2 ** -1022;
+function assertStableJsonNumber(value, path) {
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`stableJsonString: non-finite number at ${path}`);
+  }
+}
+function assertStrictJsonNumber(value, path) {
+  assertStableJsonNumber(value, path);
+  if (Object.is(value, -0)) {
+    throw new TypeError(`stableJsonString: non-canonical number at ${path}`);
+  }
+  const abs = Math.abs(value);
+  if (abs > 0 && abs < JS_MIN_NORMAL_NUMBER) {
+    throw new TypeError(`stableJsonString: subnormal number at ${path}`);
+  }
+  if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
+    throw new TypeError(`stableJsonString: integer outside safe range at ${path}`);
+  }
+}
+function sortedJsonValue(value, seen = /* @__PURE__ */ new Set(), path = "$", strictNumbers = false) {
+  if (value === null) return null;
+  if (typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (strictNumbers) assertStrictJsonNumber(value, path);
+    else assertStableJsonNumber(value, path);
+    return value;
+  }
+  if (typeof value !== "object") {
+    throw new TypeError(`stableJsonString: value at ${path} is not JSON-encodable`);
+  }
+  if (seen.has(value)) throw new TypeError(`stableJsonString: circular reference at ${path}`);
+  const proto = Object.getPrototypeOf(value);
+  if (!Array.isArray(value) && proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`stableJsonString: non-plain object at ${path}`);
+  }
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      if (Object.getOwnPropertySymbols(value).length > 0) {
+        throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+      }
+      for (const key of Object.getOwnPropertyNames(value)) {
+        const isIndex = /^(0|[1-9]\d*)$/.test(key) && Number.isSafeInteger(Number(key)) && Number(key) < value.length;
+        if (key !== "length" && !isIndex) {
+          throw new TypeError(`stableJsonString: non-index array property at ${path}.${key}`);
+        }
+      }
+      const out2 = [];
+      for (let i = 0; i < value.length; i += 1) {
+        if (!(i in value)) {
+          throw new TypeError(`stableJsonString: sparse array hole at ${path}[${i}]`);
+        }
+        out2.push(sortedJsonValue(value[i], seen, `${path}[${i}]`, strictNumbers));
+      }
+      return out2;
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+      throw new TypeError(`stableJsonString: symbol-keyed properties at ${path}`);
+    }
+    const out = /* @__PURE__ */ Object.create(null);
+    for (const key of Object.keys(value).sort()) {
+      out[key] = sortedJsonValue(
+        value[key],
+        seen,
+        `${path}.${key}`,
+        strictNumbers
+      );
+    }
+    return out;
+  } finally {
+    seen.delete(value);
+  }
+}
+function stableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value));
+}
+function strictStableJsonString(value) {
+  return JSON.stringify(sortedJsonValue(value, /* @__PURE__ */ new Set(), "$", true));
+}
+function jsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder();
+  return {
+    encode(value) {
+      return encoder.encode(stableJsonString(value));
+    },
+    decode(bytes) {
+      return JSON.parse(decoder.decode(bytes));
+    }
+  };
+}
+var jsonCodec = jsonCodecFor();
+function bytesEqual(a, b) {
+  if (a.byteLength !== b.byteLength) return false;
+  for (let i = 0; i < a.byteLength; i += 1) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+function hasUnpairedSurrogate(value) {
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        i += 1;
+        continue;
+      }
+      return true;
+    }
+    if (code >= 56320 && code <= 57343) return true;
+  }
+  return false;
+}
+function assertNoUnpairedSurrogates(value, seen = /* @__PURE__ */ new Set(), path = "$") {
+  if (typeof value === "string") {
+    if (hasUnpairedSurrogate(value)) {
+      throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}`);
+    }
+    return;
+  }
+  if (value === null || typeof value !== "object") return;
+  if (seen.has(value)) return;
+  seen.add(value);
+  try {
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i += 1) {
+        assertNoUnpairedSurrogates(value[i], seen, `${path}[${i}]`);
+      }
+      return;
+    }
+    for (const key of Object.keys(value)) {
+      if (hasUnpairedSurrogate(key)) {
+        throw new TypeError(`strictJsonCodec: unpaired surrogate at ${path}.${key}`);
+      }
+      assertNoUnpairedSurrogates(value[key], seen, `${path}.${key}`);
+    }
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertNoDuplicateJsonObjectKeys(text) {
+  let index = 0;
+  function fail(message) {
+    throw new TypeError(`strictJsonCodec: ${message}`);
+  }
+  function skipWhitespace() {
+    while (/\s/.test(text[index] ?? "")) index += 1;
+  }
+  function readJsonString() {
+    const start = index;
+    index += 1;
+    while (index < text.length) {
+      const ch = text[index];
+      if (ch === '"') {
+        index += 1;
+        try {
+          return JSON.parse(text.slice(start, index));
+        } catch {
+          fail("malformed JSON string");
+        }
+      }
+      if (ch === "\\") {
+        index += 2;
+        continue;
+      }
+      index += 1;
+    }
+    fail("unterminated JSON string");
+  }
+  function consumeLiteral(literal) {
+    if (text.slice(index, index + literal.length) !== literal) {
+      fail(`malformed JSON near byte ${index}`);
+    }
+    index += literal.length;
+  }
+  function consumeNumber() {
+    const match = /^-?(0|[1-9]\d*)(\.\d+)?([eE][+-]?\d+)?/.exec(text.slice(index));
+    if (!match) fail(`malformed JSON number near byte ${index}`);
+    index += match[0].length;
+  }
+  function parseValue(path) {
+    skipWhitespace();
+    const ch = text[index];
+    if (ch === "{") {
+      parseObject(path);
+      return;
+    }
+    if (ch === "[") {
+      parseArray(path);
+      return;
+    }
+    if (ch === '"') {
+      readJsonString();
+      return;
+    }
+    if (ch === "t") {
+      consumeLiteral("true");
+      return;
+    }
+    if (ch === "f") {
+      consumeLiteral("false");
+      return;
+    }
+    if (ch === "n") {
+      consumeLiteral("null");
+      return;
+    }
+    if (ch === "-" || ch !== void 0 && ch >= "0" && ch <= "9") {
+      consumeNumber();
+      return;
+    }
+    fail(`malformed JSON near byte ${index}`);
+  }
+  function parseObject(path) {
+    const keys = /* @__PURE__ */ new Set();
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "}") {
+      index += 1;
+      return;
+    }
+    while (index < text.length) {
+      skipWhitespace();
+      if (text[index] !== '"') fail(`expected object key near byte ${index}`);
+      const key = readJsonString();
+      if (keys.has(key)) {
+        throw new TypeError(
+          `strictJsonCodec: duplicate object key ${JSON.stringify(key)} at ${path}`
+        );
+      }
+      keys.add(key);
+      skipWhitespace();
+      if (text[index] !== ":") fail(`expected ':' after object key near byte ${index}`);
+      index += 1;
+      parseValue(`${path}.${key}`);
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "}") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or '}' near byte ${index}`);
+    }
+    fail("unterminated JSON object");
+  }
+  function parseArray(path) {
+    index += 1;
+    skipWhitespace();
+    if (text[index] === "]") {
+      index += 1;
+      return;
+    }
+    let item = 0;
+    while (index < text.length) {
+      parseValue(`${path}[${item}]`);
+      item += 1;
+      skipWhitespace();
+      if (text[index] === ",") {
+        index += 1;
+        continue;
+      }
+      if (text[index] === "]") {
+        index += 1;
+        return;
+      }
+      fail(`expected ',' or ']' near byte ${index}`);
+    }
+    fail("unterminated JSON array");
+  }
+  parseValue("$");
+  skipWhitespace();
+  if (index !== text.length) fail(`trailing JSON token near byte ${index}`);
+}
+function strictJsonCodecFor() {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  return {
+    encode(value) {
+      assertNoUnpairedSurrogates(value);
+      return encoder.encode(strictStableJsonString(value));
+    },
+    decode(bytes) {
+      const text = decoder.decode(bytes);
+      assertNoDuplicateJsonObjectKeys(text);
+      const decoded = JSON.parse(text);
+      assertNoUnpairedSurrogates(decoded);
+      const canonical = encoder.encode(strictStableJsonString(decoded));
+      if (!bytesEqual(bytes, canonical)) {
+        throw new TypeError("strictJsonCodec: bytes are not canonical stable JSON");
+      }
+      return decoded;
+    }
+  };
+}
+var strictJsonCodec = strictJsonCodecFor();
+
+// src/storage/kv.ts
+function defer(fn) {
+  return Promise.resolve().then(fn);
+}
+function kvStorage(opts) {
+  const codec = opts.codec ?? jsonCodecFor();
+  const { backend } = opts;
+  const tier = {
+    get(key) {
+      return defer(() => backend.get(key)).then(
+        (bytes) => bytes === void 0 ? void 0 : codec.decode(bytes)
+      );
+    },
+    set(key, value) {
+      return defer(() => backend.put(key, codec.encode(value))).then(() => void 0);
+    },
+    delete(key) {
+      return defer(() => backend.delete?.(key)).then(() => void 0);
+    },
+    list(prefix = "") {
+      return defer(() => {
+        if (!backend.list) throw new Error("kvStorage.list: backend does not support listing");
+        return backend.list(prefix);
+      }).then((keys) => [...keys].sort());
+    }
+  };
+  let out = tier;
+  if (hasStoragePutIfAbsent(backend)) {
+    out = {
+      ...out,
+      putIfAbsent(key, value) {
+        return defer(() => backend.putIfAbsent(key, codec.encode(value)));
+      }
+    };
+  }
+  if (hasStorageVersioned(backend)) {
+    out = {
+      ...out,
+      getVersioned(key) {
+        return defer(() => backend.getVersioned(key)).then((result) => {
+          if (result.kind === "miss") return { kind: "miss", generation: result.generation };
+          return {
+            kind: "hit",
+            value: codec.decode(result.value),
+            generation: result.generation
+          };
+        });
+      },
+      setIfMatch(key, value, generation) {
+        return defer(() => backend.setIfMatch(key, codec.encode(value), generation));
+      }
+    };
+  }
+  return out;
+}
+
+// src/storage/append-log.ts
+var APPEND_LOG_SEQ_PAD = 20;
+function appendLogKey(prefix, seq) {
+  if (!Number.isSafeInteger(seq) || seq < 0) {
+    throw new RangeError(`appendLogKey: seq must be a non-negative safe integer, got ${seq}`);
+  }
+  return `${prefix}/${seq.toString().padStart(APPEND_LOG_SEQ_PAD, "0")}`;
+}
+function seqFromKey(prefix, key) {
+  const head = `${prefix}/`;
+  if (!key.startsWith(head)) throw new Error(`append log key outside prefix: ${key}`);
+  const raw = key.slice(head.length);
+  if (!/^\d+$/.test(raw)) {
+    throw new Error(`append log key has a non-numeric sequence: ${key}`);
+  }
+  if (raw.length !== APPEND_LOG_SEQ_PAD) {
+    throw new Error(`append log key sequence must be ${APPEND_LOG_SEQ_PAD} padded digits: ${key}`);
+  }
+  const seq = Number(raw);
+  if (!Number.isSafeInteger(seq)) {
+    throw new Error(`append log key sequence is outside the safe integer range: ${key}`);
+  }
+  return seq;
+}
+function nextSeqFromKeys(prefix, keys) {
+  if (keys.length === 0) return 0;
+  const next = Math.max(...keys.map((key) => seqFromKey(prefix, key))) + 1;
+  if (!Number.isSafeInteger(next)) {
+    throw new RangeError(`append log next sequence is outside the safe integer range: ${prefix}`);
+  }
+  return next;
+}
+function sizeFromKeys(prefix, keys) {
+  for (const key of keys) seqFromKey(prefix, key);
+  return keys.length;
+}
+function validateReadOptions(opts) {
+  const after = opts.after ?? -1;
+  const limit = opts.limit ?? Number.POSITIVE_INFINITY;
+  if (!Number.isSafeInteger(after) || after < -1) {
+    throw new RangeError(
+      `appendLogStorage.read: after must be an integer cursor >= -1, got ${after}`
+    );
+  }
+  if (limit !== Number.POSITIVE_INFINITY && (!Number.isSafeInteger(limit) || limit < 0)) {
+    throw new RangeError(
+      `appendLogStorage.read: limit must be a non-negative safe integer or Infinity, got ${limit}`
+    );
+  }
+  return { after, limit };
+}
+function readAppendLogEntries(kv, prefix, opts) {
+  const { after, limit } = validateReadOptions(opts);
+  return kv.list(`${prefix}/`).then((listed) => {
+    const keys = listed.map((key) => ({ key, seq: seqFromKey(prefix, key) })).filter(({ seq }) => seq > after).sort((a, b) => a.seq - b.seq).slice(0, limit);
+    return Promise.all(
+      keys.map(
+        ({ key, seq }) => kv.get(key).then((value) => {
+          if (value === void 0) {
+            throw new Error(`append log listed key is missing: ${key}`);
+          }
+          return { key, seq, value };
+        })
+      )
+    ).then((entries) => {
+      const out = [];
+      for (const entry of entries) if (entry !== void 0) out.push(entry);
+      return out;
+    });
+  });
+}
+function deleteAppendLogEntriesAfter(kv, prefix, seq) {
+  return kv.list(`${prefix}/`).then(
+    (keys) => Promise.all(keys.filter((key) => seqFromKey(prefix, key) > seq).map((key) => kv.delete(key)))
+  ).then(() => kv.list(`${prefix}/`)).then(() => void 0);
+}
+function appendLogStorage(opts) {
+  const { kv, prefix = "event-log" } = opts;
+  let tail = Promise.resolve();
+  function initNextSeq() {
+    return kv.list(`${prefix}/`).then((keys) => {
+      return nextSeqFromKeys(prefix, keys);
+    });
+  }
+  function enqueue(task) {
+    const run = tail.then(task, task);
+    tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    return run;
+  }
+  return {
+    append(value) {
+      return enqueue(
+        () => initNextSeq().then((seq) => {
+          const key = appendLogKey(prefix, seq);
+          return kv.set(key, value).then(() => {
+            return { key, seq, value };
+          });
+        })
+      );
+    },
+    read(opts2 = {}) {
+      return enqueue(() => readAppendLogEntries(kv, prefix, opts2));
+    },
+    truncateAfter(seq) {
+      return enqueue(() => deleteAppendLogEntriesAfter(kv, prefix, seq));
+    },
+    size() {
+      return enqueue(() => kv.list(`${prefix}/`).then((keys) => sizeFromKeys(prefix, keys)));
+    }
+  };
+}
+
+// src/storage/browser.ts
+var KEY_SEPARATOR = "\0";
+function isConstraintError(error) {
+  return error instanceof DOMException && error.name === "ConstraintError";
+}
+function validateKey(key) {
+  if (typeof key !== "string") {
+    throw new TypeError("indexedDbBackend: key must be a string");
+  }
+  if (key.includes(KEY_SEPARATOR)) {
+    throw new TypeError("indexedDbBackend: key must not contain U+0000");
+  }
+  return key;
+}
+function validateListPrefix(prefix) {
+  if (typeof prefix !== "string") {
+    throw new TypeError("indexedDbBackend: list prefix must be a string");
+  }
+  if (prefix.includes(KEY_SEPARATOR)) {
+    throw new TypeError("indexedDbBackend: list prefix must not contain U+0000");
+  }
+  return prefix;
+}
+function decodeStoredBytes(raw) {
+  if (raw === void 0 || raw === null) return void 0;
+  if (raw instanceof Uint8Array) return Uint8Array.from(raw);
+  if (raw instanceof ArrayBuffer) return new Uint8Array(raw.slice(0));
+  throw new TypeError("indexedDbBackend: malformed stored bytes");
+}
+function normalizeKeys(prefix, raw) {
+  const out = [];
+  for (const key of raw) {
+    if (typeof key !== "string") {
+      throw new TypeError("indexedDbBackend: stored key must be a string");
+    }
+    if (key.includes(KEY_SEPARATOR)) {
+      throw new TypeError("indexedDbBackend: malformed stored key");
+    }
+    if (key.startsWith(prefix)) out.push(key);
+  }
+  out.sort();
+  return out;
+}
+function openDb(spec, version = spec.version) {
+  return new Promise((resolve, reject) => {
+    if (typeof indexedDB === "undefined") {
+      reject(new TypeError("indexedDbBackend: indexedDB is not available in this environment"));
+      return;
+    }
+    const req = version === void 0 ? indexedDB.open(spec.dbName) : indexedDB.open(spec.dbName, version);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(spec.storeName)) {
+        db.createObjectStore(spec.storeName);
+      }
+    };
+    req.onblocked = () => reject(
+      new Error("indexedDbBackend: open blocked; close existing database connections and retry")
+    );
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error ?? new TypeError("indexedDbBackend: open failed"));
+  });
+}
+function openDbWithStore(spec) {
+  return openDb(spec).then((db) => {
+    if (db.objectStoreNames.contains(spec.storeName)) return db;
+    if (spec.version !== void 0) {
+      db.close();
+      throw new Error(
+        `indexedDbBackend: object store "${spec.storeName}" is missing; bump the IndexedDB version to create it`
+      );
+    }
+    const nextVersion = db.version + 1;
+    db.close();
+    return openDb(spec, nextVersion).then((upgraded) => {
+      if (upgraded.objectStoreNames.contains(spec.storeName)) return upgraded;
+      upgraded.close();
+      throw new Error(`indexedDbBackend: object store "${spec.storeName}" was not created`);
+    });
+  });
+}
+function indexedDbBackend(spec) {
+  let dbCache;
+  const db = () => {
+    if (dbCache !== void 0) return dbCache;
+    const attempt = openDbWithStore(spec);
+    const cached = attempt.catch((error) => {
+      if (dbCache === cached) dbCache = void 0;
+      throw error;
+    });
+    dbCache = cached;
+    return dbCache;
+  };
+  return {
+    name: `idb:${spec.dbName}/${spec.storeName}`,
+    get(key) {
+      validateKey(key);
+      return db().then(
+        (database) => new Promise((resolve, reject) => {
+          try {
+            const tx = database.transaction(spec.storeName, "readonly");
+            const store = tx.objectStore(spec.storeName);
+            const req = store.get(key);
+            req.onsuccess = () => {
+              try {
+                resolve(decodeStoredBytes(req.result));
+              } catch (error) {
+                reject(error);
+              }
+            };
+            req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: read failed"));
+            tx.onabort = () => reject(tx.error ?? new Error("indexedDbBackend: read transaction aborted"));
+            tx.oncomplete = () => {
+            };
+          } catch (error) {
+            reject(error);
+          }
+        })
+      );
+    },
+    put(key, value) {
+      validateKey(key);
+      return db().then(
+        (database) => new Promise((resolve, reject) => {
+          try {
+            const tx = database.transaction(spec.storeName, "readwrite");
+            const store = tx.objectStore(spec.storeName);
+            const req = store.put(value, key);
+            req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: write failed"));
+            tx.oncomplete = () => resolve();
+            tx.onabort = () => reject(tx.error ?? new Error("indexedDbBackend: write transaction aborted"));
+            tx.onerror = () => reject(tx.error ?? new Error("indexedDbBackend: write transaction failed"));
+          } catch (error) {
+            reject(error);
+          }
+        })
+      );
+    },
+    putIfAbsent(key, value) {
+      validateKey(key);
+      return db().then(
+        (database) => new Promise((resolve, reject) => {
+          let requestOk = false;
+          let requestConflict = false;
+          let requestError;
+          let settled = false;
+          const settle = (fn) => {
+            if (settled) return;
+            settled = true;
+            fn();
+          };
+          try {
+            const tx = database.transaction(spec.storeName, "readwrite");
+            const store = tx.objectStore(spec.storeName);
+            const req = store.add(value, key);
+            req.onsuccess = () => {
+              requestOk = true;
+            };
+            req.onerror = (event) => {
+              const error = req.error;
+              if (isConstraintError(error)) {
+                requestConflict = true;
+                event.preventDefault();
+                return;
+              }
+              requestError = error ?? new Error("indexedDbBackend: write-if-absent failed");
+            };
+            tx.oncomplete = () => settle(() => {
+              if (requestConflict) {
+                resolve(false);
+              } else if (requestOk) {
+                resolve(true);
+              } else {
+                reject(
+                  requestError ?? new Error("indexedDbBackend: write-if-absent did not complete")
+                );
+              }
+            });
+            tx.onabort = () => {
+              const error = tx.error;
+              if (isConstraintError(error)) {
+                settle(() => resolve(false));
+                return;
+              }
+              settle(
+                () => reject(
+                  requestError ?? tx.error ?? new Error("indexedDbBackend: write-if-absent transaction aborted")
+                )
+              );
+            };
+            tx.onerror = () => {
+              const error = tx.error;
+              if (isConstraintError(error)) {
+                settle(() => resolve(false));
+                return;
+              }
+              settle(
+                () => reject(
+                  requestError ?? error ?? new Error("indexedDbBackend: write-if-absent transaction failed")
+                )
+              );
+            };
+          } catch (error) {
+            settle(() => reject(error));
+          }
+        })
+      );
+    },
+    delete(key) {
+      validateKey(key);
+      return db().then(
+        (database) => new Promise((resolve, reject) => {
+          try {
+            const tx = database.transaction(spec.storeName, "readwrite");
+            const store = tx.objectStore(spec.storeName);
+            const req = store.delete(key);
+            req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: delete failed"));
+            tx.oncomplete = () => resolve();
+            tx.onabort = () => reject(tx.error ?? new Error("indexedDbBackend: delete transaction aborted"));
+            tx.onerror = () => reject(tx.error ?? new Error("indexedDbBackend: delete transaction failed"));
+          } catch (error) {
+            reject(error);
+          }
+        })
+      );
+    },
+    list(prefix = "") {
+      const validatedPrefix = validateListPrefix(prefix);
+      return db().then(
+        (database) => new Promise((resolve, reject) => {
+          try {
+            const tx = database.transaction(spec.storeName, "readonly");
+            const store = tx.objectStore(spec.storeName);
+            const req = store.getAllKeys();
+            req.onsuccess = () => {
+              try {
+                resolve(normalizeKeys(validatedPrefix, req.result));
+              } catch (error) {
+                reject(error);
+              }
+            };
+            req.onerror = () => reject(req.error ?? new Error("indexedDbBackend: list failed"));
+            tx.onabort = () => reject(tx.error ?? new Error("indexedDbBackend: list transaction aborted"));
+          } catch (error) {
+            reject(error);
+          }
+        })
+      );
+    }
+  };
+}
+function indexedDbKv(spec, opts = {}) {
+  return kvStorage({ backend: indexedDbBackend(spec), ...opts });
+}
+function indexedDbAppendLog(spec, opts = {}) {
+  const kv = kvStorage({
+    backend: indexedDbBackend(spec),
+    codec: opts.codec
+  });
+  return appendLogStorage({ kv, prefix: opts.prefix ?? "append-log" });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  indexedDbAppendLog,
+  indexedDbBackend,
+  indexedDbKv
+});
+//# sourceMappingURL=browser.cjs.map