@firebase/firestore 3.13.0-canary.684bb4e45 → 3.13.0-canary.794441e73

package/dist/firestore/src/global_index.d.ts

@@ -9154,6 +9154,20 @@ interface ExistenceFilterMismatchInfo {
         bitmapLength: number;
         /** The number of bits of padding in the last byte of the bloom filter. */
         padding: number;
+        /**
+         * Check if the given document path is contained in the bloom filter.
+         *
+         * The "path" of a document can be retrieved from the
+         * `DocumentReference.path` property.
+         *
+         * Note that due to the probabilistic nature of a bloom filter, it is
+         * possible that false positives may occur; that is, this function may
+         * return `true` even though the given string is not in the bloom filter.
+         *
+         * This property is "optional"; if it is undefined then parsing the bloom
+         * filter failed.
+         */
+        mightContain?(documentPath: string): boolean;
     };
 }
 /**

package/dist/firestore/src/util/testing_hooks.d.ts

@@ -94,6 +94,20 @@ export interface ExistenceFilterMismatchInfo {
         bitmapLength: number;
         /** The number of bits of padding in the last byte of the bloom filter. */
         padding: number;
+        /**
+         * Check if the given document path is contained in the bloom filter.
+         *
+         * The "path" of a document can be retrieved from the
+         * `DocumentReference.path` property.
+         *
+         * Note that due to the probabilistic nature of a bloom filter, it is
+         * possible that false positives may occur; that is, this function may
+         * return `true` even though the given string is not in the bloom filter.
+         *
+         * This property is "optional"; if it is undefined then parsing the bloom
+         * filter failed.
+         */
+        mightContain?(documentPath: string): boolean;
     };
 }
 /**

package/dist/firestore/test/integration/util/testing_hooks_util.d.ts

@@ -42,5 +42,6 @@ export interface ExistenceFilterMismatchInfo {
         hashCount: number;
         bitmapLength: number;
         padding: number;
+        mightContain?(documentPath: string): boolean;
     };
 }

package/dist/index.cjs.js

@@ -70,7 +70,7 @@ User.MOCK_USER = new User("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let b = "9.23.0-canary.684bb4e45";
+let b = "9.23.0-canary.794441e73";
 
 /**
  * @license
@@ -5897,7 +5897,7 @@ class BloomFilter {
     Ve(e) {
         return 0 != (this.bitmap[Math.floor(e / 8)] & 1 << e % 8);
     }
-    me(e) {
+    mightContain(e) {
         // Empty bitmap should always return false on membership check.
         if (0 === this.de) return !1;
         const t = __PRIVATE_getMd5HashValue(e), [n, r] = __PRIVATE_get64BitUints(t);
@@ -5916,10 +5916,10 @@ class BloomFilter {
         const t = __PRIVATE_getMd5HashValue(e), [n, r] = __PRIVATE_get64BitUints(t);
         for (let e = 0; e < this.hashCount; e++) {
             const t = this.Re(n, r, e);
-            this.fe(t);
+            this.me(t);
         }
     }
-    fe(e) {
+    me(e) {
         const t = Math.floor(e / 8), n = e % 8;
         this.bitmap[t] |= 1 << n;
     }
@@ -6076,13 +6076,13 @@ class __PRIVATE_BloomFilterError extends Error {
      * document went out of view without the server sending a new document.
      */
     r) {
-        this.ge = e, this.removedTargetIds = t, this.key = n, this.pe = r;
+        this.fe = e, this.removedTargetIds = t, this.key = n, this.ge = r;
     }
 }
 
 class __PRIVATE_ExistenceFilterChange {
     constructor(e, t) {
-        this.targetId = e, this.ye = t;
+        this.targetId = e, this.pe = t;
     }
 }
 
@@ -6110,22 +6110,22 @@ class __PRIVATE_WatchTargetChange {
          * The number of pending responses (adds or removes) that we are waiting on.
          * We only consider targets active that have no pending responses.
          */
-        this.we = 0, 
+        this.ye = 0, 
         /**
          * Keeps track of the document changes since the last raised snapshot.
          *
          * These changes are continuously updated as we receive document updates and
          * always reflect the current set of changes against the last issued snapshot.
          */
-        this.Se = __PRIVATE_snapshotChangesMap(), 
+        this.we = __PRIVATE_snapshotChangesMap(), 
         /** See public getters for explanations of these fields. */
-        this.be = ByteString.EMPTY_BYTE_STRING, this.De = !1, 
+        this.Se = ByteString.EMPTY_BYTE_STRING, this.be = !1, 
         /**
          * Whether this target state should be included in the next snapshot. We
          * initialize to true so that newly-added targets are included in the next
          * RemoteEvent.
          */
-        this.ve = !0;
+        this.De = !0;
     }
     /**
      * Whether this target has been marked 'current'.
@@ -6135,31 +6135,31 @@ class __PRIVATE_WatchTargetChange {
      * was added and that the target is consistent with the rest of the watch
      * stream.
      */    get current() {
-        return this.De;
+        return this.be;
     }
     /** The last resume token sent to us for this target. */    get resumeToken() {
-        return this.be;
+        return this.Se;
     }
-    /** Whether this target has pending target adds or target removes. */    get Ce() {
-        return 0 !== this.we;
+    /** Whether this target has pending target adds or target removes. */    get ve() {
+        return 0 !== this.ye;
     }
-    /** Whether we have modified any state that should trigger a snapshot. */    get Fe() {
-        return this.ve;
+    /** Whether we have modified any state that should trigger a snapshot. */    get Ce() {
+        return this.De;
     }
     /**
      * Applies the resume token to the TargetChange, but only when it has a new
      * value. Empty resumeTokens are discarded.
-     */    Me(e) {
-        e.approximateByteSize() > 0 && (this.ve = !0, this.be = e);
+     */    Fe(e) {
+        e.approximateByteSize() > 0 && (this.De = !0, this.Se = e);
     }
     /**
      * Creates a target change from the current set of changes.
      *
      * To reset the document changes after raising this snapshot, call
      * `clearPendingChanges()`.
-     */    xe() {
+     */    Me() {
         let e = __PRIVATE_documentKeySet(), t = __PRIVATE_documentKeySet(), n = __PRIVATE_documentKeySet();
-        return this.Se.forEach(((r, i) => {
+        return this.we.forEach(((r, i) => {
             switch (i) {
               case 0 /* ChangeType.Added */ :
                 e = e.add(r);
@@ -6176,27 +6176,27 @@ class __PRIVATE_WatchTargetChange {
               default:
                 fail();
             }
-        })), new TargetChange(this.be, this.De, e, t, n);
+        })), new TargetChange(this.Se, this.be, e, t, n);
     }
     /**
      * Resets the document changes and sets `hasPendingChanges` to false.
-     */    Oe() {
-        this.ve = !1, this.Se = __PRIVATE_snapshotChangesMap();
+     */    xe() {
+        this.De = !1, this.we = __PRIVATE_snapshotChangesMap();
+    }
+    Oe(e, t) {
+        this.De = !0, this.we = this.we.insert(e, t);
     }
-    Ne(e, t) {
-        this.ve = !0, this.Se = this.Se.insert(e, t);
+    Ne(e) {
+        this.De = !0, this.we = this.we.remove(e);
     }
-    Be(e) {
-        this.ve = !0, this.Se = this.Se.remove(e);
+    Be() {
+        this.ye += 1;
     }
     Le() {
-        this.we += 1;
+        this.ye -= 1;
     }
     ke() {
-        this.we -= 1;
-    }
-    qe() {
-        this.ve = !0, this.De = !0;
+        this.De = !0, this.be = !0;
     }
 }
 
@@ -6205,42 +6205,42 @@ class __PRIVATE_WatchTargetChange {
  */
 class __PRIVATE_WatchChangeAggregator {
     constructor(e) {
-        this.Qe = e, 
+        this.qe = e, 
         /** The internal state of all tracked targets. */
-        this.Ke = new Map, 
+        this.Qe = new Map, 
         /** Keeps track of the documents to update since the last raised snapshot. */
-        this.$e = __PRIVATE_mutableDocumentMap(), 
+        this.Ke = __PRIVATE_mutableDocumentMap(), 
         /** A mapping of document keys to their set of target IDs. */
-        this.Ue = __PRIVATE_documentTargetMap(), 
+        this.$e = __PRIVATE_documentTargetMap(), 
         /**
          * A map of targets with existence filter mismatches. These targets are
          * known to be inconsistent and their listens needs to be re-established by
          * RemoteStore.
          */
-        this.We = new SortedMap(__PRIVATE_primitiveComparator);
+        this.Ue = new SortedMap(__PRIVATE_primitiveComparator);
     }
     /**
      * Processes and adds the DocumentWatchChange to the current set of changes.
-     */    Ge(e) {
-        for (const t of e.ge) e.pe && e.pe.isFoundDocument() ? this.ze(t, e.pe) : this.je(t, e.key, e.pe);
-        for (const t of e.removedTargetIds) this.je(t, e.key, e.pe);
+     */    We(e) {
+        for (const t of e.fe) e.ge && e.ge.isFoundDocument() ? this.Ge(t, e.ge) : this.ze(t, e.key, e.ge);
+        for (const t of e.removedTargetIds) this.ze(t, e.key, e.ge);
     }
-    /** Processes and adds the WatchTargetChange to the current set of changes. */    He(e) {
+    /** Processes and adds the WatchTargetChange to the current set of changes. */    je(e) {
         this.forEachTarget(e, (t => {
-            const n = this.Je(t);
+            const n = this.He(t);
             switch (e.state) {
               case 0 /* WatchTargetChangeState.NoChange */ :
-                this.Ye(t) && n.Me(e.resumeToken);
+                this.Je(t) && n.Fe(e.resumeToken);
                 break;
 
               case 1 /* WatchTargetChangeState.Added */ :
                 // We need to decrement the number of pending acks needed from watch
                 // for this targetId.
-                n.ke(), n.Ce || 
+                n.Le(), n.ve || 
                 // We have a freshly added target, so we need to reset any state
                 // that we had previously. This can happen e.g. when remove and add
                 // back a target for existence filter mismatches.
-                n.Oe(), n.Me(e.resumeToken);
+                n.xe(), n.Fe(e.resumeToken);
                 break;
 
               case 2 /* WatchTargetChangeState.Removed */ :
@@ -6248,19 +6248,19 @@ class __PRIVATE_WatchChangeAggregator {
                 // remove any target changes.
                 // We need to decrement the number of pending acks needed from watch
                 // for this targetId.
-                n.ke(), n.Ce || this.removeTarget(t);
+                n.Le(), n.ve || this.removeTarget(t);
                 break;
 
               case 3 /* WatchTargetChangeState.Current */ :
-                this.Ye(t) && (n.qe(), n.Me(e.resumeToken));
+                this.Je(t) && (n.ke(), n.Fe(e.resumeToken));
                 break;
 
               case 4 /* WatchTargetChangeState.Reset */ :
-                this.Ye(t) && (
+                this.Je(t) && (
                 // Reset the target and synthesizes removes for all existing
                 // documents. The backend will re-add any documents that still
                 // match the target before it sends the next global snapshot.
-                this.Ze(t), n.Me(e.resumeToken));
+                this.Ye(t), n.Fe(e.resumeToken));
                 break;
 
               default:
@@ -6273,55 +6273,55 @@ class __PRIVATE_WatchChangeAggregator {
      * targetIds explicitly listed in the change or the targetIds of all currently
      * active targets.
      */    forEachTarget(e, t) {
-        e.targetIds.length > 0 ? e.targetIds.forEach(t) : this.Ke.forEach(((e, n) => {
-            this.Ye(n) && t(n);
+        e.targetIds.length > 0 ? e.targetIds.forEach(t) : this.Qe.forEach(((e, n) => {
+            this.Je(n) && t(n);
         }));
     }
     /**
      * Handles existence filters and synthesizes deletes for filter mismatches.
      * Targets that are invalidated by filter mismatches are added to
      * `pendingTargetResets`.
-     */    Xe(e) {
-        var t;
-        const n = e.targetId, r = e.ye.count, i = this.et(n);
-        if (i) {
-            const s = i.target;
-            if (__PRIVATE_targetIsDocumentTarget(s)) if (0 === r) {
+     */    Ze(e) {
+        var t, n;
+        const r = e.targetId, i = e.pe.count, s = this.Xe(r);
+        if (s) {
+            const o = s.target;
+            if (__PRIVATE_targetIsDocumentTarget(o)) if (0 === i) {
                 // The existence filter told us the document does not exist. We deduce
                 // that this document does not exist and apply a deleted document to
                 // our updates. Without applying this deleted document there might be
                 // another query that will raise this document as part of a snapshot
                 // until it is resolved, essentially exposing inconsistency between
                 // queries.
-                const e = new DocumentKey(s.path);
-                this.je(n, e, MutableDocument.newNoDocument(e, SnapshotVersion.min()));
-            } else __PRIVATE_hardAssert(1 === r); else {
-                const i = this.tt(n);
+                const e = new DocumentKey(o.path);
+                this.ze(r, e, MutableDocument.newNoDocument(e, SnapshotVersion.min()));
+            } else __PRIVATE_hardAssert(1 === i); else {
+                const s = this.et(r);
                 // Existence filter mismatch. Mark the documents as being in limbo, and
                 // raise a snapshot with `isFromCache:true`.
-                                if (i !== r) {
+                                if (s !== i) {
                     // Apply bloom filter to identify and mark removed documents.
-                    const r = this.nt(e, i);
-                    if (0 /* BloomFilterApplicationStatus.Success */ !== r) {
+                    const i = this.tt(e, s);
+                    if (0 /* BloomFilterApplicationStatus.Success */ !== i.status) {
                         // If bloom filter application fails, we reset the mapping and
                         // trigger re-run of the query.
-                        this.Ze(n);
-                        const e = 2 /* BloomFilterApplicationStatus.FalsePositive */ === r ? "TargetPurposeExistenceFilterMismatchBloom" /* TargetPurpose.ExistenceFilterMismatchBloom */ : "TargetPurposeExistenceFilterMismatch" /* TargetPurpose.ExistenceFilterMismatch */;
-                        this.We = this.We.insert(n, e);
+                        this.Ye(r);
+                        const e = 2 /* BloomFilterApplicationStatus.FalsePositive */ === i.status ? "TargetPurposeExistenceFilterMismatchBloom" /* TargetPurpose.ExistenceFilterMismatchBloom */ : "TargetPurposeExistenceFilterMismatch" /* TargetPurpose.ExistenceFilterMismatch */;
+                        this.Ue = this.Ue.insert(r, e);
                     }
-                    null === (t = __PRIVATE_TestingHooks.instance) || void 0 === t || t.notifyOnExistenceFilterMismatch(function __PRIVATE_createExistenceFilterMismatchInfoForTestingHooks(e, t, n) {
-                        var r, i, s, o, _, a;
-                        const u = {
-                            localCacheCount: t,
-                            existenceFilterCount: n.count
-                        }, c = n.unchangedNames;
-                        c && (u.bloomFilter = {
+                    null === (t = __PRIVATE_TestingHooks.instance) || void 0 === t || t.notifyOnExistenceFilterMismatch(function __PRIVATE_createExistenceFilterMismatchInfoForTestingHooks(e, t, n, r) {
+                        var i, s, o, _, a, u;
+                        const c = {
+                            localCacheCount: n,
+                            existenceFilterCount: r.count
+                        }, l = r.unchangedNames;
+                        l && (c.bloomFilter = {
                             applied: 0 /* BloomFilterApplicationStatus.Success */ === e,
-                            hashCount: null !== (r = null == c ? void 0 : c.hashCount) && void 0 !== r ? r : 0,
-                            bitmapLength: null !== (o = null === (s = null === (i = null == c ? void 0 : c.bits) || void 0 === i ? void 0 : i.bitmap) || void 0 === s ? void 0 : s.length) && void 0 !== o ? o : 0,
-                            padding: null !== (a = null === (_ = null == c ? void 0 : c.bits) || void 0 === _ ? void 0 : _.padding) && void 0 !== a ? a : 0
-                        });
-                        return u;
+                            hashCount: null !== (i = null == l ? void 0 : l.hashCount) && void 0 !== i ? i : 0,
+                            bitmapLength: null !== (_ = null === (o = null === (s = null == l ? void 0 : l.bits) || void 0 === s ? void 0 : s.bitmap) || void 0 === o ? void 0 : o.length) && void 0 !== _ ? _ : 0,
+                            padding: null !== (u = null === (a = null == l ? void 0 : l.bits) || void 0 === a ? void 0 : a.padding) && void 0 !== u ? u : 0
+                        }, t && (c.bloomFilter.mightContain = t));
+                        return c;
                     }
                     /**
  * @license
@@ -6338,7 +6338,7 @@ class __PRIVATE_WatchChangeAggregator {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ (r, i, e.ye));
+ */ (i.status, null !== (n = i.nt) && void 0 !== n ? n : null, s, e.pe));
                 }
             }
         }
@@ -6346,16 +6346,20 @@ class __PRIVATE_WatchChangeAggregator {
     /**
      * Apply bloom filter to remove the deleted documents, and return the
      * application status.
-     */    nt(e, t) {
-        const {unchangedNames: n, count: r} = e.ye;
-        if (!n || !n.bits) return 1 /* BloomFilterApplicationStatus.Skipped */;
+     */    tt(e, t) {
+        const {unchangedNames: n, count: r} = e.pe;
+        if (!n || !n.bits) return {
+            status: 1
+ /* BloomFilterApplicationStatus.Skipped */        };
         const {bits: {bitmap: i = "", padding: s = 0}, hashCount: o = 0} = n;
         let _, a;
         try {
             _ = __PRIVATE_normalizeByteString(i).toUint8Array();
         } catch (e) {
             if (e instanceof __PRIVATE_Base64DecodeError) return __PRIVATE_logWarn("Decoding the base64 bloom filter in existence filter failed (" + e.message + "); ignoring the bloom filter and falling back to full re-query."), 
-            1 /* BloomFilterApplicationStatus.Skipped */;
+            {
+                status: 1
+ /* BloomFilterApplicationStatus.Skipped */            };
             throw e;
         }
         try {
@@ -6363,20 +6367,30 @@ class __PRIVATE_WatchChangeAggregator {
             a = new BloomFilter(_, s, o);
         } catch (e) {
             return __PRIVATE_logWarn(e instanceof __PRIVATE_BloomFilterError ? "BloomFilter error: " : "Applying bloom filter failed: ", e), 
-            1 /* BloomFilterApplicationStatus.Skipped */;
+            {
+                status: 1
+ /* BloomFilterApplicationStatus.Skipped */            };
         }
-        if (0 === a.de) return 1 /* BloomFilterApplicationStatus.Skipped */;
-        return r !== t - this.rt(e.targetId, a) ? 2 /* BloomFilterApplicationStatus.FalsePositive */ : 0 /* BloomFilterApplicationStatus.Success */;
+        const __PRIVATE_bloomFilterMightContain = e => {
+            const t = this.qe.rt();
+            return a.mightContain(`projects/${t.projectId}/databases/${t.database}/documents/${e}`);
+        };
+        if (0 === a.de) return {
+            status: 1
+ /* BloomFilterApplicationStatus.Skipped */        };
+        return {
+            status: r === t - this.it(e.targetId, __PRIVATE_bloomFilterMightContain) ? 0 /* BloomFilterApplicationStatus.Success */ : 2 /* BloomFilterApplicationStatus.FalsePositive */ ,
+            nt: __PRIVATE_bloomFilterMightContain
+        };
     }
     /**
      * Filter out removed documents based on bloom filter membership result and
      * return number of documents removed.
-     */    rt(e, t) {
-        const n = this.Qe.getRemoteKeysForTarget(e);
+     */    it(e, t) {
+        const n = this.qe.getRemoteKeysForTarget(e);
         let r = 0;
         return n.forEach((n => {
-            const i = this.Qe.it(), s = `projects/${i.projectId}/databases/${i.database}/documents/${n.path.canonicalString()}`;
-            t.me(s) || (this.je(e, n, /*updatedDocument=*/ null), r++);
+            t(n.path.canonicalString()) || (this.ze(e, n, /*updatedDocument=*/ null), r++);
         })), r;
     }
     /**
@@ -6384,8 +6398,8 @@ class __PRIVATE_WatchChangeAggregator {
      * provided snapshot version. Resets the accumulated changes before returning.
      */    st(e) {
         const t = new Map;
-        this.Ke.forEach(((n, r) => {
-            const i = this.et(r);
+        this.Qe.forEach(((n, r) => {
+            const i = this.Xe(r);
             if (i) {
                 if (n.current && __PRIVATE_targetIsDocumentTarget(i.target)) {
                     // Document queries for document that don't exist can produce an empty
@@ -6397,9 +6411,9 @@ class __PRIVATE_WatchChangeAggregator {
                     // instead resulting in an explicit delete message and we could
                     // remove this special logic.
                     const t = new DocumentKey(i.target.path);
-                    null !== this.$e.get(t) || this.ot(r, t) || this.je(r, t, MutableDocument.newNoDocument(t, e));
+                    null !== this.Ke.get(t) || this.ot(r, t) || this.ze(r, t, MutableDocument.newNoDocument(t, e));
                 }
-                n.Fe && (t.set(r, n.xe()), n.Oe());
+                n.Ce && (t.set(r, n.Me()), n.xe());
             }
         }));
         let n = __PRIVATE_documentKeySet();
@@ -6408,27 +6422,27 @@ class __PRIVATE_WatchChangeAggregator {
         
         // TODO(gsoltis): Expand on this comment once GC is available in the JS
         // client.
-                this.Ue.forEach(((e, t) => {
+                this.$e.forEach(((e, t) => {
             let r = !0;
             t.forEachWhile((e => {
-                const t = this.et(e);
+                const t = this.Xe(e);
                 return !t || "TargetPurposeLimboResolution" /* TargetPurpose.LimboResolution */ === t.purpose || (r = !1, 
                 !1);
             })), r && (n = n.add(e));
-        })), this.$e.forEach(((t, n) => n.setReadTime(e)));
-        const r = new RemoteEvent(e, t, this.We, this.$e, n);
-        return this.$e = __PRIVATE_mutableDocumentMap(), this.Ue = __PRIVATE_documentTargetMap(), 
-        this.We = new SortedMap(__PRIVATE_primitiveComparator), r;
+        })), this.Ke.forEach(((t, n) => n.setReadTime(e)));
+        const r = new RemoteEvent(e, t, this.Ue, this.Ke, n);
+        return this.Ke = __PRIVATE_mutableDocumentMap(), this.$e = __PRIVATE_documentTargetMap(), 
+        this.Ue = new SortedMap(__PRIVATE_primitiveComparator), r;
     }
     /**
      * Adds the provided document to the internal list of document updates and
      * its document key to the given target's mapping.
      */
     // Visible for testing.
-    ze(e, t) {
-        if (!this.Ye(e)) return;
+    Ge(e, t) {
+        if (!this.Je(e)) return;
         const n = this.ot(e, t.key) ? 2 /* ChangeType.Modified */ : 0 /* ChangeType.Added */;
-        this.Je(e).Ne(t.key, n), this.$e = this.$e.insert(t.key, t), this.Ue = this.Ue.insert(t.key, this._t(t.key).add(e));
+        this.He(e).Oe(t.key, n), this.Ke = this.Ke.insert(t.key, t), this.$e = this.$e.insert(t.key, this._t(t.key).add(e));
     }
     /**
      * Removes the provided document from the target mapping. If the
@@ -6438,71 +6452,71 @@ class __PRIVATE_WatchChangeAggregator {
      * to update the remote document cache.
      */
     // Visible for testing.
-    je(e, t, n) {
-        if (!this.Ye(e)) return;
-        const r = this.Je(e);
-        this.ot(e, t) ? r.Ne(t, 1 /* ChangeType.Removed */) : 
+    ze(e, t, n) {
+        if (!this.Je(e)) return;
+        const r = this.He(e);
+        this.ot(e, t) ? r.Oe(t, 1 /* ChangeType.Removed */) : 
         // The document may have entered and left the target before we raised a
         // snapshot, so we can just ignore the change.
-        r.Be(t), this.Ue = this.Ue.insert(t, this._t(t).delete(e)), n && (this.$e = this.$e.insert(t, n));
+        r.Ne(t), this.$e = this.$e.insert(t, this._t(t).delete(e)), n && (this.Ke = this.Ke.insert(t, n));
     }
     removeTarget(e) {
-        this.Ke.delete(e);
+        this.Qe.delete(e);
     }
     /**
      * Returns the current count of documents in the target. This includes both
      * the number of documents that the LocalStore considers to be part of the
      * target as well as any accumulated changes.
-     */    tt(e) {
-        const t = this.Je(e).xe();
-        return this.Qe.getRemoteKeysForTarget(e).size + t.addedDocuments.size - t.removedDocuments.size;
+     */    et(e) {
+        const t = this.He(e).Me();
+        return this.qe.getRemoteKeysForTarget(e).size + t.addedDocuments.size - t.removedDocuments.size;
     }
     /**
      * Increment the number of acks needed from watch before we can consider the
      * server to be 'in-sync' with the client's active targets.
-     */    Le(e) {
-        this.Je(e).Le();
+     */    Be(e) {
+        this.He(e).Be();
     }
-    Je(e) {
-        let t = this.Ke.get(e);
-        return t || (t = new __PRIVATE_TargetState, this.Ke.set(e, t)), t;
+    He(e) {
+        let t = this.Qe.get(e);
+        return t || (t = new __PRIVATE_TargetState, this.Qe.set(e, t)), t;
     }
     _t(e) {
-        let t = this.Ue.get(e);
-        return t || (t = new SortedSet(__PRIVATE_primitiveComparator), this.Ue = this.Ue.insert(e, t)), 
+        let t = this.$e.get(e);
+        return t || (t = new SortedSet(__PRIVATE_primitiveComparator), this.$e = this.$e.insert(e, t)), 
         t;
     }
     /**
      * Verifies that the user is still interested in this target (by calling
      * `getTargetDataForTarget()`) and that we are not waiting for pending ADDs
      * from watch.
-     */    Ye(e) {
-        const t = null !== this.et(e);
+     */    Je(e) {
+        const t = null !== this.Xe(e);
         return t || __PRIVATE_logDebug("WatchChangeAggregator", "Detected inactive target", e), 
         t;
     }
     /**
      * Returns the TargetData for an active target (i.e. a target that the user
      * is still interested in that has no outstanding target change requests).
-     */    et(e) {
-        const t = this.Ke.get(e);
-        return t && t.Ce ? null : this.Qe.ut(e);
+     */    Xe(e) {
+        const t = this.Qe.get(e);
+        return t && t.ve ? null : this.qe.ut(e);
     }
     /**
      * Resets the state of a Watch target to its initial state (e.g. sets
      * 'current' to false, clears the resume token and removes its target mapping
      * from all documents).
-     */    Ze(e) {
-        this.Ke.set(e, new __PRIVATE_TargetState);
-        this.Qe.getRemoteKeysForTarget(e).forEach((t => {
-            this.je(e, t, /*updatedDocument=*/ null);
+     */    Ye(e) {
+        this.Qe.set(e, new __PRIVATE_TargetState);
+        this.qe.getRemoteKeysForTarget(e).forEach((t => {
+            this.ze(e, t, /*updatedDocument=*/ null);
         }));
     }
     /**
      * Returns whether the LocalStore considers the document to be part of the
      * specified target.
      */    ot(e, t) {
-        return this.Qe.getRemoteKeysForTarget(e).has(t);
+        return this.qe.getRemoteKeysForTarget(e).has(t);
     }
 }
 
@@ -14563,7 +14577,7 @@ function __PRIVATE_remoteStoreListen(e, t) {
  * We need to increment the the expected number of pending responses we're due
  * from watch so we wait for the ack to process any messages from this target.
  */ function __PRIVATE_sendWatchRequest(e, t) {
-    if (e.b_.Le(t.targetId), t.resumeToken.approximateByteSize() > 0 || t.snapshotVersion.compareTo(SnapshotVersion.min()) > 0) {
+    if (e.b_.Be(t.targetId), t.resumeToken.approximateByteSize() > 0 || t.snapshotVersion.compareTo(SnapshotVersion.min()) > 0) {
         const n = e.remoteSyncer.getRemoteKeysForTarget(t.targetId).size;
         t = t.withExpectedCount(n);
     }
@@ -14575,14 +14589,14 @@ function __PRIVATE_remoteStoreListen(e, t) {
  * from watch so we wait for the removal on the server before we process any
  * messages from this target.
  */ function __PRIVATE_sendUnwatchRequest(e, t) {
-    e.b_.Le(t), __PRIVATE_ensureWatchStream(e).i_(t);
+    e.b_.Be(t), __PRIVATE_ensureWatchStream(e).i_(t);
 }
 
 function __PRIVATE_startWatchStream(e) {
     e.b_ = new __PRIVATE_WatchChangeAggregator({
         getRemoteKeysForTarget: t => e.remoteSyncer.getRemoteKeysForTarget(t),
         ut: t => e.g_.get(t) || null,
-        it: () => e.datastore.serializer.databaseId
+        rt: () => e.datastore.serializer.databaseId
     }), __PRIVATE_ensureWatchStream(e).start(), e.S_.d_();
 }
 
@@ -14643,7 +14657,7 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
     } catch (n) {
         __PRIVATE_logDebug("RemoteStore", "Failed to remove targets %s: %s ", t.targetIds.join(","), n), 
         await __PRIVATE_disableNetworkUntilRecovery(e, n);
-    } else if (t instanceof __PRIVATE_DocumentWatchChange ? e.b_.Ge(t) : t instanceof __PRIVATE_ExistenceFilterChange ? e.b_.Xe(t) : e.b_.He(t), 
+    } else if (t instanceof __PRIVATE_DocumentWatchChange ? e.b_.We(t) : t instanceof __PRIVATE_ExistenceFilterChange ? e.b_.Ze(t) : e.b_.je(t), 
     !n.isEqual(SnapshotVersion.min())) try {
         const t = await __PRIVATE_localStoreGetLastRemoteSnapshotVersion(e.localStore);
         n.compareTo(t) >= 0 && 
@@ -21537,9 +21551,9 @@ function __PRIVATE_tryGetString(e, t) {
         return r = Object.assign({
             useFetchStreams: t
         }, r), s._setSettings(r), s;
-    }), "PUBLIC").setMultipleInstances(!0)), app.registerVersion(S, "3.13.0-canary.684bb4e45", e), 
+    }), "PUBLIC").setMultipleInstances(!0)), app.registerVersion(S, "3.13.0-canary.794441e73", e), 
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    app.registerVersion(S, "3.13.0-canary.684bb4e45", "cjs2017");
+    app.registerVersion(S, "3.13.0-canary.794441e73", "cjs2017");
 }();
 
 exports.AbstractUserDataWriter = AbstractUserDataWriter;