@firebase/firestore 4.6.0-canary.84f9ff008 → 4.6.0-canary.b74d8a211

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 S = "10.11.0-canary.84f9ff008";
+let S = "10.11.0-canary.b74d8a211";
 
 /**
  * @license
@@ -13600,8 +13600,11 @@ class __PRIVATE_StreamBridge {
     Io(e) {
         this.To = e;
     }
+    Eo(e) {
+        this.Ao = e;
+    }
     onMessage(e) {
-        this.Eo = e;
+        this.Ro = e;
     }
     close() {
         this.lo();
@@ -13609,14 +13612,17 @@ class __PRIVATE_StreamBridge {
     send(e) {
         this.co(e);
     }
-    Ao() {
+    Vo() {
         this.Po();
     }
-    Ro(e) {
-        this.To(e);
+    mo() {
+        this.To();
+    }
+    fo(e) {
+        this.Ao(e);
     }
-    Vo(e) {
-        this.Eo(e);
+    po(e) {
+        this.Ro(e);
     }
 }
 
@@ -13646,35 +13652,35 @@ class __PRIVATE_RestConnection {
     constructor(e) {
         this.databaseInfo = e, this.databaseId = e.databaseId;
         const t = e.ssl ? "https" : "http", n = encodeURIComponent(this.databaseId.projectId), r = encodeURIComponent(this.databaseId.database);
-        this.mo = t + "://" + e.host, this.fo = `projects/${n}/databases/${r}`, this.po = "(default)" === this.databaseId.database ? `project_id=${n}` : `project_id=${n}&database_id=${r}`;
+        this.yo = t + "://" + e.host, this.wo = `projects/${n}/databases/${r}`, this.So = "(default)" === this.databaseId.database ? `project_id=${n}` : `project_id=${n}&database_id=${r}`;
     }
-    get yo() {
+    get bo() {
         // Both `invokeRPC()` and `invokeStreamingRPC()` use their `path` arguments to determine
         // where to run the query, and expect the `request` to NOT specify the "path".
         return !1;
     }
-    wo(e, t, n, r, i) {
-        const s = __PRIVATE_generateUniqueDebugId(), o = this.So(e, t.toUriEncodedString());
+    Do(e, t, n, r, i) {
+        const s = __PRIVATE_generateUniqueDebugId(), o = this.Co(e, t.toUriEncodedString());
         __PRIVATE_logDebug("RestConnection", `Sending RPC '${e}' ${s}:`, o, n);
         const _ = {
-            "google-cloud-resource-prefix": this.fo,
-            "x-goog-request-params": this.po
+            "google-cloud-resource-prefix": this.wo,
+            "x-goog-request-params": this.So
         };
-        return this.bo(_, r, i), this.Do(e, o, _, n).then((t => (__PRIVATE_logDebug("RestConnection", `Received RPC '${e}' ${s}: `, t), 
+        return this.vo(_, r, i), this.Fo(e, o, _, n).then((t => (__PRIVATE_logDebug("RestConnection", `Received RPC '${e}' ${s}: `, t), 
         t)), (t => {
             throw __PRIVATE_logWarn("RestConnection", `RPC '${e}' ${s} failed with error: `, t, "url: ", o, "request:", n), 
             t;
         }));
     }
-    Co(e, t, n, r, i, s) {
+    Mo(e, t, n, r, i, s) {
         // The REST API automatically aggregates all of the streamed results, so we
         // can just use the normal invoke() method.
-        return this.wo(e, t, n, r, i);
+        return this.Do(e, t, n, r, i);
     }
     /**
      * Modifies the headers for a request, adding any authorization token if
      * present and any additional headers for the request.
-     */    bo(e, t, n) {
+     */    vo(e, t, n) {
         e["X-Goog-Api-Client"] = 
         // SDK_VERSION is updated to different value at runtime depending on the entry point,
         // so we need to get its value when we need it in a function.
@@ -13688,9 +13694,9 @@ class __PRIVATE_RestConnection {
         e["Content-Type"] = "text/plain", this.databaseInfo.appId && (e["X-Firebase-GMPID"] = this.databaseInfo.appId), 
         t && t.headers.forEach(((t, n) => e[n] = t)), n && n.headers.forEach(((t, n) => e[n] = t));
     }
-    So(e, t) {
+    Co(e, t) {
         const n = Ve[e];
-        return `${this.mo}/v1/${t}:${n}`;
+        return `${this.yo}/v1/${t}:${n}`;
     }
     /**
      * Closes and cleans up any resources associated with the connection. This
@@ -13704,7 +13710,7 @@ class __PRIVATE_RestConnection {
         super(e), this.forceLongPolling = e.forceLongPolling, this.autoDetectLongPolling = e.autoDetectLongPolling, 
         this.useFetchStreams = e.useFetchStreams, this.longPollingOptions = e.longPollingOptions;
     }
-    Do(e, t, n, r) {
+    Fo(e, t, n, r) {
         const i = __PRIVATE_generateUniqueDebugId();
         return new Promise(((s, o) => {
             const _ = new webchannelWrapper.XhrIo;
@@ -13752,8 +13758,8 @@ class __PRIVATE_RestConnection {
             __PRIVATE_logDebug(me, `RPC '${e}' ${i} sending request:`, r), _.send(t, "POST", a, n, 15);
         }));
     }
-    vo(e, t, n) {
-        const r = __PRIVATE_generateUniqueDebugId(), i = [ this.mo, "/", "google.firestore.v1.Firestore", "/", e, "/channel" ], s = webchannelWrapper.createWebChannelTransport(), o = webchannelWrapper.getStatEventTarget(), _ = {
+    xo(e, t, n) {
+        const r = __PRIVATE_generateUniqueDebugId(), i = [ this.yo, "/", "google.firestore.v1.Firestore", "/", e, "/channel" ], s = webchannelWrapper.createWebChannelTransport(), o = webchannelWrapper.getStatEventTarget(), _ = {
             // Required for backend stickiness, routing behavior is based on this
             // parameter.
             httpSessionIdParam: "gsessionid",
@@ -13778,7 +13784,7 @@ class __PRIVATE_RestConnection {
             detectBufferingProxy: this.autoDetectLongPolling
         }, a = this.longPollingOptions.timeoutSeconds;
         void 0 !== a && (_.longPollingTimeout = Math.round(1e3 * a)), this.useFetchStreams && (_.useFetchStreams = !0), 
-        this.bo(_.initMessageHeaders, t, n), 
+        this.vo(_.initMessageHeaders, t, n), 
         // Sending the custom headers we just added to request.initMessageHeaders
         // (Authorization, etc.) will trigger the browser to make a CORS preflight
         // request because the XHR will no longer meet the criteria for a "simple"
@@ -13826,13 +13832,13 @@ class __PRIVATE_RestConnection {
         // Note that eventually this function could go away if we are confident
         // enough the code is exception free.
                 return __PRIVATE_unguardedEventListen(c, webchannelWrapper.WebChannel.EventType.OPEN, (() => {
-            h || __PRIVATE_logDebug(me, `RPC '${e}' stream ${r} transport opened.`);
+            h || (__PRIVATE_logDebug(me, `RPC '${e}' stream ${r} transport opened.`), P.Vo());
         })), __PRIVATE_unguardedEventListen(c, webchannelWrapper.WebChannel.EventType.CLOSE, (() => {
             h || (h = !0, __PRIVATE_logDebug(me, `RPC '${e}' stream ${r} transport closed`), 
-            P.Ro());
+            P.fo());
         })), __PRIVATE_unguardedEventListen(c, webchannelWrapper.WebChannel.EventType.ERROR, (t => {
             h || (h = !0, __PRIVATE_logWarn(me, `RPC '${e}' stream ${r} transport errored:`, t), 
-            P.Ro(new FirestoreError(D.UNAVAILABLE, "The operation could not be completed")));
+            P.fo(new FirestoreError(D.UNAVAILABLE, "The operation could not be completed")));
         })), __PRIVATE_unguardedEventListen(c, webchannelWrapper.WebChannel.EventType.MESSAGE, (t => {
             var n;
             if (!h) {
@@ -13863,8 +13869,8 @@ class __PRIVATE_RestConnection {
                     }(t), i = o.message;
                     void 0 === n && (n = D.INTERNAL, i = "Unknown error status: " + t + " with message " + o.message), 
                     // Mark closed so no further events are propagated
-                    h = !0, P.Ro(new FirestoreError(n, i)), c.close();
-                } else __PRIVATE_logDebug(me, `RPC '${e}' stream ${r} received:`, i), P.Vo(i);
+                    h = !0, P.fo(new FirestoreError(n, i)), c.close();
+                } else __PRIVATE_logDebug(me, `RPC '${e}' stream ${r} received:`, i), P.po(i);
             }
         })), __PRIVATE_unguardedEventListen(o, webchannelWrapper.Event.STAT_EVENT, (t => {
             t.stat === webchannelWrapper.Stat.PROXY ? __PRIVATE_logDebug(me, `RPC '${e}' stream ${r} detected buffering proxy`) : t.stat === webchannelWrapper.Stat.NOPROXY && __PRIVATE_logDebug(me, `RPC '${e}' stream ${r} detected no buffering proxy`);
@@ -13873,7 +13879,7 @@ class __PRIVATE_RestConnection {
             // but because we want to send the first message with the WebChannel
             // handshake we pretend the channel opened here (asynchronously), and
             // then delay the actual open until the first message is sent.
-            P.Ao();
+            P.mo();
         }), 0), P;
     }
 }
@@ -13993,10 +13999,10 @@ class __PRIVATE_ExponentialBackoff {
      * Note that jitter will still be applied, so the actual delay could be as
      * much as 1.5*maxDelayMs.
      */ , i = 6e4) {
-        this.si = e, this.timerId = t, this.Fo = n, this.Mo = r, this.xo = i, this.Oo = 0, 
-        this.No = null, 
+        this.si = e, this.timerId = t, this.Oo = n, this.No = r, this.Lo = i, this.Bo = 0, 
+        this.ko = null, 
         /** The last backoff attempt, as epoch milliseconds. */
-        this.Lo = Date.now(), this.reset();
+        this.qo = Date.now(), this.reset();
     }
     /**
      * Resets the backoff delay.
@@ -14005,40 +14011,40 @@ class __PRIVATE_ExponentialBackoff {
      * (i.e. due to an error), initialDelayMs (plus jitter) will be used, and
      * subsequent ones will increase according to the backoffFactor.
      */    reset() {
-        this.Oo = 0;
+        this.Bo = 0;
     }
     /**
      * Resets the backoff delay to the maximum delay (e.g. for use after a
      * RESOURCE_EXHAUSTED error).
-     */    Bo() {
-        this.Oo = this.xo;
+     */    Qo() {
+        this.Bo = this.Lo;
     }
     /**
      * Returns a promise that resolves after currentDelayMs, and increases the
      * delay for any subsequent attempts. If there was a pending backoff operation
      * already, it will be canceled.
-     */    ko(e) {
+     */    Ko(e) {
         // Cancel any pending backoff operation.
         this.cancel();
         // First schedule using the current base (which may be 0 and should be
         // honored as such).
-        const t = Math.floor(this.Oo + this.qo()), n = Math.max(0, Date.now() - this.Lo), r = Math.max(0, t - n);
+        const t = Math.floor(this.Bo + this.$o()), n = Math.max(0, Date.now() - this.qo), r = Math.max(0, t - n);
         // Guard against lastAttemptTime being in the future due to a clock change.
-                r > 0 && __PRIVATE_logDebug("ExponentialBackoff", `Backing off for ${r} ms (base delay: ${this.Oo} ms, delay with jitter: ${t} ms, last attempt: ${n} ms ago)`), 
-        this.No = this.si.enqueueAfterDelay(this.timerId, r, (() => (this.Lo = Date.now(), 
+                r > 0 && __PRIVATE_logDebug("ExponentialBackoff", `Backing off for ${r} ms (base delay: ${this.Bo} ms, delay with jitter: ${t} ms, last attempt: ${n} ms ago)`), 
+        this.ko = this.si.enqueueAfterDelay(this.timerId, r, (() => (this.qo = Date.now(), 
         e()))), 
         // Apply backoff factor to determine next delay and ensure it is within
         // bounds.
-        this.Oo *= this.Mo, this.Oo < this.Fo && (this.Oo = this.Fo), this.Oo > this.xo && (this.Oo = this.xo);
+        this.Bo *= this.No, this.Bo < this.Oo && (this.Bo = this.Oo), this.Bo > this.Lo && (this.Bo = this.Lo);
     }
-    Qo() {
-        null !== this.No && (this.No.skipDelay(), this.No = null);
+    Uo() {
+        null !== this.ko && (this.ko.skipDelay(), this.ko = null);
     }
     cancel() {
-        null !== this.No && (this.No.cancel(), this.No = null);
+        null !== this.ko && (this.ko.cancel(), this.ko = null);
     }
-    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */    qo() {
-        return (Math.random() - .5) * this.Oo;
+    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */    $o() {
+        return (Math.random() - .5) * this.Bo;
     }
 }
 
@@ -14092,14 +14098,14 @@ class __PRIVATE_ExponentialBackoff {
  */
 class __PRIVATE_PersistentStream {
     constructor(e, t, n, r, i, s, o, _) {
-        this.si = e, this.Ko = n, this.$o = r, this.connection = i, this.authCredentialsProvider = s, 
+        this.si = e, this.Wo = n, this.Go = r, this.connection = i, this.authCredentialsProvider = s, 
         this.appCheckCredentialsProvider = o, this.listener = _, this.state = 0 /* PersistentStreamState.Initial */ , 
         /**
          * A close count that's incremented every time the stream is closed; used by
          * getCloseGuardedDispatcher() to invalidate callbacks that happen after
          * close.
          */
-        this.Uo = 0, this.Wo = null, this.Go = null, this.stream = null, this.zo = new __PRIVATE_ExponentialBackoff(e, t);
+        this.zo = 0, this.jo = null, this.Ho = null, this.stream = null, this.Jo = new __PRIVATE_ExponentialBackoff(e, t);
     }
     /**
      * Returns true if start() has been called and no error has occurred. True
@@ -14107,13 +14113,13 @@ class __PRIVATE_PersistentStream {
      * encompasses respecting backoff, getting auth tokens, and starting the
      * actual RPC). Use isOpen() to determine if the stream is open and ready for
      * outbound requests.
-     */    jo() {
-        return 1 /* PersistentStreamState.Starting */ === this.state || 5 /* PersistentStreamState.Backoff */ === this.state || this.Ho();
+     */    Yo() {
+        return 1 /* PersistentStreamState.Starting */ === this.state || 5 /* PersistentStreamState.Backoff */ === this.state || this.Zo();
     }
     /**
      * Returns true if the underlying RPC is open (the onOpen() listener has been
      * called) and the stream is ready for outbound requests.
-     */    Ho() {
+     */    Zo() {
         return 2 /* PersistentStreamState.Open */ === this.state || 3 /* PersistentStreamState.Healthy */ === this.state;
     }
     /**
@@ -14123,7 +14129,7 @@ class __PRIVATE_PersistentStream {
      *
      * When start returns, isStarted() will return true.
      */    start() {
-        4 /* PersistentStreamState.Error */ !== this.state ? this.auth() : this.Jo();
+        4 /* PersistentStreamState.Error */ !== this.state ? this.auth() : this.Xo();
     }
     /**
      * Stops the RPC. This call is idempotent and allowed regardless of the
@@ -14131,7 +14137,7 @@ class __PRIVATE_PersistentStream {
      *
      * When stop returns, isStarted() and isOpen() will both return false.
      */    async stop() {
-        this.jo() && await this.close(0 /* PersistentStreamState.Initial */);
+        this.Yo() && await this.close(0 /* PersistentStreamState.Initial */);
     }
     /**
      * After an error the stream will usually back off on the next attempt to
@@ -14140,8 +14146,8 @@ class __PRIVATE_PersistentStream {
      *
      * Each error will call the onClose() listener. That function can decide to
      * inhibit backoff if required.
-     */    Yo() {
-        this.state = 0 /* PersistentStreamState.Initial */ , this.zo.reset();
+     */    e_() {
+        this.state = 0 /* PersistentStreamState.Initial */ , this.Jo.reset();
     }
     /**
      * Marks this stream as idle. If no further actions are performed on the
@@ -14152,25 +14158,25 @@ class __PRIVATE_PersistentStream {
      *
      * Only streams that are in state 'Open' can be marked idle, as all other
      * states imply pending network operations.
-     */    Zo() {
+     */    t_() {
         // Starts the idle time if we are in state 'Open' and are not yet already
         // running a timer (in which case the previous idle timeout still applies).
-        this.Ho() && null === this.Wo && (this.Wo = this.si.enqueueAfterDelay(this.Ko, 6e4, (() => this.Xo())));
+        this.Zo() && null === this.jo && (this.jo = this.si.enqueueAfterDelay(this.Wo, 6e4, (() => this.n_())));
     }
-    /** Sends a message to the underlying stream. */    e_(e) {
-        this.t_(), this.stream.send(e);
+    /** Sends a message to the underlying stream. */    r_(e) {
+        this.i_(), this.stream.send(e);
     }
-    /** Called by the idle timer when the stream should close due to inactivity. */    async Xo() {
-        if (this.Ho()) 
+    /** Called by the idle timer when the stream should close due to inactivity. */    async n_() {
+        if (this.Zo()) 
         // When timing out an idle stream there's no reason to force the stream into backoff when
         // it restarts so set the stream state to Initial instead of Error.
         return this.close(0 /* PersistentStreamState.Initial */);
     }
-    /** Marks the stream as active again. */    t_() {
-        this.Wo && (this.Wo.cancel(), this.Wo = null);
+    /** Marks the stream as active again. */    i_() {
+        this.jo && (this.jo.cancel(), this.jo = null);
     }
-    /** Cancels the health check delayed operation. */    n_() {
-        this.Go && (this.Go.cancel(), this.Go = null);
+    /** Cancels the health check delayed operation. */    s_() {
+        this.Ho && (this.Ho.cancel(), this.Ho = null);
     }
     /**
      * Closes the stream and cleans up as necessary:
@@ -14186,15 +14192,15 @@ class __PRIVATE_PersistentStream {
      * @param error - the error the connection was closed with.
      */    async close(e, t) {
         // Cancel any outstanding timers (they're guaranteed not to execute).
-        this.t_(), this.n_(), this.zo.cancel(), 
+        this.i_(), this.s_(), this.Jo.cancel(), 
         // Invalidates any stream-related callbacks (e.g. from auth or the
         // underlying stream), guaranteeing they won't execute.
-        this.Uo++, 4 /* PersistentStreamState.Error */ !== e ? 
+        this.zo++, 4 /* PersistentStreamState.Error */ !== e ? 
         // If this is an intentional close ensure we don't delay our next connection attempt.
-        this.zo.reset() : t && t.code === D.RESOURCE_EXHAUSTED ? (
+        this.Jo.reset() : t && t.code === D.RESOURCE_EXHAUSTED ? (
         // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)
         __PRIVATE_logError(t.toString()), __PRIVATE_logError("Using maximum backoff delay to prevent overloading the backend."), 
-        this.zo.Bo()) : t && t.code === D.UNAUTHENTICATED && 3 /* PersistentStreamState.Healthy */ !== this.state && (
+        this.Jo.Qo()) : t && t.code === D.UNAUTHENTICATED && 3 /* PersistentStreamState.Healthy */ !== this.state && (
         // "unauthenticated" error means the token was rejected. This should rarely
         // happen since both Auth and AppCheck ensure a sufficient TTL when we
         // request a token. If a user manually resets their system clock this can
@@ -14203,56 +14209,58 @@ class __PRIVATE_PersistentStream {
         // to ensure that we fetch a new token.
         this.authCredentialsProvider.invalidateToken(), this.appCheckCredentialsProvider.invalidateToken()), 
         // Clean up the underlying stream because we are no longer interested in events.
-        null !== this.stream && (this.r_(), this.stream.close(), this.stream = null), 
+        null !== this.stream && (this.o_(), this.stream.close(), this.stream = null), 
         // This state must be assigned before calling onClose() to allow the callback to
         // inhibit backoff or otherwise manipulate the state in its non-started state.
         this.state = e, 
         // Notify the listener that the stream closed.
-        await this.listener.Io(t);
+        await this.listener.Eo(t);
     }
     /**
      * Can be overridden to perform additional cleanup before the stream is closed.
      * Calling super.tearDown() is not required.
-     */    r_() {}
+     */    o_() {}
     auth() {
         this.state = 1 /* PersistentStreamState.Starting */;
-        const e = this.i_(this.Uo), t = this.Uo;
+        const e = this.__(this.zo), t = this.zo;
         // TODO(mikelehen): Just use dispatchIfNotClosed, but see TODO below.
                 Promise.all([ this.authCredentialsProvider.getToken(), this.appCheckCredentialsProvider.getToken() ]).then((([e, n]) => {
             // Stream can be stopped while waiting for authentication.
             // TODO(mikelehen): We really should just use dispatchIfNotClosed
             // and let this dispatch onto the queue, but that opened a spec test can
             // of worms that I don't want to deal with in this PR.
-            this.Uo === t && 
+            this.zo === t && 
             // Normally we'd have to schedule the callback on the AsyncQueue.
             // However, the following calls are safe to be called outside the
             // AsyncQueue since they don't chain asynchronous calls
-            this.s_(e, n);
+            this.a_(e, n);
         }), (t => {
             e((() => {
                 const e = new FirestoreError(D.UNKNOWN, "Fetching auth token failed: " + t.message);
-                return this.o_(e);
+                return this.u_(e);
             }));
         }));
     }
-    s_(e, t) {
-        const n = this.i_(this.Uo);
-        this.stream = this.__(e, t), this.stream.ho((() => {
-            n((() => (this.state = 2 /* PersistentStreamState.Open */ , this.Go = this.si.enqueueAfterDelay(this.$o, 1e4, (() => (this.Ho() && (this.state = 3 /* PersistentStreamState.Healthy */), 
-            Promise.resolve()))), this.listener.ho())));
-        })), this.stream.Io((e => {
-            n((() => this.o_(e)));
+    a_(e, t) {
+        const n = this.__(this.zo);
+        this.stream = this.c_(e, t), this.stream.ho((() => {
+            n((() => this.listener.ho()));
+        })), this.stream.Io((() => {
+            n((() => (this.state = 2 /* PersistentStreamState.Open */ , this.Ho = this.si.enqueueAfterDelay(this.Go, 1e4, (() => (this.Zo() && (this.state = 3 /* PersistentStreamState.Healthy */), 
+            Promise.resolve()))), this.listener.Io())));
+        })), this.stream.Eo((e => {
+            n((() => this.u_(e)));
         })), this.stream.onMessage((e => {
             n((() => this.onMessage(e)));
         }));
     }
-    Jo() {
-        this.state = 5 /* PersistentStreamState.Backoff */ , this.zo.ko((async () => {
+    Xo() {
+        this.state = 5 /* PersistentStreamState.Backoff */ , this.Jo.Ko((async () => {
             this.state = 0 /* PersistentStreamState.Initial */ , this.start();
         }));
     }
     // Visible for tests
-    o_(e) {
+    u_(e) {
         // In theory the stream could close cleanly, however, in our current model
         // we never expect this to happen because if we stop a stream ourselves,
         // this callback will never be called. To prevent cases where we retry
@@ -14265,9 +14273,9 @@ class __PRIVATE_PersistentStream {
      * AsyncQueue but only runs them if closeCount remains unchanged. This allows
      * us to turn auth / stream callbacks into no-ops if the stream is closed /
      * re-opened, etc.
-     */    i_(e) {
+     */    __(e) {
         return t => {
-            this.si.enqueueAndForget((() => this.Uo === e ? t() : (__PRIVATE_logDebug("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
+            this.si.enqueueAndForget((() => this.zo === e ? t() : (__PRIVATE_logDebug("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
             Promise.resolve())));
         };
     }
@@ -14284,12 +14292,12 @@ class __PRIVATE_PersistentStream {
         super(e, "listen_stream_connection_backoff" /* TimerId.ListenStreamConnectionBackoff */ , "listen_stream_idle" /* TimerId.ListenStreamIdle */ , "health_check_timeout" /* TimerId.HealthCheckTimeout */ , t, n, r, s), 
         this.serializer = i;
     }
-    __(e, t) {
-        return this.connection.vo("Listen", e, t);
+    c_(e, t) {
+        return this.connection.xo("Listen", e, t);
     }
     onMessage(e) {
         // A successful response means the stream is healthy
-        this.zo.reset();
+        this.Jo.reset();
         const t = __PRIVATE_fromWatchChange(this.serializer, e), n = function __PRIVATE_versionFromListenResponse(e) {
             // We have only reached a consistent snapshot for the entire stream if there
             // is a read_time set and it applies to all targets (i.e. the list of
@@ -14298,14 +14306,14 @@ class __PRIVATE_PersistentStream {
             const t = e.targetChange;
             return t.targetIds && t.targetIds.length ? SnapshotVersion.min() : t.readTime ? __PRIVATE_fromVersion(t.readTime) : SnapshotVersion.min();
         }(e);
-        return this.listener.a_(t, n);
+        return this.listener.l_(t, n);
     }
     /**
      * Registers interest in the results of the given target. If the target
      * includes a resumeToken it will be included in the request. Results that
      * affect the target will be streamed back as WatchChange messages that
      * reference the targetId.
-     */    u_(e) {
+     */    h_(e) {
         const t = {};
         t.database = __PRIVATE_getEncodedDatabaseId(this.serializer), t.addTarget = function __PRIVATE_toTarget(e, t) {
             let n;
@@ -14329,15 +14337,15 @@ class __PRIVATE_PersistentStream {
             return n;
         }(this.serializer, e);
         const n = __PRIVATE_toListenRequestLabels(this.serializer, e);
-        n && (t.labels = n), this.e_(t);
+        n && (t.labels = n), this.r_(t);
     }
     /**
      * Unregisters interest in the results of the target associated with the
      * given targetId.
-     */    c_(e) {
+     */    P_(e) {
         const t = {};
         t.database = __PRIVATE_getEncodedDatabaseId(this.serializer), t.removeTarget = e, 
-        this.e_(t);
+        this.r_(t);
     }
 }
 
@@ -14360,55 +14368,55 @@ class __PRIVATE_PersistentStream {
  */ class __PRIVATE_PersistentWriteStream extends __PRIVATE_PersistentStream {
     constructor(e, t, n, r, i, s) {
         super(e, "write_stream_connection_backoff" /* TimerId.WriteStreamConnectionBackoff */ , "write_stream_idle" /* TimerId.WriteStreamIdle */ , "health_check_timeout" /* TimerId.HealthCheckTimeout */ , t, n, r, s), 
-        this.serializer = i, this.l_ = !1;
+        this.serializer = i, this.I_ = !1;
     }
     /**
      * Tracks whether or not a handshake has been successfully exchanged and
      * the stream is ready to accept mutations.
-     */    get h_() {
-        return this.l_;
+     */    get T_() {
+        return this.I_;
     }
     // Override of PersistentStream.start
     start() {
-        this.l_ = !1, this.lastStreamToken = void 0, super.start();
+        this.I_ = !1, this.lastStreamToken = void 0, super.start();
     }
-    r_() {
-        this.l_ && this.P_([]);
+    o_() {
+        this.I_ && this.E_([]);
     }
-    __(e, t) {
-        return this.connection.vo("Write", e, t);
+    c_(e, t) {
+        return this.connection.xo("Write", e, t);
     }
     onMessage(e) {
         if (
         // Always capture the last stream token.
-        __PRIVATE_hardAssert(!!e.streamToken), this.lastStreamToken = e.streamToken, this.l_) {
+        __PRIVATE_hardAssert(!!e.streamToken), this.lastStreamToken = e.streamToken, this.I_) {
             // A successful first write response means the stream is healthy,
             // Note, that we could consider a successful handshake healthy, however,
             // the write itself might be causing an error we want to back off from.
-            this.zo.reset();
+            this.Jo.reset();
             const t = __PRIVATE_fromWriteResults(e.writeResults, e.commitTime), n = __PRIVATE_fromVersion(e.commitTime);
-            return this.listener.I_(n, t);
+            return this.listener.d_(n, t);
         }
         // The first response is always the handshake response
-        return __PRIVATE_hardAssert(!e.writeResults || 0 === e.writeResults.length), this.l_ = !0, 
-        this.listener.T_();
+        return __PRIVATE_hardAssert(!e.writeResults || 0 === e.writeResults.length), this.I_ = !0, 
+        this.listener.A_();
     }
     /**
      * Sends an initial streamToken to the server, performing the handshake
      * required to make the StreamingWrite RPC work. Subsequent
      * calls should wait until onHandshakeComplete was called.
-     */    E_() {
+     */    R_() {
         // TODO(dimond): Support stream resumption. We intentionally do not set the
         // stream token on the handshake, ignoring any stream token we might have.
         const e = {};
-        e.database = __PRIVATE_getEncodedDatabaseId(this.serializer), this.e_(e);
+        e.database = __PRIVATE_getEncodedDatabaseId(this.serializer), this.r_(e);
     }
-    /** Sends a group of mutations to the Firestore backend to apply. */    P_(e) {
+    /** Sends a group of mutations to the Firestore backend to apply. */    E_(e) {
         const t = {
             streamToken: this.lastStreamToken,
             writes: e.map((e => toMutation(this.serializer, e)))
         };
-        this.e_(t);
+        this.r_(t);
     }
 }
 
@@ -14440,25 +14448,25 @@ class __PRIVATE_PersistentStream {
 class __PRIVATE_DatastoreImpl extends class Datastore {} {
     constructor(e, t, n, r) {
         super(), this.authCredentials = e, this.appCheckCredentials = t, this.connection = n, 
-        this.serializer = r, this.d_ = !1;
+        this.serializer = r, this.V_ = !1;
     }
-    A_() {
-        if (this.d_) throw new FirestoreError(D.FAILED_PRECONDITION, "The client has already been terminated.");
+    m_() {
+        if (this.V_) throw new FirestoreError(D.FAILED_PRECONDITION, "The client has already been terminated.");
     }
-    /** Invokes the provided RPC with auth and AppCheck tokens. */    wo(e, t, n, r) {
-        return this.A_(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([i, s]) => this.connection.wo(e, __PRIVATE_toResourcePath(t, n), r, i, s))).catch((e => {
+    /** Invokes the provided RPC with auth and AppCheck tokens. */    Do(e, t, n, r) {
+        return this.m_(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([i, s]) => this.connection.Do(e, __PRIVATE_toResourcePath(t, n), r, i, s))).catch((e => {
             throw "FirebaseError" === e.name ? (e.code === D.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), e) : new FirestoreError(D.UNKNOWN, e.toString());
         }));
     }
-    /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */    Co(e, t, n, r, i) {
-        return this.A_(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, o]) => this.connection.Co(e, __PRIVATE_toResourcePath(t, n), r, s, o, i))).catch((e => {
+    /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */    Mo(e, t, n, r, i) {
+        return this.m_(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, o]) => this.connection.Mo(e, __PRIVATE_toResourcePath(t, n), r, s, o, i))).catch((e => {
             throw "FirebaseError" === e.name ? (e.code === D.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), e) : new FirestoreError(D.UNKNOWN, e.toString());
         }));
     }
     terminate() {
-        this.d_ = !0, this.connection.terminate();
+        this.V_ = !0, this.connection.terminate();
     }
 }
 
@@ -14466,7 +14474,7 @@ class __PRIVATE_DatastoreImpl extends class Datastore {} {
 // firestore-exp client.
 async function __PRIVATE_invokeRunAggregationQueryRpc(e, t, n) {
     var r;
-    const i = __PRIVATE_debugCast(e), {request: s, R_: o, parent: _} = function __PRIVATE_toRunAggregationQueryRequest(e, t, n) {
+    const i = __PRIVATE_debugCast(e), {request: s, f_: o, parent: _} = function __PRIVATE_toRunAggregationQueryRequest(e, t, n) {
         const {_t: r, parent: i} = __PRIVATE_toQueryTarget(e, t), s = {}, o = [];
         let _ = 0;
         return n.forEach((e => {
@@ -14496,7 +14504,7 @@ async function __PRIVATE_invokeRunAggregationQueryRpc(e, t, n) {
                 },
                 parent: r.parent
             },
-            R_: s,
+            f_: s,
             parent: i
         };
     }(i.serializer, function __PRIVATE_queryToAggregateTarget(e) {
@@ -14505,8 +14513,8 @@ async function __PRIVATE_invokeRunAggregationQueryRpc(e, t, n) {
         // Do not include implicit order-bys for aggregate queries.
         t.he = __PRIVATE__queryToTarget(t, e.explicitOrderBy)), t.he;
     }(t), n);
-    i.connection.yo || delete s.parent;
-    const a = (await i.Co("RunAggregationQuery", i.serializer.databaseId, _, s, 
+    i.connection.bo || delete s.parent;
+    const a = (await i.Mo("RunAggregationQuery", i.serializer.databaseId, _, s, 
     /*expectedResponseCount=*/ 1)).filter((e => !!e.result));
     // Omit RunAggregationQueryResponse that only contain readTimes.
         __PRIVATE_hardAssert(1 === a.length);
@@ -14538,19 +14546,19 @@ class __PRIVATE_OnlineStateTracker {
          * maximum defined by MAX_WATCH_STREAM_FAILURES, we'll set the OnlineState to
          * Offline.
          */
-        this.V_ = 0, 
+        this.g_ = 0, 
         /**
          * A timer that elapses after ONLINE_STATE_TIMEOUT_MS, at which point we
          * transition from OnlineState.Unknown to OnlineState.Offline without waiting
          * for the stream to actually fail (MAX_WATCH_STREAM_FAILURES times).
          */
-        this.m_ = null, 
+        this.p_ = null, 
         /**
          * Whether the client should log a warning message if it fails to connect to
          * the backend (initially true, cleared after a successful stream, or if we've
          * logged the message already).
          */
-        this.f_ = !0;
+        this.y_ = !0;
     }
     /**
      * Called by RemoteStore when a watch stream is started (including on each
@@ -14558,9 +14566,9 @@ class __PRIVATE_OnlineStateTracker {
      *
      * If this is the first attempt, it sets the OnlineState to Unknown and starts
      * the onlineStateTimer.
-     */    g_() {
-        0 === this.V_ && (this.p_("Unknown" /* OnlineState.Unknown */), this.m_ = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* TimerId.OnlineStateTimeout */ , 1e4, (() => (this.m_ = null, 
-        this.y_("Backend didn't respond within 10 seconds."), this.p_("Offline" /* OnlineState.Offline */), 
+     */    w_() {
+        0 === this.g_ && (this.S_("Unknown" /* OnlineState.Unknown */), this.p_ = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* TimerId.OnlineStateTimeout */ , 1e4, (() => (this.p_ = null, 
+        this.b_("Backend didn't respond within 10 seconds."), this.S_("Offline" /* OnlineState.Offline */), 
         Promise.resolve()))));
     }
     /**
@@ -14568,10 +14576,10 @@ class __PRIVATE_OnlineStateTracker {
      * failure. The first failure moves us to the 'Unknown' state. We then may
      * allow multiple failures (based on MAX_WATCH_STREAM_FAILURES) before we
      * actually transition to the 'Offline' state.
-     */    w_(e) {
-        "Online" /* OnlineState.Online */ === this.state ? this.p_("Unknown" /* OnlineState.Unknown */) : (this.V_++, 
-        this.V_ >= 1 && (this.S_(), this.y_(`Connection failed 1 times. Most recent error: ${e.toString()}`), 
-        this.p_("Offline" /* OnlineState.Offline */)));
+     */    D_(e) {
+        "Online" /* OnlineState.Online */ === this.state ? this.S_("Unknown" /* OnlineState.Unknown */) : (this.g_++, 
+        this.g_ >= 1 && (this.C_(), this.b_(`Connection failed 1 times. Most recent error: ${e.toString()}`), 
+        this.S_("Offline" /* OnlineState.Offline */)));
     }
     /**
      * Explicitly sets the OnlineState to the specified state.
@@ -14580,20 +14588,20 @@ class __PRIVATE_OnlineStateTracker {
      * Offline heuristics, so must not be used in place of
      * handleWatchStreamStart() and handleWatchStreamFailure().
      */    set(e) {
-        this.S_(), this.V_ = 0, "Online" /* OnlineState.Online */ === e && (
+        this.C_(), this.g_ = 0, "Online" /* OnlineState.Online */ === e && (
         // We've connected to watch at least once. Don't warn the developer
         // about being offline going forward.
-        this.f_ = !1), this.p_(e);
+        this.y_ = !1), this.S_(e);
     }
-    p_(e) {
+    S_(e) {
         e !== this.state && (this.state = e, this.onlineStateHandler(e));
     }
-    y_(e) {
+    b_(e) {
         const t = `Could not reach Cloud Firestore backend. ${e}\nThis typically indicates that your device does not have a healthy Internet connection at the moment. The client will operate in offline mode until it is able to successfully connect to the backend.`;
-        this.f_ ? (__PRIVATE_logError(t), this.f_ = !1) : __PRIVATE_logDebug("OnlineStateTracker", t);
+        this.y_ ? (__PRIVATE_logError(t), this.y_ = !1) : __PRIVATE_logDebug("OnlineStateTracker", t);
     }
-    S_() {
-        null !== this.m_ && (this.m_.cancel(), this.m_ = null);
+    C_() {
+        null !== this.p_ && (this.p_.cancel(), this.p_ = null);
     }
 }
 
@@ -14638,7 +14646,7 @@ class __PRIVATE_OnlineStateTracker {
          * purely based on order, and so we can just shift() writes from the front of
          * the writePipeline as we receive responses.
          */
-        this.b_ = [], 
+        this.v_ = [], 
         /**
          * A mapping of watched targets that the client cares about tracking and the
          * user has explicitly called a 'listen' for this target.
@@ -14648,12 +14656,12 @@ class __PRIVATE_OnlineStateTracker {
          * to the server. The targets removed with unlistens are removed eagerly
          * without waiting for confirmation from the listen stream.
          */
-        this.D_ = new Map, 
+        this.F_ = new Map, 
         /**
          * A set of reasons for why the RemoteStore may be offline. If empty, the
          * RemoteStore may start its network connections.
          */
-        this.C_ = new Set, 
+        this.M_ = new Set, 
         /**
          * Event handlers that get called when the network is disabled or enabled.
          *
@@ -14661,7 +14669,7 @@ class __PRIVATE_OnlineStateTracker {
          * underlying streams (to support tree-shakeable streams). On Android and iOS,
          * the streams are created during construction of RemoteStore.
          */
-        this.v_ = [], this.F_ = i, this.F_.ro((e => {
+        this.x_ = [], this.O_ = i, this.O_.ro((e => {
             n.enqueueAndForget((async () => {
                 // Porting Note: Unlike iOS, `restartNetwork()` is called even when the
                 // network becomes unreachable as we don't have any other way to tear
@@ -14669,24 +14677,24 @@ class __PRIVATE_OnlineStateTracker {
                 __PRIVATE_canUseNetwork(this) && (__PRIVATE_logDebug("RemoteStore", "Restarting streams for network reachability change."), 
                 await async function __PRIVATE_restartNetwork(e) {
                     const t = __PRIVATE_debugCast(e);
-                    t.C_.add(4 /* OfflineCause.ConnectivityChange */), await __PRIVATE_disableNetworkInternal(t), 
-                    t.M_.set("Unknown" /* OnlineState.Unknown */), t.C_.delete(4 /* OfflineCause.ConnectivityChange */), 
+                    t.M_.add(4 /* OfflineCause.ConnectivityChange */), await __PRIVATE_disableNetworkInternal(t), 
+                    t.N_.set("Unknown" /* OnlineState.Unknown */), t.M_.delete(4 /* OfflineCause.ConnectivityChange */), 
                     await __PRIVATE_enableNetworkInternal(t);
                 }(this));
             }));
-        })), this.M_ = new __PRIVATE_OnlineStateTracker(n, r);
+        })), this.N_ = new __PRIVATE_OnlineStateTracker(n, r);
     }
 }
 
 async function __PRIVATE_enableNetworkInternal(e) {
-    if (__PRIVATE_canUseNetwork(e)) for (const t of e.v_) await t(/* enabled= */ !0);
+    if (__PRIVATE_canUseNetwork(e)) for (const t of e.x_) await t(/* enabled= */ !0);
 }
 
 /**
  * Temporarily disables the network. The network can be re-enabled using
  * enableNetwork().
  */ async function __PRIVATE_disableNetworkInternal(e) {
-    for (const t of e.v_) await t(/* enabled= */ !1);
+    for (const t of e.x_) await t(/* enabled= */ !1);
 }
 
 /**
@@ -14695,11 +14703,11 @@ async function __PRIVATE_enableNetworkInternal(e) {
  */
 function __PRIVATE_remoteStoreListen(e, t) {
     const n = __PRIVATE_debugCast(e);
-    n.D_.has(t.targetId) || (
+    n.F_.has(t.targetId) || (
     // Mark this as something the client is currently listening for.
-    n.D_.set(t.targetId, t), __PRIVATE_shouldStartWatchStream(n) ? 
+    n.F_.set(t.targetId, t), __PRIVATE_shouldStartWatchStream(n) ? 
     // The listen will be sent in onWatchStreamOpen
-    __PRIVATE_startWatchStream(n) : __PRIVATE_ensureWatchStream(n).Ho() && __PRIVATE_sendWatchRequest(n, t));
+    __PRIVATE_startWatchStream(n) : __PRIVATE_ensureWatchStream(n).Zo() && __PRIVATE_sendWatchRequest(n, t));
 }
 
 /**
@@ -14707,22 +14715,22 @@ function __PRIVATE_remoteStoreListen(e, t) {
  * not being listened to.
  */ function __PRIVATE_remoteStoreUnlisten(e, t) {
     const n = __PRIVATE_debugCast(e), r = __PRIVATE_ensureWatchStream(n);
-    n.D_.delete(t), r.Ho() && __PRIVATE_sendUnwatchRequest(n, t), 0 === n.D_.size && (r.Ho() ? r.Zo() : __PRIVATE_canUseNetwork(n) && 
+    n.F_.delete(t), r.Zo() && __PRIVATE_sendUnwatchRequest(n, t), 0 === n.F_.size && (r.Zo() ? r.t_() : __PRIVATE_canUseNetwork(n) && 
     // Revert to OnlineState.Unknown if the watch stream is not open and we
     // have no listeners, since without any listens to send we cannot
     // confirm if the stream is healthy and upgrade to OnlineState.Online.
-    n.M_.set("Unknown" /* OnlineState.Unknown */));
+    n.N_.set("Unknown" /* OnlineState.Unknown */));
 }
 
 /**
  * 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.x_.xe(t.targetId), t.resumeToken.approximateByteSize() > 0 || t.snapshotVersion.compareTo(SnapshotVersion.min()) > 0) {
+    if (e.L_.xe(t.targetId), t.resumeToken.approximateByteSize() > 0 || t.snapshotVersion.compareTo(SnapshotVersion.min()) > 0) {
         const n = e.remoteSyncer.getRemoteKeysForTarget(t.targetId).size;
         t = t.withExpectedCount(n);
     }
-    __PRIVATE_ensureWatchStream(e).u_(t);
+    __PRIVATE_ensureWatchStream(e).h_(t);
 }
 
 /**
@@ -14730,34 +14738,39 @@ 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.x_.xe(t), __PRIVATE_ensureWatchStream(e).c_(t);
+    e.L_.xe(t), __PRIVATE_ensureWatchStream(e).P_(t);
 }
 
 function __PRIVATE_startWatchStream(e) {
-    e.x_ = new __PRIVATE_WatchChangeAggregator({
+    e.L_ = new __PRIVATE_WatchChangeAggregator({
         getRemoteKeysForTarget: t => e.remoteSyncer.getRemoteKeysForTarget(t),
-        ot: t => e.D_.get(t) || null,
+        ot: t => e.F_.get(t) || null,
         tt: () => e.datastore.serializer.databaseId
-    }), __PRIVATE_ensureWatchStream(e).start(), e.M_.g_();
+    }), __PRIVATE_ensureWatchStream(e).start(), e.N_.w_();
 }
 
 /**
  * Returns whether the watch stream should be started because it's necessary
  * and has not yet been started.
  */ function __PRIVATE_shouldStartWatchStream(e) {
-    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWatchStream(e).jo() && e.D_.size > 0;
+    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWatchStream(e).Yo() && e.F_.size > 0;
 }
 
 function __PRIVATE_canUseNetwork(e) {
-    return 0 === __PRIVATE_debugCast(e).C_.size;
+    return 0 === __PRIVATE_debugCast(e).M_.size;
 }
 
 function __PRIVATE_cleanUpWatchStreamState(e) {
-    e.x_ = void 0;
+    e.L_ = void 0;
+}
+
+async function __PRIVATE_onWatchStreamConnected(e) {
+    // Mark the client as online since we got a "connected" notification.
+    e.N_.set("Online" /* OnlineState.Online */);
 }
 
 async function __PRIVATE_onWatchStreamOpen(e) {
-    e.D_.forEach(((t, n) => {
+    e.F_.forEach(((t, n) => {
         __PRIVATE_sendWatchRequest(e, t);
     }));
 }
@@ -14765,17 +14778,17 @@ async function __PRIVATE_onWatchStreamOpen(e) {
 async function __PRIVATE_onWatchStreamClose(e, t) {
     __PRIVATE_cleanUpWatchStreamState(e), 
     // If we still need the watch stream, retry the connection.
-    __PRIVATE_shouldStartWatchStream(e) ? (e.M_.w_(t), __PRIVATE_startWatchStream(e)) : 
+    __PRIVATE_shouldStartWatchStream(e) ? (e.N_.D_(t), __PRIVATE_startWatchStream(e)) : 
     // No need to restart watch stream because there are no active targets.
     // The online state is set to unknown because there is no active attempt
     // at establishing a connection
-    e.M_.set("Unknown" /* OnlineState.Unknown */);
+    e.N_.set("Unknown" /* OnlineState.Unknown */);
 }
 
 async function __PRIVATE_onWatchStreamChange(e, t, n) {
     if (
     // Mark the client as online since we got a message from the server
-    e.M_.set("Online" /* OnlineState.Online */), t instanceof __PRIVATE_WatchTargetChange && 2 /* WatchTargetChangeState.Removed */ === t.state && t.cause) 
+    e.N_.set("Online" /* OnlineState.Online */), t instanceof __PRIVATE_WatchTargetChange && 2 /* WatchTargetChangeState.Removed */ === t.state && t.cause) 
     // There was an error on a target, don't wait for a consistent snapshot
     // to raise events
     try {
@@ -14785,7 +14798,7 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
             const n = t.cause;
             for (const r of t.targetIds) 
             // A watched target might have been removed already.
-            e.D_.has(r) && (await e.remoteSyncer.rejectListen(r, n), e.D_.delete(r), e.x_.removeTarget(r));
+            e.F_.has(r) && (await e.remoteSyncer.rejectListen(r, n), e.F_.delete(r), e.L_.removeTarget(r));
         }
         /**
  * Attempts to fill our write pipeline with writes from the LocalStore.
@@ -14798,7 +14811,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.x_.Ke(t) : t instanceof __PRIVATE_ExistenceFilterChange ? e.x_.He(t) : e.x_.We(t), 
+    } else if (t instanceof __PRIVATE_DocumentWatchChange ? e.L_.Ke(t) : t instanceof __PRIVATE_ExistenceFilterChange ? e.L_.He(t) : e.L_.We(t), 
     !n.isEqual(SnapshotVersion.min())) try {
         const t = await __PRIVATE_localStoreGetLastRemoteSnapshotVersion(e.localStore);
         n.compareTo(t) >= 0 && 
@@ -14811,26 +14824,26 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
  * SyncEngine.
  */
         function __PRIVATE_raiseWatchSnapshot(e, t) {
-            const n = e.x_.rt(t);
+            const n = e.L_.rt(t);
             // Update in-memory resume tokens. LocalStore will update the
             // persistent view of these when applying the completed RemoteEvent.
                         return n.targetChanges.forEach(((n, r) => {
                 if (n.resumeToken.approximateByteSize() > 0) {
-                    const i = e.D_.get(r);
+                    const i = e.F_.get(r);
                     // A watched target might have been removed already.
-                                        i && e.D_.set(r, i.withResumeToken(n.resumeToken, t));
+                                        i && e.F_.set(r, i.withResumeToken(n.resumeToken, t));
                 }
             })), 
             // Re-establish listens for the targets that have been invalidated by
             // existence filter mismatches.
             n.targetMismatches.forEach(((t, n) => {
-                const r = e.D_.get(t);
+                const r = e.F_.get(t);
                 if (!r) 
                 // A watched target might have been removed already.
                 return;
                 // Clear the resume token for the target, since we're in a known mismatch
                 // state.
-                                e.D_.set(t, r.withResumeToken(ByteString.EMPTY_BYTE_STRING, r.snapshotVersion)), 
+                                e.F_.set(t, r.withResumeToken(ByteString.EMPTY_BYTE_STRING, r.snapshotVersion)), 
                 // Cause a hard reset by unwatching and rewatching immediately, but
                 // deliberately don't send a resume token so that we get a full update.
                 __PRIVATE_sendUnwatchRequest(e, t);
@@ -14857,9 +14870,9 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
  * any retry attempt.
  */ async function __PRIVATE_disableNetworkUntilRecovery(e, t, n) {
     if (!__PRIVATE_isIndexedDbTransactionError(t)) throw t;
-    e.C_.add(1 /* OfflineCause.IndexedDbFailed */), 
+    e.M_.add(1 /* OfflineCause.IndexedDbFailed */), 
     // Disable network and raise offline snapshots
-    await __PRIVATE_disableNetworkInternal(e), e.M_.set("Offline" /* OnlineState.Offline */), 
+    await __PRIVATE_disableNetworkInternal(e), e.N_.set("Offline" /* OnlineState.Offline */), 
     n || (
     // Use a simple read operation to determine if IndexedDB recovered.
     // Ideally, we would expose a health check directly on SimpleDb, but
@@ -14867,7 +14880,7 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
     n = () => __PRIVATE_localStoreGetLastRemoteSnapshotVersion(e.localStore)), 
     // Probe IndexedDB periodically and re-enable network
     e.asyncQueue.enqueueRetryable((async () => {
-        __PRIVATE_logDebug("RemoteStore", "Retrying IndexedDB access"), await n(), e.C_.delete(1 /* OfflineCause.IndexedDbFailed */), 
+        __PRIVATE_logDebug("RemoteStore", "Retrying IndexedDB access"), await n(), e.M_.delete(1 /* OfflineCause.IndexedDbFailed */), 
         await __PRIVATE_enableNetworkInternal(e);
     }));
 }
@@ -14881,11 +14894,11 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
 
 async function __PRIVATE_fillWritePipeline(e) {
     const t = __PRIVATE_debugCast(e), n = __PRIVATE_ensureWriteStream(t);
-    let r = t.b_.length > 0 ? t.b_[t.b_.length - 1].batchId : -1;
+    let r = t.v_.length > 0 ? t.v_[t.v_.length - 1].batchId : -1;
     for (;__PRIVATE_canAddToWritePipeline(t); ) try {
         const e = await __PRIVATE_localStoreGetNextMutationBatch(t.localStore, r);
         if (null === e) {
-            0 === t.b_.length && n.Zo();
+            0 === t.v_.length && n.t_();
             break;
         }
         r = e.batchId, __PRIVATE_addToWritePipeline(t, e);
@@ -14899,20 +14912,20 @@ async function __PRIVATE_fillWritePipeline(e) {
  * Returns true if we can add to the write pipeline (i.e. the network is
  * enabled and the write pipeline is not full).
  */ function __PRIVATE_canAddToWritePipeline(e) {
-    return __PRIVATE_canUseNetwork(e) && e.b_.length < 10;
+    return __PRIVATE_canUseNetwork(e) && e.v_.length < 10;
 }
 
 /**
  * Queues additional writes to be sent to the write stream, sending them
  * immediately if the write stream is established.
  */ function __PRIVATE_addToWritePipeline(e, t) {
-    e.b_.push(t);
+    e.v_.push(t);
     const n = __PRIVATE_ensureWriteStream(e);
-    n.Ho() && n.h_ && n.P_(t.mutations);
+    n.Zo() && n.T_ && n.E_(t.mutations);
 }
 
 function __PRIVATE_shouldStartWriteStream(e) {
-    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWriteStream(e).jo() && e.b_.length > 0;
+    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWriteStream(e).Yo() && e.v_.length > 0;
 }
 
 function __PRIVATE_startWriteStream(e) {
@@ -14920,17 +14933,17 @@ function __PRIVATE_startWriteStream(e) {
 }
 
 async function __PRIVATE_onWriteStreamOpen(e) {
-    __PRIVATE_ensureWriteStream(e).E_();
+    __PRIVATE_ensureWriteStream(e).R_();
 }
 
 async function __PRIVATE_onWriteHandshakeComplete(e) {
     const t = __PRIVATE_ensureWriteStream(e);
     // Send the write pipeline now that the stream is established.
-        for (const n of e.b_) t.P_(n.mutations);
+        for (const n of e.v_) t.E_(n.mutations);
 }
 
 async function __PRIVATE_onMutationResult(e, t, n) {
-    const r = e.b_.shift(), i = MutationBatchResult.from(r, t, n);
+    const r = e.v_.shift(), i = MutationBatchResult.from(r, t, n);
     await __PRIVATE_executeWithRecovery(e, (() => e.remoteSyncer.applySuccessfulWrite(i))), 
     // It's possible that with the completion of this mutation another
     // slot has freed up.
@@ -14940,7 +14953,7 @@ async function __PRIVATE_onMutationResult(e, t, n) {
 async function __PRIVATE_onWriteStreamClose(e, t) {
     // If the write stream closed after the write handshake completes, a write
     // operation failed and we fail the pending operation.
-    t && __PRIVATE_ensureWriteStream(e).h_ && 
+    t && __PRIVATE_ensureWriteStream(e).T_ && 
     // This error affects the actual write.
     await async function __PRIVATE_handleWriteError(e, t) {
         // Only handle permanent errors here. If it's transient, just let the retry
@@ -14950,11 +14963,11 @@ async function __PRIVATE_onWriteStreamClose(e, t) {
         }(t.code)) {
             // This was a permanent error, the request itself was the problem
             // so it's not going to succeed if we resend it.
-            const n = e.b_.shift();
+            const n = e.v_.shift();
             // In this case it's also unlikely that the server itself is melting
             // down -- this was just a bad request so inhibit backoff on the next
             // restart.
-                        __PRIVATE_ensureWriteStream(e).Yo(), await __PRIVATE_executeWithRecovery(e, (() => e.remoteSyncer.rejectFailedWrite(n.batchId, t))), 
+                        __PRIVATE_ensureWriteStream(e).e_(), await __PRIVATE_executeWithRecovery(e, (() => e.remoteSyncer.rejectFailedWrite(n.batchId, t))), 
             // It's possible that with the completion of this mutation
             // another slot has freed up.
             await __PRIVATE_fillWritePipeline(e);
@@ -14972,19 +14985,19 @@ async function __PRIVATE_remoteStoreHandleCredentialChange(e, t) {
     // Tear down and re-create our network streams. This will ensure we get a
     // fresh auth token for the new user and re-fill the write pipeline with
     // new mutations from the LocalStore (since mutations are per-user).
-        n.C_.add(3 /* OfflineCause.CredentialChange */), await __PRIVATE_disableNetworkInternal(n), 
+        n.M_.add(3 /* OfflineCause.CredentialChange */), await __PRIVATE_disableNetworkInternal(n), 
     r && 
     // Don't set the network status to Unknown if we are offline.
-    n.M_.set("Unknown" /* OnlineState.Unknown */), await n.remoteSyncer.handleCredentialChange(t), 
-    n.C_.delete(3 /* OfflineCause.CredentialChange */), await __PRIVATE_enableNetworkInternal(n);
+    n.N_.set("Unknown" /* OnlineState.Unknown */), await n.remoteSyncer.handleCredentialChange(t), 
+    n.M_.delete(3 /* OfflineCause.CredentialChange */), await __PRIVATE_enableNetworkInternal(n);
 }
 
 /**
  * Toggles the network state when the client gains or loses its primary lease.
  */ async function __PRIVATE_remoteStoreApplyPrimaryState(e, t) {
     const n = __PRIVATE_debugCast(e);
-    t ? (n.C_.delete(2 /* OfflineCause.IsSecondary */), await __PRIVATE_enableNetworkInternal(n)) : t || (n.C_.add(2 /* OfflineCause.IsSecondary */), 
-    await __PRIVATE_disableNetworkInternal(n), n.M_.set("Unknown" /* OnlineState.Unknown */));
+    t ? (n.M_.delete(2 /* OfflineCause.IsSecondary */), await __PRIVATE_enableNetworkInternal(n)) : t || (n.M_.add(2 /* OfflineCause.IsSecondary */), 
+    await __PRIVATE_disableNetworkInternal(n), n.N_.set("Unknown" /* OnlineState.Unknown */));
 }
 
 /**
@@ -14995,11 +15008,11 @@ async function __PRIVATE_remoteStoreHandleCredentialChange(e, t) {
  * PORTING NOTE: On iOS and Android, the WatchStream gets registered on startup.
  * This is not done on Web to allow it to be tree-shaken.
  */ function __PRIVATE_ensureWatchStream(e) {
-    return e.O_ || (
+    return e.B_ || (
     // Create stream (but note that it is not started yet).
-    e.O_ = function __PRIVATE_newPersistentWatchStream(e, t, n) {
+    e.B_ = function __PRIVATE_newPersistentWatchStream(e, t, n) {
         const r = __PRIVATE_debugCast(e);
-        return r.A_(), new __PRIVATE_PersistentListenStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
+        return r.m_(), new __PRIVATE_PersistentListenStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
     }
     /**
  * @license
@@ -15017,13 +15030,14 @@ async function __PRIVATE_remoteStoreHandleCredentialChange(e, t) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */ (e.datastore, e.asyncQueue, {
-        ho: __PRIVATE_onWatchStreamOpen.bind(null, e),
-        Io: __PRIVATE_onWatchStreamClose.bind(null, e),
-        a_: __PRIVATE_onWatchStreamChange.bind(null, e)
-    }), e.v_.push((async t => {
-        t ? (e.O_.Yo(), __PRIVATE_shouldStartWatchStream(e) ? __PRIVATE_startWatchStream(e) : e.M_.set("Unknown" /* OnlineState.Unknown */)) : (await e.O_.stop(), 
+        ho: __PRIVATE_onWatchStreamConnected.bind(null, e),
+        Io: __PRIVATE_onWatchStreamOpen.bind(null, e),
+        Eo: __PRIVATE_onWatchStreamClose.bind(null, e),
+        l_: __PRIVATE_onWatchStreamChange.bind(null, e)
+    }), e.x_.push((async t => {
+        t ? (e.B_.e_(), __PRIVATE_shouldStartWatchStream(e) ? __PRIVATE_startWatchStream(e) : e.N_.set("Unknown" /* OnlineState.Unknown */)) : (await e.B_.stop(), 
         __PRIVATE_cleanUpWatchStreamState(e));
-    }))), e.O_;
+    }))), e.B_;
 }
 
 /**
@@ -15034,22 +15048,23 @@ async function __PRIVATE_remoteStoreHandleCredentialChange(e, t) {
  * PORTING NOTE: On iOS and Android, the WriteStream gets registered on startup.
  * This is not done on Web to allow it to be tree-shaken.
  */ function __PRIVATE_ensureWriteStream(e) {
-    return e.N_ || (
+    return e.k_ || (
     // Create stream (but note that it is not started yet).
-    e.N_ = function __PRIVATE_newPersistentWriteStream(e, t, n) {
+    e.k_ = function __PRIVATE_newPersistentWriteStream(e, t, n) {
         const r = __PRIVATE_debugCast(e);
-        return r.A_(), new __PRIVATE_PersistentWriteStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
+        return r.m_(), new __PRIVATE_PersistentWriteStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
     }(e.datastore, e.asyncQueue, {
-        ho: __PRIVATE_onWriteStreamOpen.bind(null, e),
-        Io: __PRIVATE_onWriteStreamClose.bind(null, e),
-        T_: __PRIVATE_onWriteHandshakeComplete.bind(null, e),
-        I_: __PRIVATE_onMutationResult.bind(null, e)
-    }), e.v_.push((async t => {
-        t ? (e.N_.Yo(), 
+        ho: () => Promise.resolve(),
+        Io: __PRIVATE_onWriteStreamOpen.bind(null, e),
+        Eo: __PRIVATE_onWriteStreamClose.bind(null, e),
+        A_: __PRIVATE_onWriteHandshakeComplete.bind(null, e),
+        d_: __PRIVATE_onMutationResult.bind(null, e)
+    }), e.x_.push((async t => {
+        t ? (e.k_.e_(), 
         // This will start the write stream if necessary.
-        await __PRIVATE_fillWritePipeline(e)) : (await e.N_.stop(), e.b_.length > 0 && (__PRIVATE_logDebug("RemoteStore", `Stopping write stream with ${e.b_.length} pending writes`), 
-        e.b_ = []));
-    }))), e.N_;
+        await __PRIVATE_fillWritePipeline(e)) : (await e.k_.stop(), e.v_.length > 0 && (__PRIVATE_logDebug("RemoteStore", `Stopping write stream with ${e.v_.length} pending writes`), 
+        e.v_ = []));
+    }))), e.k_;
 }
 
 /**
@@ -15262,25 +15277,25 @@ class DelayedOperation {
  * duplicate events for the same doc.
  */ class __PRIVATE_DocumentChangeSet {
     constructor() {
-        this.L_ = new SortedMap(DocumentKey.comparator);
+        this.q_ = new SortedMap(DocumentKey.comparator);
     }
     track(e) {
-        const t = e.doc.key, n = this.L_.get(t);
+        const t = e.doc.key, n = this.q_.get(t);
         n ? 
         // Merge the new change with the existing change.
-        0 /* ChangeType.Added */ !== e.type && 3 /* ChangeType.Metadata */ === n.type ? this.L_ = this.L_.insert(t, e) : 3 /* ChangeType.Metadata */ === e.type && 1 /* ChangeType.Removed */ !== n.type ? this.L_ = this.L_.insert(t, {
+        0 /* ChangeType.Added */ !== e.type && 3 /* ChangeType.Metadata */ === n.type ? this.q_ = this.q_.insert(t, e) : 3 /* ChangeType.Metadata */ === e.type && 1 /* ChangeType.Removed */ !== n.type ? this.q_ = this.q_.insert(t, {
             type: n.type,
             doc: e.doc
-        }) : 2 /* ChangeType.Modified */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.L_ = this.L_.insert(t, {
+        }) : 2 /* ChangeType.Modified */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.q_ = this.q_.insert(t, {
             type: 2 /* ChangeType.Modified */ ,
             doc: e.doc
-        }) : 2 /* ChangeType.Modified */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.L_ = this.L_.insert(t, {
+        }) : 2 /* ChangeType.Modified */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.q_ = this.q_.insert(t, {
             type: 0 /* ChangeType.Added */ ,
             doc: e.doc
-        }) : 1 /* ChangeType.Removed */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.L_ = this.L_.remove(t) : 1 /* ChangeType.Removed */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.L_ = this.L_.insert(t, {
+        }) : 1 /* ChangeType.Removed */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.q_ = this.q_.remove(t) : 1 /* ChangeType.Removed */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.q_ = this.q_.insert(t, {
             type: 1 /* ChangeType.Removed */ ,
             doc: n.doc
-        }) : 0 /* ChangeType.Added */ === e.type && 1 /* ChangeType.Removed */ === n.type ? this.L_ = this.L_.insert(t, {
+        }) : 0 /* ChangeType.Added */ === e.type && 1 /* ChangeType.Removed */ === n.type ? this.q_ = this.q_.insert(t, {
             type: 2 /* ChangeType.Modified */ ,
             doc: e.doc
         }) : 
@@ -15291,11 +15306,11 @@ class DelayedOperation {
         // Removed->Modified
         // Metadata->Added
         // Removed->Metadata
-        fail() : this.L_ = this.L_.insert(t, e);
+        fail() : this.q_ = this.q_.insert(t, e);
     }
-    B_() {
+    Q_() {
         const e = [];
-        return this.L_.inorderTraversal(((t, n) => {
+        return this.q_.inorderTraversal(((t, n) => {
             e.push(n);
         })), e;
     }
@@ -15351,18 +15366,18 @@ class ViewSnapshot {
  * tracked by EventManager.
  */ class __PRIVATE_QueryListenersInfo {
     constructor() {
-        this.k_ = void 0, this.q_ = [];
+        this.K_ = void 0, this.U_ = [];
     }
     // Helper methods that checks if the query has listeners that listening to remote store
-    Q_() {
-        return this.q_.some((e => e.K_()));
+    W_() {
+        return this.U_.some((e => e.G_()));
     }
 }
 
 class __PRIVATE_EventManagerImpl {
     constructor() {
         this.queries = new ObjectMap((e => __PRIVATE_canonifyQuery(e)), __PRIVATE_queryEquals), 
-        this.onlineState = "Unknown" /* OnlineState.Unknown */ , this.U_ = new Set;
+        this.onlineState = "Unknown" /* OnlineState.Unknown */ , this.z_ = new Set;
     }
 }
 
@@ -15371,19 +15386,19 @@ async function __PRIVATE_eventManagerListen(e, t) {
     let r = 3 /* ListenerSetupAction.NoActionRequired */;
     const i = t.query;
     let s = n.queries.get(i);
-    s ? !s.Q_() && t.K_() && (
+    s ? !s.W_() && t.G_() && (
     // Query has been listening to local cache, and tries to add a new listener sourced from watch.
     r = 2 /* ListenerSetupAction.RequireWatchConnectionOnly */) : (s = new __PRIVATE_QueryListenersInfo, 
-    r = t.K_() ? 0 /* ListenerSetupAction.InitializeLocalListenAndRequireWatchConnection */ : 1 /* ListenerSetupAction.InitializeLocalListenOnly */);
+    r = t.G_() ? 0 /* ListenerSetupAction.InitializeLocalListenAndRequireWatchConnection */ : 1 /* ListenerSetupAction.InitializeLocalListenOnly */);
     try {
         switch (r) {
           case 0 /* ListenerSetupAction.InitializeLocalListenAndRequireWatchConnection */ :
-            s.k_ = await n.onListen(i, 
+            s.K_ = await n.onListen(i, 
             /** enableRemoteListen= */ !0);
             break;
 
           case 1 /* ListenerSetupAction.InitializeLocalListenOnly */ :
-            s.k_ = await n.onListen(i, 
+            s.K_ = await n.onListen(i, 
             /** enableRemoteListen= */ !1);
             break;
 
@@ -15394,10 +15409,10 @@ async function __PRIVATE_eventManagerListen(e, t) {
         const n = __PRIVATE_wrapInUserErrorIfRecoverable(e, `Initialization of query '${__PRIVATE_stringifyQuery(t.query)}' failed`);
         return void t.onError(n);
     }
-    if (n.queries.set(i, s), s.q_.push(t), 
+    if (n.queries.set(i, s), s.U_.push(t), 
     // Run global snapshot listeners if a consistent snapshot has been emitted.
-    t.W_(n.onlineState), s.k_) {
-        t.G_(s.k_) && __PRIVATE_raiseSnapshotsInSyncEvent(n);
+    t.j_(n.onlineState), s.K_) {
+        t.H_(s.K_) && __PRIVATE_raiseSnapshotsInSyncEvent(n);
     }
 }
 
@@ -15406,8 +15421,8 @@ async function __PRIVATE_eventManagerUnlisten(e, t) {
     let i = 3 /* ListenerRemovalAction.NoActionRequired */;
     const s = n.queries.get(r);
     if (s) {
-        const e = s.q_.indexOf(t);
-        e >= 0 && (s.q_.splice(e, 1), 0 === s.q_.length ? i = t.K_() ? 0 /* ListenerRemovalAction.TerminateLocalListenAndRequireWatchDisconnection */ : 1 /* ListenerRemovalAction.TerminateLocalListenOnly */ : !s.Q_() && t.K_() && (
+        const e = s.U_.indexOf(t);
+        e >= 0 && (s.U_.splice(e, 1), 0 === s.U_.length ? i = t.G_() ? 0 /* ListenerRemovalAction.TerminateLocalListenAndRequireWatchDisconnection */ : 1 /* ListenerRemovalAction.TerminateLocalListenOnly */ : !s.W_() && t.G_() && (
         // The removed listener is the last one that sourced from watch.
         i = 2 /* ListenerRemovalAction.RequireWatchDisconnectionOnly */));
     }
@@ -15434,8 +15449,8 @@ function __PRIVATE_eventManagerOnWatchChange(e, t) {
     for (const e of t) {
         const t = e.query, i = n.queries.get(t);
         if (i) {
-            for (const t of i.q_) t.G_(e) && (r = !0);
-            i.k_ = e;
+            for (const t of i.U_) t.H_(e) && (r = !0);
+            i.K_ = e;
         }
     }
     r && __PRIVATE_raiseSnapshotsInSyncEvent(n);
@@ -15443,7 +15458,7 @@ function __PRIVATE_eventManagerOnWatchChange(e, t) {
 
 function __PRIVATE_eventManagerOnWatchError(e, t, n) {
     const r = __PRIVATE_debugCast(e), i = r.queries.get(t);
-    if (i) for (const e of i.q_) e.onError(n);
+    if (i) for (const e of i.U_) e.onError(n);
     // Remove all listeners. NOTE: We don't need to call syncEngine.unlisten()
     // after an error.
         r.queries.delete(t);
@@ -15451,7 +15466,7 @@ function __PRIVATE_eventManagerOnWatchError(e, t, n) {
 
 // Call all global snapshot listeners that have been set.
 function __PRIVATE_raiseSnapshotsInSyncEvent(e) {
-    e.U_.forEach((e => {
+    e.z_.forEach((e => {
         e.next();
     }));
 }
@@ -15459,7 +15474,7 @@ function __PRIVATE_raiseSnapshotsInSyncEvent(e) {
 var fe, ge;
 
 /** Listen to both cache and server changes */
-(ge = fe || (fe = {})).z_ = "default", 
+(ge = fe || (fe = {})).J_ = "default", 
 /** Listen to changes in cache only */
 ge.Cache = "cache";
 
@@ -15471,12 +15486,12 @@ ge.Cache = "cache";
  */
 class __PRIVATE_QueryListener {
     constructor(e, t, n) {
-        this.query = e, this.j_ = t, 
+        this.query = e, this.Y_ = t, 
         /**
          * Initial snapshots (e.g. from cache) may not be propagated to the wrapped
          * observer. This flag is set to true once we've actually raised an event.
          */
-        this.H_ = !1, this.J_ = null, this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
+        this.Z_ = !1, this.X_ = null, this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
         this.options = n || {};
     }
     /**
@@ -15484,7 +15499,7 @@ class __PRIVATE_QueryListener {
      * if applicable (depending on what changed, whether the user has opted into
      * metadata-only changes, etc.). Returns true if a user-facing event was
      * indeed raised.
-     */    G_(e) {
+     */    H_(e) {
         if (!this.options.includeMetadataChanges) {
             // Remove the metadata only changes.
             const t = [];
@@ -15493,49 +15508,49 @@ class __PRIVATE_QueryListener {
             /* excludesMetadataChanges= */ !0, e.hasCachedResults);
         }
         let t = !1;
-        return this.H_ ? this.Y_(e) && (this.j_.next(e), t = !0) : this.Z_(e, this.onlineState) && (this.X_(e), 
-        t = !0), this.J_ = e, t;
+        return this.Z_ ? this.ea(e) && (this.Y_.next(e), t = !0) : this.ta(e, this.onlineState) && (this.na(e), 
+        t = !0), this.X_ = e, t;
     }
     onError(e) {
-        this.j_.error(e);
+        this.Y_.error(e);
     }
-    /** Returns whether a snapshot was raised. */    W_(e) {
+    /** Returns whether a snapshot was raised. */    j_(e) {
         this.onlineState = e;
         let t = !1;
-        return this.J_ && !this.H_ && this.Z_(this.J_, e) && (this.X_(this.J_), t = !0), 
+        return this.X_ && !this.Z_ && this.ta(this.X_, e) && (this.na(this.X_), t = !0), 
         t;
     }
-    Z_(e, t) {
+    ta(e, t) {
         // Always raise the first event when we're synced
         if (!e.fromCache) return !0;
         // Always raise event if listening to cache
-                if (!this.K_()) return !0;
+                if (!this.G_()) return !0;
         // NOTE: We consider OnlineState.Unknown as online (it should become Offline
         // or Online if we wait long enough).
                 const n = "Offline" /* OnlineState.Offline */ !== t;
         // Don't raise the event if we're online, aren't synced yet (checked
         // above) and are waiting for a sync.
-                return (!this.options.ea || !n) && (!e.docs.isEmpty() || e.hasCachedResults || "Offline" /* OnlineState.Offline */ === t);
+                return (!this.options.ra || !n) && (!e.docs.isEmpty() || e.hasCachedResults || "Offline" /* OnlineState.Offline */ === t);
         // Raise data from cache if we have any documents, have cached results before,
         // or we are offline.
         }
-    Y_(e) {
+    ea(e) {
         // We don't need to handle includeDocumentMetadataChanges here because
         // the Metadata only changes have already been stripped out if needed.
         // At this point the only changes we will see are the ones we should
         // propagate.
         if (e.docChanges.length > 0) return !0;
-        const t = this.J_ && this.J_.hasPendingWrites !== e.hasPendingWrites;
+        const t = this.X_ && this.X_.hasPendingWrites !== e.hasPendingWrites;
         return !(!e.syncStateChanged && !t) && !0 === this.options.includeMetadataChanges;
         // Generally we should have hit one of the cases above, but it's possible
         // to get here if there were only metadata docChanges and they got
         // stripped out.
         }
-    X_(e) {
+    na(e) {
         e = ViewSnapshot.fromInitialDocuments(e.query, e.docs, e.mutatedKeys, e.fromCache, e.hasCachedResults), 
-        this.H_ = !0, this.j_.next(e);
+        this.Z_ = !0, this.Y_.next(e);
     }
-    K_() {
+    G_() {
         return this.options.source !== fe.Cache;
     }
 }
@@ -15563,10 +15578,10 @@ class __PRIVATE_QueryListener {
     constructor(e, 
     // How many bytes this element takes to store in the bundle.
     t) {
-        this.ta = e, this.byteLength = t;
+        this.ia = e, this.byteLength = t;
     }
-    na() {
-        return "metadata" in this.ta;
+    sa() {
+        return "metadata" in this.ia;
     }
 }
 
@@ -15610,7 +15625,7 @@ class __PRIVATE_QueryListener {
  * storage and provide progress update while loading.
  */ class __PRIVATE_BundleLoader {
     constructor(e, t, n) {
-        this.ra = e, this.localStore = t, this.serializer = n, 
+        this.oa = e, this.localStore = t, this.serializer = n, 
         /** Batched queries to be saved into storage */
         this.queries = [], 
         /** Batched documents to be saved into storage */
@@ -15623,21 +15638,21 @@ class __PRIVATE_QueryListener {
      *
      * Returns a new progress if adding the element leads to a new progress,
      * otherwise returns null.
-     */    ia(e) {
+     */    _a(e) {
         this.progress.bytesLoaded += e.byteLength;
         let t = this.progress.documentsLoaded;
-        if (e.ta.namedQuery) this.queries.push(e.ta.namedQuery); else if (e.ta.documentMetadata) {
+        if (e.ia.namedQuery) this.queries.push(e.ia.namedQuery); else if (e.ia.documentMetadata) {
             this.documents.push({
-                metadata: e.ta.documentMetadata
-            }), e.ta.documentMetadata.exists || ++t;
-            const n = ResourcePath.fromString(e.ta.documentMetadata.name);
+                metadata: e.ia.documentMetadata
+            }), e.ia.documentMetadata.exists || ++t;
+            const n = ResourcePath.fromString(e.ia.documentMetadata.name);
             this.collectionGroups.add(n.get(n.length - 2));
-        } else e.ta.document && (this.documents[this.documents.length - 1].document = e.ta.document, 
+        } else e.ia.document && (this.documents[this.documents.length - 1].document = e.ia.document, 
         ++t);
         return t !== this.progress.documentsLoaded ? (this.progress.documentsLoaded = t, 
         Object.assign({}, this.progress)) : null;
     }
-    sa(e) {
+    aa(e) {
         const t = new Map, n = new __PRIVATE_BundleConverterImpl(this.serializer);
         for (const r of e) if (r.metadata.queries) {
             const e = n.hs(r.metadata.name);
@@ -15651,12 +15666,12 @@ class __PRIVATE_QueryListener {
     /**
      * Update the progress to 'Success' and return the updated progress.
      */    async complete() {
-        const e = await __PRIVATE_localStoreApplyBundledDocuments(this.localStore, new __PRIVATE_BundleConverterImpl(this.serializer), this.documents, this.ra.id), t = this.sa(this.documents);
+        const e = await __PRIVATE_localStoreApplyBundledDocuments(this.localStore, new __PRIVATE_BundleConverterImpl(this.serializer), this.documents, this.oa.id), t = this.aa(this.documents);
         for (const e of this.queries) await __PRIVATE_localStoreSaveNamedQuery(this.localStore, e, t.get(e.name));
         return this.progress.taskState = "Success", {
             progress: this.progress,
-            oa: this.collectionGroups,
-            _a: e
+            ua: this.collectionGroups,
+            ca: e
         };
     }
 }
@@ -15714,7 +15729,7 @@ class __PRIVATE_RemovedLimboDocument {
     constructor(e, 
     /** Documents included in the remote target */
     t) {
-        this.query = e, this.aa = t, this.ua = null, this.hasCachedResults = !1, 
+        this.query = e, this.la = t, this.ha = null, this.hasCachedResults = !1, 
         /**
          * A flag whether the view is current with the backend. A view is considered
          * current after it has seen the current flag from the backend and did not
@@ -15723,16 +15738,16 @@ class __PRIVATE_RemovedLimboDocument {
          */
         this.current = !1, 
         /** Documents in the view but not in the remote target */
-        this.ca = __PRIVATE_documentKeySet(), 
+        this.Pa = __PRIVATE_documentKeySet(), 
         /** Document Keys that have local changes */
-        this.mutatedKeys = __PRIVATE_documentKeySet(), this.la = __PRIVATE_newQueryComparator(e), 
-        this.ha = new DocumentSet(this.la);
+        this.mutatedKeys = __PRIVATE_documentKeySet(), this.Ia = __PRIVATE_newQueryComparator(e), 
+        this.Ta = new DocumentSet(this.Ia);
     }
     /**
      * The set of remote documents that the server has told us belongs to the target associated with
      * this view.
-     */    get Pa() {
-        return this.aa;
+     */    get Ea() {
+        return this.la;
     }
     /**
      * Iterates over a set of doc changes, applies the query limit, and computes
@@ -15743,8 +15758,8 @@ class __PRIVATE_RemovedLimboDocument {
      * @param previousChanges - If this is being called with a refill, then start
      *        with this set of docs and changes instead of the current view.
      * @returns a new set of docs, changes, and refill flag.
-     */    Ia(e, t) {
-        const n = t ? t.Ta : new __PRIVATE_DocumentChangeSet, r = t ? t.ha : this.ha;
+     */    da(e, t) {
+        const n = t ? t.Aa : new __PRIVATE_DocumentChangeSet, r = t ? t.Ta : this.Ta;
         let i = t ? t.mutatedKeys : this.mutatedKeys, s = r, o = !1;
         // Track the last doc in a (full) limit. This is necessary, because some
         // update (a delete, or an update moving a doc past the old limit) might
@@ -15767,10 +15782,10 @@ class __PRIVATE_RemovedLimboDocument {
                 u.data.isEqual(c.data) ? l !== h && (n.track({
                     type: 3 /* ChangeType.Metadata */ ,
                     doc: c
-                }), P = !0) : this.Ea(u, c) || (n.track({
+                }), P = !0) : this.Ra(u, c) || (n.track({
                     type: 2 /* ChangeType.Modified */ ,
                     doc: c
-                }), P = !0, (_ && this.la(c, _) > 0 || a && this.la(c, a) < 0) && (
+                }), P = !0, (_ && this.Ia(c, _) > 0 || a && this.Ia(c, a) < 0) && (
                 // This doc moved from inside the limit to outside the limit.
                 // That means there may be some other doc in the local cache
                 // that should be included instead.
@@ -15795,13 +15810,13 @@ class __PRIVATE_RemovedLimboDocument {
             });
         }
         return {
-            ha: s,
-            Ta: n,
+            Ta: s,
+            Aa: n,
             Zi: o,
             mutatedKeys: i
         };
     }
-    Ea(e, t) {
+    Ra(e, t) {
         // We suppress the initial change event for documents that were modified as
         // part of a write acknowledgment (e.g. when the value of a server transform
         // is applied) as Watch will send us the same document again.
@@ -15826,10 +15841,10 @@ class __PRIVATE_RemovedLimboDocument {
      */
     // PORTING NOTE: The iOS/Android clients always compute limbo document changes.
     applyChanges(e, t, n, r) {
-        const i = this.ha;
-        this.ha = e.ha, this.mutatedKeys = e.mutatedKeys;
+        const i = this.Ta;
+        this.Ta = e.Ta, this.mutatedKeys = e.mutatedKeys;
         // Sort changes based on type and query comparator
-        const s = e.Ta.B_();
+        const s = e.Aa.Q_();
         s.sort(((e, t) => function __PRIVATE_compareChangeType(e, t) {
             const order = e => {
                 switch (e) {
@@ -15867,70 +15882,70 @@ class __PRIVATE_RemovedLimboDocument {
  * 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.
- */ (e.type, t.type) || this.la(e.doc, t.doc))), this.da(n), r = null != r && r;
-        const o = t && !r ? this.Aa() : [], _ = 0 === this.ca.size && this.current && !r ? 1 /* SyncState.Synced */ : 0 /* SyncState.Local */ , a = _ !== this.ua;
+ */ (e.type, t.type) || this.Ia(e.doc, t.doc))), this.Va(n), r = null != r && r;
+        const o = t && !r ? this.ma() : [], _ = 0 === this.Pa.size && this.current && !r ? 1 /* SyncState.Synced */ : 0 /* SyncState.Local */ , a = _ !== this.ha;
         // We are at synced state if there is no limbo docs are waiting to be resolved, view is current
         // with the backend, and the query is not pending to reset due to existence filter mismatch.
-                if (this.ua = _, 0 !== s.length || a) {
+                if (this.ha = _, 0 !== s.length || a) {
             return {
-                snapshot: new ViewSnapshot(this.query, e.ha, i, s, e.mutatedKeys, 0 /* SyncState.Local */ === _, a, 
+                snapshot: new ViewSnapshot(this.query, e.Ta, i, s, e.mutatedKeys, 0 /* SyncState.Local */ === _, a, 
                 /* excludesMetadataChanges= */ !1, !!n && n.resumeToken.approximateByteSize() > 0),
-                Ra: o
+                fa: o
             };
         }
         // no changes
         return {
-            Ra: o
+            fa: o
         };
     }
     /**
      * Applies an OnlineState change to the view, potentially generating a
      * ViewChange if the view's syncState changes as a result.
-     */    W_(e) {
+     */    j_(e) {
         return this.current && "Offline" /* OnlineState.Offline */ === e ? (
         // If we're offline, set `current` to false and then call applyChanges()
         // to refresh our syncState and generate a ViewChange as appropriate. We
         // are guaranteed to get a new TargetChange that sets `current` back to
         // true once the client is back online.
         this.current = !1, this.applyChanges({
-            ha: this.ha,
-            Ta: new __PRIVATE_DocumentChangeSet,
+            Ta: this.Ta,
+            Aa: new __PRIVATE_DocumentChangeSet,
             mutatedKeys: this.mutatedKeys,
             Zi: !1
         }, 
         /* limboResolutionEnabled= */ !1)) : {
-            Ra: []
+            fa: []
         };
     }
     /**
      * Returns whether the doc for the given key should be in limbo.
-     */    Va(e) {
+     */    ga(e) {
         // If the remote end says it's part of this query, it's not in limbo.
-        return !this.aa.has(e) && (
+        return !this.la.has(e) && (
         // The local store doesn't think it's a result, so it shouldn't be in limbo.
-        !!this.ha.has(e) && !this.ha.get(e).hasLocalMutations);
+        !!this.Ta.has(e) && !this.Ta.get(e).hasLocalMutations);
     }
     /**
      * Updates syncedDocuments, current, and limbo docs based on the given change.
      * Returns the list of changes to which docs are in limbo.
-     */    da(e) {
-        e && (e.addedDocuments.forEach((e => this.aa = this.aa.add(e))), e.modifiedDocuments.forEach((e => {})), 
-        e.removedDocuments.forEach((e => this.aa = this.aa.delete(e))), this.current = e.current);
+     */    Va(e) {
+        e && (e.addedDocuments.forEach((e => this.la = this.la.add(e))), e.modifiedDocuments.forEach((e => {})), 
+        e.removedDocuments.forEach((e => this.la = this.la.delete(e))), this.current = e.current);
     }
-    Aa() {
+    ma() {
         // We can only determine limbo documents when we're in-sync with the server.
         if (!this.current) return [];
         // TODO(klimt): Do this incrementally so that it's not quadratic when
         // updating many documents.
-                const e = this.ca;
-        this.ca = __PRIVATE_documentKeySet(), this.ha.forEach((e => {
-            this.Va(e.key) && (this.ca = this.ca.add(e.key));
+                const e = this.Pa;
+        this.Pa = __PRIVATE_documentKeySet(), this.Ta.forEach((e => {
+            this.ga(e.key) && (this.Pa = this.Pa.add(e.key));
         }));
         // Diff the new limbo docs with the old limbo docs.
         const t = [];
         return e.forEach((e => {
-            this.ca.has(e) || t.push(new __PRIVATE_RemovedLimboDocument(e));
-        })), this.ca.forEach((n => {
+            this.Pa.has(e) || t.push(new __PRIVATE_RemovedLimboDocument(e));
+        })), this.Pa.forEach((n => {
             e.has(n) || t.push(new __PRIVATE_AddedLimboDocument(n));
         })), t;
     }
@@ -15954,9 +15969,9 @@ class __PRIVATE_RemovedLimboDocument {
      * @returns The ViewChange that resulted from this synchronization.
      */
     // PORTING NOTE: Multi-tab only.
-    ma(e) {
-        this.aa = e.ls, this.ca = __PRIVATE_documentKeySet();
-        const t = this.Ia(e.documents);
+    pa(e) {
+        this.la = e.ls, this.Pa = __PRIVATE_documentKeySet();
+        const t = this.da(e.documents);
         return this.applyChanges(t, /* limboResolutionEnabled= */ !0);
     }
     /**
@@ -15965,8 +15980,8 @@ class __PRIVATE_RemovedLimboDocument {
      * `hasPendingWrites` status of the already established view.
      */
     // PORTING NOTE: Multi-tab only.
-    fa() {
-        return ViewSnapshot.fromInitialDocuments(this.query, this.ha, this.mutatedKeys, 0 /* SyncState.Local */ === this.ua, this.hasCachedResults);
+    ya() {
+        return ViewSnapshot.fromInitialDocuments(this.query, this.Ta, this.mutatedKeys, 0 /* SyncState.Local */ === this.ha, this.hasCachedResults);
     }
 }
 
@@ -16005,7 +16020,7 @@ class __PRIVATE_QueryView {
          * decide whether it needs to manufacture a delete event for the target once
          * the target is CURRENT.
          */
-        this.ga = !1;
+        this.wa = !1;
     }
 }
 
@@ -16026,8 +16041,8 @@ class __PRIVATE_QueryView {
     // PORTING NOTE: Manages state synchronization in multi-tab environments.
     r, i, s) {
         this.localStore = e, this.remoteStore = t, this.eventManager = n, this.sharedClientState = r, 
-        this.currentUser = i, this.maxConcurrentLimboResolutions = s, this.pa = {}, this.ya = new ObjectMap((e => __PRIVATE_canonifyQuery(e)), __PRIVATE_queryEquals), 
-        this.wa = new Map, 
+        this.currentUser = i, this.maxConcurrentLimboResolutions = s, this.Sa = {}, this.ba = new ObjectMap((e => __PRIVATE_canonifyQuery(e)), __PRIVATE_queryEquals), 
+        this.Da = new Map, 
         /**
          * The keys of documents that are in limbo for which we haven't yet started a
          * limbo resolution query. The strings in this set are the result of calling
@@ -16037,28 +16052,28 @@ class __PRIVATE_QueryView {
          * of arbitrary elements and it also maintains insertion order, providing the
          * desired queue-like FIFO semantics.
          */
-        this.Sa = new Set, 
+        this.Ca = new Set, 
         /**
          * Keeps track of the target ID for each document that is in limbo with an
          * active target.
          */
-        this.ba = new SortedMap(DocumentKey.comparator), 
+        this.va = new SortedMap(DocumentKey.comparator), 
         /**
          * Keeps track of the information about an active limbo resolution for each
          * active target ID that was started for the purpose of limbo resolution.
          */
-        this.Da = new Map, this.Ca = new __PRIVATE_ReferenceSet, 
+        this.Fa = new Map, this.Ma = new __PRIVATE_ReferenceSet, 
         /** Stores user completion handlers, indexed by User and BatchId. */
-        this.va = {}, 
+        this.xa = {}, 
         /** Stores user callbacks waiting for all pending writes to be acknowledged. */
-        this.Fa = new Map, this.Ma = __PRIVATE_TargetIdGenerator.Nn(), this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
+        this.Oa = new Map, this.Na = __PRIVATE_TargetIdGenerator.Nn(), this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
         // The primary state is set to `true` or `false` immediately after Firestore
         // startup. In the interim, a client should only be considered primary if
         // `isPrimary` is true.
-        this.xa = void 0;
+        this.La = void 0;
     }
     get isPrimaryClient() {
-        return !0 === this.xa;
+        return !0 === this.La;
     }
 }
 
@@ -16070,7 +16085,7 @@ class __PRIVATE_QueryView {
 async function __PRIVATE_syncEngineListen(e, t, n = !0) {
     const r = __PRIVATE_ensureWatchCallbacks(e);
     let i;
-    const s = r.ya.get(t);
+    const s = r.ba.get(t);
     return s ? (
     // PORTING NOTE: With Multi-Tab Web, it is possible that a query view
     // already exists when EventManager calls us for the first time. This
@@ -16078,7 +16093,7 @@ async function __PRIVATE_syncEngineListen(e, t, n = !0) {
     // behalf of another tab and the user of the primary also starts listening
     // to the query. EventManager will not have an assigned target ID in this
     // case and calls `listen` to obtain this ID.
-    r.sharedClientState.addLocalQueryTarget(s.targetId), i = s.view.fa()) : i = await __PRIVATE_allocateTargetAndMaybeListen(r, t, n, 
+    r.sharedClientState.addLocalQueryTarget(s.targetId), i = s.view.ya()) : i = await __PRIVATE_allocateTargetAndMaybeListen(r, t, n, 
     /** shouldInitializeView= */ !0), i;
 }
 
@@ -16103,30 +16118,30 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
     // PORTING NOTE: On Web only, we inject the code that registers new Limbo
     // targets based on view changes. This allows us to only depend on Limbo
     // changes when user code includes queries.
-    e.Oa = (t, n, r) => async function __PRIVATE_applyDocChanges(e, t, n, r) {
-        let i = t.view.Ia(n);
+    e.Ba = (t, n, r) => async function __PRIVATE_applyDocChanges(e, t, n, r) {
+        let i = t.view.da(n);
         i.Zi && (
         // The query has a limit and some docs were removed, so we need
         // to re-run the query against the local store to make sure we
         // didn't lose any good docs that had been past the limit.
         i = await __PRIVATE_localStoreExecuteQuery(e.localStore, t.query, 
-        /* usePreviousResults= */ !1).then((({documents: e}) => t.view.Ia(e, i))));
+        /* usePreviousResults= */ !1).then((({documents: e}) => t.view.da(e, i))));
         const s = r && r.targetChanges.get(t.targetId), o = r && null != r.targetMismatches.get(t.targetId), _ = t.view.applyChanges(i, 
         /* limboResolutionEnabled= */ e.isPrimaryClient, s, o);
-        return __PRIVATE_updateTrackedLimbos(e, t.targetId, _.Ra), _.snapshot;
+        return __PRIVATE_updateTrackedLimbos(e, t.targetId, _.fa), _.snapshot;
     }(e, t, n, r);
     const s = await __PRIVATE_localStoreExecuteQuery(e.localStore, t, 
-    /* usePreviousResults= */ !0), o = new __PRIVATE_View(t, s.ls), _ = o.Ia(s.documents), a = TargetChange.createSynthesizedTargetChangeForCurrentChange(n, r && "Offline" /* OnlineState.Offline */ !== e.onlineState, i), u = o.applyChanges(_, 
+    /* usePreviousResults= */ !0), o = new __PRIVATE_View(t, s.ls), _ = o.da(s.documents), a = TargetChange.createSynthesizedTargetChangeForCurrentChange(n, r && "Offline" /* OnlineState.Offline */ !== e.onlineState, i), u = o.applyChanges(_, 
     /* limboResolutionEnabled= */ e.isPrimaryClient, a);
-    __PRIVATE_updateTrackedLimbos(e, n, u.Ra);
+    __PRIVATE_updateTrackedLimbos(e, n, u.fa);
     const c = new __PRIVATE_QueryView(t, n, o);
-    return e.ya.set(t, c), e.wa.has(n) ? e.wa.get(n).push(t) : e.wa.set(n, [ t ]), u.snapshot;
+    return e.ba.set(t, c), e.Da.has(n) ? e.Da.get(n).push(t) : e.Da.set(n, [ t ]), u.snapshot;
 }
 
 /** Stops listening to the query. */ async function __PRIVATE_syncEngineUnlisten(e, t, n) {
-    const r = __PRIVATE_debugCast(e), i = r.ya.get(t), s = r.wa.get(i.targetId);
-    if (s.length > 1) return r.wa.set(i.targetId, s.filter((e => !__PRIVATE_queryEquals(e, t)))), 
-    void r.ya.delete(t);
+    const r = __PRIVATE_debugCast(e), i = r.ba.get(t), s = r.Da.get(i.targetId);
+    if (s.length > 1) return r.Da.set(i.targetId, s.filter((e => !__PRIVATE_queryEquals(e, t)))), 
+    void r.ba.delete(t);
     // No other queries are mapped to the target, clean up the query and the target.
         if (r.isPrimaryClient) {
         // We need to remove the local query target first to allow us to verify
@@ -16142,7 +16157,7 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
 }
 
 /** Unlistens to the remote store while still listening to the cache. */ async function __PRIVATE_triggerRemoteStoreUnlisten(e, t) {
-    const n = __PRIVATE_debugCast(e), r = n.ya.get(t), i = n.wa.get(r.targetId);
+    const n = __PRIVATE_debugCast(e), r = n.ba.get(t), i = n.Da.get(r.targetId);
     n.isPrimaryClient && 1 === i.length && (
     // PORTING NOTE: Unregister the target ID with local Firestore client as
     // watch target.
@@ -16204,9 +16219,9 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
             })));
         }(r.localStore, t);
         r.sharedClientState.addPendingMutation(e.batchId), function __PRIVATE_addMutationCallback(e, t, n) {
-            let r = e.va[e.currentUser.toKey()];
+            let r = e.xa[e.currentUser.toKey()];
             r || (r = new SortedMap(__PRIVATE_primitiveComparator));
-            r = r.insert(t, n), e.va[e.currentUser.toKey()] = r;
+            r = r.insert(t, n), e.xa[e.currentUser.toKey()] = r;
         }
         /**
  * Resolves or rejects the user callback for the given batch and then discards
@@ -16231,13 +16246,13 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
         const e = await __PRIVATE_localStoreApplyRemoteEventToLocalCache(n.localStore, t);
         // Update `receivedDocument` as appropriate for any limbo targets.
                 t.targetChanges.forEach(((e, t) => {
-            const r = n.Da.get(t);
+            const r = n.Fa.get(t);
             r && (
             // Since this is a limbo resolution lookup, it's for a single document
             // and it could be added, modified, or removed, but not a combination.
             __PRIVATE_hardAssert(e.addedDocuments.size + e.modifiedDocuments.size + e.removedDocuments.size <= 1), 
-            e.addedDocuments.size > 0 ? r.ga = !0 : e.modifiedDocuments.size > 0 ? __PRIVATE_hardAssert(r.ga) : e.removedDocuments.size > 0 && (__PRIVATE_hardAssert(r.ga), 
-            r.ga = !1));
+            e.addedDocuments.size > 0 ? r.wa = !0 : e.modifiedDocuments.size > 0 ? __PRIVATE_hardAssert(r.wa) : e.removedDocuments.size > 0 && (__PRIVATE_hardAssert(r.wa), 
+            r.wa = !1));
         })), await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(n, e, t);
     } catch (e) {
         await __PRIVATE_ignoreIfPrimaryLeaseLoss(e);
@@ -16255,19 +16270,19 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
     // SharedClientState.
         if (r.isPrimaryClient && 0 /* OnlineStateSource.RemoteStore */ === n || !r.isPrimaryClient && 1 /* OnlineStateSource.SharedClientState */ === n) {
         const e = [];
-        r.ya.forEach(((n, r) => {
-            const i = r.view.W_(t);
+        r.ba.forEach(((n, r) => {
+            const i = r.view.j_(t);
             i.snapshot && e.push(i.snapshot);
         })), function __PRIVATE_eventManagerOnOnlineStateChange(e, t) {
             const n = __PRIVATE_debugCast(e);
             n.onlineState = t;
             let r = !1;
             n.queries.forEach(((e, n) => {
-                for (const e of n.q_) 
+                for (const e of n.U_) 
                 // Run global snapshot listeners if a consistent snapshot has been emitted.
-                e.W_(t) && (r = !0);
+                e.j_(t) && (r = !0);
             })), r && __PRIVATE_raiseSnapshotsInSyncEvent(n);
-        }(r.eventManager, t), e.length && r.pa.a_(e), r.onlineState = t, r.isPrimaryClient && r.sharedClientState.setOnlineState(t);
+        }(r.eventManager, t), e.length && r.Sa.l_(e), r.onlineState = t, r.isPrimaryClient && r.sharedClientState.setOnlineState(t);
     }
 }
 
@@ -16285,7 +16300,7 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
     const r = __PRIVATE_debugCast(e);
     // PORTING NOTE: Multi-tab only.
         r.sharedClientState.updateQueryState(t, "rejected", n);
-    const i = r.Da.get(t), s = i && i.key;
+    const i = r.Fa.get(t), s = i && i.key;
     if (s) {
         // TODO(klimt): We really only should do the following on permission
         // denied errors, but we don't have the cause code here.
@@ -16307,7 +16322,7 @@ async function __PRIVATE_allocateTargetAndMaybeListen(e, t, n, r) {
         // RemoteEvent. If `applyRemoteEvent()` throws, we want to re-listen to
         // this query when the RemoteStore restarts the Watch stream, which should
         // re-trigger the target failure.
-        r.ba = r.ba.remove(s), r.Da.delete(t), __PRIVATE_pumpEnqueuedLimboResolutions(r);
+        r.va = r.va.remove(s), r.Fa.delete(t), __PRIVATE_pumpEnqueuedLimboResolutions(r);
     } else await __PRIVATE_localStoreReleaseTarget(r.localStore, t, 
     /* keepPersistedTargetData */ !1).then((() => __PRIVATE_removeAndCleanupTarget(r, t, n))).catch(__PRIVATE_ignoreIfPrimaryLeaseLoss);
 }
@@ -16369,8 +16384,8 @@ async function __PRIVATE_syncEngineRejectFailedWrite(e, t, n) {
         if (-1 === e) 
         // Trigger the callback right away if there is no pending writes at the moment.
         return void t.resolve();
-        const r = n.Fa.get(e) || [];
-        r.push(t), n.Fa.set(e, r);
+        const r = n.Oa.get(e) || [];
+        r.push(t), n.Oa.set(e, r);
     } catch (e) {
         const n = __PRIVATE_wrapInUserErrorIfRecoverable(e, "Initialization of waitForPendingWrites() operation failed");
         t.reject(n);
@@ -16381,28 +16396,28 @@ async function __PRIVATE_syncEngineRejectFailedWrite(e, t, n) {
  * Triggers the callbacks that are waiting for this batch id to get acknowledged by server,
  * if there are any.
  */ function __PRIVATE_triggerPendingWritesCallbacks(e, t) {
-    (e.Fa.get(t) || []).forEach((e => {
+    (e.Oa.get(t) || []).forEach((e => {
         e.resolve();
-    })), e.Fa.delete(t);
+    })), e.Oa.delete(t);
 }
 
 /** Reject all outstanding callbacks waiting for pending writes to complete. */ function __PRIVATE_processUserCallback(e, t, n) {
     const r = __PRIVATE_debugCast(e);
-    let i = r.va[r.currentUser.toKey()];
+    let i = r.xa[r.currentUser.toKey()];
     // NOTE: Mutations restored from persistence won't have callbacks, so it's
     // okay for there to be no callback for this ID.
         if (i) {
         const e = i.get(t);
-        e && (n ? e.reject(n) : e.resolve(), i = i.remove(t)), r.va[r.currentUser.toKey()] = i;
+        e && (n ? e.reject(n) : e.resolve(), i = i.remove(t)), r.xa[r.currentUser.toKey()] = i;
     }
 }
 
 function __PRIVATE_removeAndCleanupTarget(e, t, n = null) {
     e.sharedClientState.removeLocalQueryTarget(t);
-    for (const r of e.wa.get(t)) e.ya.delete(r), n && e.pa.Na(r, n);
-    if (e.wa.delete(t), e.isPrimaryClient) {
-        e.Ca.Rr(t).forEach((t => {
-            e.Ca.containsKey(t) || 
+    for (const r of e.Da.get(t)) e.ba.delete(r), n && e.Sa.ka(r, n);
+    if (e.Da.delete(t), e.isPrimaryClient) {
+        e.Ma.Rr(t).forEach((t => {
+            e.Ma.containsKey(t) || 
             // We removed the last reference for this key
             __PRIVATE_removeLimboTarget(e, t);
         }));
@@ -16410,19 +16425,19 @@ function __PRIVATE_removeAndCleanupTarget(e, t, n = null) {
 }
 
 function __PRIVATE_removeLimboTarget(e, t) {
-    e.Sa.delete(t.path.canonicalString());
+    e.Ca.delete(t.path.canonicalString());
     // It's possible that the target already got removed because the query failed. In that case,
     // the key won't exist in `limboTargetsByKey`. Only do the cleanup if we still have the target.
-    const n = e.ba.get(t);
-    null !== n && (__PRIVATE_remoteStoreUnlisten(e.remoteStore, n), e.ba = e.ba.remove(t), 
-    e.Da.delete(n), __PRIVATE_pumpEnqueuedLimboResolutions(e));
+    const n = e.va.get(t);
+    null !== n && (__PRIVATE_remoteStoreUnlisten(e.remoteStore, n), e.va = e.va.remove(t), 
+    e.Fa.delete(n), __PRIVATE_pumpEnqueuedLimboResolutions(e));
 }
 
 function __PRIVATE_updateTrackedLimbos(e, t, n) {
-    for (const r of n) if (r instanceof __PRIVATE_AddedLimboDocument) e.Ca.addReference(r.key, t), 
+    for (const r of n) if (r instanceof __PRIVATE_AddedLimboDocument) e.Ma.addReference(r.key, t), 
     __PRIVATE_trackLimboChange(e, r); else if (r instanceof __PRIVATE_RemovedLimboDocument) {
-        __PRIVATE_logDebug("SyncEngine", "Document no longer in limbo: " + r.key), e.Ca.removeReference(r.key, t);
-        e.Ca.containsKey(r.key) || 
+        __PRIVATE_logDebug("SyncEngine", "Document no longer in limbo: " + r.key), e.Ma.removeReference(r.key, t);
+        e.Ma.containsKey(r.key) || 
         // We removed the last reference for this key
         __PRIVATE_removeLimboTarget(e, r.key);
     } else fail();
@@ -16430,8 +16445,8 @@ function __PRIVATE_updateTrackedLimbos(e, t, n) {
 
 function __PRIVATE_trackLimboChange(e, t) {
     const n = t.key, r = n.path.canonicalString();
-    e.ba.get(n) || e.Sa.has(r) || (__PRIVATE_logDebug("SyncEngine", "New document in limbo: " + n), 
-    e.Sa.add(r), __PRIVATE_pumpEnqueuedLimboResolutions(e));
+    e.va.get(n) || e.Ca.has(r) || (__PRIVATE_logDebug("SyncEngine", "New document in limbo: " + n), 
+    e.Ca.add(r), __PRIVATE_pumpEnqueuedLimboResolutions(e));
 }
 
 /**
@@ -16442,18 +16457,18 @@ function __PRIVATE_trackLimboChange(e, t) {
  * with "resource exhausted" errors which can lead to pathological client
  * behavior as seen in https://github.com/firebase/firebase-js-sdk/issues/2683.
  */ function __PRIVATE_pumpEnqueuedLimboResolutions(e) {
-    for (;e.Sa.size > 0 && e.ba.size < e.maxConcurrentLimboResolutions; ) {
-        const t = e.Sa.values().next().value;
-        e.Sa.delete(t);
-        const n = new DocumentKey(ResourcePath.fromString(t)), r = e.Ma.next();
-        e.Da.set(r, new LimboResolution(n)), e.ba = e.ba.insert(n, r), __PRIVATE_remoteStoreListen(e.remoteStore, new TargetData(__PRIVATE_queryToTarget(__PRIVATE_newQueryForPath(n.path)), r, "TargetPurposeLimboResolution" /* TargetPurpose.LimboResolution */ , __PRIVATE_ListenSequence.oe));
+    for (;e.Ca.size > 0 && e.va.size < e.maxConcurrentLimboResolutions; ) {
+        const t = e.Ca.values().next().value;
+        e.Ca.delete(t);
+        const n = new DocumentKey(ResourcePath.fromString(t)), r = e.Na.next();
+        e.Fa.set(r, new LimboResolution(n)), e.va = e.va.insert(n, r), __PRIVATE_remoteStoreListen(e.remoteStore, new TargetData(__PRIVATE_queryToTarget(__PRIVATE_newQueryForPath(n.path)), r, "TargetPurposeLimboResolution" /* TargetPurpose.LimboResolution */ , __PRIVATE_ListenSequence.oe));
     }
 }
 
 async function __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, t, n) {
     const r = __PRIVATE_debugCast(e), i = [], s = [], o = [];
-    r.ya.isEmpty() || (r.ya.forEach(((e, _) => {
-        o.push(r.Oa(_, t, n).then((e => {
+    r.ba.isEmpty() || (r.ba.forEach(((e, _) => {
+        o.push(r.Ba(_, t, n).then((e => {
             // Update views if there are actual changes.
             if (
             // If there are changes, or we are handling a global snapshot, notify
@@ -16465,7 +16480,7 @@ async function __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, t, n) {
                 s.push(t);
             }
         })));
-    })), await Promise.all(o), r.pa.a_(i), await async function __PRIVATE_localStoreNotifyLocalViewChanges(e, t) {
+    })), await Promise.all(o), r.Sa.l_(i), await async function __PRIVATE_localStoreNotifyLocalViewChanges(e, t) {
         const n = __PRIVATE_debugCast(e);
         try {
             await n.persistence.runTransaction("notifyLocalViewChanges", "readwrite", (e => PersistencePromise.forEach(t, (t => PersistencePromise.forEach(t.ki, (r => n.persistence.referenceDelegate.addReference(e, t.targetId, r))).next((() => PersistencePromise.forEach(t.qi, (r => n.persistence.referenceDelegate.removeReference(e, t.targetId, r)))))))));
@@ -16496,11 +16511,11 @@ async function __PRIVATE_syncEngineHandleCredentialChange(e, t) {
         n.currentUser = t, 
         // Fails tasks waiting for pending writes requested by previous user.
         function __PRIVATE_rejectOutstandingPendingWritesCallbacks(e, t) {
-            e.Fa.forEach((e => {
+            e.Oa.forEach((e => {
                 e.forEach((e => {
                     e.reject(new FirestoreError(D.CANCELLED, t));
                 }));
-            })), e.Fa.clear();
+            })), e.Oa.clear();
         }(n, "'waitForPendingWrites' promise is rejected due to a user change."), 
         // TODO(b/114226417): Consider calling this only in the primary tab.
         n.sharedClientState.handleUserChange(t, e.removedBatchIds, e.addedBatchIds), await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(n, e._s);
@@ -16508,15 +16523,15 @@ async function __PRIVATE_syncEngineHandleCredentialChange(e, t) {
 }
 
 function __PRIVATE_syncEngineGetRemoteKeysForTarget(e, t) {
-    const n = __PRIVATE_debugCast(e), r = n.Da.get(t);
-    if (r && r.ga) return __PRIVATE_documentKeySet().add(r.key);
+    const n = __PRIVATE_debugCast(e), r = n.Fa.get(t);
+    if (r && r.wa) return __PRIVATE_documentKeySet().add(r.key);
     {
         let e = __PRIVATE_documentKeySet();
-        const r = n.wa.get(t);
+        const r = n.Da.get(t);
         if (!r) return e;
         for (const t of r) {
-            const r = n.ya.get(t);
-            e = e.unionWith(r.view.Pa);
+            const r = n.ba.get(t);
+            e = e.unionWith(r.view.Ea);
         }
         return e;
     }
@@ -16527,8 +16542,8 @@ function __PRIVATE_syncEngineGetRemoteKeysForTarget(e, t) {
  * from persistence.
  */ async function __PRIVATE_synchronizeViewAndComputeSnapshot(e, t) {
     const n = __PRIVATE_debugCast(e), r = await __PRIVATE_localStoreExecuteQuery(n.localStore, t.query, 
-    /* usePreviousResults= */ !0), i = t.view.ma(r);
-    return n.isPrimaryClient && __PRIVATE_updateTrackedLimbos(n, t.targetId, i.Ra), 
+    /* usePreviousResults= */ !0), i = t.view.pa(r);
+    return n.isPrimaryClient && __PRIVATE_updateTrackedLimbos(n, t.targetId, i.fa), 
     i;
 }
 
@@ -16579,7 +16594,7 @@ async function __PRIVATE_syncEngineApplyBatchState(e, t, n, r) {
 async function __PRIVATE_syncEngineApplyPrimaryState(e, t) {
     const n = __PRIVATE_debugCast(e);
     if (__PRIVATE_ensureWatchCallbacks(n), __PRIVATE_syncEngineEnsureWriteCallbacks(n), 
-    !0 === t && !0 !== n.xa) {
+    !0 === t && !0 !== n.La) {
         // Secondary tabs only maintain Views for their local listeners and the
         // Views internal state may not be 100% populated (in particular
         // secondary tabs don't track syncedDocuments, the set of documents the
@@ -16587,12 +16602,12 @@ async function __PRIVATE_syncEngineApplyPrimaryState(e, t) {
         // primary, we need to need to make sure that all views for all targets
         // match the state on disk.
         const e = n.sharedClientState.getAllActiveQueryTargets(), t = await __PRIVATE_synchronizeQueryViewsAndRaiseSnapshots(n, e.toArray());
-        n.xa = !0, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !0);
+        n.La = !0, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !0);
         for (const e of t) __PRIVATE_remoteStoreListen(n.remoteStore, e);
-    } else if (!1 === t && !1 !== n.xa) {
+    } else if (!1 === t && !1 !== n.La) {
         const e = [];
         let t = Promise.resolve();
-        n.wa.forEach(((r, i) => {
+        n.Da.forEach(((r, i) => {
             n.sharedClientState.isLocalQueryTarget(i) ? e.push(i) : t = t.then((() => (__PRIVATE_removeAndCleanupTarget(n, i), 
             __PRIVATE_localStoreReleaseTarget(n.localStore, i, 
             /*keepPersistedTargetData=*/ !0)))), __PRIVATE_remoteStoreUnlisten(n.remoteStore, i);
@@ -16600,9 +16615,9 @@ async function __PRIVATE_syncEngineApplyPrimaryState(e, t) {
         // PORTING NOTE: Multi-Tab only.
         function __PRIVATE_resetLimboDocuments(e) {
             const t = __PRIVATE_debugCast(e);
-            t.Da.forEach(((e, n) => {
+            t.Fa.forEach(((e, n) => {
                 __PRIVATE_remoteStoreUnlisten(t.remoteStore, n);
-            })), t.Ca.Vr(), t.Da = new Map, t.ba = new SortedMap(DocumentKey.comparator);
+            })), t.Ma.Vr(), t.Fa = new Map, t.va = new SortedMap(DocumentKey.comparator);
         }
         /**
  * Reconcile the query views of the provided query targets with the state from
@@ -16615,7 +16630,7 @@ async function __PRIVATE_syncEngineApplyPrimaryState(e, t) {
  * tab to a primary tab
  */
         // PORTING NOTE: Multi-Tab only.
-        (n), n.xa = !1, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !1);
+        (n), n.La = !1, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !1);
     }
 }
 
@@ -16623,7 +16638,7 @@ async function __PRIVATE_synchronizeQueryViewsAndRaiseSnapshots(e, t, n) {
     const r = __PRIVATE_debugCast(e), i = [], s = [];
     for (const e of t) {
         let t;
-        const n = r.wa.get(e);
+        const n = r.Da.get(e);
         if (n && 0 !== n.length) {
             // For queries that have a local View, we fetch their current state
             // from LocalStore (as the resume token and the snapshot version
@@ -16631,7 +16646,7 @@ async function __PRIVATE_synchronizeQueryViewsAndRaiseSnapshots(e, t, n) {
             // state (the list of syncedDocuments may have gotten out of sync).
             t = await __PRIVATE_localStoreAllocateTarget(r.localStore, __PRIVATE_queryToTarget(n[0]));
             for (const e of n) {
-                const t = r.ya.get(e), n = await __PRIVATE_synchronizeViewAndComputeSnapshot(r, t);
+                const t = r.ba.get(e), n = await __PRIVATE_synchronizeViewAndComputeSnapshot(r, t);
                 n.snapshot && s.push(n.snapshot);
             }
         } else {
@@ -16643,7 +16658,7 @@ async function __PRIVATE_synchronizeQueryViewsAndRaiseSnapshots(e, t, n) {
         }
         i.push(t);
     }
-    return r.pa.a_(s), i;
+    return r.Sa.l_(s), i;
 }
 
 /**
@@ -16673,11 +16688,11 @@ function __PRIVATE_syncEngineGetActiveClients(e) {
 // PORTING NOTE: Multi-Tab only.
 async function __PRIVATE_syncEngineApplyTargetState(e, t, n, r) {
     const i = __PRIVATE_debugCast(e);
-    if (i.xa) 
+    if (i.La) 
     // If we receive a target state notification via WebStorage, we are
     // either already secondary or another tab has taken the primary lease.
     return void __PRIVATE_logDebug("SyncEngine", "Ignoring unexpected query state notification.");
-    const s = i.wa.get(t);
+    const s = i.Da.get(t);
     if (s && s.length > 0) switch (n) {
       case "current":
       case "not-current":
@@ -16699,9 +16714,9 @@ async function __PRIVATE_syncEngineApplyTargetState(e, t, n, r) {
 
 /** Adds or removes Watch targets for queries from different tabs. */ async function __PRIVATE_syncEngineApplyActiveTargetsChange(e, t, n) {
     const r = __PRIVATE_ensureWatchCallbacks(e);
-    if (r.xa) {
+    if (r.La) {
         for (const e of t) {
-            if (r.wa.has(e) && r.sharedClientState.isActiveQueryTarget(e)) {
+            if (r.Da.has(e) && r.sharedClientState.isActiveQueryTarget(e)) {
                 __PRIVATE_logDebug("SyncEngine", "Adding an already active target " + e);
                 continue;
             }
@@ -16712,7 +16727,7 @@ async function __PRIVATE_syncEngineApplyTargetState(e, t, n, r) {
         for (const e of n) 
         // Check that the target is still active since the target might have been
         // removed if it has been rejected by the backend.
-        r.wa.has(e) && 
+        r.Da.has(e) && 
         // Release queries that are still active.
         await __PRIVATE_localStoreReleaseTarget(r.localStore, e, 
         /* keepPersistedTargetData */ !1).then((() => {
@@ -16726,7 +16741,7 @@ function __PRIVATE_ensureWatchCallbacks(e) {
     return t.remoteStore.remoteSyncer.applyRemoteEvent = __PRIVATE_syncEngineApplyRemoteEvent.bind(null, t), 
     t.remoteStore.remoteSyncer.getRemoteKeysForTarget = __PRIVATE_syncEngineGetRemoteKeysForTarget.bind(null, t), 
     t.remoteStore.remoteSyncer.rejectListen = __PRIVATE_syncEngineRejectListen.bind(null, t), 
-    t.pa.a_ = __PRIVATE_eventManagerOnWatchChange.bind(null, t.eventManager), t.pa.Na = __PRIVATE_eventManagerOnWatchError.bind(null, t.eventManager), 
+    t.Sa.l_ = __PRIVATE_eventManagerOnWatchChange.bind(null, t.eventManager), t.Sa.ka = __PRIVATE_eventManagerOnWatchError.bind(null, t.eventManager), 
     t;
 }
 
@@ -16769,13 +16784,13 @@ function __PRIVATE_syncEngineEnsureWriteCallbacks(e) {
             }(r)), Promise.resolve(new Set);
             n._updateProgress(__PRIVATE_bundleInitialProgress(r));
             const i = new __PRIVATE_BundleLoader(r, e.localStore, t.serializer);
-            let s = await t.La();
+            let s = await t.qa();
             for (;s; ) {
-                const e = await i.ia(s);
-                e && n._updateProgress(e), s = await t.La();
+                const e = await i._a(s);
+                e && n._updateProgress(e), s = await t.qa();
             }
             const o = await i.complete();
-            return await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, o._a, 
+            return await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, o.ca, 
             /* remoteEvent */ void 0), 
             // Save metadata, so loading the same bundle will skip.
             await function __PRIVATE_localStoreSaveBundle(e, t) {
@@ -16785,7 +16800,7 @@ function __PRIVATE_syncEngineEnsureWriteCallbacks(e) {
             /**
  * Returns a promise of a `NamedQuery` associated with given query name. Promise
  * resolves to undefined if no persisted data can be found.
- */ (e.localStore, r), n._completeWith(o.progress), Promise.resolve(o.oa);
+ */ (e.localStore, r), n._completeWith(o.progress), Promise.resolve(o.ua);
         } catch (e) {
             return __PRIVATE_logWarn("SyncEngine", `Loading bundle failed with ${e}`), n._failWith(e), 
             Promise.resolve(new Set);
@@ -16865,12 +16880,12 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends MemoryOfflineCompone
  * Provides all components needed for Firestore with IndexedDB persistence.
  */ class __PRIVATE_IndexedDbOfflineComponentProvider extends MemoryOfflineComponentProvider {
     constructor(e, t, n) {
-        super(), this.Ba = e, this.cacheSizeBytes = t, this.forceOwnership = n, this.synchronizeTabs = !1;
+        super(), this.Qa = e, this.cacheSizeBytes = t, this.forceOwnership = n, this.synchronizeTabs = !1;
     }
     async initialize(e) {
-        await super.initialize(e), await this.Ba.initialize(this, e), 
+        await super.initialize(e), await this.Qa.initialize(this, e), 
         // Enqueue writes from a previous session
-        await __PRIVATE_syncEngineEnsureWriteCallbacks(this.Ba.syncEngine), await __PRIVATE_fillWritePipeline(this.Ba.remoteStore), 
+        await __PRIVATE_syncEngineEnsureWriteCallbacks(this.Qa.syncEngine), await __PRIVATE_fillWritePipeline(this.Qa.remoteStore), 
         // NOTE: This will immediately call the listener, so we make sure to
         // set it after localStore / remoteStore are started.
         await this.persistence.mi((() => (this.gcScheduler && !this.gcScheduler.started && this.gcScheduler.start(), 
@@ -16906,11 +16921,11 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends MemoryOfflineCompone
  * `synchronizeTabs` will be enabled.
  */ class __PRIVATE_MultiTabOfflineComponentProvider extends __PRIVATE_IndexedDbOfflineComponentProvider {
     constructor(e, t) {
-        super(e, t, /* forceOwnership= */ !1), this.Ba = e, this.cacheSizeBytes = t, this.synchronizeTabs = !0;
+        super(e, t, /* forceOwnership= */ !1), this.Qa = e, this.cacheSizeBytes = t, this.synchronizeTabs = !0;
     }
     async initialize(e) {
         await super.initialize(e);
-        const t = this.Ba.syncEngine;
+        const t = this.Qa.syncEngine;
         this.sharedClientState instanceof __PRIVATE_WebStorageSharedClientState && (this.sharedClientState.syncEngine = {
             Ys: __PRIVATE_syncEngineApplyBatchState.bind(null, t),
             Zs: __PRIVATE_syncEngineApplyTargetState.bind(null, t),
@@ -16921,7 +16936,7 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends MemoryOfflineCompone
         // NOTE: This will immediately call the listener, so we make sure to
         // set it after localStore / remoteStore are started.
         await this.persistence.mi((async e => {
-            await __PRIVATE_syncEngineApplyPrimaryState(this.Ba.syncEngine, e), this.gcScheduler && (e && !this.gcScheduler.started ? this.gcScheduler.start() : e || this.gcScheduler.stop()), 
+            await __PRIVATE_syncEngineApplyPrimaryState(this.Qa.syncEngine, e), this.gcScheduler && (e && !this.gcScheduler.started ? this.gcScheduler.start() : e || this.gcScheduler.stop()), 
             this.indexBackfillerScheduler && (e && !this.indexBackfillerScheduler.started ? this.indexBackfillerScheduler.start() : e || this.indexBackfillerScheduler.stop());
         }));
     }
@@ -16972,18 +16987,18 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends MemoryOfflineCompone
         // PORTING NOTE: Manages state synchronization in multi-tab environments.
         r, i, s, o) {
             const _ = new __PRIVATE_SyncEngineImpl(e, t, n, r, i, s);
-            return o && (_.xa = !0), _;
+            return o && (_.La = !0), _;
         }(this.localStore, this.remoteStore, this.eventManager, this.sharedClientState, e.initialUser, e.maxConcurrentLimboResolutions, t);
     }
     async terminate() {
         var e;
         await async function __PRIVATE_remoteStoreShutdown(e) {
             const t = __PRIVATE_debugCast(e);
-            __PRIVATE_logDebug("RemoteStore", "RemoteStore shutting down."), t.C_.add(5 /* OfflineCause.Shutdown */), 
-            await __PRIVATE_disableNetworkInternal(t), t.F_.shutdown(), 
+            __PRIVATE_logDebug("RemoteStore", "RemoteStore shutting down."), t.M_.add(5 /* OfflineCause.Shutdown */), 
+            await __PRIVATE_disableNetworkInternal(t), t.O_.shutdown(), 
             // Set the OnlineState to Unknown (rather than Offline) to avoid potentially
             // triggering spurious listener events with cached data, etc.
-            t.M_.set("Unknown" /* OnlineState.Unknown */);
+            t.N_.set("Unknown" /* OnlineState.Unknown */);
         }(this.remoteStore), null === (e = this.datastore) || void 0 === e || e.terminate();
     }
 }
@@ -17091,15 +17106,15 @@ class __PRIVATE_AsyncObserver {
         this.muted = !1;
     }
     next(e) {
-        this.observer.next && this.ka(this.observer.next, e);
+        this.observer.next && this.Ka(this.observer.next, e);
     }
     error(e) {
-        this.observer.error ? this.ka(this.observer.error, e) : __PRIVATE_logError("Uncaught Error in snapshot listener:", e.toString());
+        this.observer.error ? this.Ka(this.observer.error, e) : __PRIVATE_logError("Uncaught Error in snapshot listener:", e.toString());
     }
-    qa() {
+    $a() {
         this.muted = !0;
     }
-    ka(e, t) {
+    Ka(e, t) {
         this.muted || setTimeout((() => {
             this.muted || e(t);
         }), 0);
@@ -17131,30 +17146,30 @@ class __PRIVATE_AsyncObserver {
     constructor(
     /** The reader to read from underlying binary bundle data source. */
     e, t) {
-        this.Qa = e, this.serializer = t, 
+        this.Ua = e, this.serializer = t, 
         /** Cached bundle metadata. */
         this.metadata = new __PRIVATE_Deferred, 
         /**
          * Internal buffer to hold bundle content, accumulating incomplete element
          * content.
          */
-        this.buffer = new Uint8Array, this.Ka = function __PRIVATE_newTextDecoder() {
+        this.buffer = new Uint8Array, this.Wa = function __PRIVATE_newTextDecoder() {
             return new TextDecoder("utf-8");
         }(), 
         // Read the metadata (which is the first element).
-        this.$a().then((e => {
-            e && e.na() ? this.metadata.resolve(e.ta.metadata) : this.metadata.reject(new Error(`The first element of the bundle is not a metadata, it is\n             ${JSON.stringify(null == e ? void 0 : e.ta)}`));
+        this.Ga().then((e => {
+            e && e.sa() ? this.metadata.resolve(e.ia.metadata) : this.metadata.reject(new Error(`The first element of the bundle is not a metadata, it is\n             ${JSON.stringify(null == e ? void 0 : e.ia)}`));
         }), (e => this.metadata.reject(e)));
     }
     close() {
-        return this.Qa.cancel();
+        return this.Ua.cancel();
     }
     async getMetadata() {
         return this.metadata.promise;
     }
-    async La() {
+    async qa() {
         // Makes sure metadata is read before proceeding.
-        return await this.getMetadata(), this.$a();
+        return await this.getMetadata(), this.Ga();
     }
     /**
      * Reads from the head of internal buffer, and pulling more data from
@@ -17165,15 +17180,15 @@ class __PRIVATE_AsyncObserver {
      *
      * Returns either the bundled element, or null if we have reached the end of
      * the stream.
-     */    async $a() {
-        const e = await this.Ua();
+     */    async Ga() {
+        const e = await this.za();
         if (null === e) return null;
-        const t = this.Ka.decode(e), n = Number(t);
-        isNaN(n) && this.Wa(`length string (${t}) is not valid number`);
-        const r = await this.Ga(n);
+        const t = this.Wa.decode(e), n = Number(t);
+        isNaN(n) && this.ja(`length string (${t}) is not valid number`);
+        const r = await this.Ha(n);
         return new __PRIVATE_SizedBundleElement(JSON.parse(r), e.length + n);
     }
-    /** First index of '{' from the underlying buffer. */    za() {
+    /** First index of '{' from the underlying buffer. */    Ja() {
         return this.buffer.findIndex((e => e === "{".charCodeAt(0)));
     }
     /**
@@ -17181,17 +17196,17 @@ class __PRIVATE_AsyncObserver {
      * return the content.
      *
      * If reached end of the stream, returns a null.
-     */    async Ua() {
-        for (;this.za() < 0; ) {
-            if (await this.ja()) break;
+     */    async za() {
+        for (;this.Ja() < 0; ) {
+            if (await this.Ya()) break;
         }
         // Broke out of the loop because underlying stream is closed, and there
         // happens to be no more data to process.
                 if (0 === this.buffer.length) return null;
-        const e = this.za();
+        const e = this.Ja();
         // Broke out of the loop because underlying stream is closed, but still
         // cannot find an open bracket.
-                e < 0 && this.Wa("Reached the end of bundle when a length string is expected.");
+                e < 0 && this.ja("Reached the end of bundle when a length string is expected.");
         const t = this.buffer.slice(0, e);
         // Update the internal buffer to drop the read length.
                 return this.buffer = this.buffer.slice(e), t;
@@ -17201,23 +17216,23 @@ class __PRIVATE_AsyncObserver {
      * number of bytes, pulling more data from the underlying stream if needed.
      *
      * Returns a string decoded from the read bytes.
-     */    async Ga(e) {
+     */    async Ha(e) {
         for (;this.buffer.length < e; ) {
-            await this.ja() && this.Wa("Reached the end of bundle when more is expected.");
+            await this.Ya() && this.ja("Reached the end of bundle when more is expected.");
         }
-        const t = this.Ka.decode(this.buffer.slice(0, e));
+        const t = this.Wa.decode(this.buffer.slice(0, e));
         // Update the internal buffer to drop the read json string.
                 return this.buffer = this.buffer.slice(e), t;
     }
-    Wa(e) {
+    ja(e) {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        throw this.Qa.cancel(), new Error(`Invalid bundle format: ${e}`);
+        throw this.Ua.cancel(), new Error(`Invalid bundle format: ${e}`);
     }
     /**
      * Pulls more data from underlying stream to internal buffer.
      * Returns a boolean indicating whether the stream is finished.
-     */    async ja() {
-        const e = await this.Qa.read();
+     */    async Ya() {
+        const e = await this.Ua.read();
         if (!e.done) {
             const t = new Uint8Array(this.buffer.length + e.value.length);
             t.set(this.buffer), t.set(e.value, this.buffer.length), this.buffer = t;
@@ -17270,7 +17285,7 @@ class Transaction$2 {
         const t = await async function __PRIVATE_invokeBatchGetDocumentsRpc(e, t) {
             const n = __PRIVATE_debugCast(e), r = {
                 documents: t.map((e => __PRIVATE_toName(n.serializer, e)))
-            }, i = await n.Co("BatchGetDocuments", n.serializer.databaseId, ResourcePath.emptyPath(), r, t.length), s = new Map;
+            }, i = await n.Mo("BatchGetDocuments", n.serializer.databaseId, ResourcePath.emptyPath(), r, t.length), s = new Map;
             i.forEach((e => {
                 const t = __PRIVATE_fromBatchGetDocumentsResponse(n.serializer, e);
                 s.set(t.key.toString(), t);
@@ -17313,7 +17328,7 @@ class Transaction$2 {
             const n = __PRIVATE_debugCast(e), r = {
                 writes: t.map((e => toMutation(n.serializer, e)))
             };
-            await n.wo("Commit", n.serializer.databaseId, ResourcePath.emptyPath(), r);
+            await n.Do("Commit", n.serializer.databaseId, ResourcePath.emptyPath(), r);
         }(this.datastore, this.mutations), this.committed = !0;
     }
     recordVersion(e) {
@@ -17390,26 +17405,26 @@ class Transaction$2 {
  */ class __PRIVATE_TransactionRunner {
     constructor(e, t, n, r, i) {
         this.asyncQueue = e, this.datastore = t, this.options = n, this.updateFunction = r, 
-        this.deferred = i, this.Ha = n.maxAttempts, this.zo = new __PRIVATE_ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
+        this.deferred = i, this.Za = n.maxAttempts, this.Jo = new __PRIVATE_ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
     }
-    /** Runs the transaction and sets the result on deferred. */    Ja() {
-        this.Ha -= 1, this.Ya();
+    /** Runs the transaction and sets the result on deferred. */    Xa() {
+        this.Za -= 1, this.eu();
     }
-    Ya() {
-        this.zo.ko((async () => {
-            const e = new Transaction$2(this.datastore), t = this.Za(e);
+    eu() {
+        this.Jo.Ko((async () => {
+            const e = new Transaction$2(this.datastore), t = this.tu(e);
             t && t.then((t => {
                 this.asyncQueue.enqueueAndForget((() => e.commit().then((() => {
                     this.deferred.resolve(t);
                 })).catch((e => {
-                    this.Xa(e);
+                    this.nu(e);
                 }))));
             })).catch((e => {
-                this.Xa(e);
+                this.nu(e);
             }));
         }));
     }
-    Za(e) {
+    tu(e) {
         try {
             const t = this.updateFunction(e);
             return !__PRIVATE_isNullOrUndefined(t) && t.catch && t.then ? t : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
@@ -17419,11 +17434,11 @@ class Transaction$2 {
             return this.deferred.reject(e), null;
         }
     }
-    Xa(e) {
-        this.Ha > 0 && this.eu(e) ? (this.Ha -= 1, this.asyncQueue.enqueueAndForget((() => (this.Ya(), 
+    nu(e) {
+        this.Za > 0 && this.ru(e) ? (this.Za -= 1, this.asyncQueue.enqueueAndForget((() => (this.eu(), 
         Promise.resolve())))) : this.deferred.reject(e);
     }
-    eu(e) {
+    ru(e) {
         if ("FirebaseError" === e.name) {
             // In transactions, the backend will fail outdated reads with FAILED_PRECONDITION and
             // non-matching document versions with ABORTED. These errors should be retried.
@@ -17608,7 +17623,7 @@ async function __PRIVATE_getEventManager(e) {
         const t = await __PRIVATE_getPersistence(e), n = await __PRIVATE_getRemoteStore(e);
         return t.setNetworkEnabled(!0), function __PRIVATE_remoteStoreEnableNetwork(e) {
             const t = __PRIVATE_debugCast(e);
-            return t.C_.delete(0 /* OfflineCause.UserDisabled */), __PRIVATE_enableNetworkInternal(t);
+            return t.M_.delete(0 /* OfflineCause.UserDisabled */), __PRIVATE_enableNetworkInternal(t);
         }(n);
     }));
 }
@@ -17618,9 +17633,9 @@ async function __PRIVATE_getEventManager(e) {
         const t = await __PRIVATE_getPersistence(e), n = await __PRIVATE_getRemoteStore(e);
         return t.setNetworkEnabled(!1), async function __PRIVATE_remoteStoreDisableNetwork(e) {
             const t = __PRIVATE_debugCast(e);
-            t.C_.add(0 /* OfflineCause.UserDisabled */), await __PRIVATE_disableNetworkInternal(t), 
+            t.M_.add(0 /* OfflineCause.UserDisabled */), await __PRIVATE_disableNetworkInternal(t), 
             // Set the OnlineState to Offline so get()s return from cache, etc.
-            t.M_.set("Offline" /* OnlineState.Offline */);
+            t.N_.set("Offline" /* OnlineState.Offline */);
         }(n);
     }));
 }
@@ -17671,7 +17686,7 @@ function __PRIVATE_firestoreClientGetDocumentViaSnapshotListener(e, t, n = {}) {
             error: e => i.reject(e)
         }), o = new __PRIVATE_QueryListener(__PRIVATE_newQueryForPath(n.path), s, {
             includeMetadataChanges: !0,
-            ea: !0
+            ra: !0
         });
         return __PRIVATE_eventManagerListen(e, o);
     }(await __PRIVATE_getEventManager(e), e.asyncQueue, t, n, r))), r.promise;
@@ -17682,7 +17697,7 @@ function __PRIVATE_firestoreClientGetDocumentsFromLocalCache(e, t) {
     return e.asyncQueue.enqueueAndForget((async () => async function __PRIVATE_executeQueryFromCache(e, t, n) {
         try {
             const r = await __PRIVATE_localStoreExecuteQuery(e, t, 
-            /* usePreviousResults= */ !0), i = new __PRIVATE_View(t, r.ls), s = i.Ia(r.documents), o = i.applyChanges(s, 
+            /* usePreviousResults= */ !0), i = new __PRIVATE_View(t, r.ls), s = i.da(r.documents), o = i.applyChanges(s, 
             /* limboResolutionEnabled= */ !1);
             n.resolve(o.snapshot);
         } catch (e) {
@@ -17708,7 +17723,7 @@ function __PRIVATE_firestoreClientGetDocumentsViaSnapshotListener(e, t, n = {})
             error: e => i.reject(e)
         }), o = new __PRIVATE_QueryListener(n, s, {
             includeMetadataChanges: !0,
-            ea: !0
+            ra: !0
         });
         return __PRIVATE_eventManagerListen(e, o);
     }(await __PRIVATE_getEventManager(e), e.asyncQueue, t, n, r))), r.promise;
@@ -17717,13 +17732,13 @@ function __PRIVATE_firestoreClientGetDocumentsViaSnapshotListener(e, t, n = {})
 function __PRIVATE_firestoreClientAddSnapshotsInSyncListener(e, t) {
     const n = new __PRIVATE_AsyncObserver(t);
     return e.asyncQueue.enqueueAndForget((async () => function __PRIVATE_addSnapshotsInSyncListener(e, t) {
-        __PRIVATE_debugCast(e).U_.add(t), 
+        __PRIVATE_debugCast(e).z_.add(t), 
         // Immediately fire an initial event, indicating all existing listeners
         // are in-sync.
         t.next();
     }(await __PRIVATE_getEventManager(e), n))), () => {
-        n.qa(), e.asyncQueue.enqueueAndForget((async () => function __PRIVATE_removeSnapshotsInSyncListener(e, t) {
-            __PRIVATE_debugCast(e).U_.delete(t);
+        n.$a(), e.asyncQueue.enqueueAndForget((async () => function __PRIVATE_removeSnapshotsInSyncListener(e, t) {
+            __PRIVATE_debugCast(e).z_.delete(t);
         }(await __PRIVATE_getEventManager(e), n)));
     };
 }
@@ -18388,40 +18403,40 @@ function doc(e, t, ...n) {
  */ class __PRIVATE_AsyncQueueImpl {
     constructor() {
         // The last promise in the queue.
-        this.tu = Promise.resolve(), 
+        this.iu = Promise.resolve(), 
         // A list of retryable operations. Retryable operations are run in order and
         // retried with backoff.
-        this.nu = [], 
+        this.su = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.ru = !1, 
+        this.ou = !1, 
         // Operations scheduled to be queued in the future. Operations are
         // automatically removed after they are run or canceled.
-        this.iu = [], 
+        this._u = [], 
         // visible for testing
-        this.su = null, 
+        this.au = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.ou = !1, 
+        this.uu = !1, 
         // Enabled during shutdown on Safari to prevent future access to IndexedDB.
-        this._u = !1, 
+        this.cu = !1, 
         // List of TimerIds to fast-forward delays for.
-        this.au = [], 
+        this.lu = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.zo = new __PRIVATE_ExponentialBackoff(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */), 
+        this.Jo = new __PRIVATE_ExponentialBackoff(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */), 
         // Visibility handler that triggers an immediate retry of all retryable
         // operations. Meant to speed up recovery when we regain file system access
         // after page comes into foreground.
-        this.uu = () => {
+        this.hu = () => {
             const e = getDocument();
             e && __PRIVATE_logDebug("AsyncQueue", "Visibility state changed to " + e.visibilityState), 
-            this.zo.Qo();
+            this.Jo.Uo();
         };
         const e = getDocument();
-        e && "function" == typeof e.addEventListener && e.addEventListener("visibilitychange", this.uu);
+        e && "function" == typeof e.addEventListener && e.addEventListener("visibilitychange", this.hu);
     }
     get isShuttingDown() {
-        return this.ru;
+        return this.ou;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -18431,44 +18446,44 @@ function doc(e, t, ...n) {
         this.enqueue(e);
     }
     enqueueAndForgetEvenWhileRestricted(e) {
-        this.cu(), 
+        this.Pu(), 
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.lu(e);
+        this.Iu(e);
     }
     enterRestrictedMode(e) {
-        if (!this.ru) {
-            this.ru = !0, this._u = e || !1;
+        if (!this.ou) {
+            this.ou = !0, this.cu = e || !1;
             const t = getDocument();
-            t && "function" == typeof t.removeEventListener && t.removeEventListener("visibilitychange", this.uu);
+            t && "function" == typeof t.removeEventListener && t.removeEventListener("visibilitychange", this.hu);
         }
     }
     enqueue(e) {
-        if (this.cu(), this.ru) 
+        if (this.Pu(), this.ou) 
         // Return a Promise which never resolves.
         return new Promise((() => {}));
         // Create a deferred Promise that we can return to the callee. This
         // allows us to return a "hanging Promise" only to the callee and still
         // advance the queue even when the operation is not run.
                 const t = new __PRIVATE_Deferred;
-        return this.lu((() => this.ru && this._u ? Promise.resolve() : (e().then(t.resolve, t.reject), 
+        return this.Iu((() => this.ou && this.cu ? Promise.resolve() : (e().then(t.resolve, t.reject), 
         t.promise))).then((() => t.promise));
     }
     enqueueRetryable(e) {
-        this.enqueueAndForget((() => (this.nu.push(e), this.hu())));
+        this.enqueueAndForget((() => (this.su.push(e), this.Tu())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async hu() {
-        if (0 !== this.nu.length) {
+     */    async Tu() {
+        if (0 !== this.su.length) {
             try {
-                await this.nu[0](), this.nu.shift(), this.zo.reset();
+                await this.su[0](), this.su.shift(), this.Jo.reset();
             } catch (e) {
                 if (!__PRIVATE_isIndexedDbTransactionError(e)) throw e;
  // Failure will be handled by AsyncQueue
                                 __PRIVATE_logDebug("AsyncQueue", "Operation failed with retryable error: " + e);
             }
-            this.nu.length > 0 && 
+            this.su.length > 0 && 
             // If there are additional operations, we re-schedule `retryNextOp()`.
             // This is necessary to run retryable operations that failed during
             // their initial attempt since we don't know whether they are already
@@ -18479,12 +18494,12 @@ function doc(e, t, ...n) {
             // Since `backoffAndRun()` cancels an existing backoff and schedules a
             // new backoff on every call, there is only ever a single additional
             // operation in the queue.
-            this.zo.ko((() => this.hu()));
+            this.Jo.Ko((() => this.Tu()));
         }
     }
-    lu(e) {
-        const t = this.tu.then((() => (this.ou = !0, e().catch((e => {
-            this.su = e, this.ou = !1;
+    Iu(e) {
+        const t = this.iu.then((() => (this.uu = !0, e().catch((e => {
+            this.au = e, this.uu = !1;
             const t = 
             /**
  * Chrome includes Error.message in Error.stack. Other browsers do not.
@@ -18516,38 +18531,38 @@ function doc(e, t, ...n) {
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw __PRIVATE_logError("INTERNAL UNHANDLED ERROR: ", t), e;
-        })).then((e => (this.ou = !1, e))))));
-        return this.tu = t, t;
+        })).then((e => (this.uu = !1, e))))));
+        return this.iu = t, t;
     }
     enqueueAfterDelay(e, t, n) {
-        this.cu(), 
+        this.Pu(), 
         // Fast-forward delays for timerIds that have been overriden.
-        this.au.indexOf(e) > -1 && (t = 0);
-        const r = DelayedOperation.createAndSchedule(this, e, t, n, (e => this.Pu(e)));
-        return this.iu.push(r), r;
+        this.lu.indexOf(e) > -1 && (t = 0);
+        const r = DelayedOperation.createAndSchedule(this, e, t, n, (e => this.Eu(e)));
+        return this._u.push(r), r;
     }
-    cu() {
-        this.su && fail();
+    Pu() {
+        this.au && fail();
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async Iu() {
+     */    async du() {
         // Operations in the queue prior to draining may have enqueued additional
         // operations. Keep draining the queue until the tail is no longer advanced,
         // which indicates that no more new operations were enqueued and that all
         // operations were executed.
         let e;
         do {
-            e = this.tu, await e;
-        } while (e !== this.tu);
+            e = this.iu, await e;
+        } while (e !== this.iu);
     }
     /**
      * For Tests: Determine if a delayed operation with a particular TimerId
      * exists.
-     */    Tu(e) {
-        for (const t of this.iu) if (t.timerId === e) return !0;
+     */    Au(e) {
+        for (const t of this._u) if (t.timerId === e) return !0;
         return !1;
     }
     /**
@@ -18556,24 +18571,24 @@ function doc(e, t, ...n) {
      * @param lastTimerId - Delayed operations up to and including this TimerId
      * will be drained. Pass TimerId.All to run all delayed operations.
      * @returns a Promise that resolves once all operations have been run.
-     */    Eu(e) {
+     */    Ru(e) {
         // Note that draining may generate more delayed ops, so we do that first.
-        return this.Iu().then((() => {
+        return this.du().then((() => {
             // Run ops in the same order they'd run if they ran naturally.
-            this.iu.sort(((e, t) => e.targetTimeMs - t.targetTimeMs));
-            for (const t of this.iu) if (t.skipDelay(), "all" /* TimerId.All */ !== e && t.timerId === e) break;
-            return this.Iu();
+            this._u.sort(((e, t) => e.targetTimeMs - t.targetTimeMs));
+            for (const t of this._u) if (t.skipDelay(), "all" /* TimerId.All */ !== e && t.timerId === e) break;
+            return this.du();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    du(e) {
-        this.au.push(e);
+     */    Vu(e) {
+        this.lu.push(e);
     }
-    /** Called once a DelayedOperation is run or canceled. */    Pu(e) {
+    /** Called once a DelayedOperation is run or canceled. */    Eu(e) {
         // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.
-        const t = this.iu.indexOf(e);
-        this.iu.splice(t, 1);
+        const t = this._u.indexOf(e);
+        this._u.splice(t, 1);
     }
 }
 
@@ -19387,55 +19402,55 @@ function __PRIVATE_isWrite(e) {
         this.settings = e, this.databaseId = t, this.serializer = n, this.ignoreUndefinedProperties = r, 
         // Minor hack: If fieldTransforms is undefined, we assume this is an
         // external call and we need to validate the entire path.
-        void 0 === i && this.Au(), this.fieldTransforms = i || [], this.fieldMask = s || [];
+        void 0 === i && this.mu(), this.fieldTransforms = i || [], this.fieldMask = s || [];
     }
     get path() {
         return this.settings.path;
     }
-    get Ru() {
-        return this.settings.Ru;
+    get fu() {
+        return this.settings.fu;
     }
-    /** Returns a new context with the specified settings overwritten. */    Vu(e) {
+    /** Returns a new context with the specified settings overwritten. */    gu(e) {
         return new __PRIVATE_ParseContextImpl(Object.assign(Object.assign({}, this.settings), e), this.databaseId, this.serializer, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
     }
-    mu(e) {
+    pu(e) {
         var t;
-        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.Vu({
+        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.gu({
             path: n,
-            fu: !1
+            yu: !1
         });
-        return r.gu(e), r;
+        return r.wu(e), r;
     }
-    pu(e) {
+    Su(e) {
         var t;
-        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.Vu({
+        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.gu({
             path: n,
-            fu: !1
+            yu: !1
         });
-        return r.Au(), r;
+        return r.mu(), r;
     }
-    yu(e) {
+    bu(e) {
         // TODO(b/34871131): We don't support array paths right now; so make path
         // undefined.
-        return this.Vu({
+        return this.gu({
             path: void 0,
-            fu: !0
+            yu: !0
         });
     }
-    wu(e) {
-        return __PRIVATE_createError(e, this.settings.methodName, this.settings.Su || !1, this.path, this.settings.bu);
+    Du(e) {
+        return __PRIVATE_createError(e, this.settings.methodName, this.settings.Cu || !1, this.path, this.settings.vu);
     }
     /** Returns 'true' if 'fieldPath' was traversed when creating this context. */    contains(e) {
         return void 0 !== this.fieldMask.find((t => e.isPrefixOf(t))) || void 0 !== this.fieldTransforms.find((t => e.isPrefixOf(t.field)));
     }
-    Au() {
+    mu() {
         // TODO(b/34871131): Remove null check once we have proper paths for fields
         // within arrays.
-        if (this.path) for (let e = 0; e < this.path.length; e++) this.gu(this.path.get(e));
+        if (this.path) for (let e = 0; e < this.path.length; e++) this.wu(this.path.get(e));
     }
-    gu(e) {
-        if (0 === e.length) throw this.wu("Document fields must not be empty");
-        if (__PRIVATE_isWrite(this.Ru) && we.test(e)) throw this.wu('Document fields cannot begin and end with "__"');
+    wu(e) {
+        if (0 === e.length) throw this.Du("Document fields must not be empty");
+        if (__PRIVATE_isWrite(this.fu) && we.test(e)) throw this.Du('Document fields cannot begin and end with "__"');
     }
 }
 
@@ -19446,14 +19461,14 @@ function __PRIVATE_isWrite(e) {
     constructor(e, t, n) {
         this.databaseId = e, this.ignoreUndefinedProperties = t, this.serializer = n || __PRIVATE_newSerializer(e);
     }
-    /** Creates a new top-level parse context. */    Du(e, t, n, r = !1) {
+    /** Creates a new top-level parse context. */    Fu(e, t, n, r = !1) {
         return new __PRIVATE_ParseContextImpl({
-            Ru: e,
+            fu: e,
             methodName: t,
-            bu: n,
+            vu: n,
             path: FieldPath$1.emptyPath(),
-            fu: !1,
-            Su: r
+            yu: !1,
+            Cu: r
         }, this.databaseId, this.serializer, this.ignoreUndefinedProperties);
     }
 }
@@ -19464,7 +19479,7 @@ function __PRIVATE_newUserDataReader(e) {
 }
 
 /** Parse document data from a set() call. */ function __PRIVATE_parseSetData(e, t, n, r, i, s = {}) {
-    const o = e.Du(s.merge || s.mergeFields ? 2 /* UserDataSource.MergeSet */ : 0 /* UserDataSource.Set */ , t, n, i);
+    const o = e.Fu(s.merge || s.mergeFields ? 2 /* UserDataSource.MergeSet */ : 0 /* UserDataSource.Set */ , t, n, i);
     __PRIVATE_validatePlainObject("Data must be an object, but it was:", o, r);
     const _ = __PRIVATE_parseObject(r, o);
     let a, u;
@@ -19482,7 +19497,7 @@ function __PRIVATE_newUserDataReader(e) {
 
 class __PRIVATE_DeleteFieldValueImpl extends FieldValue {
     _toFieldTransform(e) {
-        if (2 /* UserDataSource.MergeSet */ !== e.Ru) throw 1 /* UserDataSource.Update */ === e.Ru ? e.wu(`${this._methodName}() can only appear at the top level of your update data`) : e.wu(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
+        if (2 /* UserDataSource.MergeSet */ !== e.fu) throw 1 /* UserDataSource.Update */ === e.fu ? e.Du(`${this._methodName}() can only appear at the top level of your update data`) : e.Du(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
         // No transform to add for a delete, but we need to add it to our
         // fieldMask so it gets deleted.
         return e.fieldMask.push(e.path), null;
@@ -19509,10 +19524,10 @@ class __PRIVATE_DeleteFieldValueImpl extends FieldValue {
  * @param arrayElement - Whether or not the FieldValue has an array.
  */ function __PRIVATE_createSentinelChildContext(e, t, n) {
     return new __PRIVATE_ParseContextImpl({
-        Ru: 3 /* UserDataSource.Argument */ ,
-        bu: t.settings.bu,
+        fu: 3 /* UserDataSource.Argument */ ,
+        vu: t.settings.vu,
         methodName: e._methodName,
-        fu: n
+        yu: n
     }, t.databaseId, t.serializer, t.ignoreUndefinedProperties);
 }
 
@@ -19527,47 +19542,47 @@ class __PRIVATE_ServerTimestampFieldValueImpl extends FieldValue {
 
 class __PRIVATE_ArrayUnionFieldValueImpl extends FieldValue {
     constructor(e, t) {
-        super(e), this.Cu = t;
+        super(e), this.Mu = t;
     }
     _toFieldTransform(e) {
         const t = __PRIVATE_createSentinelChildContext(this, e, 
-        /*array=*/ !0), n = this.Cu.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayUnionTransformOperation(n);
+        /*array=*/ !0), n = this.Mu.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayUnionTransformOperation(n);
         return new FieldTransform(e.path, r);
     }
     isEqual(e) {
-        return e instanceof __PRIVATE_ArrayUnionFieldValueImpl && util.deepEqual(this.Cu, e.Cu);
+        return e instanceof __PRIVATE_ArrayUnionFieldValueImpl && util.deepEqual(this.Mu, e.Mu);
     }
 }
 
 class __PRIVATE_ArrayRemoveFieldValueImpl extends FieldValue {
     constructor(e, t) {
-        super(e), this.Cu = t;
+        super(e), this.Mu = t;
     }
     _toFieldTransform(e) {
         const t = __PRIVATE_createSentinelChildContext(this, e, 
-        /*array=*/ !0), n = this.Cu.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayRemoveTransformOperation(n);
+        /*array=*/ !0), n = this.Mu.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayRemoveTransformOperation(n);
         return new FieldTransform(e.path, r);
     }
     isEqual(e) {
-        return e instanceof __PRIVATE_ArrayRemoveFieldValueImpl && util.deepEqual(this.Cu, e.Cu);
+        return e instanceof __PRIVATE_ArrayRemoveFieldValueImpl && util.deepEqual(this.Mu, e.Mu);
     }
 }
 
 class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
     constructor(e, t) {
-        super(e), this.vu = t;
+        super(e), this.xu = t;
     }
     _toFieldTransform(e) {
-        const t = new __PRIVATE_NumericIncrementTransformOperation(e.serializer, toNumber(e.serializer, this.vu));
+        const t = new __PRIVATE_NumericIncrementTransformOperation(e.serializer, toNumber(e.serializer, this.xu));
         return new FieldTransform(e.path, t);
     }
     isEqual(e) {
-        return e instanceof __PRIVATE_NumericIncrementFieldValueImpl && this.vu === e.vu;
+        return e instanceof __PRIVATE_NumericIncrementFieldValueImpl && this.xu === e.xu;
     }
 }
 
 /** Parse update data from an update() call. */ function __PRIVATE_parseUpdateData(e, t, n, r) {
-    const i = e.Du(1 /* UserDataSource.Update */ , t, n);
+    const i = e.Fu(1 /* UserDataSource.Update */ , t, n);
     __PRIVATE_validatePlainObject("Data must be an object, but it was:", i, r);
     const s = [], o = ObjectValue.empty();
     forEach(r, ((e, r) => {
@@ -19575,7 +19590,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 r = util.getModularInstance(r);
-        const a = i.pu(_);
+        const a = i.Su(_);
         if (r instanceof __PRIVATE_DeleteFieldValueImpl) 
         // Add it to the field mask, but don't add anything to updateData.
         s.push(_); else {
@@ -19588,7 +19603,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
 }
 
 /** Parse update data from a list of field/value arguments. */ function __PRIVATE_parseUpdateVarargs(e, t, n, r, i, s) {
-    const o = e.Du(1 /* UserDataSource.Update */ , t, n), _ = [ __PRIVATE_fieldPathFromArgument$1(t, r, n) ], a = [ i ];
+    const o = e.Fu(1 /* UserDataSource.Update */ , t, n), _ = [ __PRIVATE_fieldPathFromArgument$1(t, r, n) ], a = [ i ];
     if (s.length % 2 != 0) throw new FirestoreError(D.INVALID_ARGUMENT, `Function ${t}() needs to be called with an even number of arguments that alternate between field names and values.`);
     for (let e = 0; e < s.length; e += 2) _.push(__PRIVATE_fieldPathFromArgument$1(t, s[e])), 
     a.push(s[e + 1]);
@@ -19601,7 +19616,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = util.getModularInstance(n);
-        const r = o.pu(t);
+        const r = o.Su(t);
         if (n instanceof __PRIVATE_DeleteFieldValueImpl) 
         // Add it to the field mask, but don't add anything to updateData.
         u.push(t); else {
@@ -19620,7 +19635,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
  */ function __PRIVATE_parseQueryValue(e, t, n, r = !1) {
-    return __PRIVATE_parseData(n, e.Du(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , t));
+    return __PRIVATE_parseData(n, e.Fu(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , t));
 }
 
 /**
@@ -19649,8 +19664,8 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
  */
     return function __PRIVATE_parseSentinelFieldValue(e, t) {
         // Sentinels are only supported with writes, and not within arrays.
-        if (!__PRIVATE_isWrite(t.Ru)) throw t.wu(`${e._methodName}() can only be used with update() and set()`);
-        if (!t.path) throw t.wu(`${e._methodName}() is not currently supported inside arrays`);
+        if (!__PRIVATE_isWrite(t.fu)) throw t.Du(`${e._methodName}() can only be used with update() and set()`);
+        if (!t.path) throw t.Du(`${e._methodName}() is not currently supported inside arrays`);
         const n = e._toFieldTransform(t);
         n && t.fieldTransforms.push(n);
     }
@@ -19674,12 +19689,12 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         // the set of values to be included for the IN query) that may directly
         // contain additional arrays (each representing an individual field
         // value), so we disable this validation.
-        if (t.settings.fu && 4 /* UserDataSource.ArrayArgument */ !== t.Ru) throw t.wu("Nested arrays are not supported");
+        if (t.settings.yu && 4 /* UserDataSource.ArrayArgument */ !== t.fu) throw t.Du("Nested arrays are not supported");
         return function __PRIVATE_parseArray(e, t) {
             const n = [];
             let r = 0;
             for (const i of e) {
-                let e = __PRIVATE_parseData(i, t.yu(r));
+                let e = __PRIVATE_parseData(i, t.bu(r));
                 null == e && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -19731,12 +19746,12 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         };
         if (e instanceof DocumentReference) {
             const n = t.databaseId, r = e.firestore._databaseId;
-            if (!r.isEqual(n)) throw t.wu(`Document reference is for database ${r.projectId}/${r.database} but should be for database ${n.projectId}/${n.database}`);
+            if (!r.isEqual(n)) throw t.Du(`Document reference is for database ${r.projectId}/${r.database} but should be for database ${n.projectId}/${n.database}`);
             return {
                 referenceValue: __PRIVATE_toResourceName(e.firestore._databaseId || t.databaseId, e._key.path)
             };
         }
-        throw t.wu(`Unsupported field value: ${__PRIVATE_valueDescription(e)}`);
+        throw t.Du(`Unsupported field value: ${__PRIVATE_valueDescription(e)}`);
     }
     /**
  * Checks whether an object looks like a JSON object that should be converted
@@ -19753,7 +19768,7 @@ function __PRIVATE_parseObject(e, t) {
     // If we encounter an empty object, we explicitly add it to the update
     // mask to ensure that the server creates a map entry.
     t.path && t.path.length > 0 && t.fieldMask.push(t.path) : forEach(e, ((e, r) => {
-        const i = __PRIVATE_parseData(r, t.mu(e));
+        const i = __PRIVATE_parseData(r, t.pu(e));
         null != i && (n[e] = i);
     })), {
         mapValue: {
@@ -19771,7 +19786,7 @@ function __PRIVATE_validatePlainObject(e, t, n) {
         return "object" == typeof e && null !== e && (Object.getPrototypeOf(e) === Object.prototype || null === Object.getPrototypeOf(e));
     }(n)) {
         const r = __PRIVATE_valueDescription(n);
-        throw "an object" === r ? t.wu(e + " a custom object") : t.wu(e + " " + r);
+        throw "an object" === r ? t.Du(e + " a custom object") : t.Du(e + " " + r);
     }
 }
 
@@ -21058,7 +21073,7 @@ function onSnapshot(e, ...t) {
         const i = new __PRIVATE_AsyncObserver(r), s = new __PRIVATE_QueryListener(t, i, n);
         return e.asyncQueue.enqueueAndForget((async () => __PRIVATE_eventManagerListen(await __PRIVATE_getEventManager(e), s))), 
         () => {
-            i.qa(), e.asyncQueue.enqueueAndForget((async () => __PRIVATE_eventManagerUnlisten(await __PRIVATE_getEventManager(e), s)));
+            i.$a(), e.asyncQueue.enqueueAndForget((async () => __PRIVATE_eventManagerUnlisten(await __PRIVATE_getEventManager(e), s)));
         };
     }(ensureFirestoreConfigured(u), c, _, a);
 }
@@ -21575,7 +21590,7 @@ class Transaction extends class Transaction$1 {
         const r = new __PRIVATE_Deferred;
         return e.asyncQueue.enqueueAndForget((async () => {
             const i = await __PRIVATE_getDatastore(e);
-            new __PRIVATE_TransactionRunner(e.asyncQueue, i, n, t, r).Ja();
+            new __PRIVATE_TransactionRunner(e.asyncQueue, i, n, t, r).Xa();
         })), r.promise;
     }(ensureFirestoreConfigured(e), (n => t(new Transaction(e, n))), r);
 }
@@ -21881,7 +21896,7 @@ function __PRIVATE_setPersistentCacheIndexAutoCreationEnabled(e, t) {
  * The implementation of `TestingHooksSpi`.
  */ class __PRIVATE_TestingHooksSpiImpl {
     constructor() {
-        this.Fu = new Map;
+        this.Ou = new Map;
     }
     static get instance() {
         return Ce || (Ce = new __PRIVATE_TestingHooksSpiImpl, function __PRIVATE_setTestingHooksSpi(e) {
@@ -21890,10 +21905,10 @@ function __PRIVATE_setPersistentCacheIndexAutoCreationEnabled(e, t) {
         }(Ce)), Ce;
     }
     et(e) {
-        this.Fu.forEach((t => t(e)));
+        this.Ou.forEach((t => t(e)));
     }
     onExistenceFilterMismatch(e) {
-        const t = Symbol(), n = this.Fu;
+        const t = Symbol(), n = this.Ou;
         return n.set(t, e), () => n.delete(t);
     }
 }
@@ -21915,9 +21930,9 @@ let Ce = null;
         return r = Object.assign({
             useFetchStreams: t
         }, r), s._setSettings(r), s;
-    }), "PUBLIC").setMultipleInstances(!0)), app.registerVersion(w, "4.6.0-canary.84f9ff008", e), 
+    }), "PUBLIC").setMultipleInstances(!0)), app.registerVersion(w, "4.6.0-canary.b74d8a211", e), 
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    app.registerVersion(w, "4.6.0-canary.84f9ff008", "cjs2017");
+    app.registerVersion(w, "4.6.0-canary.b74d8a211", "cjs2017");
 }();
 
 exports.AbstractUserDataWriter = AbstractUserDataWriter;