@firesystem/indexeddb/dist/testing.js

IndexedDB implementation of Virtual File System

import { IndexedDBFileSystem } from "./chunk-I74V6NX4.js";
import { __commonJS, __publicField } from "./chunk-JVWSFFO4.js";

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/errors.js
var require_errors = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/errors.js"(
    exports,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.VersionError =
      exports.TransactionInactiveError =
      exports.ReadOnlyError =
      exports.NotFoundError =
      exports.InvalidStateError =
      exports.InvalidAccessError =
      exports.DataError =
      exports.DataCloneError =
      exports.ConstraintError =
      exports.AbortError =
        void 0;
    var messages = {
      AbortError:
        "A request was aborted, for example through a call to IDBTransaction.abort.",
      ConstraintError:
        "A mutation operation in the transaction failed because a constraint was not satisfied. For example, an object such as an object store or index already exists and a request attempted to create a new one.",
      DataCloneError:
        "The data being stored could not be cloned by the internal structured cloning algorithm.",
      DataError: "Data provided to an operation does not meet requirements.",
      InvalidAccessError:
        "An invalid operation was performed on an object. For example transaction creation attempt was made, but an empty scope was provided.",
      InvalidStateError:
        "An operation was called on an object on which it is not allowed or at a time when it is not allowed. Also occurs if a request is made on a source object that has been deleted or removed. Use TransactionInactiveError or ReadOnlyError when possible, as they are more specific variations of InvalidStateError.",
      NotFoundError:
        "The operation failed because the requested database object could not be found. For example, an object store did not exist but was being opened.",
      ReadOnlyError:
        'The mutating operation was attempted in a "readonly" transaction.',
      TransactionInactiveError:
        "A request was placed against a transaction which is currently not active, or which is finished.",
      VersionError:
        "An attempt was made to open a database using a lower version than the existing version.",
    };
    var AbortError = class extends DOMException {
      constructor(message = messages.AbortError) {
        super(message, "AbortError");
      }
    };
    exports.AbortError = AbortError;
    var ConstraintError = class extends DOMException {
      constructor(message = messages.ConstraintError) {
        super(message, "ConstraintError");
      }
    };
    exports.ConstraintError = ConstraintError;
    var DataCloneError = class extends DOMException {
      constructor(message = messages.DataCloneError) {
        super(message, "DataCloneError");
      }
    };
    exports.DataCloneError = DataCloneError;
    var DataError = class extends DOMException {
      constructor(message = messages.DataError) {
        super(message, "DataError");
      }
    };
    exports.DataError = DataError;
    var InvalidAccessError = class extends DOMException {
      constructor(message = messages.InvalidAccessError) {
        super(message, "InvalidAccessError");
      }
    };
    exports.InvalidAccessError = InvalidAccessError;
    var InvalidStateError = class extends DOMException {
      constructor(message = messages.InvalidStateError) {
        super(message, "InvalidStateError");
      }
    };
    exports.InvalidStateError = InvalidStateError;
    var NotFoundError = class extends DOMException {
      constructor(message = messages.NotFoundError) {
        super(message, "NotFoundError");
      }
    };
    exports.NotFoundError = NotFoundError;
    var ReadOnlyError = class extends DOMException {
      constructor(message = messages.ReadOnlyError) {
        super(message, "ReadOnlyError");
      }
    };
    exports.ReadOnlyError = ReadOnlyError;
    var TransactionInactiveError = class extends DOMException {
      constructor(message = messages.TransactionInactiveError) {
        super(message, "TransactionInactiveError");
      }
    };
    exports.TransactionInactiveError = TransactionInactiveError;
    var VersionError = class extends DOMException {
      constructor(message = messages.VersionError) {
        super(message, "VersionError");
      }
    };
    exports.VersionError = VersionError;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/valueToKey.js
var require_valueToKey = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/valueToKey.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _errors = require_errors();
    var valueToKey = (input, seen) => {
      if (typeof input === "number") {
        if (isNaN(input)) {
          throw new _errors.DataError();
        }
        return input;
      } else if (Object.prototype.toString.call(input) === "[object Date]") {
        const ms = input.valueOf();
        if (isNaN(ms)) {
          throw new _errors.DataError();
        }
        return new Date(ms);
      } else if (typeof input === "string") {
        return input;
      } else if (
        input instanceof ArrayBuffer ||
        (typeof SharedArrayBuffer !== "undefined" &&
          input instanceof SharedArrayBuffer) ||
        (typeof ArrayBuffer !== "undefined" &&
          ArrayBuffer.isView &&
          ArrayBuffer.isView(input))
      ) {
        let arrayBuffer;
        let offset = 0;
        let length = 0;
        if (
          input instanceof ArrayBuffer ||
          (typeof SharedArrayBuffer !== "undefined" &&
            input instanceof SharedArrayBuffer)
        ) {
          arrayBuffer = input;
          length = input.byteLength;
        } else {
          arrayBuffer = input.buffer;
          offset = input.byteOffset;
          length = input.byteLength;
        }
        if (arrayBuffer.detached) {
          return new ArrayBuffer(0);
        }
        return arrayBuffer.slice(offset, offset + length);
      } else if (Array.isArray(input)) {
        if (seen === void 0) {
          seen = /* @__PURE__ */ new Set();
        } else if (seen.has(input)) {
          throw new _errors.DataError();
        }
        seen.add(input);
        const keys = [];
        for (let i = 0; i < input.length; i++) {
          const hop = Object.hasOwn(input, i);
          if (!hop) {
            throw new _errors.DataError();
          }
          const entry = input[i];
          const key = valueToKey(entry, seen);
          keys.push(key);
        }
        return keys;
      } else {
        throw new _errors.DataError();
      }
    };
    var _default = (exports.default = valueToKey);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/cmp.js
var require_cmp = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/cmp.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _errors = require_errors();
    var _valueToKey = _interopRequireDefault(require_valueToKey());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var getType = (x) => {
      if (typeof x === "number") {
        return "Number";
      }
      if (Object.prototype.toString.call(x) === "[object Date]") {
        return "Date";
      }
      if (Array.isArray(x)) {
        return "Array";
      }
      if (typeof x === "string") {
        return "String";
      }
      if (x instanceof ArrayBuffer) {
        return "Binary";
      }
      throw new _errors.DataError();
    };
    var cmp = (first, second) => {
      if (second === void 0) {
        throw new TypeError();
      }
      first = (0, _valueToKey.default)(first);
      second = (0, _valueToKey.default)(second);
      const t1 = getType(first);
      const t2 = getType(second);
      if (t1 !== t2) {
        if (t1 === "Array") {
          return 1;
        }
        if (
          t1 === "Binary" &&
          (t2 === "String" || t2 === "Date" || t2 === "Number")
        ) {
          return 1;
        }
        if (t1 === "String" && (t2 === "Date" || t2 === "Number")) {
          return 1;
        }
        if (t1 === "Date" && t2 === "Number") {
          return 1;
        }
        return -1;
      }
      if (t1 === "Binary") {
        first = new Uint8Array(first);
        second = new Uint8Array(second);
      }
      if (t1 === "Array" || t1 === "Binary") {
        const length = Math.min(first.length, second.length);
        for (let i = 0; i < length; i++) {
          const result = cmp(first[i], second[i]);
          if (result !== 0) {
            return result;
          }
        }
        if (first.length > second.length) {
          return 1;
        }
        if (first.length < second.length) {
          return -1;
        }
        return 0;
      }
      if (t1 === "Date") {
        if (first.getTime() === second.getTime()) {
          return 0;
        }
      } else {
        if (first === second) {
          return 0;
        }
      }
      return first > second ? 1 : -1;
    };
    var _default = (exports.default = cmp);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBKeyRange.js
var require_FDBKeyRange = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBKeyRange.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _cmp = _interopRequireDefault(require_cmp());
    var _errors = require_errors();
    var _valueToKey = _interopRequireDefault(require_valueToKey());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var FDBKeyRange = class _FDBKeyRange {
      static only(value) {
        if (arguments.length === 0) {
          throw new TypeError();
        }
        value = (0, _valueToKey.default)(value);
        return new _FDBKeyRange(value, value, false, false);
      }
      static lowerBound(lower, open = false) {
        if (arguments.length === 0) {
          throw new TypeError();
        }
        lower = (0, _valueToKey.default)(lower);
        return new _FDBKeyRange(lower, void 0, open, true);
      }
      static upperBound(upper, open = false) {
        if (arguments.length === 0) {
          throw new TypeError();
        }
        upper = (0, _valueToKey.default)(upper);
        return new _FDBKeyRange(void 0, upper, true, open);
      }
      static bound(lower, upper, lowerOpen = false, upperOpen = false) {
        if (arguments.length < 2) {
          throw new TypeError();
        }
        const cmpResult = (0, _cmp.default)(lower, upper);
        if (cmpResult === 1 || (cmpResult === 0 && (lowerOpen || upperOpen))) {
          throw new _errors.DataError();
        }
        lower = (0, _valueToKey.default)(lower);
        upper = (0, _valueToKey.default)(upper);
        return new _FDBKeyRange(lower, upper, lowerOpen, upperOpen);
      }
      constructor(lower, upper, lowerOpen, upperOpen) {
        this.lower = lower;
        this.upper = upper;
        this.lowerOpen = lowerOpen;
        this.upperOpen = upperOpen;
      }
      // https://w3c.github.io/IndexedDB/#dom-idbkeyrange-includes
      includes(key) {
        if (arguments.length === 0) {
          throw new TypeError();
        }
        key = (0, _valueToKey.default)(key);
        if (this.lower !== void 0) {
          const cmpResult = (0, _cmp.default)(this.lower, key);
          if (cmpResult === 1 || (cmpResult === 0 && this.lowerOpen)) {
            return false;
          }
        }
        if (this.upper !== void 0) {
          const cmpResult = (0, _cmp.default)(this.upper, key);
          if (cmpResult === -1 || (cmpResult === 0 && this.upperOpen)) {
            return false;
          }
        }
        return true;
      }
      toString() {
        return "[object IDBKeyRange]";
      }
    };
    var _default = (exports.default = FDBKeyRange);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/extractKey.js
var require_extractKey = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/extractKey.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _valueToKey = _interopRequireDefault(require_valueToKey());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var extractKey = (keyPath, value) => {
      if (Array.isArray(keyPath)) {
        const result = [];
        for (let item of keyPath) {
          if (
            item !== void 0 &&
            item !== null &&
            typeof item !== "string" &&
            item.toString
          ) {
            item = item.toString();
          }
          const key = extractKey(item, value).key;
          result.push((0, _valueToKey.default)(key));
        }
        return {
          type: "found",
          key: result,
        };
      }
      if (keyPath === "") {
        return {
          type: "found",
          key: value,
        };
      }
      let remainingKeyPath = keyPath;
      let object = value;
      while (remainingKeyPath !== null) {
        let identifier;
        const i = remainingKeyPath.indexOf(".");
        if (i >= 0) {
          identifier = remainingKeyPath.slice(0, i);
          remainingKeyPath = remainingKeyPath.slice(i + 1);
        } else {
          identifier = remainingKeyPath;
          remainingKeyPath = null;
        }
        if (
          object === void 0 ||
          object === null ||
          !Object.hasOwn(object, identifier)
        ) {
          return {
            type: "notFound",
          };
        }
        object = object[identifier];
      }
      return {
        type: "found",
        key: object,
      };
    };
    var _default = (exports.default = extractKey);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBCursor.js
var require_FDBCursor = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBCursor.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _FDBKeyRange = _interopRequireDefault(require_FDBKeyRange());
    var _FDBObjectStore = _interopRequireDefault(require_FDBObjectStore());
    var _cmp = _interopRequireDefault(require_cmp());
    var _errors = require_errors();
    var _extractKey = _interopRequireDefault(require_extractKey());
    var _valueToKey = _interopRequireDefault(require_valueToKey());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var getEffectiveObjectStore = (cursor) => {
      if (cursor.source instanceof _FDBObjectStore.default) {
        return cursor.source;
      }
      return cursor.source.objectStore;
    };
    var makeKeyRange = (range, lowers, uppers) => {
      let lower = range !== void 0 ? range.lower : void 0;
      let upper = range !== void 0 ? range.upper : void 0;
      for (const lowerTemp of lowers) {
        if (lowerTemp === void 0) {
          continue;
        }
        if (lower === void 0 || (0, _cmp.default)(lower, lowerTemp) === 1) {
          lower = lowerTemp;
        }
      }
      for (const upperTemp of uppers) {
        if (upperTemp === void 0) {
          continue;
        }
        if (upper === void 0 || (0, _cmp.default)(upper, upperTemp) === -1) {
          upper = upperTemp;
        }
      }
      if (lower !== void 0 && upper !== void 0) {
        return _FDBKeyRange.default.bound(lower, upper);
      }
      if (lower !== void 0) {
        return _FDBKeyRange.default.lowerBound(lower);
      }
      if (upper !== void 0) {
        return _FDBKeyRange.default.upperBound(upper);
      }
    };
    var FDBCursor = class {
      constructor(source, range, direction = "next", request, keyOnly = false) {
        __publicField(this, "_gotValue", false);
        __publicField(this, "_position");
        // Key of previously returned record
        __publicField(this, "_objectStorePosition");
        __publicField(this, "_keyOnly", false);
        __publicField(this, "_key");
        __publicField(this, "_primaryKey");
        this._range = range;
        this._source = source;
        this._direction = direction;
        this._request = request;
        this._keyOnly = keyOnly;
      }
      // Read only properties
      get source() {
        return this._source;
      }
      set source(val) {}
      get request() {
        return this._request;
      }
      set request(val) {}
      get direction() {
        return this._direction;
      }
      set direction(val) {}
      get key() {
        return this._key;
      }
      set key(val) {}
      get primaryKey() {
        return this._primaryKey;
      }
      set primaryKey(val) {}
      // https://w3c.github.io/IndexedDB/#iterate-a-cursor
      _iterate(key, primaryKey) {
        const sourceIsObjectStore =
          this.source instanceof _FDBObjectStore.default;
        const records =
          this.source instanceof _FDBObjectStore.default
            ? this.source._rawObjectStore.records
            : this.source._rawIndex.records;
        let foundRecord;
        if (this.direction === "next") {
          const range = makeKeyRange(this._range, [key, this._position], []);
          for (const record of records.values(range)) {
            const cmpResultKey =
              key !== void 0 ? (0, _cmp.default)(record.key, key) : void 0;
            const cmpResultPosition =
              this._position !== void 0
                ? (0, _cmp.default)(record.key, this._position)
                : void 0;
            if (key !== void 0) {
              if (cmpResultKey === -1) {
                continue;
              }
            }
            if (primaryKey !== void 0) {
              if (cmpResultKey === -1) {
                continue;
              }
              const cmpResultPrimaryKey = (0, _cmp.default)(
                record.value,
                primaryKey,
              );
              if (cmpResultKey === 0 && cmpResultPrimaryKey === -1) {
                continue;
              }
            }
            if (this._position !== void 0 && sourceIsObjectStore) {
              if (cmpResultPosition !== 1) {
                continue;
              }
            }
            if (this._position !== void 0 && !sourceIsObjectStore) {
              if (cmpResultPosition === -1) {
                continue;
              }
              if (
                cmpResultPosition === 0 &&
                (0, _cmp.default)(record.value, this._objectStorePosition) !== 1
              ) {
                continue;
              }
            }
            if (this._range !== void 0) {
              if (!this._range.includes(record.key)) {
                continue;
              }
            }
            foundRecord = record;
            break;
          }
        } else if (this.direction === "nextunique") {
          const range = makeKeyRange(this._range, [key, this._position], []);
          for (const record of records.values(range)) {
            if (key !== void 0) {
              if ((0, _cmp.default)(record.key, key) === -1) {
                continue;
              }
            }
            if (this._position !== void 0) {
              if ((0, _cmp.default)(record.key, this._position) !== 1) {
                continue;
              }
            }
            if (this._range !== void 0) {
              if (!this._range.includes(record.key)) {
                continue;
              }
            }
            foundRecord = record;
            break;
          }
        } else if (this.direction === "prev") {
          const range = makeKeyRange(this._range, [], [key, this._position]);
          for (const record of records.values(range, "prev")) {
            const cmpResultKey =
              key !== void 0 ? (0, _cmp.default)(record.key, key) : void 0;
            const cmpResultPosition =
              this._position !== void 0
                ? (0, _cmp.default)(record.key, this._position)
                : void 0;
            if (key !== void 0) {
              if (cmpResultKey === 1) {
                continue;
              }
            }
            if (primaryKey !== void 0) {
              if (cmpResultKey === 1) {
                continue;
              }
              const cmpResultPrimaryKey = (0, _cmp.default)(
                record.value,
                primaryKey,
              );
              if (cmpResultKey === 0 && cmpResultPrimaryKey === 1) {
                continue;
              }
            }
            if (this._position !== void 0 && sourceIsObjectStore) {
              if (cmpResultPosition !== -1) {
                continue;
              }
            }
            if (this._position !== void 0 && !sourceIsObjectStore) {
              if (cmpResultPosition === 1) {
                continue;
              }
              if (
                cmpResultPosition === 0 &&
                (0, _cmp.default)(record.value, this._objectStorePosition) !==
                  -1
              ) {
                continue;
              }
            }
            if (this._range !== void 0) {
              if (!this._range.includes(record.key)) {
                continue;
              }
            }
            foundRecord = record;
            break;
          }
        } else if (this.direction === "prevunique") {
          let tempRecord;
          const range = makeKeyRange(this._range, [], [key, this._position]);
          for (const record of records.values(range, "prev")) {
            if (key !== void 0) {
              if ((0, _cmp.default)(record.key, key) === 1) {
                continue;
              }
            }
            if (this._position !== void 0) {
              if ((0, _cmp.default)(record.key, this._position) !== -1) {
                continue;
              }
            }
            if (this._range !== void 0) {
              if (!this._range.includes(record.key)) {
                continue;
              }
            }
            tempRecord = record;
            break;
          }
          if (tempRecord) {
            foundRecord = records.get(tempRecord.key);
          }
        }
        let result;
        if (!foundRecord) {
          this._key = void 0;
          if (!sourceIsObjectStore) {
            this._objectStorePosition = void 0;
          }
          if (
            !this._keyOnly &&
            this.toString() === "[object IDBCursorWithValue]"
          ) {
            this.value = void 0;
          }
          result = null;
        } else {
          this._position = foundRecord.key;
          if (!sourceIsObjectStore) {
            this._objectStorePosition = foundRecord.value;
          }
          this._key = foundRecord.key;
          if (sourceIsObjectStore) {
            this._primaryKey = structuredClone(foundRecord.key);
            if (
              !this._keyOnly &&
              this.toString() === "[object IDBCursorWithValue]"
            ) {
              this.value = structuredClone(foundRecord.value);
            }
          } else {
            this._primaryKey = structuredClone(foundRecord.value);
            if (
              !this._keyOnly &&
              this.toString() === "[object IDBCursorWithValue]"
            ) {
              if (this.source instanceof _FDBObjectStore.default) {
                throw new Error("This should never happen");
              }
              const value = this.source.objectStore._rawObjectStore.getValue(
                foundRecord.value,
              );
              this.value = structuredClone(value);
            }
          }
          this._gotValue = true;
          result = this;
        }
        return result;
      }
      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-update-IDBRequest-any-value
      update(value) {
        if (value === void 0) {
          throw new TypeError();
        }
        const effectiveObjectStore = getEffectiveObjectStore(this);
        const effectiveKey = Object.hasOwn(this.source, "_rawIndex")
          ? this.primaryKey
          : this._position;
        const transaction = effectiveObjectStore.transaction;
        if (transaction._state !== "active") {
          throw new _errors.TransactionInactiveError();
        }
        if (transaction.mode === "readonly") {
          throw new _errors.ReadOnlyError();
        }
        if (effectiveObjectStore._rawObjectStore.deleted) {
          throw new _errors.InvalidStateError();
        }
        if (
          !(this.source instanceof _FDBObjectStore.default) &&
          this.source._rawIndex.deleted
        ) {
          throw new _errors.InvalidStateError();
        }
        if (!this._gotValue || !Object.hasOwn(this, "value")) {
          throw new _errors.InvalidStateError();
        }
        const clone = structuredClone(value);
        if (effectiveObjectStore.keyPath !== null) {
          let tempKey;
          try {
            tempKey = (0, _extractKey.default)(
              effectiveObjectStore.keyPath,
              clone,
            ).key;
          } catch (err) {}
          if ((0, _cmp.default)(tempKey, effectiveKey) !== 0) {
            throw new _errors.DataError();
          }
        }
        const record = {
          key: effectiveKey,
          value: clone,
        };
        return transaction._execRequestAsync({
          operation: effectiveObjectStore._rawObjectStore.storeRecord.bind(
            effectiveObjectStore._rawObjectStore,
            record,
            false,
            transaction._rollbackLog,
          ),
          source: this,
        });
      }
      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-advance-void-unsigned-long-count
      advance(count) {
        if (!Number.isInteger(count) || count <= 0) {
          throw new TypeError();
        }
        const effectiveObjectStore = getEffectiveObjectStore(this);
        const transaction = effectiveObjectStore.transaction;
        if (transaction._state !== "active") {
          throw new _errors.TransactionInactiveError();
        }
        if (effectiveObjectStore._rawObjectStore.deleted) {
          throw new _errors.InvalidStateError();
        }
        if (
          !(this.source instanceof _FDBObjectStore.default) &&
          this.source._rawIndex.deleted
        ) {
          throw new _errors.InvalidStateError();
        }
        if (!this._gotValue) {
          throw new _errors.InvalidStateError();
        }
        if (this._request) {
          this._request.readyState = "pending";
        }
        transaction._execRequestAsync({
          operation: () => {
            let result;
            for (let i = 0; i < count; i++) {
              result = this._iterate();
              if (!result) {
                break;
              }
            }
            return result;
          },
          request: this._request,
          source: this.source,
        });
        this._gotValue = false;
      }
      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBCursor-continue-void-any-key
      continue(key) {
        const effectiveObjectStore = getEffectiveObjectStore(this);
        const transaction = effectiveObjectStore.transaction;
        if (transaction._state !== "active") {
          throw new _errors.TransactionInactiveError();
        }
        if (effectiveObjectStore._rawObjectStore.deleted) {
          throw new _errors.InvalidStateError();
        }
        if (
          !(this.source instanceof _FDBObjectStore.default) &&
          this.source._rawIndex.deleted
        ) {
          throw new _errors.InvalidStateError();
        }
        if (!this._gotValue) {
          throw new _errors.InvalidStateError();
        }
        if (key !== void 0) {
          key = (0, _valueToKey.default)(key);
          const cmpResult = (0, _cmp.default)(key, this._position);
          if (
            (cmpResult <= 0 &&
              (this.direction === "next" || this.direction === "nextunique")) ||
            (cmpResult >= 0 &&
              (this.direction === "prev" || this.direction === "prevunique"))
          ) {
            throw new _errors.DataError();
          }
        }
        if (this._request) {
          this._request.readyState = "pending";
        }
        transaction._execRequestAsync({
          operation: this._iterate.bind(this, key),
          request: this._request,
          source: this.source,
        });
        this._gotValue = false;
      }
      // hthttps://w3c.github.io/IndexedDB/#dom-idbcursor-continueprimarykey
      continuePrimaryKey(key, primaryKey) {
        const effectiveObjectStore = getEffectiveObjectStore(this);
        const transaction = effectiveObjectStore.transaction;
        if (transaction._state !== "active") {
          throw new _errors.TransactionInactiveError();
        }
        if (effectiveObjectStore._rawObjectStore.deleted) {
          throw new _errors.InvalidStateError();
        }
        if (
          !(this.source instanceof _FDBObjectStore.default) &&
          this.source._rawIndex.deleted
        ) {
          throw new _errors.InvalidStateError();
        }
        if (
          this.source instanceof _FDBObjectStore.default ||
          (this.direction !== "next" && this.direction !== "prev")
        ) {
          throw new _errors.InvalidAccessError();
        }
        if (!this._gotValue) {
          throw new _errors.InvalidStateError();
        }
        if (key === void 0 || primaryKey === void 0) {
          throw new _errors.DataError();
        }
        key = (0, _valueToKey.default)(key);
        const cmpResult = (0, _cmp.default)(key, this._position);
        if (
          (cmpResult === -1 && this.direction === "next") ||
          (cmpResult === 1 && this.direction === "prev")
        ) {
          throw new _errors.DataError();
        }
        const cmpResult2 = (0, _cmp.default)(
          primaryKey,
          this._objectStorePosition,
        );
        if (cmpResult === 0) {
          if (
            (cmpResult2 <= 0 && this.direction === "next") ||
            (cmpResult2 >= 0 && this.direction === "prev")
          ) {
            throw new _errors.DataError();
          }
        }
        if (this._request) {
          this._request.readyState = "pending";
        }
        transaction._execRequestAsync({
          operation: this._iterate.bind(this, key, primaryKey),
          request: this._request,
          source: this.source,
        });
        this._gotValue = false;
      }
      delete() {
        const effectiveObjectStore = getEffectiveObjectStore(this);
        const effectiveKey = Object.hasOwn(this.source, "_rawIndex")
          ? this.primaryKey
          : this._position;
        const transaction = effectiveObjectStore.transaction;
        if (transaction._state !== "active") {
          throw new _errors.TransactionInactiveError();
        }
        if (transaction.mode === "readonly") {
          throw new _errors.ReadOnlyError();
        }
        if (effectiveObjectStore._rawObjectStore.deleted) {
          throw new _errors.InvalidStateError();
        }
        if (
          !(this.source instanceof _FDBObjectStore.default) &&
          this.source._rawIndex.deleted
        ) {
          throw new _errors.InvalidStateError();
        }
        if (!this._gotValue || !Object.hasOwn(this, "value")) {
          throw new _errors.InvalidStateError();
        }
        return transaction._execRequestAsync({
          operation: effectiveObjectStore._rawObjectStore.deleteRecord.bind(
            effectiveObjectStore._rawObjectStore,
            effectiveKey,
            transaction._rollbackLog,
          ),
          source: this,
        });
      }
      toString() {
        return "[object IDBCursor]";
      }
    };
    var _default = (exports.default = FDBCursor);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBCursorWithValue.js
var require_FDBCursorWithValue = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBCursorWithValue.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _FDBCursor = _interopRequireDefault(require_FDBCursor());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var FDBCursorWithValue = class extends _FDBCursor.default {
      constructor(source, range, direction, request) {
        super(source, range, direction, request);
        __publicField(this, "value");
      }
      toString() {
        return "[object IDBCursorWithValue]";
      }
    };
    var _default = (exports.default = FDBCursorWithValue);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/FakeEventTarget.js
var require_FakeEventTarget = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/FakeEventTarget.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _errors = require_errors();
    var stopped = (event, listener) => {
      return (
        event.immediatePropagationStopped ||
        (event.eventPhase === event.CAPTURING_PHASE &&
          listener.capture === false) ||
        (event.eventPhase === event.BUBBLING_PHASE && listener.capture === true)
      );
    };
    var invokeEventListeners = (event, obj) => {
      event.currentTarget = obj;
      for (const listener of obj.listeners.slice()) {
        if (event.type !== listener.type || stopped(event, listener)) {
          continue;
        }
        listener.callback.call(event.currentTarget, event);
      }
      const typeToProp = {
        abort: "onabort",
        blocked: "onblocked",
        complete: "oncomplete",
        error: "onerror",
        success: "onsuccess",
        upgradeneeded: "onupgradeneeded",
        versionchange: "onversionchange",
      };
      const prop = typeToProp[event.type];
      if (prop === void 0) {
        throw new Error(`Unknown event type: "${event.type}"`);
      }
      const callback = event.currentTarget[prop];
      if (callback) {
        const listener = {
          callback,
          capture: false,
          type: event.type,
        };
        if (!stopped(event, listener)) {
          listener.callback.call(event.currentTarget, event);
        }
      }
    };
    var FakeEventTarget = class {
      constructor() {
        __publicField(this, "listeners", []);
      }
      // These will be overridden in individual subclasses and made not readonly
      addEventListener(type, callback, capture = false) {
        this.listeners.push({
          callback,
          capture,
          type,
        });
      }
      removeEventListener(type, callback, capture = false) {
        const i = this.listeners.findIndex((listener) => {
          return (
            listener.type === type &&
            listener.callback === callback &&
            listener.capture === capture
          );
        });
        this.listeners.splice(i, 1);
      }
      // http://www.w3.org/TR/dom/#dispatching-events
      dispatchEvent(event) {
        if (event.dispatched || !event.initialized) {
          throw new _errors.InvalidStateError(
            "The object is in an invalid state.",
          );
        }
        event.isTrusted = false;
        event.dispatched = true;
        event.target = this;
        event.eventPhase = event.CAPTURING_PHASE;
        for (const obj of event.eventPath) {
          if (!event.propagationStopped) {
            invokeEventListeners(event, obj);
          }
        }
        event.eventPhase = event.AT_TARGET;
        if (!event.propagationStopped) {
          invokeEventListeners(event, event.target);
        }
        if (event.bubbles) {
          event.eventPath.reverse();
          event.eventPhase = event.BUBBLING_PHASE;
          for (const obj of event.eventPath) {
            if (!event.propagationStopped) {
              invokeEventListeners(event, obj);
            }
          }
        }
        event.dispatched = false;
        event.eventPhase = event.NONE;
        event.currentTarget = null;
        if (event.canceled) {
          return false;
        }
        return true;
      }
    };
    var _default = (exports.default = FakeEventTarget);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBRequest.js
var require_FDBRequest = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBRequest.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _errors = require_errors();
    var _FakeEventTarget = _interopRequireDefault(require_FakeEventTarget());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var FDBRequest = class extends _FakeEventTarget.default {
      constructor() {
        super(...arguments);
        __publicField(this, "_result", null);
        __publicField(this, "_error", null);
        __publicField(this, "source", null);
        __publicField(this, "transaction", null);
        __publicField(this, "readyState", "pending");
        __publicField(this, "onsuccess", null);
        __publicField(this, "onerror", null);
      }
      get error() {
        if (this.readyState === "pending") {
          throw new _errors.InvalidStateError();
        }
        return this._error;
      }
      set error(value) {
        this._error = value;
      }
      get result() {
        if (this.readyState === "pending") {
          throw new _errors.InvalidStateError();
        }
        return this._result;
      }
      set result(value) {
        this._result = value;
      }
      toString() {
        return "[object IDBRequest]";
      }
    };
    var _default = (exports.default = FDBRequest);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/enforceRange.js
var require_enforceRange = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/enforceRange.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var enforceRange = (num, type) => {
      const min = 0;
      const max = type === "unsigned long" ? 4294967295 : 9007199254740991;
      if (isNaN(num) || num < min || num > max) {
        throw new TypeError();
      }
      if (num >= 0) {
        return Math.floor(num);
      }
    };
    var _default = (exports.default = enforceRange);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/FakeDOMStringList.js
var require_FakeDOMStringList = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/FakeDOMStringList.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var FakeDOMStringList = class extends Array {
      contains(value) {
        for (const value2 of this) {
          if (value === value2) {
            return true;
          }
        }
        return false;
      }
      item(i) {
        if (i < 0 || i >= this.length) {
          return null;
        }
        return this[i];
      }
      // Used internally, should not be used by others. I could maybe get rid of these and replace rather than mutate, but too lazy to check the spec.
      _push(...values) {
        return Array.prototype.push.call(this, ...values);
      }
      _sort(...values) {
        return Array.prototype.sort.call(this, ...values);
      }
    };
    var _default = (exports.default = FakeDOMStringList);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/valueToKeyRange.js
var require_valueToKeyRange = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/lib/valueToKeyRange.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _FDBKeyRange = _interopRequireDefault(require_FDBKeyRange());
    var _errors = require_errors();
    var _valueToKey = _interopRequireDefault(require_valueToKey());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var valueToKeyRange = (value, nullDisallowedFlag = false) => {
      if (value instanceof _FDBKeyRange.default) {
        return value;
      }
      if (value === null || value === void 0) {
        if (nullDisallowedFlag) {
          throw new _errors.DataError();
        }
        return new _FDBKeyRange.default(void 0, void 0, false, false);
      }
      const key = (0, _valueToKey.default)(value);
      return _FDBKeyRange.default.only(key);
    };
    var _default = (exports.default = valueToKeyRange);
    module.exports = exports.default;
  },
});

// ../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBIndex.js
var require_FDBIndex = __commonJS({
  "../../node_modules/.pnpm/fake-indexeddb@6.0.1/node_modules/fake-indexeddb/build/cjs/FDBIndex.js"(
    exports,
    module,
  ) {
    "use strict";
    Object.defineProperty(exports, "__esModule", {
      value: true,
    });
    exports.default = void 0;
    var _FDBCursor = _interopRequireDefault(require_FDBCursor());
    var _FDBCursorWithValue = _interopRequireDefault(
      require_FDBCursorWithValue(),
    );
    var _FDBKeyRange = _interopRequireDefault(require_FDBKeyRange());
    var _FDBRequest = _interopRequireDefault(require_FDBRequest());
    var _enforceRange = _interopRequireDefault(require_enforceRange());
    var _errors = require_errors();
    var _FakeDOMStringList = _interopRequireDefault(
      require_FakeDOMStringList(),
    );
    var _valueToKey = _interopRequireDefault(require_valueToKey());
    var _valueToKeyRange = _interopRequireDefault(require_valueToKeyRange());
    function _interopRequireDefault(e) {
      return e && e.__esModule ? e : { default: e };
    }
    var confirmActiveTransaction = (index) => {
      if (
        index._rawIndex.deleted ||
        index.objectStore._rawObjectStore.deleted
      ) {
        throw new _errors.InvalidStateError();
      }
      if (index.objectStore.transaction._state !== "active") {
        throw new _errors.TransactionInactiveError();
      }
    };
    var FDBIndex = class {
      constructor(objectStore, rawIndex) {
        this._rawIndex = rawIndex;
        this._name = rawIndex.name;
        this.objectStore = objectStore;
        this.keyPath = rawIndex.keyPath;
        this.multiEntry = rawIndex.multiEntry;
        this.unique = rawIndex.unique;
      }
      get name() {
        return this._name;
      }
      // https://w3c.github.io/IndexedDB/#dom-idbindex-name
      set name(name) {
        const transaction = this.objectStore.transaction;
        if (!transaction.db._runningVersionchangeTransaction) {
          throw new _errors.InvalidStateError();
        }
        if (transaction._state !== "active") {
          throw new _errors.TransactionInactiveError();
        }
        if (
          this._rawIndex.deleted ||
          this.objectStore._rawObjectStore.deleted
        ) {
          throw new _errors.InvalidStateError();
        }
        name = String(name);
        if (name === this._name) {
          return;
        }
        if (this.objectStore.indexNames.contains(name)) {
          throw new _errors.ConstraintError();
        }
        const oldName = this._name;
        const oldIndexNames = [...this.objectStore.indexNames];
        this._name = name;
        this._rawIndex.name = name;
        this.objectStore._indexesCache.delete(oldName);
        this.objectStore._indexesCache.set(name, this);
        this.objectStore._rawObjectStore.rawIndexes.delete(oldName);
        this.objectStore._rawObjectStore.rawIndexes.set(name, this._rawIndex);
        this.objectStore.indexNames = new _FakeDOMStringList.default(
          ...Array.from(this.objectStore._rawObjectStore.rawIndexes.keys())
            .filter((indexName) => {
              const index =
                this.objectStore._rawObjectStore.rawIndexes.get(indexName);
              return index && !index.deleted;
            })
            .sort(),
        );
        transaction._rollbackLog.push(() => {
          this._name = oldName;
          this._rawIndex.name = oldName;
          this.objectStore._indexesCache.delete(name);
          this.objectStore._indexesCache.set(oldName, this);
          this.objectStore._rawObjectStore.rawIndexes.delete(name);
          this.objectStore._rawObjectStore.rawIndexes.set(
            oldName,
            this._rawIndex,
          );
          this.objectStore.indexNames = new _FakeDOMStringList.default(
            ...oldIndexNames,
          );
        });
      }
      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-openCursor-IDBRequest-any-range-IDBCursorDirection-direction
      openCursor(range, direction) {
        confirmActiveTransaction(this);
        if (range === null) {
          range = void 0;
        }
        if (range !== void 0 && !(range instanceof _FDBKeyRange.default)) {
          range = _FDBKeyRange.default.only((0, _valueToKey.default)(range));
        }
        const request = new _FDBRequest.default();
        request.source = this;
        request.transaction = this.objectStore.transaction;
        const cursor = new _FDBCursorWithValue.default(
          this,
          range,
          direction,
          request,
        );
        return this.objectStore.transaction._execRequestAsync({
          operation: cursor._iterate.bind(cursor),
          request,
          source: this,
        });
      }
      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-openKeyCursor-IDBRequest-any-range-IDBCursorDirection-direction
      openKeyCursor(range, direction) {
        confirmActiveTransaction(this);
        if (range === null) {
          range = void 0;
        }
        if (range !== void 0 && !(range instanceof _FDBKeyRange.default)) {
          range = _FDBKeyRange.default.only((0, _valueToKey.default)(range));
        }
        const request = new _FDBRequest.default();
        request.source = this;
        request.transaction = this.objectStore.transaction;
        const cursor = new _FDBCursor.default(
          this,
          range,
          direction,
          request,
          true,
        );
        return this.objectStore.transaction._execRequestAsync({
          operation: cursor._iterate.bind(cursor),
          request,
          source: this,
        });
      }
      get(key) {
        confirmActiveTransaction(this);
        if (!(key instanceof _FDBKeyRange.default)) {
          key = (0, _valueToKey.default)(key);
        }
        return this.objectStore.transaction._execRequestAsync({
          operation: this._rawIndex.getValue.bind(this._rawIndex, key),
          source: this,
        });
      }
      // http://w3c.github.io/IndexedDB/#dom-idbindex-getall
      getAll(query, count) {
        if (arguments.length > 1 && count !== void 0) {
          count = (0, _enforceRange.default)(count, "unsigned long");
        }
        confirmActiveTransaction(this);
        const range = (0, _valueToKeyRange.default)(query);
        return this.objectStore.transaction._execRequestAsync({
          operation: this._rawIndex.getAllValues.bind(
            this._rawIndex,
            range,
            count,
          ),
          source: this,
        });
      }
      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#widl-IDBIndex-getKey-IDBRequest-any-key
      getKey(key) {
        confirmActiveTransaction(this);
        if (!(key instanceof _FDBKeyRange.default)) {
          key = (0, _valueToKey.default)(key);
        }
        return this.objectStore.transaction._execRequestAsync({
          operation: this._rawIndex.getKey.bind(this._rawIndex, key),
          source: this,
        });