@dabble/patches 0.3.2 → 0.4.1

package/dist/client/IndexedDBStore.js

@@ -51,7 +51,6 @@ const SNAPSHOT_INTERVAL = 200;
  * A snapshot will not be created if there are pending changes based on revisions older than the 200th committed change until those pending changes are committed.
  */
 let IndexedDBStore = (() => {
-    var _a;
     let _instanceExtraInitializers = [];
     let _getDoc_decorators;
     let _deleteDoc_decorators;
@@ -62,369 +61,372 @@ let IndexedDBStore = (() => {
     let _replacePendingChanges_decorators;
     let _saveCommittedChanges_decorators;
     let _getLastRevs_decorators;
-    return _a = class IndexedDBStore {
-            constructor(dbName) {
-                this.db = (__runInitializers(this, _instanceExtraInitializers), null);
-                this.dbName = dbName;
-                this.dbPromise = deferred();
-                if (this.dbName) {
-                    this.initDB();
-                }
-            }
-            async initDB() {
-                if (!this.dbName)
-                    return;
-                const request = indexedDB.open(this.dbName, DB_VERSION);
-                request.onerror = () => this.dbPromise.reject(request.error);
-                request.onsuccess = () => {
-                    this.db = request.result;
-                    this.dbPromise.resolve(this.db);
-                };
-                request.onupgradeneeded = event => {
-                    const db = event.target.result;
-                    // Create stores
-                    if (!db.objectStoreNames.contains('snapshots')) {
-                        db.createObjectStore('snapshots', { keyPath: 'docId' });
-                    }
-                    if (!db.objectStoreNames.contains('committedChanges')) {
-                        db.createObjectStore('committedChanges', { keyPath: ['docId', 'rev'] });
-                    }
-                    if (!db.objectStoreNames.contains('pendingChanges')) {
-                        db.createObjectStore('pendingChanges', { keyPath: ['docId', 'rev'] });
-                    }
-                    if (!db.objectStoreNames.contains('docs')) {
-                        db.createObjectStore('docs', { keyPath: 'docId' });
-                    }
-                };
-            }
-            getDB() {
-                return this.dbPromise.promise;
-            }
-            /**
-             * Set the name of the database, loads a new database connection.
-             * @param dbName - The new name of the database.
-             */
-            setName(dbName) {
-                this.dbName = dbName;
-                if (this.db) {
-                    this.db.close();
-                    this.db = null;
-                    this.dbPromise = deferred();
-                }
+    return class IndexedDBStore {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _getDoc_decorators = [blockable];
+            _deleteDoc_decorators = [blockable];
+            _confirmDeleteDoc_decorators = [blockable];
+            _saveDoc_decorators = [blockable];
+            _savePendingChanges_decorators = [blockable];
+            _getPendingChanges_decorators = [blockable];
+            _replacePendingChanges_decorators = [blockable];
+            _saveCommittedChanges_decorators = [blockable];
+            _getLastRevs_decorators = [blockable];
+            __esDecorate(this, null, _getDoc_decorators, { kind: "method", name: "getDoc", static: false, private: false, access: { has: obj => "getDoc" in obj, get: obj => obj.getDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _deleteDoc_decorators, { kind: "method", name: "deleteDoc", static: false, private: false, access: { has: obj => "deleteDoc" in obj, get: obj => obj.deleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _confirmDeleteDoc_decorators, { kind: "method", name: "confirmDeleteDoc", static: false, private: false, access: { has: obj => "confirmDeleteDoc" in obj, get: obj => obj.confirmDeleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _saveDoc_decorators, { kind: "method", name: "saveDoc", static: false, private: false, access: { has: obj => "saveDoc" in obj, get: obj => obj.saveDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _savePendingChanges_decorators, { kind: "method", name: "savePendingChanges", static: false, private: false, access: { has: obj => "savePendingChanges" in obj, get: obj => obj.savePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getPendingChanges_decorators, { kind: "method", name: "getPendingChanges", static: false, private: false, access: { has: obj => "getPendingChanges" in obj, get: obj => obj.getPendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _replacePendingChanges_decorators, { kind: "method", name: "replacePendingChanges", static: false, private: false, access: { has: obj => "replacePendingChanges" in obj, get: obj => obj.replacePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _saveCommittedChanges_decorators, { kind: "method", name: "saveCommittedChanges", static: false, private: false, access: { has: obj => "saveCommittedChanges" in obj, get: obj => obj.saveCommittedChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getLastRevs_decorators, { kind: "method", name: "getLastRevs", static: false, private: false, access: { has: obj => "getLastRevs" in obj, get: obj => obj.getLastRevs }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        db = (__runInitializers(this, _instanceExtraInitializers), null);
+        dbName;
+        dbPromise;
+        constructor(dbName) {
+            this.dbName = dbName;
+            this.dbPromise = deferred();
+            if (this.dbName) {
                 this.initDB();
             }
-            /**
-             * Closes the database connection. After calling this method, the store
-             * will no longer be usable. A new instance must be created to reopen
-             * the database.
-             */
-            async close() {
-                await this.dbPromise.promise;
-                if (this.db) {
-                    this.db.close();
-                    this.db = null;
-                    this.dbPromise = deferred();
-                    this.dbPromise.resolve(null);
+        }
+        async initDB() {
+            if (!this.dbName)
+                return;
+            const request = indexedDB.open(this.dbName, DB_VERSION);
+            request.onerror = () => this.dbPromise.reject(request.error);
+            request.onsuccess = () => {
+                this.db = request.result;
+                this.dbPromise.resolve(this.db);
+            };
+            request.onupgradeneeded = event => {
+                const db = event.target.result;
+                // Create stores
+                if (!db.objectStoreNames.contains('snapshots')) {
+                    db.createObjectStore('snapshots', { keyPath: 'docId' });
                 }
-            }
-            async deleteDB() {
-                if (!this.dbName)
-                    return;
-                await this.close();
-                await new Promise((resolve, reject) => {
-                    const request = indexedDB.deleteDatabase(this.dbName);
-                    request.onsuccess = () => resolve();
-                    request.onerror = () => reject(request.error);
-                    request.onblocked = () => reject(request.error);
-                });
-            }
-            async transaction(storeNames, mode) {
-                const db = await this.getDB();
-                const tx = new IDBTransactionWrapper(db.transaction(storeNames, mode));
-                const stores = storeNames.map(name => tx.getStore(name));
-                return [tx, ...stores];
-            }
-            /**
-             * Rebuilds a document snapshot + pending queue *without* loading
-             * the full PatchesDoc into memory.
-             *
-             * 1. load the last snapshot (state + rev)
-             * 2. load committedChanges[rev > snapshot.rev]
-             * 3. load pendingChanges
-             * 4. apply committed changes, rebase pending
-             * 5. return { state, rev, changes: pending }
-             */
-            async getDoc(docId) {
-                const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readonly');
-                const docMeta = await docsStore.get(docId);
-                if (docMeta?.deleted) {
-                    await tx.complete();
-                    return undefined;
+                if (!db.objectStoreNames.contains('committedChanges')) {
+                    db.createObjectStore('committedChanges', { keyPath: ['docId', 'rev'] });
                 }
-                const snapshot = await snapshots.get(docId);
-                const committed = await committedChanges.getAll([docId, snapshot?.rev ?? 0], [docId, Infinity]);
-                const pending = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
-                if (!snapshot && !committed.length && !pending.length)
-                    return undefined;
-                // Apply any committed changes to the snapshot state
-                const state = applyChanges(snapshot?.state, committed);
-                // Rebase pending changes if there are any committed changes received since their baseRev
-                const lastCommitted = committed[committed.length - 1];
-                const baseRev = pending[0]?.baseRev;
-                if (lastCommitted && baseRev && baseRev < lastCommitted.rev) {
-                    const patch = committed
-                        .filter(change => change.rev > baseRev)
-                        .map(change => change.ops)
-                        .flat();
-                    const offset = lastCommitted.rev - baseRev;
-                    pending.forEach(change => {
-                        change.rev += offset;
-                        change.ops = transformPatch(state, patch, change.ops);
-                    });
+                if (!db.objectStoreNames.contains('pendingChanges')) {
+                    db.createObjectStore('pendingChanges', { keyPath: ['docId', 'rev'] });
                 }
-                await tx.complete();
-                return {
-                    state,
-                    rev: committed[committed.length - 1]?.rev ?? snapshot?.rev ?? 0,
-                    changes: pending,
-                };
+                if (!db.objectStoreNames.contains('docs')) {
+                    db.createObjectStore('docs', { keyPath: 'docId' });
+                }
+            };
+        }
+        getDB() {
+            return this.dbPromise.promise;
+        }
+        /**
+         * Set the name of the database, loads a new database connection.
+         * @param dbName - The new name of the database.
+         */
+        setName(dbName) {
+            this.dbName = dbName;
+            if (this.db) {
+                this.db.close();
+                this.db = null;
+                this.dbPromise = deferred();
             }
-            /**
-             * Completely remove all data for this docId and mark it as deleted (tombstone).
-             */
-            async deleteDoc(docId) {
-                const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
-                const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
-                await docsStore.put({ ...docMeta, deleted: true });
-                await Promise.all([
-                    snapshots.delete(docId),
-                    committedChanges.delete([docId, 0], [docId, Infinity]),
-                    pendingChanges.delete([docId, 0], [docId, Infinity]),
-                ]);
-                await tx.complete();
+            this.initDB();
+        }
+        /**
+         * Closes the database connection. After calling this method, the store
+         * will no longer be usable. A new instance must be created to reopen
+         * the database.
+         */
+        async close() {
+            await this.dbPromise.promise;
+            if (this.db) {
+                this.db.close();
+                this.db = null;
+                this.dbPromise = deferred();
+                this.dbPromise.resolve(null);
             }
-            /**
-             * Confirm the deletion of a document.
-             * @param docId - The ID of the document to delete.
-             */
-            async confirmDeleteDoc(docId) {
-                const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
-                await docsStore.delete(docId);
+        }
+        async deleteDB() {
+            if (!this.dbName)
+                return;
+            await this.close();
+            await new Promise((resolve, reject) => {
+                const request = indexedDB.deleteDatabase(this.dbName);
+                request.onsuccess = () => resolve();
+                request.onerror = () => reject(request.error);
+                request.onblocked = () => reject(request.error);
+            });
+        }
+        async transaction(storeNames, mode) {
+            const db = await this.getDB();
+            const tx = new IDBTransactionWrapper(db.transaction(storeNames, mode));
+            const stores = storeNames.map(name => tx.getStore(name));
+            return [tx, ...stores];
+        }
+        /**
+         * Rebuilds a document snapshot + pending queue *without* loading
+         * the full PatchesDoc into memory.
+         *
+         * 1. load the last snapshot (state + rev)
+         * 2. load committedChanges[rev > snapshot.rev]
+         * 3. load pendingChanges
+         * 4. apply committed changes, rebase pending
+         * 5. return { state, rev, changes: pending }
+         */
+        async getDoc(docId) {
+            const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readonly');
+            const docMeta = await docsStore.get(docId);
+            if (docMeta?.deleted) {
                 await tx.complete();
+                return undefined;
             }
-            /**
-             * Save a document's state to the store.
-             * @param docId - The ID of the document to save.
-             * @param docState - The state of the document to save.
-             */
-            async saveDoc(docId, docState) {
-                const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
-                const { rev, state } = docState;
-                await Promise.all([
-                    docsStore.put({ docId, committedRev: rev }),
-                    snapshots.put({ docId, state, rev }),
-                    committedChanges.delete([docId, 0], [docId, Infinity]),
-                    pendingChanges.delete([docId, 0], [docId, Infinity]),
-                ]);
-                await tx.complete();
+            const snapshot = await snapshots.get(docId);
+            const committed = await committedChanges.getAll([docId, snapshot?.rev ?? 0], [docId, Infinity]);
+            const pending = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
+            if (!snapshot && !committed.length && !pending.length)
+                return undefined;
+            // Apply any committed changes to the snapshot state
+            const state = applyChanges(snapshot?.state, committed);
+            // Rebase pending changes if there are any committed changes received since their baseRev
+            const lastCommitted = committed[committed.length - 1];
+            const baseRev = pending[0]?.baseRev;
+            if (lastCommitted && baseRev && baseRev < lastCommitted.rev) {
+                const patch = committed
+                    .filter(change => change.rev > baseRev)
+                    .map(change => change.ops)
+                    .flat();
+                const offset = lastCommitted.rev - baseRev;
+                pending.forEach(change => {
+                    change.rev += offset;
+                    change.ops = transformPatch(state, patch, change.ops);
+                });
             }
-            /**
-             * Append an array of local changes to the pending queue.
-             * Called *before* you attempt to send them to the server.
-             */
-            async savePendingChanges(docId, changes) {
-                const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
-                let docMeta = await docsStore.get(docId);
-                if (!docMeta) {
-                    docMeta = { docId, committedRev: 0 };
-                    await docsStore.put(docMeta);
-                }
-                else if (docMeta.deleted) {
-                    delete docMeta.deleted;
-                    await docsStore.put(docMeta);
-                    console.warn(`Revived document ${docId} by saving pending changes.`);
-                }
-                await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
-                await tx.complete();
+            await tx.complete();
+            return {
+                state,
+                rev: committed[committed.length - 1]?.rev ?? snapshot?.rev ?? 0,
+                changes: pending,
+            };
+        }
+        /**
+         * Completely remove all data for this docId and mark it as deleted (tombstone).
+         */
+        async deleteDoc(docId) {
+            const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
+            const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
+            await docsStore.put({ ...docMeta, deleted: true });
+            await Promise.all([
+                snapshots.delete(docId),
+                committedChanges.delete([docId, 0], [docId, Infinity]),
+                pendingChanges.delete([docId, 0], [docId, Infinity]),
+            ]);
+            await tx.complete();
+        }
+        /**
+         * Confirm the deletion of a document.
+         * @param docId - The ID of the document to delete.
+         */
+        async confirmDeleteDoc(docId) {
+            const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
+            await docsStore.delete(docId);
+            await tx.complete();
+        }
+        /**
+         * Save a document's state to the store.
+         * @param docId - The ID of the document to save.
+         * @param docState - The state of the document to save.
+         */
+        async saveDoc(docId, docState) {
+            const [tx, snapshots, committedChanges, pendingChanges, docsStore] = await this.transaction(['snapshots', 'committedChanges', 'pendingChanges', 'docs'], 'readwrite');
+            const { rev, state } = docState;
+            await Promise.all([
+                docsStore.put({ docId, committedRev: rev }),
+                snapshots.put({ docId, state, rev }),
+                committedChanges.delete([docId, 0], [docId, Infinity]),
+                pendingChanges.delete([docId, 0], [docId, Infinity]),
+            ]);
+            await tx.complete();
+        }
+        /**
+         * Append an array of local changes to the pending queue.
+         * Called *before* you attempt to send them to the server.
+         */
+        async savePendingChanges(docId, changes) {
+            const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
+            let docMeta = await docsStore.get(docId);
+            if (!docMeta) {
+                docMeta = { docId, committedRev: 0 };
+                await docsStore.put(docMeta);
             }
-            /**
-             * Read back all pending changes for this docId (in order).
-             * @param docId - The ID of the document to get the pending changes for.
-             * @returns The pending changes.
-             */
-            async getPendingChanges(docId) {
-                const [tx, pendingChanges] = await this.transaction(['pendingChanges'], 'readonly');
-                const result = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
-                await tx.complete();
-                return result;
+            else if (docMeta.deleted) {
+                delete docMeta.deleted;
+                await docsStore.put(docMeta);
+                console.warn(`Revived document ${docId} by saving pending changes.`);
             }
-            /**
-             * Replace all pending changes for a document (used after rebasing).
-             * @param docId - The ID of the document to replace the pending changes for.
-             * @param changes - The changes to replace the pending changes with.
-             */
-            async replacePendingChanges(docId, changes) {
-                const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
-                // Ensure the document is tracked
-                let docMeta = await docsStore.get(docId);
-                if (!docMeta) {
-                    docMeta = { docId, committedRev: 0 };
-                    await docsStore.put(docMeta);
-                }
-                else if (docMeta.deleted) {
-                    delete docMeta.deleted;
-                    await docsStore.put(docMeta);
-                    console.warn(`Revived document ${docId} by replacing pending changes.`);
-                }
-                // Remove all existing pending changes and add the new ones
-                await pendingChanges.delete([docId, 0], [docId, Infinity]);
-                await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
-                await tx.complete();
+            await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
+            await tx.complete();
+        }
+        /**
+         * Read back all pending changes for this docId (in order).
+         * @param docId - The ID of the document to get the pending changes for.
+         * @returns The pending changes.
+         */
+        async getPendingChanges(docId) {
+            const [tx, pendingChanges] = await this.transaction(['pendingChanges'], 'readonly');
+            const result = await pendingChanges.getAll([docId, 0], [docId, Infinity]);
+            await tx.complete();
+            return result;
+        }
+        /**
+         * Replace all pending changes for a document (used after rebasing).
+         * @param docId - The ID of the document to replace the pending changes for.
+         * @param changes - The changes to replace the pending changes with.
+         */
+        async replacePendingChanges(docId, changes) {
+            const [tx, pendingChanges, docsStore] = await this.transaction(['pendingChanges', 'docs'], 'readwrite');
+            // Ensure the document is tracked
+            let docMeta = await docsStore.get(docId);
+            if (!docMeta) {
+                docMeta = { docId, committedRev: 0 };
+                await docsStore.put(docMeta);
             }
-            // ─── Committed Changes ─────────────────────────────────────────────────────
-            /**
-             * Store server‐confirmed changes.  Will:
-             * - persist them in the committedChanges store
-             * - remove any pending changes whose rev falls within `sentPendingRange`
-             * - optionally compact a new snapshot after N changes (hidden internally)
-             * @param docId - The ID of the document to save the changes for
-             * @param changes - The changes to save
-             * @param sentPendingRange - The range of pending changes to remove, *must* be provided after receiving the changes
-             * from the server in response to a patchesDoc request.
-             */
-            async saveCommittedChanges(docId, changes, sentPendingRange) {
-                const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(['committedChanges', 'pendingChanges', 'snapshots', 'docs'], 'readwrite');
-                // Save committed changes
-                await Promise.all(changes.map(change => committedChanges.put({ ...change, docId })));
-                // Remove pending changes if range provided
-                if (sentPendingRange) {
-                    await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
-                }
-                // Check if we should create a snapshot
-                const count = await committedChanges.count([docId, 0], [docId, Infinity]);
-                if (count >= SNAPSHOT_INTERVAL) {
-                    // Update the snapshot. A snapshot will not be updated if there are pending changes based on revisions older than
-                    // the latest committed change until those pending changes are committed.
-                    const [snapshot, committed, firstPending] = await Promise.all([
-                        snapshots.get(docId),
-                        committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
-                        pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity]),
+            else if (docMeta.deleted) {
+                delete docMeta.deleted;
+                await docsStore.put(docMeta);
+                console.warn(`Revived document ${docId} by replacing pending changes.`);
+            }
+            // Remove all existing pending changes and add the new ones
+            await pendingChanges.delete([docId, 0], [docId, Infinity]);
+            await Promise.all(changes.map(change => pendingChanges.put({ ...change, docId })));
+            await tx.complete();
+        }
+        // ─── Committed Changes ─────────────────────────────────────────────────────
+        /**
+         * Store server‐confirmed changes.  Will:
+         * - persist them in the committedChanges store
+         * - remove any pending changes whose rev falls within `sentPendingRange`
+         * - optionally compact a new snapshot after N changes (hidden internally)
+         * @param docId - The ID of the document to save the changes for
+         * @param changes - The changes to save
+         * @param sentPendingRange - The range of pending changes to remove, *must* be provided after receiving the changes
+         * from the server in response to a patchesDoc request.
+         */
+        async saveCommittedChanges(docId, changes, sentPendingRange) {
+            const [tx, committedChanges, pendingChanges, snapshots, docsStore] = await this.transaction(['committedChanges', 'pendingChanges', 'snapshots', 'docs'], 'readwrite');
+            // Save committed changes
+            await Promise.all(changes.map(change => committedChanges.put({ ...change, docId })));
+            // Remove pending changes if range provided
+            if (sentPendingRange) {
+                await pendingChanges.delete([docId, sentPendingRange[0]], [docId, sentPendingRange[1]]);
+            }
+            // Check if we should create a snapshot
+            const count = await committedChanges.count([docId, 0], [docId, Infinity]);
+            if (count >= SNAPSHOT_INTERVAL) {
+                // Update the snapshot. A snapshot will not be updated if there are pending changes based on revisions older than
+                // the latest committed change until those pending changes are committed.
+                const [snapshot, committed, firstPending] = await Promise.all([
+                    snapshots.get(docId),
+                    committedChanges.getAll([docId, 0], [docId, Infinity], SNAPSHOT_INTERVAL),
+                    pendingChanges.getFirstFromCursor([docId, 0], [docId, Infinity]),
+                ]);
+                // Update the snapshot
+                const lastRev = committed[committed.length - 1]?.rev;
+                if (!firstPending?.baseRev || firstPending?.baseRev >= lastRev) {
+                    const state = applyChanges(snapshot?.state, committed);
+                    await Promise.all([
+                        snapshots.put({
+                            docId,
+                            rev: lastRev,
+                            state,
+                        }),
+                        committedChanges.delete([docId, 0], [docId, lastRev]),
                     ]);
-                    // Update the snapshot
-                    const lastRev = committed[committed.length - 1]?.rev;
-                    if (!firstPending?.baseRev || firstPending?.baseRev >= lastRev) {
-                        const state = applyChanges(snapshot?.state, committed);
-                        await Promise.all([
-                            snapshots.put({
-                                docId,
-                                rev: lastRev,
-                                state,
-                            }),
-                            committedChanges.delete([docId, 0], [docId, lastRev]),
-                        ]);
-                    }
                 }
-                // Update committedRev in the docs store if changes were saved
-                const lastCommittedRev = changes.at(-1)?.rev;
-                if (lastCommittedRev !== undefined) {
-                    const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
-                    if (lastCommittedRev > docMeta.committedRev) {
-                        await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: undefined });
-                    }
-                }
-                await tx.complete();
             }
-            /**
-             * List all documents in the store.
-             * @param includeDeleted - Whether to include deleted documents.
-             * @returns The list of documents.
-             */
-            async listDocs(includeDeleted = false) {
-                const [tx, docsStore] = await this.transaction(['docs'], 'readonly');
-                const allDocs = await docsStore.getAll();
-                await tx.complete();
-                return includeDeleted ? allDocs : allDocs.filter(doc => !doc.deleted);
+            // Update committedRev in the docs store if changes were saved
+            const lastCommittedRev = changes.at(-1)?.rev;
+            if (lastCommittedRev !== undefined) {
+                const docMeta = (await docsStore.get(docId)) ?? { docId, committedRev: 0 };
+                if (lastCommittedRev > docMeta.committedRev) {
+                    await docsStore.put({ ...docMeta, committedRev: lastCommittedRev, deleted: undefined });
+                }
             }
-            /**
-             * Track a document.
-             * @param docIds - The IDs of the documents to track.
-             */
-            async trackDocs(docIds) {
-                const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
-                await Promise.all(docIds.map(async (docId) => {
-                    const existing = await docsStore.get(docId);
-                    if (existing) {
-                        // If exists but deleted, undelete it
-                        if (existing.deleted) {
-                            await docsStore.put({ ...existing, deleted: undefined });
-                        }
-                        // Otherwise, it's already tracked and not deleted, do nothing
-                    }
-                    else {
-                        // If doesn't exist, add it
-                        await docsStore.put({ docId, committedRev: 0 });
+            await tx.complete();
+        }
+        /**
+         * List all documents in the store.
+         * @param includeDeleted - Whether to include deleted documents.
+         * @returns The list of documents.
+         */
+        async listDocs(includeDeleted = false) {
+            const [tx, docsStore] = await this.transaction(['docs'], 'readonly');
+            const allDocs = await docsStore.getAll();
+            await tx.complete();
+            return includeDeleted ? allDocs : allDocs.filter(doc => !doc.deleted);
+        }
+        /**
+         * Track a document.
+         * @param docIds - The IDs of the documents to track.
+         */
+        async trackDocs(docIds) {
+            const [tx, docsStore] = await this.transaction(['docs'], 'readwrite');
+            await Promise.all(docIds.map(async (docId) => {
+                const existing = await docsStore.get(docId);
+                if (existing) {
+                    // If exists but deleted, undelete it
+                    if (existing.deleted) {
+                        await docsStore.put({ ...existing, deleted: undefined });
                     }
-                }));
-                await tx.complete();
-            }
-            /**
-             * Untrack a document.
-             * @param docIds - The IDs of the documents to untrack.
-             */
-            async untrackDocs(docIds) {
-                const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readwrite');
-                await Promise.all(docIds.map(docId => {
-                    return Promise.all([
-                        docsStore.delete(docId),
-                        snapshots.delete(docId),
-                        committedChanges.delete([docId, 0], [docId, Infinity]),
-                        pendingChanges.delete([docId, 0], [docId, Infinity]),
-                    ]);
-                }));
-                await tx.complete();
-            }
-            /**
-             * Tell me the last committed revision you have *and* the highest
-             * rev of any change.  Use these to drive:
-             *   - fetch changes:   api.getChangesSince(docId, committedRev)
-             *   - build new patch: newChange.rev = pendingRev; baseRev = committedRev
-             */
-            async getLastRevs(docId) {
-                const [tx, committedChanges, pendingChanges] = await this.transaction(['committedChanges', 'pendingChanges'], 'readonly');
-                const [lastCommitted, lastPending] = await Promise.all([
-                    committedChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
-                    pendingChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
+                    // Otherwise, it's already tracked and not deleted, do nothing
+                }
+                else {
+                    // If doesn't exist, add it
+                    await docsStore.put({ docId, committedRev: 0 });
+                }
+            }));
+            await tx.complete();
+        }
+        /**
+         * Untrack a document.
+         * @param docIds - The IDs of the documents to untrack.
+         */
+        async untrackDocs(docIds) {
+            const [tx, docsStore, snapshots, committedChanges, pendingChanges] = await this.transaction(['docs', 'snapshots', 'committedChanges', 'pendingChanges'], 'readwrite');
+            await Promise.all(docIds.map(docId => {
+                return Promise.all([
+                    docsStore.delete(docId),
+                    snapshots.delete(docId),
+                    committedChanges.delete([docId, 0], [docId, Infinity]),
+                    pendingChanges.delete([docId, 0], [docId, Infinity]),
                 ]);
-                await tx.complete();
-                return [lastCommitted?.rev ?? 0, lastPending?.rev ?? lastCommitted?.rev ?? 0];
-            }
-        },
-        (() => {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
-            _getDoc_decorators = [blockable];
-            _deleteDoc_decorators = [blockable];
-            _confirmDeleteDoc_decorators = [blockable];
-            _saveDoc_decorators = [blockable];
-            _savePendingChanges_decorators = [blockable];
-            _getPendingChanges_decorators = [blockable];
-            _replacePendingChanges_decorators = [blockable];
-            _saveCommittedChanges_decorators = [blockable];
-            _getLastRevs_decorators = [blockable];
-            __esDecorate(_a, null, _getDoc_decorators, { kind: "method", name: "getDoc", static: false, private: false, access: { has: obj => "getDoc" in obj, get: obj => obj.getDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _deleteDoc_decorators, { kind: "method", name: "deleteDoc", static: false, private: false, access: { has: obj => "deleteDoc" in obj, get: obj => obj.deleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _confirmDeleteDoc_decorators, { kind: "method", name: "confirmDeleteDoc", static: false, private: false, access: { has: obj => "confirmDeleteDoc" in obj, get: obj => obj.confirmDeleteDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _saveDoc_decorators, { kind: "method", name: "saveDoc", static: false, private: false, access: { has: obj => "saveDoc" in obj, get: obj => obj.saveDoc }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _savePendingChanges_decorators, { kind: "method", name: "savePendingChanges", static: false, private: false, access: { has: obj => "savePendingChanges" in obj, get: obj => obj.savePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _getPendingChanges_decorators, { kind: "method", name: "getPendingChanges", static: false, private: false, access: { has: obj => "getPendingChanges" in obj, get: obj => obj.getPendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _replacePendingChanges_decorators, { kind: "method", name: "replacePendingChanges", static: false, private: false, access: { has: obj => "replacePendingChanges" in obj, get: obj => obj.replacePendingChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _saveCommittedChanges_decorators, { kind: "method", name: "saveCommittedChanges", static: false, private: false, access: { has: obj => "saveCommittedChanges" in obj, get: obj => obj.saveCommittedChanges }, metadata: _metadata }, null, _instanceExtraInitializers);
-            __esDecorate(_a, null, _getLastRevs_decorators, { kind: "method", name: "getLastRevs", static: false, private: false, access: { has: obj => "getLastRevs" in obj, get: obj => obj.getLastRevs }, metadata: _metadata }, null, _instanceExtraInitializers);
-            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
-        })(),
-        _a;
+            }));
+            await tx.complete();
+        }
+        /**
+         * Tell me the last committed revision you have *and* the highest
+         * rev of any change.  Use these to drive:
+         *   - fetch changes:   api.getChangesSince(docId, committedRev)
+         *   - build new patch: newChange.rev = pendingRev; baseRev = committedRev
+         */
+        async getLastRevs(docId) {
+            const [tx, committedChanges, pendingChanges] = await this.transaction(['committedChanges', 'pendingChanges'], 'readonly');
+            const [lastCommitted, lastPending] = await Promise.all([
+                committedChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
+                pendingChanges.getLastFromCursor([docId, 0], [docId, Infinity]),
+            ]);
+            await tx.complete();
+            return [lastCommitted?.rev ?? 0, lastPending?.rev ?? lastCommitted?.rev ?? 0];
+        }
+    };
 })();
 export { IndexedDBStore };
 class IDBTransactionWrapper {
+    tx;
+    promise;
     constructor(tx) {
         this.tx = tx;
         this.promise = new Promise((resolve, reject) => {
@@ -440,6 +442,7 @@ class IDBTransactionWrapper {
     }
 }
 class IDBStoreWrapper {
+    store;
     constructor(store) {
         this.store = store;
     }