@dxos/random-access-storage 0.8.4-main.1f223c7 → 0.8.4-main.21d9917

package/dist/lib/browser/browser/index.mjs

@@ -0,0 +1,807 @@
+import "@dxos/node-std/globals";
+import import$d$random_access_storage from 'random-access-storage';
+import import$d$inherits from 'inherits';
+import import$d$next_tick from 'next-tick';
+import import$d$once from 'once';
+import import$d$buffer_from from 'buffer-from';
+import import$d$buffer_alloc from 'buffer-alloc';
+import {
+  AbstractStorage,
+  Directory,
+  MemoryStorage,
+  StorageType,
+  __commonJS,
+  __require,
+  __toESM,
+  getFullPath,
+  stringDiff,
+  wrapFile
+} from "../chunk-QQKT3REB.mjs";
+
+// ../../../node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=207ec2404ef8b5e9e6d9de8ce83586d215ef77b94a7d0cadced03125874a1d9e/node_modules/random-access-idb/lib/blocks.js
+var require_blocks = __commonJS({
+  "../../../node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=207ec2404ef8b5e9e6d9de8ce83586d215ef77b94a7d0cadced03125874a1d9e/node_modules/random-access-idb/lib/blocks.js"(exports, module) {
+    module.exports = function(size, start, end) {
+      var result = [];
+      for (var n = Math.floor(start / size) * size; n < end; n += size) {
+        result.push({
+          block: Math.floor(n / size),
+          start: Math.max(n, start) % size,
+          end: Math.min(n + size, end) % size || size
+        });
+      }
+      return result;
+    };
+  }
+});
+
+// ../../../node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=207ec2404ef8b5e9e6d9de8ce83586d215ef77b94a7d0cadced03125874a1d9e/node_modules/random-access-idb/index.js
+var require_random_access_idb = __commonJS({
+  "../../../node_modules/.pnpm/random-access-idb@1.2.2_patch_hash=207ec2404ef8b5e9e6d9de8ce83586d215ef77b94a7d0cadced03125874a1d9e/node_modules/random-access-idb/index.js"(exports, module) {
+    var RandomAccess = import$d$random_access_storage;
+    var inherits = import$d$inherits;
+    var nextTick = import$d$next_tick;
+    var once = import$d$once;
+    var blocks = require_blocks();
+    var bufferFrom = import$d$buffer_from;
+    var bufferAlloc = import$d$buffer_alloc;
+    var DELIM2 = "\0";
+    var win = typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {};
+    module.exports = function(dbname, xopts) {
+      if (!xopts) xopts = {};
+      var idb2 = xopts.idb || (typeof win !== "undefined" ? win.indexedDB || win.mozIndexedDB || win.webkitIndexedDB || win.msIndexedDB : null);
+      if (!idb2) throw new Error("indexedDB not present and not given");
+      var db = null, dbqueue = [];
+      if (typeof idb2.open === "function") {
+        var req = idb2.open(dbname);
+        req.addEventListener("upgradeneeded", function() {
+          db = req.result;
+          db.createObjectStore("data");
+        });
+        req.addEventListener("success", function() {
+          db = req.result;
+          dbqueue.forEach(function(cb) {
+            cb(db);
+          });
+          dbqueue = null;
+        });
+      } else {
+        db = idb2;
+      }
+      function getdb(cb) {
+        if (db) nextTick(function() {
+          cb(db);
+        });
+        else dbqueue.push(cb);
+      }
+      return {
+        create: function(name, opts) {
+          if (typeof name === "object") {
+            opts = name;
+            name = opts.name;
+          }
+          if (!opts) opts = {};
+          opts.name = name;
+          return new Store(Object.assign({ db: getdb }, xopts, opts));
+        },
+        getdb
+      };
+    };
+    function Store(opts) {
+      if (!(this instanceof Store)) return new Store(opts);
+      RandomAccess.call(this);
+      if (!opts) opts = {};
+      if (typeof opts === "string") opts = { name: opts };
+      this.size = opts.size || 4096;
+      this.name = opts.name;
+      this.length = opts.length || 0;
+      this._getdb = opts.db;
+    }
+    inherits(Store, RandomAccess);
+    Store.prototype._blocks = function(i, j) {
+      return blocks(this.size, i, j);
+    };
+    Store.prototype._read = function(req) {
+      var self2 = this;
+      var buffers = [];
+      self2._store("readonly", function(err, store) {
+        if ((self2.length || 0) < req.offset + req.size) {
+          return req.callback(new Error("Could not satisfy length"));
+        }
+        if (err) return req.callback(err);
+        var offsets = self2._blocks(req.offset, req.offset + req.size);
+        var pending = offsets.length + 1;
+        var firstBlock = offsets.length > 0 ? offsets[0].block : 0;
+        var j = 0;
+        for (var i = 0; i < offsets.length; i++) (function(o) {
+          var key = self2.name + DELIM2 + o.block;
+          backify(store.get(key), function(err2, ev) {
+            if (err2) return req.callback(err2);
+            buffers[o.block - firstBlock] = ev.target.result ? bufferFrom(ev.target.result.subarray(o.start, o.end)) : bufferAlloc(o.end - o.start);
+            if (--pending === 0) req.callback(null, Buffer.concat(buffers));
+          });
+        })(offsets[i]);
+        if (--pending === 0) req.callback(null, Buffer.concat(buffers));
+      });
+    };
+    Store.prototype._write = function(req) {
+      var self2 = this;
+      self2._store("readwrite", function(err, store) {
+        if (err) return req.callback(err);
+        var offsets = self2._blocks(req.offset, req.offset + req.data.length);
+        var pending = 1;
+        var buffers = {};
+        for (var i = 0; i < offsets.length; i++) (function(o, i2) {
+          if (o.end - o.start === self2.size) return;
+          pending++;
+          var key = self2.name + DELIM2 + o.block;
+          backify(store.get(key), function(err2, ev) {
+            if (err2) return req.callback(err2);
+            buffers[i2] = bufferFrom(ev.target.result || bufferAlloc(self2.size));
+            if (--pending === 0) write(store, offsets, buffers);
+          });
+        })(offsets[i], i);
+        if (--pending === 0) write(store, offsets, buffers);
+      });
+      function write(store, offsets, buffers) {
+        var block;
+        for (var i = 0, j = 0; i < offsets.length; i++) {
+          var o = offsets[i];
+          var len = o.end - o.start;
+          if (len === self2.size) {
+            block = bufferFrom(req.data.slice(j, j + len));
+          } else {
+            block = buffers[i];
+            req.data.copy(block, o.start, j, j + len);
+          }
+          store.put(block, self2.name + DELIM2 + o.block);
+          j += len;
+        }
+        var length = Math.max(self2.length || 0, req.offset + req.data.length);
+        store.put(length, self2.name + DELIM2 + "length");
+        store.transaction.addEventListener("complete", function() {
+          self2.length = length;
+          req.callback(null);
+        });
+        store.transaction.addEventListener("error", function(err) {
+          req.callback(err);
+        });
+      }
+    };
+    Store.prototype._store = function(mode, cb) {
+      cb = once(cb);
+      var self2 = this;
+      self2._getdb(function(db) {
+        var tx = db.transaction(["data"], mode);
+        var store = tx.objectStore("data");
+        tx.addEventListener("error", cb);
+        cb(null, store);
+      });
+    };
+    Store.prototype._open = function(req) {
+      var self2 = this;
+      this._getdb(function(db) {
+        self2._store("readonly", function(err, store) {
+          backify(store.get(self2.name + DELIM2 + "length"), function(err2, ev) {
+            self2.length = ev.target.result || 0;
+            req.callback(null);
+          });
+        });
+      });
+    };
+    Store.prototype._close = function(req) {
+      this._getdb(function(db) {
+        req.callback();
+      });
+    };
+    Store.prototype._stat = function(req) {
+      var self2 = this;
+      nextTick(function() {
+        req.callback(null, { size: self2.length });
+      });
+    };
+    function backify(r, cb) {
+      r.addEventListener("success", function(ev) {
+        cb(null, ev);
+      });
+      r.addEventListener("error", cb);
+    }
+  }
+});
+
+// src/browser/idb-storage.ts
+var import_random_access_idb = __toESM(require_random_access_idb(), 1);
+import { invariant } from "@dxos/invariant";
+var __dxlog_file = "/__w/dxos/dxos/packages/common/random-access-storage/src/browser/idb-storage.ts";
+var DELIM = "\0";
+var IDbStorage = class extends AbstractStorage {
+  type = StorageType.IDB;
+  _db;
+  _store = "data";
+  _initialized = false;
+  _fileStorage;
+  constructor(path) {
+    super(path);
+    this._fileStorage = this._createFileStorage(path);
+  }
+  _createFileStorage(path) {
+    const database = (0, import_random_access_idb.default)(path);
+    let res;
+    this._db = new Promise((resolve) => {
+      res = resolve;
+    });
+    database.getdb(res);
+    return database.create;
+  }
+  async close() {
+    await this._closeFilesInPath("");
+  }
+  async reset() {
+    await this._closeFilesInPath("");
+    await this._remove("");
+  }
+  async _destroy() {
+    throw new Error("Unreachable");
+  }
+  _createFile(path, filename) {
+    const file = this._fileStorage(getFullPath(path, filename));
+    file.destroy = (cb) => {
+      void this._db.then((db) => {
+        const lowerBound = getFullPath(path, filename);
+        const upperBound = `${lowerBound}\uFFFF`;
+        const range = IDBKeyRange.bound(lowerBound, upperBound);
+        const transaction = db.transaction(this._store, "readwrite");
+        const objectStore = transaction.objectStore(this._store);
+        objectStore.delete(range);
+        transaction.oncomplete = () => {
+          file.destroyed = true;
+          file.unlinked = true;
+          file.closed = true;
+          cb(null);
+        };
+        transaction.onerror = () => cb(transaction.error);
+      });
+    };
+    file.deletable = true;
+    return file;
+  }
+  async _loadFiles(path) {
+    const db = await this._db;
+    invariant(db, "Database is not initialized.", {
+      F: __dxlog_file,
+      L: 85,
+      S: this,
+      A: [
+        "db",
+        "'Database is not initialized.'"
+      ]
+    });
+    const lowerBound = path;
+    const upperBound = `${path}\uFFFF`;
+    const range = IDBKeyRange.bound(lowerBound, upperBound);
+    const transaction = db.transaction(this._store);
+    const objectStore = transaction.objectStore(this._store);
+    const request = objectStore.openCursor(range);
+    return new Promise((resolve, reject) => {
+      transaction.onerror = () => {
+        reject(request.error);
+      };
+      request.onsuccess = (event) => {
+        const cursor = event.target.result;
+        if (cursor) {
+          const filename = String(cursor.key).split(DELIM)[0];
+          if (filename && !this._files.has(getFullPath(this.path, filename))) {
+            const file = this._createFile(path, filename);
+            this._files.set(getFullPath(this.path, filename), wrapFile(file, this.type));
+          }
+          cursor.continue();
+        } else {
+          resolve();
+        }
+      };
+    });
+  }
+  async _getFiles(path) {
+    if (!this._initialized) {
+      await this._loadFiles(this.path);
+      this._initialized = true;
+    }
+    return super._getFiles(path);
+  }
+};
+
+// src/browser/web-fs.ts
+import { EventEmitter } from "@dxos/node-std/events";
+import { callbackify } from "@dxos/node-std/util";
+import { synchronized } from "@dxos/async";
+import { invariant as invariant2 } from "@dxos/invariant";
+import { log } from "@dxos/log";
+import { TimeSeriesCounter, trace } from "@dxos/tracing";
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+var __dxlog_file2 = "/__w/dxos/dxos/packages/common/random-access-storage/src/browser/web-fs.ts";
+var WebFS = class {
+  path;
+  _files = /* @__PURE__ */ new Map();
+  type = StorageType.WEBFS;
+  _root;
+  constructor(path) {
+    this.path = path;
+  }
+  get size() {
+    return this._files.size;
+  }
+  _getFiles(path) {
+    const fullName = this._getFullFilename(this.path, path);
+    return new Map([
+      ...this._files.entries()
+    ].filter(([path2, file]) => {
+      return path2.includes(fullName) && !file.destroyed;
+    }));
+  }
+  async _list(path) {
+    const fullName = this._getFullFilename(path);
+    const root = await this._initialize();
+    const entries = [];
+    for await (const entry of root.keys()) {
+      if (entry.startsWith(fullName + "_") && !entry.endsWith(".crswap")) {
+        entries.push(entry.slice(fullName.length + 1));
+      }
+    }
+    return entries;
+  }
+  async _initialize() {
+    if (this._root) {
+      return this._root;
+    }
+    this._root = await navigator.storage.getDirectory();
+    invariant2(this._root, "Root is undefined", {
+      F: __dxlog_file2,
+      L: 74,
+      S: this,
+      A: [
+        "this._root",
+        "'Root is undefined'"
+      ]
+    });
+    return this._root;
+  }
+  createDirectory(sub = "") {
+    return new Directory({
+      type: this.type,
+      path: getFullPath(this.path, sub),
+      list: (path) => this._list(path),
+      getOrCreateFile: (...args) => this.getOrCreateFile(...args),
+      remove: () => this._delete(sub),
+      onFlush: async () => {
+        await Promise.all(Array.from(this._getFiles(sub)).map(([_, file]) => file.flush()));
+      }
+    });
+  }
+  getOrCreateFile(path, filename, opts) {
+    const fullName = this._getFullFilename(path, filename);
+    const existingFile = this._files.get(fullName);
+    if (existingFile) {
+      return existingFile;
+    }
+    const file = this._createFile(fullName);
+    this._files.set(fullName, file);
+    return file;
+  }
+  _createFile(fullName) {
+    return new WebFile({
+      fileName: fullName,
+      file: this._initialize().then((root) => root.getFileHandle(fullName, {
+        create: true
+      })),
+      destroy: async () => {
+        this._files.delete(fullName);
+        const root = await this._initialize();
+        return root.removeEntry(fullName);
+      }
+    });
+  }
+  async _delete(path) {
+    await Promise.all(Array.from(this._getFiles(path)).map(async ([path2, file]) => {
+      await file.destroy().catch((err) => log.warn(err, void 0, {
+        F: __dxlog_file2,
+        L: 117,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+      this._files.delete(path2);
+    }));
+  }
+  async reset() {
+    await this._initialize();
+    for await (const filename of await this._root.keys()) {
+      await this._root.removeEntry(filename, {
+        recursive: true
+      }).catch((err) => log.warn("failed to remove an entry", {
+        filename,
+        err
+      }, {
+        F: __dxlog_file2,
+        L: 127,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+      this._files.delete(filename);
+    }
+    this._root = void 0;
+  }
+  async close() {
+    await Promise.all(Array.from(this._files.values()).map((file) => {
+      return file.close().catch((e) => log.warn("failed to close a file", {
+        file: file.fileName,
+        e
+      }, {
+        F: __dxlog_file2,
+        L: 137,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    }));
+  }
+  _getFullFilename(path, filename) {
+    if (filename) {
+      return getFullPath(path, filename).replace(/\//g, "_");
+    } else {
+      return path.replace(/\//g, "_");
+    }
+  }
+  async getDiskInfo() {
+    let used = 0;
+    const recurse = async (handle) => {
+      const promises = [];
+      for await (const entry of handle.values()) {
+        promises.push((async () => {
+          switch (entry.kind) {
+            case "file":
+              used += await entry.getFile().then((f) => f.size);
+              break;
+            case "directory":
+              await recurse(entry);
+              break;
+          }
+        })());
+      }
+      await Promise.all(promises);
+    };
+    await recurse(this._root);
+    return {
+      used
+    };
+  }
+};
+_ts_decorate([
+  synchronized
+], WebFS.prototype, "_initialize", null);
+var WebFile = class extends EventEmitter {
+  fileName;
+  _fileHandle;
+  _destroy;
+  /**
+  * Current view of the file contents.
+  */
+  _buffer = null;
+  _loadBufferPromise = null;
+  _flushScheduled = false;
+  _flushPromise = Promise.resolve();
+  /**
+  * Used to discard unnecessary scheduled flushes.
+  * If _flushNow() is called with a lower sequence number it should early exit.
+  */
+  _flushSequence = 0;
+  //
+  // Metrics
+  //
+  _flushes = new TimeSeriesCounter();
+  _operations = new TimeSeriesCounter();
+  _reads = new TimeSeriesCounter();
+  _readBytes = new TimeSeriesCounter();
+  _writes = new TimeSeriesCounter();
+  _writeBytes = new TimeSeriesCounter();
+  get _bufferSize() {
+    return this._buffer?.length;
+  }
+  constructor({ fileName, file, destroy }) {
+    super();
+    this.fileName = fileName;
+    this._fileHandle = file;
+    this._destroy = destroy;
+    void this._loadBufferGuarded();
+  }
+  type = StorageType.WEBFS;
+  //
+  // random-access-storage library compatibility
+  //
+  // TODO(dmaretskyi): Are those all needed?
+  opened = true;
+  suspended = false;
+  closed = false;
+  unlinked = false;
+  writing = false;
+  readable = true;
+  writable = true;
+  deletable = true;
+  truncatable = true;
+  statable = true;
+  destroyed = false;
+  directory = "";
+  // TODO(dmaretskyi): is this used?
+  filename = "";
+  native = {
+    write: callbackify(this.write.bind(this)),
+    read: callbackify(this.read.bind(this)),
+    del: callbackify(this.del.bind(this)),
+    stat: callbackify(this.stat.bind(this)),
+    destroy: callbackify(this.destroy.bind(this)),
+    truncate: callbackify(this.truncate?.bind(this))
+  };
+  async _loadBuffer() {
+    const fileHandle = await this._fileHandle;
+    const file = await fileHandle.getFile();
+    this._buffer = new Uint8Array(await file.arrayBuffer());
+  }
+  async _loadBufferGuarded() {
+    await (this._loadBufferPromise ??= this._loadBuffer());
+  }
+  // Do not call directly, use _flushLater or _flushNow.
+  async _flushCache(sequence) {
+    if (this.destroyed || sequence < this._flushSequence) {
+      return;
+    }
+    this._flushSequence = sequence + 1;
+    this._flushes.inc();
+    await this._loadBufferGuarded();
+    invariant2(this._buffer, void 0, {
+      F: __dxlog_file2,
+      L: 301,
+      S: this,
+      A: [
+        "this._buffer",
+        ""
+      ]
+    });
+    const fileHandle = await this._fileHandle;
+    const writable = await fileHandle.createWritable({
+      keepExistingData: true
+    });
+    await writable.write({
+      type: "write",
+      data: this._buffer,
+      position: 0
+    });
+    await writable.close();
+  }
+  _flushLater() {
+    if (this._flushScheduled) {
+      return;
+    }
+    const sequence = this._flushSequence;
+    setTimeout(async () => {
+      await this._flushPromise;
+      this._flushScheduled = false;
+      this._flushPromise = this._flushCache(sequence).catch((err) => log.warn(err, void 0, {
+        F: __dxlog_file2,
+        L: 319,
+        S: this,
+        C: (f, a) => f(...a)
+      }));
+    });
+    this._flushScheduled = true;
+  }
+  async _flushNow() {
+    await this._flushPromise;
+    this._flushPromise = this._flushCache(this._flushSequence).catch((err) => log.warn(err, void 0, {
+      F: __dxlog_file2,
+      L: 327,
+      S: this,
+      C: (f, a) => f(...a)
+    }));
+    await this._flushPromise;
+  }
+  async read(offset, size) {
+    this.assertNotDestroyed("Read");
+    this._operations.inc();
+    this._reads.inc();
+    this._readBytes.inc(size);
+    if (!this._buffer) {
+      await this._loadBufferGuarded();
+      invariant2(this._buffer, void 0, {
+        F: __dxlog_file2,
+        L: 340,
+        S: this,
+        A: [
+          "this._buffer",
+          ""
+        ]
+      });
+    }
+    if (offset + size > this._buffer.length) {
+      throw new Error("Read out of bounds");
+    }
+    return Buffer.from(this._buffer.slice(offset, offset + size));
+  }
+  async write(offset, data) {
+    this.assertNotDestroyed("Write");
+    this._operations.inc();
+    this._writes.inc();
+    this._writeBytes.inc(data.length);
+    if (!this._buffer) {
+      await this._loadBufferGuarded();
+      invariant2(this._buffer, void 0, {
+        F: __dxlog_file2,
+        L: 360,
+        S: this,
+        A: [
+          "this._buffer",
+          ""
+        ]
+      });
+    }
+    if (offset + data.length <= this._buffer.length) {
+      this._buffer.set(data, offset);
+    } else {
+      const newCache = new Uint8Array(offset + data.length);
+      newCache.set(this._buffer);
+      newCache.set(data, offset);
+      this._buffer = newCache;
+    }
+    this._flushLater();
+  }
+  async del(offset, size) {
+    this.assertNotDestroyed("Del");
+    this._operations.inc();
+    if (offset < 0 || size <= 0) {
+      return;
+    }
+    if (!this._buffer) {
+      await this._loadBufferGuarded();
+      invariant2(this._buffer, void 0, {
+        F: __dxlog_file2,
+        L: 387,
+        S: this,
+        A: [
+          "this._buffer",
+          ""
+        ]
+      });
+    }
+    let leftoverSize = 0;
+    if (offset + size < this._buffer.length) {
+      leftoverSize = this._buffer.length - (offset + size);
+      this._buffer.set(this._buffer.slice(offset + size, offset + size + leftoverSize), offset);
+    }
+    this._buffer = this._buffer.slice(0, offset + leftoverSize);
+    this._flushLater();
+  }
+  async stat() {
+    this.assertNotDestroyed("Truncate");
+    this._operations.inc();
+    if (!this._buffer) {
+      await this._loadBufferGuarded();
+      invariant2(this._buffer, void 0, {
+        F: __dxlog_file2,
+        L: 409,
+        S: this,
+        A: [
+          "this._buffer",
+          ""
+        ]
+      });
+    }
+    return {
+      size: this._buffer.length
+    };
+  }
+  async truncate(offset) {
+    this.assertNotDestroyed("Truncate");
+    this._operations.inc();
+    if (!this._buffer) {
+      await this._loadBufferGuarded();
+      invariant2(this._buffer, void 0, {
+        F: __dxlog_file2,
+        L: 424,
+        S: this,
+        A: [
+          "this._buffer",
+          ""
+        ]
+      });
+    }
+    this._buffer = this._buffer.slice(0, offset);
+    this._flushLater();
+  }
+  async flush() {
+    this.assertNotDestroyed("Flush");
+    await this._flushNow();
+  }
+  /**
+  * It's best to avoid using this method as it doesn't really close a file.
+  * We could update the _opened flag and add a guard like for destroyed, but this would break
+  * the FileSystemFileHandle sharing required for browser tests to run, where writes are
+  * not immediately visible if using different file handles.
+  */
+  async close() {
+    await this._flushNow();
+  }
+  async destroy() {
+    if (!this.destroyed) {
+      await this._flushNow();
+      this.destroyed = true;
+      return await this._destroy();
+    }
+  }
+  assertNotDestroyed(operation) {
+    if (this.destroyed) {
+      throw new Error(`${operation} on a destroyed or closed file`);
+    }
+  }
+};
+_ts_decorate([
+  trace.info()
+], WebFile.prototype, "fileName", void 0);
+_ts_decorate([
+  trace.metricsCounter()
+], WebFile.prototype, "_flushes", void 0);
+_ts_decorate([
+  trace.metricsCounter()
+], WebFile.prototype, "_operations", void 0);
+_ts_decorate([
+  trace.metricsCounter()
+], WebFile.prototype, "_reads", void 0);
+_ts_decorate([
+  trace.metricsCounter()
+], WebFile.prototype, "_readBytes", void 0);
+_ts_decorate([
+  trace.metricsCounter()
+], WebFile.prototype, "_writes", void 0);
+_ts_decorate([
+  trace.metricsCounter()
+], WebFile.prototype, "_writeBytes", void 0);
+_ts_decorate([
+  trace.info()
+], WebFile.prototype, "_bufferSize", null);
+_ts_decorate([
+  synchronized
+], WebFile.prototype, "destroy", null);
+
+// src/browser/storage.ts
+var createStorage = ({ type, root = "" } = {}) => {
+  if (type === void 0) {
+    return new IDbStorage(root);
+  }
+  switch (type) {
+    case StorageType.RAM: {
+      return new MemoryStorage(root);
+    }
+    case StorageType.IDB:
+    case StorageType.CHROME:
+    case StorageType.FIREFOX: {
+      return new IDbStorage(root);
+    }
+    case StorageType.WEBFS: {
+      return new WebFS(root);
+    }
+    default: {
+      throw new Error(`Invalid type: ${type}`);
+    }
+  }
+};
+export {
+  AbstractStorage,
+  Directory,
+  MemoryStorage,
+  StorageType,
+  createStorage,
+  getFullPath,
+  stringDiff,
+  wrapFile
+};
+//# sourceMappingURL=index.mjs.map