@firebase/firestore 4.7.16 → 4.7.17

package/dist/index.rn.js

@@ -10,7 +10,7 @@ import { Integer as p, Md5 as y } from "@firebase/webchannel-wrapper/bloom-blob"
 
 import { XhrIo as w, EventType as S, ErrorCode as b, createWebChannelTransport as D, getStatEventTarget as v, WebChannel as C, Event as F, Stat as M } from "@firebase/webchannel-wrapper/webchannel-blob";
 
-const x = "@firebase/firestore", O = "4.7.16";
+const x = "@firebase/firestore", O = "4.7.17";
 
 /**
  * @license
@@ -72,7 +72,7 @@ User.MOCK_USER = new User("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let N = "11.8.1";
+let N = "11.9.0";
 
 /**
  * @license
@@ -14219,7 +14219,9 @@ class __PRIVATE_RestConnection {
 
 class __PRIVATE_WebChannelConnection extends __PRIVATE_RestConnection {
     constructor(e) {
-        super(e), this.forceLongPolling = e.forceLongPolling, this.autoDetectLongPolling = e.autoDetectLongPolling, 
+        super(e), 
+        /** A collection of open WebChannel instances */
+        this.l_ = [], this.forceLongPolling = e.forceLongPolling, this.autoDetectLongPolling = e.autoDetectLongPolling, 
         this.useFetchStreams = e.useFetchStreams, this.longPollingOptions = e.longPollingOptions;
     }
     Jo(e, t, n, r, i) {
@@ -14261,10 +14263,10 @@ class __PRIVATE_WebChannelConnection extends __PRIVATE_RestConnection {
 
                       default:
                         fail(9055, {
-                            l_: e,
+                            h_: e,
                             streamId: s,
-                            h_: _.getLastErrorCode(),
-                            P_: _.getLastError()
+                            P_: _.getLastErrorCode(),
+                            T_: _.getLastError()
                         });
                     }
                 } finally {
@@ -14275,7 +14277,7 @@ class __PRIVATE_WebChannelConnection extends __PRIVATE_RestConnection {
             __PRIVATE_logDebug(en, `RPC '${e}' ${s} sending request:`, r), _.send(t, "POST", a, n, 15);
         }));
     }
-    T_(e, t, n) {
+    I_(e, t, n) {
         const r = __PRIVATE_generateUniqueDebugId(), i = [ this.Ko, "/", "google.firestore.v1.Firestore", "/", e, "/channel" ], s = D(), o = v(), _ = {
             // Required for backend stickiness, routing behavior is based on this
             // parameter.
@@ -14315,12 +14317,13 @@ class __PRIVATE_WebChannelConnection extends __PRIVATE_RestConnection {
         const u = i.join("");
         __PRIVATE_logDebug(en, `Creating RPC '${e}' stream ${r}: ${u}`, _);
         const c = s.createWebChannel(u, _);
+        this.E_(c);
         // WebChannel supports sending the first message with the handshake - saving
         // a network round trip. However, it will have to call send in the same
         // JS event loop as open. In order to enforce this, we delay actually
         // opening the WebChannel until send is called. Whether we have called
         // open is tracked with this variable.
-                let l = !1, h = !1;
+        let l = !1, h = !1;
         // A flag to determine whether the stream was closed (by us or through an
         // error/close event) to avoid delivering multiple close events or sending
         // on a closed stream
@@ -14352,7 +14355,7 @@ class __PRIVATE_WebChannelConnection extends __PRIVATE_RestConnection {
             h || (__PRIVATE_logDebug(en, `RPC '${e}' stream ${r} transport opened.`), P.__());
         })), __PRIVATE_unguardedEventListen(c, C.EventType.CLOSE, (() => {
             h || (h = !0, __PRIVATE_logDebug(en, `RPC '${e}' stream ${r} transport closed`), 
-            P.u_());
+            P.u_(), this.d_(c));
         })), __PRIVATE_unguardedEventListen(c, C.EventType.ERROR, (t => {
             h || (h = !0, __PRIVATE_logWarn(en, `RPC '${e}' stream ${r} transport errored. Name:`, t.name, "Message:", t.message), 
             P.u_(new FirestoreError(L.UNAVAILABLE, "The operation could not be completed")));
@@ -14399,6 +14402,25 @@ class __PRIVATE_WebChannelConnection extends __PRIVATE_RestConnection {
             P.a_();
         }), 0), P;
     }
+    /**
+     * Closes and cleans up any resources associated with the connection.
+     */    terminate() {
+        // If the Firestore instance is terminated, we will explicitly
+        // close any remaining open WebChannel instances.
+        this.l_.forEach((e => e.close())), this.l_ = [];
+    }
+    /**
+     * Add a WebChannel instance to the collection of open instances.
+     * @param webChannel
+     */    E_(e) {
+        this.l_.push(e);
+    }
+    /**
+     * Remove a WebChannel instance from the collection of open instances.
+     * @param webChannel
+     */    d_(e) {
+        this.l_ = this.l_.filter((t => t === e));
+    }
 }
 
 /**
@@ -14516,10 +14538,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.xi = e, this.timerId = t, this.I_ = n, this.E_ = r, this.d_ = i, this.A_ = 0, 
-        this.R_ = null, 
+        this.xi = e, this.timerId = t, this.A_ = n, this.R_ = r, this.V_ = i, this.m_ = 0, 
+        this.f_ = null, 
         /** The last backoff attempt, as epoch milliseconds. */
-        this.V_ = Date.now(), this.reset();
+        this.g_ = Date.now(), this.reset();
     }
     /**
      * Resets the backoff delay.
@@ -14528,40 +14550,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.A_ = 0;
+        this.m_ = 0;
     }
     /**
      * Resets the backoff delay to the maximum delay (e.g. for use after a
      * RESOURCE_EXHAUSTED error).
-     */    m_() {
-        this.A_ = this.d_;
+     */    p_() {
+        this.m_ = this.V_;
     }
     /**
      * 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.
-     */    f_(e) {
+     */    y_(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.A_ + this.g_()), n = Math.max(0, Date.now() - this.V_), r = Math.max(0, t - n);
+        const t = Math.floor(this.m_ + this.w_()), n = Math.max(0, Date.now() - this.g_), 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.A_} ms, delay with jitter: ${t} ms, last attempt: ${n} ms ago)`), 
-        this.R_ = this.xi.enqueueAfterDelay(this.timerId, r, (() => (this.V_ = Date.now(), 
+                r > 0 && __PRIVATE_logDebug("ExponentialBackoff", `Backing off for ${r} ms (base delay: ${this.m_} ms, delay with jitter: ${t} ms, last attempt: ${n} ms ago)`), 
+        this.f_ = this.xi.enqueueAfterDelay(this.timerId, r, (() => (this.g_ = Date.now(), 
         e()))), 
         // Apply backoff factor to determine next delay and ensure it is within
         // bounds.
-        this.A_ *= this.E_, this.A_ < this.I_ && (this.A_ = this.I_), this.A_ > this.d_ && (this.A_ = this.d_);
+        this.m_ *= this.R_, this.m_ < this.A_ && (this.m_ = this.A_), this.m_ > this.V_ && (this.m_ = this.V_);
     }
-    p_() {
-        null !== this.R_ && (this.R_.skipDelay(), this.R_ = null);
+    S_() {
+        null !== this.f_ && (this.f_.skipDelay(), this.f_ = null);
     }
     cancel() {
-        null !== this.R_ && (this.R_.cancel(), this.R_ = null);
+        null !== this.f_ && (this.f_.cancel(), this.f_ = null);
     }
-    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */    g_() {
-        return (Math.random() - .5) * this.A_;
+    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */    w_() {
+        return (Math.random() - .5) * this.m_;
     }
 }
 
@@ -14617,18 +14639,18 @@ class __PRIVATE_ExponentialBackoff {
  */
 class __PRIVATE_PersistentStream {
     constructor(e, t, n, r, i, s, o, _) {
-        this.xi = e, this.y_ = n, this.w_ = r, this.connection = i, this.authCredentialsProvider = s, 
+        this.xi = e, this.b_ = n, this.D_ = 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.S_ = 0, this.b_ = null, this.D_ = null, this.stream = null, 
+        this.v_ = 0, this.C_ = null, this.F_ = null, this.stream = null, 
         /**
          * Count of response messages received.
          */
-        this.v_ = 0, this.C_ = new __PRIVATE_ExponentialBackoff(e, t);
+        this.M_ = 0, this.x_ = new __PRIVATE_ExponentialBackoff(e, t);
     }
     /**
      * Returns true if start() has been called and no error has occurred. True
@@ -14636,13 +14658,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.
-     */    F_() {
-        return 1 /* PersistentStreamState.Starting */ === this.state || 5 /* PersistentStreamState.Backoff */ === this.state || this.M_();
+     */    O_() {
+        return 1 /* PersistentStreamState.Starting */ === this.state || 5 /* PersistentStreamState.Backoff */ === this.state || this.N_();
     }
     /**
      * Returns true if the underlying RPC is open (the onOpen() listener has been
      * called) and the stream is ready for outbound requests.
-     */    M_() {
+     */    N_() {
         return 2 /* PersistentStreamState.Open */ === this.state || 3 /* PersistentStreamState.Healthy */ === this.state;
     }
     /**
@@ -14652,7 +14674,7 @@ class __PRIVATE_PersistentStream {
      *
      * When start returns, isStarted() will return true.
      */    start() {
-        this.v_ = 0, 4 /* PersistentStreamState.Error */ !== this.state ? this.auth() : this.x_();
+        this.M_ = 0, 4 /* PersistentStreamState.Error */ !== this.state ? this.auth() : this.B_();
     }
     /**
      * Stops the RPC. This call is idempotent and allowed regardless of the
@@ -14660,7 +14682,7 @@ class __PRIVATE_PersistentStream {
      *
      * When stop returns, isStarted() and isOpen() will both return false.
      */    async stop() {
-        this.F_() && await this.close(0 /* PersistentStreamState.Initial */);
+        this.O_() && await this.close(0 /* PersistentStreamState.Initial */);
     }
     /**
      * After an error the stream will usually back off on the next attempt to
@@ -14669,8 +14691,8 @@ class __PRIVATE_PersistentStream {
      *
      * Each error will call the onClose() listener. That function can decide to
      * inhibit backoff if required.
-     */    O_() {
-        this.state = 0 /* PersistentStreamState.Initial */ , this.C_.reset();
+     */    L_() {
+        this.state = 0 /* PersistentStreamState.Initial */ , this.x_.reset();
     }
     /**
      * Marks this stream as idle. If no further actions are performed on the
@@ -14681,25 +14703,25 @@ class __PRIVATE_PersistentStream {
      *
      * Only streams that are in state 'Open' can be marked idle, as all other
      * states imply pending network operations.
-     */    N_() {
+     */    k_() {
         // 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.M_() && null === this.b_ && (this.b_ = this.xi.enqueueAfterDelay(this.y_, 6e4, (() => this.B_())));
+        this.N_() && null === this.C_ && (this.C_ = this.xi.enqueueAfterDelay(this.b_, 6e4, (() => this.q_())));
     }
-    /** Sends a message to the underlying stream. */    L_(e) {
-        this.k_(), this.stream.send(e);
+    /** Sends a message to the underlying stream. */    Q_(e) {
+        this.U_(), this.stream.send(e);
     }
-    /** Called by the idle timer when the stream should close due to inactivity. */    async B_() {
-        if (this.M_()) 
+    /** Called by the idle timer when the stream should close due to inactivity. */    async q_() {
+        if (this.N_()) 
         // 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. */    k_() {
-        this.b_ && (this.b_.cancel(), this.b_ = null);
+    /** Marks the stream as active again. */    U_() {
+        this.C_ && (this.C_.cancel(), this.C_ = null);
     }
-    /** Cancels the health check delayed operation. */    q_() {
-        this.D_ && (this.D_.cancel(), this.D_ = null);
+    /** Cancels the health check delayed operation. */    K_() {
+        this.F_ && (this.F_.cancel(), this.F_ = null);
     }
     /**
      * Closes the stream and cleans up as necessary:
@@ -14715,15 +14737,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.k_(), this.q_(), this.C_.cancel(), 
+        this.U_(), this.K_(), this.x_.cancel(), 
         // Invalidates any stream-related callbacks (e.g. from auth or the
         // underlying stream), guaranteeing they won't execute.
-        this.S_++, 4 /* PersistentStreamState.Error */ !== e ? 
+        this.v_++, 4 /* PersistentStreamState.Error */ !== e ? 
         // If this is an intentional close ensure we don't delay our next connection attempt.
-        this.C_.reset() : t && t.code === L.RESOURCE_EXHAUSTED ? (
+        this.x_.reset() : t && t.code === L.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.C_.m_()) : t && t.code === L.UNAUTHENTICATED && 3 /* PersistentStreamState.Healthy */ !== this.state && (
+        this.x_.p_()) : t && t.code === L.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
@@ -14732,7 +14754,7 @@ 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.Q_(), this.stream.close(), this.stream = null), 
+        null !== this.stream && (this.W_(), 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, 
@@ -14742,48 +14764,48 @@ class __PRIVATE_PersistentStream {
     /**
      * Can be overridden to perform additional cleanup before the stream is closed.
      * Calling super.tearDown() is not required.
-     */    Q_() {}
+     */    W_() {}
     auth() {
         this.state = 1 /* PersistentStreamState.Starting */;
-        const e = this.U_(this.S_), t = this.S_;
+        const e = this.G_(this.v_), t = this.v_;
         // 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.S_ === t && 
+            this.v_ === 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.K_(e, n);
+            this.z_(e, n);
         }), (t => {
             e((() => {
                 const e = new FirestoreError(L.UNKNOWN, "Fetching auth token failed: " + t.message);
-                return this.W_(e);
+                return this.j_(e);
             }));
         }));
     }
-    K_(e, t) {
-        const n = this.U_(this.S_);
-        this.stream = this.G_(e, t), this.stream.e_((() => {
+    z_(e, t) {
+        const n = this.G_(this.v_);
+        this.stream = this.H_(e, t), this.stream.e_((() => {
             n((() => this.listener.e_()));
         })), this.stream.n_((() => {
-            n((() => (this.state = 2 /* PersistentStreamState.Open */ , this.D_ = this.xi.enqueueAfterDelay(this.w_, 1e4, (() => (this.M_() && (this.state = 3 /* PersistentStreamState.Healthy */), 
+            n((() => (this.state = 2 /* PersistentStreamState.Open */ , this.F_ = this.xi.enqueueAfterDelay(this.D_, 1e4, (() => (this.N_() && (this.state = 3 /* PersistentStreamState.Healthy */), 
             Promise.resolve()))), this.listener.n_())));
         })), this.stream.i_((e => {
-            n((() => this.W_(e)));
+            n((() => this.j_(e)));
         })), this.stream.onMessage((e => {
-            n((() => 1 == ++this.v_ ? this.z_(e) : this.onNext(e)));
+            n((() => 1 == ++this.M_ ? this.J_(e) : this.onNext(e)));
         }));
     }
-    x_() {
-        this.state = 5 /* PersistentStreamState.Backoff */ , this.C_.f_((async () => {
+    B_() {
+        this.state = 5 /* PersistentStreamState.Backoff */ , this.x_.y_((async () => {
             this.state = 0 /* PersistentStreamState.Initial */ , this.start();
         }));
     }
     // Visible for tests
-    W_(e) {
+    j_(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
@@ -14795,9 +14817,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.
-     */    U_(e) {
+     */    G_(e) {
         return t => {
-            this.xi.enqueueAndForget((() => this.S_ === e ? t() : (__PRIVATE_logDebug(tn, "stream callback skipped by getCloseGuardedDispatcher."), 
+            this.xi.enqueueAndForget((() => this.v_ === e ? t() : (__PRIVATE_logDebug(tn, "stream callback skipped by getCloseGuardedDispatcher."), 
             Promise.resolve())));
         };
     }
@@ -14814,15 +14836,15 @@ 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;
     }
-    G_(e, t) {
-        return this.connection.T_("Listen", e, t);
+    H_(e, t) {
+        return this.connection.I_("Listen", e, t);
     }
-    z_(e) {
+    J_(e) {
         return this.onNext(e);
     }
     onNext(e) {
         // A successful response means the stream is healthy
-        this.C_.reset();
+        this.x_.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
@@ -14831,14 +14853,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.j_(t, n);
+        return this.listener.Y_(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.
-     */    H_(e) {
+     */    Z_(e) {
         const t = {};
         t.database = __PRIVATE_getEncodedDatabaseId(this.serializer), t.addTarget = function __PRIVATE_toTarget(e, t) {
             let n;
@@ -14862,15 +14884,15 @@ class __PRIVATE_PersistentStream {
             return n;
         }(this.serializer, e);
         const n = __PRIVATE_toListenRequestLabels(this.serializer, e);
-        n && (t.labels = n), this.L_(t);
+        n && (t.labels = n), this.Q_(t);
     }
     /**
      * Unregisters interest in the results of the target associated with the
      * given targetId.
-     */    J_(e) {
+     */    X_(e) {
         const t = {};
         t.database = __PRIVATE_getEncodedDatabaseId(this.serializer), t.removeTarget = e, 
-        this.L_(t);
+        this.Q_(t);
     }
 }
 
@@ -14898,24 +14920,24 @@ class __PRIVATE_PersistentStream {
     /**
      * Tracks whether or not a handshake has been successfully exchanged and
      * the stream is ready to accept mutations.
-     */    get Y_() {
-        return this.v_ > 0;
+     */    get ea() {
+        return this.M_ > 0;
     }
     // Override of PersistentStream.start
     start() {
         this.lastStreamToken = void 0, super.start();
     }
-    Q_() {
-        this.Y_ && this.Z_([]);
+    W_() {
+        this.ea && this.ta([]);
     }
-    G_(e, t) {
-        return this.connection.T_("Write", e, t);
+    H_(e, t) {
+        return this.connection.I_("Write", e, t);
     }
-    z_(e) {
+    J_(e) {
         // Always capture the last stream token.
         return __PRIVATE_hardAssert(!!e.streamToken, 31322), this.lastStreamToken = e.streamToken, 
         // The first response is always the handshake response
-        __PRIVATE_hardAssert(!e.writeResults || 0 === e.writeResults.length, 55816), this.listener.X_();
+        __PRIVATE_hardAssert(!e.writeResults || 0 === e.writeResults.length, 55816), this.listener.na();
     }
     onNext(e) {
         // Always capture the last stream token.
@@ -14923,26 +14945,26 @@ class __PRIVATE_PersistentStream {
         // 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.C_.reset();
+        this.x_.reset();
         const t = __PRIVATE_fromWriteResults(e.writeResults, e.commitTime), n = __PRIVATE_fromVersion(e.commitTime);
-        return this.listener.ea(n, t);
+        return this.listener.ra(n, t);
     }
     /**
      * 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.
-     */    ta() {
+     */    ia() {
         // 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.L_(e);
+        e.database = __PRIVATE_getEncodedDatabaseId(this.serializer), this.Q_(e);
     }
-    /** Sends a group of mutations to the Firestore backend to apply. */    Z_(e) {
+    /** Sends a group of mutations to the Firestore backend to apply. */    ta(e) {
         const t = {
             streamToken: this.lastStreamToken,
             writes: e.map((e => toMutation(this.serializer, e)))
         };
-        this.L_(t);
+        this.Q_(t);
     }
 }
 
@@ -14974,25 +14996,25 @@ class __PRIVATE_PersistentStream {
  */ class __PRIVATE_DatastoreImpl extends Datastore {
     constructor(e, t, n, r) {
         super(), this.authCredentials = e, this.appCheckCredentials = t, this.connection = n, 
-        this.serializer = r, this.na = !1;
+        this.serializer = r, this.sa = !1;
     }
-    ra() {
-        if (this.na) throw new FirestoreError(L.FAILED_PRECONDITION, "The client has already been terminated.");
+    oa() {
+        if (this.sa) throw new FirestoreError(L.FAILED_PRECONDITION, "The client has already been terminated.");
     }
     /** Invokes the provided RPC with auth and AppCheck tokens. */    zo(e, t, n, r) {
-        return this.ra(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([i, s]) => this.connection.zo(e, __PRIVATE_toResourcePath(t, n), r, i, s))).catch((e => {
+        return this.oa(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([i, s]) => this.connection.zo(e, __PRIVATE_toResourcePath(t, n), r, i, s))).catch((e => {
             throw "FirebaseError" === e.name ? (e.code === L.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), e) : new FirestoreError(L.UNKNOWN, e.toString());
         }));
     }
     /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */    Yo(e, t, n, r, i) {
-        return this.ra(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, o]) => this.connection.Yo(e, __PRIVATE_toResourcePath(t, n), r, s, o, i))).catch((e => {
+        return this.oa(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, o]) => this.connection.Yo(e, __PRIVATE_toResourcePath(t, n), r, s, o, i))).catch((e => {
             throw "FirebaseError" === e.name ? (e.code === L.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), e) : new FirestoreError(L.UNKNOWN, e.toString());
         }));
     }
     terminate() {
-        this.na = !0, this.connection.terminate();
+        this.sa = !0, this.connection.terminate();
     }
 }
 
@@ -15019,19 +15041,19 @@ class __PRIVATE_OnlineStateTracker {
          * maximum defined by MAX_WATCH_STREAM_FAILURES, we'll set the OnlineState to
          * Offline.
          */
-        this.ia = 0, 
+        this._a = 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.sa = null, 
+        this.aa = 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.oa = !0;
+        this.ua = !0;
     }
     /**
      * Called by RemoteStore when a watch stream is started (including on each
@@ -15039,9 +15061,9 @@ class __PRIVATE_OnlineStateTracker {
      *
      * If this is the first attempt, it sets the OnlineState to Unknown and starts
      * the onlineStateTimer.
-     */    _a() {
-        0 === this.ia && (this.aa("Unknown" /* OnlineState.Unknown */), this.sa = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* TimerId.OnlineStateTimeout */ , 1e4, (() => (this.sa = null, 
-        this.ua("Backend didn't respond within 10 seconds."), this.aa("Offline" /* OnlineState.Offline */), 
+     */    ca() {
+        0 === this._a && (this.la("Unknown" /* OnlineState.Unknown */), this.aa = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* TimerId.OnlineStateTimeout */ , 1e4, (() => (this.aa = null, 
+        this.ha("Backend didn't respond within 10 seconds."), this.la("Offline" /* OnlineState.Offline */), 
         Promise.resolve()))));
     }
     /**
@@ -15049,10 +15071,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.
-     */    ca(e) {
-        "Online" /* OnlineState.Online */ === this.state ? this.aa("Unknown" /* OnlineState.Unknown */) : (this.ia++, 
-        this.ia >= 1 && (this.la(), this.ua(`Connection failed 1 times. Most recent error: ${e.toString()}`), 
-        this.aa("Offline" /* OnlineState.Offline */)));
+     */    Pa(e) {
+        "Online" /* OnlineState.Online */ === this.state ? this.la("Unknown" /* OnlineState.Unknown */) : (this._a++, 
+        this._a >= 1 && (this.Ta(), this.ha(`Connection failed 1 times. Most recent error: ${e.toString()}`), 
+        this.la("Offline" /* OnlineState.Offline */)));
     }
     /**
      * Explicitly sets the OnlineState to the specified state.
@@ -15061,20 +15083,20 @@ class __PRIVATE_OnlineStateTracker {
      * Offline heuristics, so must not be used in place of
      * handleWatchStreamStart() and handleWatchStreamFailure().
      */    set(e) {
-        this.la(), this.ia = 0, "Online" /* OnlineState.Online */ === e && (
+        this.Ta(), this._a = 0, "Online" /* OnlineState.Online */ === e && (
         // We've connected to watch at least once. Don't warn the developer
         // about being offline going forward.
-        this.oa = !1), this.aa(e);
+        this.ua = !1), this.la(e);
     }
-    aa(e) {
+    la(e) {
         e !== this.state && (this.state = e, this.onlineStateHandler(e));
     }
-    ua(e) {
+    ha(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.oa ? (__PRIVATE_logError(t), this.oa = !1) : __PRIVATE_logDebug("OnlineStateTracker", t);
+        this.ua ? (__PRIVATE_logError(t), this.ua = !1) : __PRIVATE_logDebug("OnlineStateTracker", t);
     }
-    la() {
-        null !== this.sa && (this.sa.cancel(), this.sa = null);
+    Ta() {
+        null !== this.aa && (this.aa.cancel(), this.aa = null);
     }
 }
 
@@ -15122,7 +15144,7 @@ class __PRIVATE_RemoteStoreImpl {
          * purely based on order, and so we can just shift() writes from the front of
          * the writePipeline as we receive responses.
          */
-        this.ha = [], 
+        this.Ia = [], 
         /**
          * A mapping of watched targets that the client cares about tracking and the
          * user has explicitly called a 'listen' for this target.
@@ -15132,12 +15154,12 @@ class __PRIVATE_RemoteStoreImpl {
          * to the server. The targets removed with unlistens are removed eagerly
          * without waiting for confirmation from the listen stream.
          */
-        this.Pa = new Map, 
+        this.Ea = new Map, 
         /**
          * A set of reasons for why the RemoteStore may be offline. If empty, the
          * RemoteStore may start its network connections.
          */
-        this.Ta = new Set, 
+        this.da = new Set, 
         /**
          * Event handlers that get called when the network is disabled or enabled.
          *
@@ -15145,7 +15167,7 @@ class __PRIVATE_RemoteStoreImpl {
          * underlying streams (to support tree-shakeable streams). On Android and iOS,
          * the streams are created during construction of RemoteStore.
          */
-        this.Ia = [], this.Ea = i, this.Ea.No((e => {
+        this.Aa = [], this.Ra = i, this.Ra.No((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
@@ -15153,24 +15175,24 @@ class __PRIVATE_RemoteStoreImpl {
                 __PRIVATE_canUseNetwork(this) && (__PRIVATE_logDebug(nn, "Restarting streams for network reachability change."), 
                 await async function __PRIVATE_restartNetwork(e) {
                     const t = __PRIVATE_debugCast(e);
-                    t.Ta.add(4 /* OfflineCause.ConnectivityChange */), await __PRIVATE_disableNetworkInternal(t), 
-                    t.da.set("Unknown" /* OnlineState.Unknown */), t.Ta.delete(4 /* OfflineCause.ConnectivityChange */), 
+                    t.da.add(4 /* OfflineCause.ConnectivityChange */), await __PRIVATE_disableNetworkInternal(t), 
+                    t.Va.set("Unknown" /* OnlineState.Unknown */), t.da.delete(4 /* OfflineCause.ConnectivityChange */), 
                     await __PRIVATE_enableNetworkInternal(t);
                 }(this));
             }));
-        })), this.da = new __PRIVATE_OnlineStateTracker(n, r);
+        })), this.Va = new __PRIVATE_OnlineStateTracker(n, r);
     }
 }
 
 async function __PRIVATE_enableNetworkInternal(e) {
-    if (__PRIVATE_canUseNetwork(e)) for (const t of e.Ia) await t(/* enabled= */ !0);
+    if (__PRIVATE_canUseNetwork(e)) for (const t of e.Aa) 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.Ia) await t(/* enabled= */ !1);
+    for (const t of e.Aa) await t(/* enabled= */ !1);
 }
 
 /**
@@ -15179,11 +15201,11 @@ async function __PRIVATE_enableNetworkInternal(e) {
  */
 function __PRIVATE_remoteStoreListen(e, t) {
     const n = __PRIVATE_debugCast(e);
-    n.Pa.has(t.targetId) || (
+    n.Ea.has(t.targetId) || (
     // Mark this as something the client is currently listening for.
-    n.Pa.set(t.targetId, t), __PRIVATE_shouldStartWatchStream(n) ? 
+    n.Ea.set(t.targetId, t), __PRIVATE_shouldStartWatchStream(n) ? 
     // The listen will be sent in onWatchStreamOpen
-    __PRIVATE_startWatchStream(n) : __PRIVATE_ensureWatchStream(n).M_() && __PRIVATE_sendWatchRequest(n, t));
+    __PRIVATE_startWatchStream(n) : __PRIVATE_ensureWatchStream(n).N_() && __PRIVATE_sendWatchRequest(n, t));
 }
 
 /**
@@ -15191,22 +15213,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.Pa.delete(t), r.M_() && __PRIVATE_sendUnwatchRequest(n, t), 0 === n.Pa.size && (r.M_() ? r.N_() : __PRIVATE_canUseNetwork(n) && 
+    n.Ea.delete(t), r.N_() && __PRIVATE_sendUnwatchRequest(n, t), 0 === n.Ea.size && (r.N_() ? r.k_() : __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.da.set("Unknown" /* OnlineState.Unknown */));
+    n.Va.set("Unknown" /* OnlineState.Unknown */));
 }
 
 /**
  * We need to increment 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.Aa.Ke(t.targetId), t.resumeToken.approximateByteSize() > 0 || t.snapshotVersion.compareTo(SnapshotVersion.min()) > 0) {
+    if (e.ma.Ke(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).H_(t);
+    __PRIVATE_ensureWatchStream(e).Z_(t);
 }
 
 /**
@@ -15214,39 +15236,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.Aa.Ke(t), __PRIVATE_ensureWatchStream(e).J_(t);
+    e.ma.Ke(t), __PRIVATE_ensureWatchStream(e).X_(t);
 }
 
 function __PRIVATE_startWatchStream(e) {
-    e.Aa = new __PRIVATE_WatchChangeAggregator({
+    e.ma = new __PRIVATE_WatchChangeAggregator({
         getRemoteKeysForTarget: t => e.remoteSyncer.getRemoteKeysForTarget(t),
-        Rt: t => e.Pa.get(t) || null,
+        Rt: t => e.Ea.get(t) || null,
         Pt: () => e.datastore.serializer.databaseId
-    }), __PRIVATE_ensureWatchStream(e).start(), e.da._a();
+    }), __PRIVATE_ensureWatchStream(e).start(), e.Va.ca();
 }
 
 /**
  * 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).F_() && e.Pa.size > 0;
+    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWatchStream(e).O_() && e.Ea.size > 0;
 }
 
 function __PRIVATE_canUseNetwork(e) {
-    return 0 === __PRIVATE_debugCast(e).Ta.size;
+    return 0 === __PRIVATE_debugCast(e).da.size;
 }
 
 function __PRIVATE_cleanUpWatchStreamState(e) {
-    e.Aa = void 0;
+    e.ma = void 0;
 }
 
 async function __PRIVATE_onWatchStreamConnected(e) {
     // Mark the client as online since we got a "connected" notification.
-    e.da.set("Online" /* OnlineState.Online */);
+    e.Va.set("Online" /* OnlineState.Online */);
 }
 
 async function __PRIVATE_onWatchStreamOpen(e) {
-    e.Pa.forEach(((t, n) => {
+    e.Ea.forEach(((t, n) => {
         __PRIVATE_sendWatchRequest(e, t);
     }));
 }
@@ -15254,17 +15276,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.da.ca(t), __PRIVATE_startWatchStream(e)) : 
+    __PRIVATE_shouldStartWatchStream(e) ? (e.Va.Pa(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.da.set("Unknown" /* OnlineState.Unknown */);
+    e.Va.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.da.set("Online" /* OnlineState.Online */), t instanceof __PRIVATE_WatchTargetChange && 2 /* WatchTargetChangeState.Removed */ === t.state && t.cause) 
+    e.Va.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 {
@@ -15273,7 +15295,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.Pa.has(r) && (await e.remoteSyncer.rejectListen(r, n), e.Pa.delete(r), e.Aa.removeTarget(r));
+            e.Ea.has(r) && (await e.remoteSyncer.rejectListen(r, n), e.Ea.delete(r), e.ma.removeTarget(r));
         }
         /**
  * Attempts to fill our write pipeline with writes from the LocalStore.
@@ -15286,7 +15308,7 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
     } catch (n) {
         __PRIVATE_logDebug(nn, "Failed to remove targets %s: %s ", t.targetIds.join(","), n), 
         await __PRIVATE_disableNetworkUntilRecovery(e, n);
-    } else if (t instanceof __PRIVATE_DocumentWatchChange ? e.Aa.Xe(t) : t instanceof __PRIVATE_ExistenceFilterChange ? e.Aa.ot(t) : e.Aa.nt(t), 
+    } else if (t instanceof __PRIVATE_DocumentWatchChange ? e.ma.Xe(t) : t instanceof __PRIVATE_ExistenceFilterChange ? e.ma.ot(t) : e.ma.nt(t), 
     !n.isEqual(SnapshotVersion.min())) try {
         const t = await __PRIVATE_localStoreGetLastRemoteSnapshotVersion(e.localStore);
         n.compareTo(t) >= 0 && 
@@ -15298,26 +15320,26 @@ async function __PRIVATE_onWatchStreamChange(e, t, n) {
  * SyncEngine.
  */
         await function __PRIVATE_raiseWatchSnapshot(e, t) {
-            const n = e.Aa.It(t);
+            const n = e.ma.It(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.Pa.get(r);
+                    const i = e.Ea.get(r);
                     // A watched target might have been removed already.
-                                        i && e.Pa.set(r, i.withResumeToken(n.resumeToken, t));
+                                        i && e.Ea.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.Pa.get(t);
+                const r = e.Ea.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.Pa.set(t, r.withResumeToken(ByteString.EMPTY_BYTE_STRING, r.snapshotVersion)), 
+                                e.Ea.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);
@@ -15344,9 +15366,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.Ta.add(1 /* OfflineCause.IndexedDbFailed */), 
+    e.da.add(1 /* OfflineCause.IndexedDbFailed */), 
     // Disable network and raise offline snapshots
-    await __PRIVATE_disableNetworkInternal(e), e.da.set("Offline" /* OnlineState.Offline */), 
+    await __PRIVATE_disableNetworkInternal(e), e.Va.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
@@ -15354,7 +15376,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(nn, "Retrying IndexedDB access"), await n(), e.Ta.delete(1 /* OfflineCause.IndexedDbFailed */), 
+        __PRIVATE_logDebug(nn, "Retrying IndexedDB access"), await n(), e.da.delete(1 /* OfflineCause.IndexedDbFailed */), 
         await __PRIVATE_enableNetworkInternal(e);
     }));
 }
@@ -15368,11 +15390,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.ha.length > 0 ? t.ha[t.ha.length - 1].batchId : j;
+    let r = t.Ia.length > 0 ? t.Ia[t.Ia.length - 1].batchId : j;
     for (;__PRIVATE_canAddToWritePipeline(t); ) try {
         const e = await __PRIVATE_localStoreGetNextMutationBatch(t.localStore, r);
         if (null === e) {
-            0 === t.ha.length && n.N_();
+            0 === t.Ia.length && n.k_();
             break;
         }
         r = e.batchId, __PRIVATE_addToWritePipeline(t, e);
@@ -15386,20 +15408,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.ha.length < 10;
+    return __PRIVATE_canUseNetwork(e) && e.Ia.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.ha.push(t);
+    e.Ia.push(t);
     const n = __PRIVATE_ensureWriteStream(e);
-    n.M_() && n.Y_ && n.Z_(t.mutations);
+    n.N_() && n.ea && n.ta(t.mutations);
 }
 
 function __PRIVATE_shouldStartWriteStream(e) {
-    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWriteStream(e).F_() && e.ha.length > 0;
+    return __PRIVATE_canUseNetwork(e) && !__PRIVATE_ensureWriteStream(e).O_() && e.Ia.length > 0;
 }
 
 function __PRIVATE_startWriteStream(e) {
@@ -15407,17 +15429,17 @@ function __PRIVATE_startWriteStream(e) {
 }
 
 async function __PRIVATE_onWriteStreamOpen(e) {
-    __PRIVATE_ensureWriteStream(e).ta();
+    __PRIVATE_ensureWriteStream(e).ia();
 }
 
 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.ha) t.Z_(n.mutations);
+        for (const n of e.Ia) t.ta(n.mutations);
 }
 
 async function __PRIVATE_onMutationResult(e, t, n) {
-    const r = e.ha.shift(), i = MutationBatchResult.from(r, t, n);
+    const r = e.Ia.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.
@@ -15427,7 +15449,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).Y_ && 
+    t && __PRIVATE_ensureWriteStream(e).ea && 
     // 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
@@ -15437,11 +15459,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.ha.shift();
+            const n = e.Ia.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).O_(), await __PRIVATE_executeWithRecovery(e, (() => e.remoteSyncer.rejectFailedWrite(n.batchId, t))), 
+                        __PRIVATE_ensureWriteStream(e).L_(), 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);
@@ -15459,19 +15481,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.Ta.add(3 /* OfflineCause.CredentialChange */), await __PRIVATE_disableNetworkInternal(n), 
+        n.da.add(3 /* OfflineCause.CredentialChange */), await __PRIVATE_disableNetworkInternal(n), 
     r && 
     // Don't set the network status to Unknown if we are offline.
-    n.da.set("Unknown" /* OnlineState.Unknown */), await n.remoteSyncer.handleCredentialChange(t), 
-    n.Ta.delete(3 /* OfflineCause.CredentialChange */), await __PRIVATE_enableNetworkInternal(n);
+    n.Va.set("Unknown" /* OnlineState.Unknown */), await n.remoteSyncer.handleCredentialChange(t), 
+    n.da.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.Ta.delete(2 /* OfflineCause.IsSecondary */), await __PRIVATE_enableNetworkInternal(n)) : t || (n.Ta.add(2 /* OfflineCause.IsSecondary */), 
-    await __PRIVATE_disableNetworkInternal(n), n.da.set("Unknown" /* OnlineState.Unknown */));
+    t ? (n.da.delete(2 /* OfflineCause.IsSecondary */), await __PRIVATE_enableNetworkInternal(n)) : t || (n.da.add(2 /* OfflineCause.IsSecondary */), 
+    await __PRIVATE_disableNetworkInternal(n), n.Va.set("Unknown" /* OnlineState.Unknown */));
 }
 
 /**
@@ -15482,11 +15504,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.Ra || (
+    return e.fa || (
     // Create stream (but note that it is not started yet).
-    e.Ra = function __PRIVATE_newPersistentWatchStream(e, t, n) {
+    e.fa = function __PRIVATE_newPersistentWatchStream(e, t, n) {
         const r = __PRIVATE_debugCast(e);
-        return r.ra(), new __PRIVATE_PersistentListenStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
+        return r.oa(), new __PRIVATE_PersistentListenStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
     }
     /**
  * @license
@@ -15507,11 +15529,11 @@ async function __PRIVATE_remoteStoreHandleCredentialChange(e, t) {
         e_: __PRIVATE_onWatchStreamConnected.bind(null, e),
         n_: __PRIVATE_onWatchStreamOpen.bind(null, e),
         i_: __PRIVATE_onWatchStreamClose.bind(null, e),
-        j_: __PRIVATE_onWatchStreamChange.bind(null, e)
-    }), e.Ia.push((async t => {
-        t ? (e.Ra.O_(), __PRIVATE_shouldStartWatchStream(e) ? __PRIVATE_startWatchStream(e) : e.da.set("Unknown" /* OnlineState.Unknown */)) : (await e.Ra.stop(), 
+        Y_: __PRIVATE_onWatchStreamChange.bind(null, e)
+    }), e.Aa.push((async t => {
+        t ? (e.fa.L_(), __PRIVATE_shouldStartWatchStream(e) ? __PRIVATE_startWatchStream(e) : e.Va.set("Unknown" /* OnlineState.Unknown */)) : (await e.fa.stop(), 
         __PRIVATE_cleanUpWatchStreamState(e));
-    }))), e.Ra;
+    }))), e.fa;
 }
 
 /**
@@ -15522,23 +15544,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.Va || (
+    return e.ga || (
     // Create stream (but note that it is not started yet).
-    e.Va = function __PRIVATE_newPersistentWriteStream(e, t, n) {
+    e.ga = function __PRIVATE_newPersistentWriteStream(e, t, n) {
         const r = __PRIVATE_debugCast(e);
-        return r.ra(), new __PRIVATE_PersistentWriteStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
+        return r.oa(), new __PRIVATE_PersistentWriteStream(t, r.connection, r.authCredentials, r.appCheckCredentials, r.serializer, n);
     }(e.datastore, e.asyncQueue, {
         e_: () => Promise.resolve(),
         n_: __PRIVATE_onWriteStreamOpen.bind(null, e),
         i_: __PRIVATE_onWriteStreamClose.bind(null, e),
-        X_: __PRIVATE_onWriteHandshakeComplete.bind(null, e),
-        ea: __PRIVATE_onMutationResult.bind(null, e)
-    }), e.Ia.push((async t => {
-        t ? (e.Va.O_(), 
+        na: __PRIVATE_onWriteHandshakeComplete.bind(null, e),
+        ra: __PRIVATE_onMutationResult.bind(null, e)
+    }), e.Aa.push((async t => {
+        t ? (e.ga.L_(), 
         // This will start the write stream if necessary.
-        await __PRIVATE_fillWritePipeline(e)) : (await e.Va.stop(), e.ha.length > 0 && (__PRIVATE_logDebug(nn, `Stopping write stream with ${e.ha.length} pending writes`), 
-        e.ha = []));
-    }))), e.Va;
+        await __PRIVATE_fillWritePipeline(e)) : (await e.ga.stop(), e.Ia.length > 0 && (__PRIVATE_logDebug(nn, `Stopping write stream with ${e.Ia.length} pending writes`), 
+        e.Ia = []));
+    }))), e.ga;
 }
 
 /**
@@ -15751,25 +15773,25 @@ class DelayedOperation {
  * duplicate events for the same doc.
  */ class __PRIVATE_DocumentChangeSet {
     constructor() {
-        this.ma = new SortedMap(DocumentKey.comparator);
+        this.pa = new SortedMap(DocumentKey.comparator);
     }
     track(e) {
-        const t = e.doc.key, n = this.ma.get(t);
+        const t = e.doc.key, n = this.pa.get(t);
         n ? 
         // Merge the new change with the existing change.
-        0 /* ChangeType.Added */ !== e.type && 3 /* ChangeType.Metadata */ === n.type ? this.ma = this.ma.insert(t, e) : 3 /* ChangeType.Metadata */ === e.type && 1 /* ChangeType.Removed */ !== n.type ? this.ma = this.ma.insert(t, {
+        0 /* ChangeType.Added */ !== e.type && 3 /* ChangeType.Metadata */ === n.type ? this.pa = this.pa.insert(t, e) : 3 /* ChangeType.Metadata */ === e.type && 1 /* ChangeType.Removed */ !== n.type ? this.pa = this.pa.insert(t, {
             type: n.type,
             doc: e.doc
-        }) : 2 /* ChangeType.Modified */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.ma = this.ma.insert(t, {
+        }) : 2 /* ChangeType.Modified */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.pa = this.pa.insert(t, {
             type: 2 /* ChangeType.Modified */ ,
             doc: e.doc
-        }) : 2 /* ChangeType.Modified */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.ma = this.ma.insert(t, {
+        }) : 2 /* ChangeType.Modified */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.pa = this.pa.insert(t, {
             type: 0 /* ChangeType.Added */ ,
             doc: e.doc
-        }) : 1 /* ChangeType.Removed */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.ma = this.ma.remove(t) : 1 /* ChangeType.Removed */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.ma = this.ma.insert(t, {
+        }) : 1 /* ChangeType.Removed */ === e.type && 0 /* ChangeType.Added */ === n.type ? this.pa = this.pa.remove(t) : 1 /* ChangeType.Removed */ === e.type && 2 /* ChangeType.Modified */ === n.type ? this.pa = this.pa.insert(t, {
             type: 1 /* ChangeType.Removed */ ,
             doc: n.doc
-        }) : 0 /* ChangeType.Added */ === e.type && 1 /* ChangeType.Removed */ === n.type ? this.ma = this.ma.insert(t, {
+        }) : 0 /* ChangeType.Added */ === e.type && 1 /* ChangeType.Removed */ === n.type ? this.pa = this.pa.insert(t, {
             type: 2 /* ChangeType.Modified */ ,
             doc: e.doc
         }) : 
@@ -15782,12 +15804,12 @@ class DelayedOperation {
         // Removed->Metadata
         fail(63341, {
             Vt: e,
-            fa: n
-        }) : this.ma = this.ma.insert(t, e);
+            ya: n
+        }) : this.pa = this.pa.insert(t, e);
     }
-    ga() {
+    wa() {
         const e = [];
-        return this.ma.inorderTraversal(((t, n) => {
+        return this.pa.inorderTraversal(((t, n) => {
             e.push(n);
         })), e;
     }
@@ -15843,25 +15865,25 @@ class ViewSnapshot {
  * tracked by EventManager.
  */ class __PRIVATE_QueryListenersInfo {
     constructor() {
-        this.pa = void 0, this.ya = [];
+        this.Sa = void 0, this.ba = [];
     }
     // Helper methods that checks if the query has listeners that listening to remote store
-    wa() {
-        return this.ya.some((e => e.Sa()));
+    Da() {
+        return this.ba.some((e => e.va()));
     }
 }
 
 class __PRIVATE_EventManagerImpl {
     constructor() {
         this.queries = __PRIVATE_newQueriesObjectMap(), this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
-        this.ba = new Set;
+        this.Ca = new Set;
     }
     terminate() {
         !function __PRIVATE_errorAllTargets(e, t) {
             const n = __PRIVATE_debugCast(e), r = n.queries;
             // Prevent further access by clearing ObjectMap.
             n.queries = __PRIVATE_newQueriesObjectMap(), r.forEach(((e, n) => {
-                for (const e of n.ya) e.onError(t);
+                for (const e of n.ba) e.onError(t);
             }));
         }
         // Call all global snapshot listeners that have been set.
@@ -15878,19 +15900,19 @@ async function __PRIVATE_eventManagerListen(e, t) {
     let r = 3 /* ListenerSetupAction.NoActionRequired */;
     const i = t.query;
     let s = n.queries.get(i);
-    s ? !s.wa() && t.Sa() && (
+    s ? !s.Da() && t.va() && (
     // 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.Sa() ? 0 /* ListenerSetupAction.InitializeLocalListenAndRequireWatchConnection */ : 1 /* ListenerSetupAction.InitializeLocalListenOnly */);
+    r = t.va() ? 0 /* ListenerSetupAction.InitializeLocalListenAndRequireWatchConnection */ : 1 /* ListenerSetupAction.InitializeLocalListenOnly */);
     try {
         switch (r) {
           case 0 /* ListenerSetupAction.InitializeLocalListenAndRequireWatchConnection */ :
-            s.pa = await n.onListen(i, 
+            s.Sa = await n.onListen(i, 
             /** enableRemoteListen= */ !0);
             break;
 
           case 1 /* ListenerSetupAction.InitializeLocalListenOnly */ :
-            s.pa = await n.onListen(i, 
+            s.Sa = await n.onListen(i, 
             /** enableRemoteListen= */ !1);
             break;
 
@@ -15901,10 +15923,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.ya.push(t), 
+    if (n.queries.set(i, s), s.ba.push(t), 
     // Run global snapshot listeners if a consistent snapshot has been emitted.
-    t.Da(n.onlineState), s.pa) {
-        t.va(s.pa) && __PRIVATE_raiseSnapshotsInSyncEvent(n);
+    t.Fa(n.onlineState), s.Sa) {
+        t.Ma(s.Sa) && __PRIVATE_raiseSnapshotsInSyncEvent(n);
     }
 }
 
@@ -15913,8 +15935,8 @@ async function __PRIVATE_eventManagerUnlisten(e, t) {
     let i = 3 /* ListenerRemovalAction.NoActionRequired */;
     const s = n.queries.get(r);
     if (s) {
-        const e = s.ya.indexOf(t);
-        e >= 0 && (s.ya.splice(e, 1), 0 === s.ya.length ? i = t.Sa() ? 0 /* ListenerRemovalAction.TerminateLocalListenAndRequireWatchDisconnection */ : 1 /* ListenerRemovalAction.TerminateLocalListenOnly */ : !s.wa() && t.Sa() && (
+        const e = s.ba.indexOf(t);
+        e >= 0 && (s.ba.splice(e, 1), 0 === s.ba.length ? i = t.va() ? 0 /* ListenerRemovalAction.TerminateLocalListenAndRequireWatchDisconnection */ : 1 /* ListenerRemovalAction.TerminateLocalListenOnly */ : !s.Da() && t.va() && (
         // The removed listener is the last one that sourced from watch.
         i = 2 /* ListenerRemovalAction.RequireWatchDisconnectionOnly */));
     }
@@ -15941,8 +15963,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.ya) t.va(e) && (r = !0);
-            i.pa = e;
+            for (const t of i.ba) t.Ma(e) && (r = !0);
+            i.Sa = e;
         }
     }
     r && __PRIVATE_raiseSnapshotsInSyncEvent(n);
@@ -15950,14 +15972,14 @@ 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.ya) e.onError(n);
+    if (i) for (const e of i.ba) e.onError(n);
     // Remove all listeners. NOTE: We don't need to call syncEngine.unlisten()
     // after an error.
         r.queries.delete(t);
 }
 
 function __PRIVATE_raiseSnapshotsInSyncEvent(e) {
-    e.ba.forEach((e => {
+    e.Ca.forEach((e => {
         e.next();
     }));
 }
@@ -15965,7 +15987,7 @@ function __PRIVATE_raiseSnapshotsInSyncEvent(e) {
 var rn, sn;
 
 /** Listen to both cache and server changes */
-(sn = rn || (rn = {})).Ca = "default", 
+(sn = rn || (rn = {})).xa = "default", 
 /** Listen to changes in cache only */
 sn.Cache = "cache";
 
@@ -15977,12 +15999,12 @@ sn.Cache = "cache";
  */
 class __PRIVATE_QueryListener {
     constructor(e, t, n) {
-        this.query = e, this.Fa = t, 
+        this.query = e, this.Oa = 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.Ma = !1, this.xa = null, this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
+        this.Na = !1, this.Ba = null, this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
         this.options = n || {};
     }
     /**
@@ -15990,7 +16012,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.
-     */    va(e) {
+     */    Ma(e) {
         if (!this.options.includeMetadataChanges) {
             // Remove the metadata only changes.
             const t = [];
@@ -15999,49 +16021,49 @@ class __PRIVATE_QueryListener {
             /* excludesMetadataChanges= */ !0, e.hasCachedResults);
         }
         let t = !1;
-        return this.Ma ? this.Oa(e) && (this.Fa.next(e), t = !0) : this.Na(e, this.onlineState) && (this.Ba(e), 
-        t = !0), this.xa = e, t;
+        return this.Na ? this.La(e) && (this.Oa.next(e), t = !0) : this.ka(e, this.onlineState) && (this.qa(e), 
+        t = !0), this.Ba = e, t;
     }
     onError(e) {
-        this.Fa.error(e);
+        this.Oa.error(e);
     }
-    /** Returns whether a snapshot was raised. */    Da(e) {
+    /** Returns whether a snapshot was raised. */    Fa(e) {
         this.onlineState = e;
         let t = !1;
-        return this.xa && !this.Ma && this.Na(this.xa, e) && (this.Ba(this.xa), t = !0), 
+        return this.Ba && !this.Na && this.ka(this.Ba, e) && (this.qa(this.Ba), t = !0), 
         t;
     }
-    Na(e, t) {
+    ka(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.Sa()) return !0;
+                if (!this.va()) 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.La || !n) && (!e.docs.isEmpty() || e.hasCachedResults || "Offline" /* OnlineState.Offline */ === t);
+                return (!this.options.Qa || !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.
         }
-    Oa(e) {
+    La(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.xa && this.xa.hasPendingWrites !== e.hasPendingWrites;
+        const t = this.Ba && this.Ba.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.
         }
-    Ba(e) {
+    qa(e) {
         e = ViewSnapshot.fromInitialDocuments(e.query, e.docs, e.mutatedKeys, e.fromCache, e.hasCachedResults), 
-        this.Ma = !0, this.Fa.next(e);
+        this.Na = !0, this.Oa.next(e);
     }
-    Sa() {
+    va() {
         return this.options.source !== rn.Cache;
     }
 }
@@ -16069,10 +16091,10 @@ class __PRIVATE_QueryListener {
     constructor(e, 
     // How many bytes this element takes to store in the bundle.
     t) {
-        this.ka = e, this.byteLength = t;
+        this.$a = e, this.byteLength = t;
     }
-    qa() {
-        return "metadata" in this.ka;
+    Ua() {
+        return "metadata" in this.$a;
     }
 }
 
@@ -16116,7 +16138,7 @@ class __PRIVATE_QueryListener {
  * storage and provide progress update while loading.
  */ class __PRIVATE_BundleLoader {
     constructor(e, t, n) {
-        this.Qa = e, this.localStore = t, this.serializer = n, 
+        this.Ka = e, this.localStore = t, this.serializer = n, 
         /** Batched queries to be saved into storage */
         this.queries = [], 
         /** Batched documents to be saved into storage */
@@ -16129,21 +16151,21 @@ class __PRIVATE_QueryListener {
      *
      * Returns a new progress if adding the element leads to a new progress,
      * otherwise returns null.
-     */    $a(e) {
+     */    Wa(e) {
         this.progress.bytesLoaded += e.byteLength;
         let t = this.progress.documentsLoaded;
-        if (e.ka.namedQuery) this.queries.push(e.ka.namedQuery); else if (e.ka.documentMetadata) {
+        if (e.$a.namedQuery) this.queries.push(e.$a.namedQuery); else if (e.$a.documentMetadata) {
             this.documents.push({
-                metadata: e.ka.documentMetadata
-            }), e.ka.documentMetadata.exists || ++t;
-            const n = ResourcePath.fromString(e.ka.documentMetadata.name);
+                metadata: e.$a.documentMetadata
+            }), e.$a.documentMetadata.exists || ++t;
+            const n = ResourcePath.fromString(e.$a.documentMetadata.name);
             this.collectionGroups.add(n.get(n.length - 2));
-        } else e.ka.document && (this.documents[this.documents.length - 1].document = e.ka.document, 
+        } else e.$a.document && (this.documents[this.documents.length - 1].document = e.$a.document, 
         ++t);
         return t !== this.progress.documentsLoaded ? (this.progress.documentsLoaded = t, 
         Object.assign({}, this.progress)) : null;
     }
-    Ua(e) {
+    Ga(e) {
         const t = new Map, n = new __PRIVATE_BundleConverterImpl(this.serializer);
         for (const r of e) if (r.metadata.queries) {
             const e = n.Us(r.metadata.name);
@@ -16157,12 +16179,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.Qa.id), t = this.Ua(this.documents);
+        const e = await __PRIVATE_localStoreApplyBundledDocuments(this.localStore, new __PRIVATE_BundleConverterImpl(this.serializer), this.documents, this.Ka.id), t = this.Ga(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,
-            Ka: this.collectionGroups,
-            Wa: e
+            za: this.collectionGroups,
+            ja: e
         };
     }
 }
@@ -16220,7 +16242,7 @@ class __PRIVATE_RemovedLimboDocument {
     constructor(e, 
     /** Documents included in the remote target */
     t) {
-        this.query = e, this.Ga = t, this.za = null, this.hasCachedResults = !1, 
+        this.query = e, this.Ha = t, this.Ja = 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
@@ -16229,16 +16251,16 @@ class __PRIVATE_RemovedLimboDocument {
          */
         this.current = !1, 
         /** Documents in the view but not in the remote target */
-        this.ja = __PRIVATE_documentKeySet(), 
+        this.Ya = __PRIVATE_documentKeySet(), 
         /** Document Keys that have local changes */
-        this.mutatedKeys = __PRIVATE_documentKeySet(), this.Ha = __PRIVATE_newQueryComparator(e), 
-        this.Ja = new DocumentSet(this.Ha);
+        this.mutatedKeys = __PRIVATE_documentKeySet(), this.Za = __PRIVATE_newQueryComparator(e), 
+        this.Xa = new DocumentSet(this.Za);
     }
     /**
      * The set of remote documents that the server has told us belongs to the target associated with
      * this view.
-     */    get Ya() {
-        return this.Ga;
+     */    get eu() {
+        return this.Ha;
     }
     /**
      * Iterates over a set of doc changes, applies the query limit, and computes
@@ -16249,8 +16271,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.
-     */    Za(e, t) {
-        const n = t ? t.Xa : new __PRIVATE_DocumentChangeSet, r = t ? t.Ja : this.Ja;
+     */    tu(e, t) {
+        const n = t ? t.nu : new __PRIVATE_DocumentChangeSet, r = t ? t.Xa : this.Xa;
         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
@@ -16273,10 +16295,10 @@ class __PRIVATE_RemovedLimboDocument {
                 u.data.isEqual(c.data) ? l !== h && (n.track({
                     type: 3 /* ChangeType.Metadata */ ,
                     doc: c
-                }), P = !0) : this.eu(u, c) || (n.track({
+                }), P = !0) : this.ru(u, c) || (n.track({
                     type: 2 /* ChangeType.Modified */ ,
                     doc: c
-                }), P = !0, (_ && this.Ha(c, _) > 0 || a && this.Ha(c, a) < 0) && (
+                }), P = !0, (_ && this.Za(c, _) > 0 || a && this.Za(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.
@@ -16301,13 +16323,13 @@ class __PRIVATE_RemovedLimboDocument {
             });
         }
         return {
-            Ja: s,
-            Xa: n,
+            Xa: s,
+            nu: n,
             Cs: o,
             mutatedKeys: i
         };
     }
-    eu(e, t) {
+    ru(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.
@@ -16332,10 +16354,10 @@ class __PRIVATE_RemovedLimboDocument {
      */
     // PORTING NOTE: The iOS/Android clients always compute limbo document changes.
     applyChanges(e, t, n, r) {
-        const i = this.Ja;
-        this.Ja = e.Ja, this.mutatedKeys = e.mutatedKeys;
+        const i = this.Xa;
+        this.Xa = e.Xa, this.mutatedKeys = e.mutatedKeys;
         // Sort changes based on type and query comparator
-        const s = e.Xa.ga();
+        const s = e.nu.wa();
         s.sort(((e, t) => function __PRIVATE_compareChangeType(e, t) {
             const order = e => {
                 switch (e) {
@@ -16375,70 +16397,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.Ha(e.doc, t.doc))), this.tu(n), r = null != r && r;
-        const o = t && !r ? this.nu() : [], _ = 0 === this.ja.size && this.current && !r ? 1 /* SyncState.Synced */ : 0 /* SyncState.Local */ , a = _ !== this.za;
+ */ (e.type, t.type) || this.Za(e.doc, t.doc))), this.iu(n), r = null != r && r;
+        const o = t && !r ? this.su() : [], _ = 0 === this.Ya.size && this.current && !r ? 1 /* SyncState.Synced */ : 0 /* SyncState.Local */ , a = _ !== this.Ja;
         // 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.za = _, 0 !== s.length || a) {
+                if (this.Ja = _, 0 !== s.length || a) {
             return {
-                snapshot: new ViewSnapshot(this.query, e.Ja, i, s, e.mutatedKeys, 0 /* SyncState.Local */ === _, a, 
+                snapshot: new ViewSnapshot(this.query, e.Xa, i, s, e.mutatedKeys, 0 /* SyncState.Local */ === _, a, 
                 /* excludesMetadataChanges= */ !1, !!n && n.resumeToken.approximateByteSize() > 0),
-                ru: o
+                ou: o
             };
         }
         // no changes
         return {
-            ru: o
+            ou: o
         };
     }
     /**
      * Applies an OnlineState change to the view, potentially generating a
      * ViewChange if the view's syncState changes as a result.
-     */    Da(e) {
+     */    Fa(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({
-            Ja: this.Ja,
-            Xa: new __PRIVATE_DocumentChangeSet,
+            Xa: this.Xa,
+            nu: new __PRIVATE_DocumentChangeSet,
             mutatedKeys: this.mutatedKeys,
             Cs: !1
         }, 
         /* limboResolutionEnabled= */ !1)) : {
-            ru: []
+            ou: []
         };
     }
     /**
      * Returns whether the doc for the given key should be in limbo.
-     */    iu(e) {
+     */    _u(e) {
         // If the remote end says it's part of this query, it's not in limbo.
-        return !this.Ga.has(e) && (
+        return !this.Ha.has(e) && (
         // The local store doesn't think it's a result, so it shouldn't be in limbo.
-        !!this.Ja.has(e) && !this.Ja.get(e).hasLocalMutations);
+        !!this.Xa.has(e) && !this.Xa.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.
-     */    tu(e) {
-        e && (e.addedDocuments.forEach((e => this.Ga = this.Ga.add(e))), e.modifiedDocuments.forEach((e => {})), 
-        e.removedDocuments.forEach((e => this.Ga = this.Ga.delete(e))), this.current = e.current);
+     */    iu(e) {
+        e && (e.addedDocuments.forEach((e => this.Ha = this.Ha.add(e))), e.modifiedDocuments.forEach((e => {})), 
+        e.removedDocuments.forEach((e => this.Ha = this.Ha.delete(e))), this.current = e.current);
     }
-    nu() {
+    su() {
         // 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.ja;
-        this.ja = __PRIVATE_documentKeySet(), this.Ja.forEach((e => {
-            this.iu(e.key) && (this.ja = this.ja.add(e.key));
+                const e = this.Ya;
+        this.Ya = __PRIVATE_documentKeySet(), this.Xa.forEach((e => {
+            this._u(e.key) && (this.Ya = this.Ya.add(e.key));
         }));
         // Diff the new limbo docs with the old limbo docs.
         const t = [];
         return e.forEach((e => {
-            this.ja.has(e) || t.push(new __PRIVATE_RemovedLimboDocument(e));
-        })), this.ja.forEach((n => {
+            this.Ya.has(e) || t.push(new __PRIVATE_RemovedLimboDocument(e));
+        })), this.Ya.forEach((n => {
             e.has(n) || t.push(new __PRIVATE_AddedLimboDocument(n));
         })), t;
     }
@@ -16462,9 +16484,9 @@ class __PRIVATE_RemovedLimboDocument {
      * @returns The ViewChange that resulted from this synchronization.
      */
     // PORTING NOTE: Multi-tab only.
-    su(e) {
-        this.Ga = e.$s, this.ja = __PRIVATE_documentKeySet();
-        const t = this.Za(e.documents);
+    au(e) {
+        this.Ha = e.$s, this.Ya = __PRIVATE_documentKeySet();
+        const t = this.tu(e.documents);
         return this.applyChanges(t, /* limboResolutionEnabled= */ !0);
     }
     /**
@@ -16473,8 +16495,8 @@ class __PRIVATE_RemovedLimboDocument {
      * `hasPendingWrites` status of the already established view.
      */
     // PORTING NOTE: Multi-tab only.
-    ou() {
-        return ViewSnapshot.fromInitialDocuments(this.query, this.Ja, this.mutatedKeys, 0 /* SyncState.Local */ === this.za, this.hasCachedResults);
+    uu() {
+        return ViewSnapshot.fromInitialDocuments(this.query, this.Xa, this.mutatedKeys, 0 /* SyncState.Local */ === this.Ja, this.hasCachedResults);
     }
 }
 
@@ -16514,7 +16536,7 @@ const on = "SyncEngine";
          * decide whether it needs to manufacture a delete event for the target once
          * the target is CURRENT.
          */
-        this._u = !1;
+        this.cu = !1;
     }
 }
 
@@ -16535,8 +16557,8 @@ const on = "SyncEngine";
     // 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.au = {}, this.uu = new ObjectMap((e => __PRIVATE_canonifyQuery(e)), __PRIVATE_queryEquals), 
-        this.cu = new Map, 
+        this.currentUser = i, this.maxConcurrentLimboResolutions = s, this.lu = {}, this.hu = new ObjectMap((e => __PRIVATE_canonifyQuery(e)), __PRIVATE_queryEquals), 
+        this.Pu = 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
@@ -16546,28 +16568,28 @@ const on = "SyncEngine";
          * of arbitrary elements and it also maintains insertion order, providing the
          * desired queue-like FIFO semantics.
          */
-        this.lu = new Set, 
+        this.Tu = new Set, 
         /**
          * Keeps track of the target ID for each document that is in limbo with an
          * active target.
          */
-        this.hu = new SortedMap(DocumentKey.comparator), 
+        this.Iu = 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.Pu = new Map, this.Tu = new __PRIVATE_ReferenceSet, 
+        this.Eu = new Map, this.du = new __PRIVATE_ReferenceSet, 
         /** Stores user completion handlers, indexed by User and BatchId. */
-        this.Iu = {}, 
+        this.Au = {}, 
         /** Stores user callbacks waiting for all pending writes to be acknowledged. */
-        this.Eu = new Map, this.du = __PRIVATE_TargetIdGenerator.lr(), this.onlineState = "Unknown" /* OnlineState.Unknown */ , 
+        this.Ru = new Map, this.Vu = __PRIVATE_TargetIdGenerator.lr(), 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.Au = void 0;
+        this.mu = void 0;
     }
     get isPrimaryClient() {
-        return !0 === this.Au;
+        return !0 === this.mu;
     }
 }
 
@@ -16579,7 +16601,7 @@ const on = "SyncEngine";
 async function __PRIVATE_syncEngineListen(e, t, n = !0) {
     const r = __PRIVATE_ensureWatchCallbacks(e);
     let i;
-    const s = r.uu.get(t);
+    const s = r.hu.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
@@ -16587,7 +16609,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.ou()) : i = await __PRIVATE_allocateTargetAndMaybeListen(r, t, n, 
+    r.sharedClientState.addLocalQueryTarget(s.targetId), i = s.view.uu()) : i = await __PRIVATE_allocateTargetAndMaybeListen(r, t, n, 
     /** shouldInitializeView= */ !0), i;
 }
 
@@ -16612,30 +16634,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.Ru = (t, n, r) => async function __PRIVATE_applyDocChanges(e, t, n, r) {
-        let i = t.view.Za(n);
+    e.fu = (t, n, r) => async function __PRIVATE_applyDocChanges(e, t, n, r) {
+        let i = t.view.tu(n);
         i.Cs && (
         // 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.Za(e, i))));
+        /* usePreviousResults= */ !1).then((({documents: e}) => t.view.tu(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, _.ru), _.snapshot;
+        return __PRIVATE_updateTrackedLimbos(e, t.targetId, _.ou), _.snapshot;
     }(e, t, n, r);
     const s = await __PRIVATE_localStoreExecuteQuery(e.localStore, t, 
-    /* usePreviousResults= */ !0), o = new __PRIVATE_View(t, s.$s), _ = o.Za(s.documents), a = TargetChange.createSynthesizedTargetChangeForCurrentChange(n, r && "Offline" /* OnlineState.Offline */ !== e.onlineState, i), u = o.applyChanges(_, 
+    /* usePreviousResults= */ !0), o = new __PRIVATE_View(t, s.$s), _ = o.tu(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.ru);
+    __PRIVATE_updateTrackedLimbos(e, n, u.ou);
     const c = new __PRIVATE_QueryView(t, n, o);
-    return e.uu.set(t, c), e.cu.has(n) ? e.cu.get(n).push(t) : e.cu.set(n, [ t ]), u.snapshot;
+    return e.hu.set(t, c), e.Pu.has(n) ? e.Pu.get(n).push(t) : e.Pu.set(n, [ t ]), u.snapshot;
 }
 
 /** Stops listening to the query. */ async function __PRIVATE_syncEngineUnlisten(e, t, n) {
-    const r = __PRIVATE_debugCast(e), i = r.uu.get(t), s = r.cu.get(i.targetId);
-    if (s.length > 1) return r.cu.set(i.targetId, s.filter((e => !__PRIVATE_queryEquals(e, t)))), 
-    void r.uu.delete(t);
+    const r = __PRIVATE_debugCast(e), i = r.hu.get(t), s = r.Pu.get(i.targetId);
+    if (s.length > 1) return r.Pu.set(i.targetId, s.filter((e => !__PRIVATE_queryEquals(e, t)))), 
+    void r.hu.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
@@ -16651,7 +16673,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.uu.get(t), i = n.cu.get(r.targetId);
+    const n = __PRIVATE_debugCast(e), r = n.hu.get(t), i = n.Pu.get(r.targetId);
     n.isPrimaryClient && 1 === i.length && (
     // PORTING NOTE: Unregister the target ID with local Firestore client as
     // watch target.
@@ -16713,9 +16735,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.Iu[e.currentUser.toKey()];
+            let r = e.Au[e.currentUser.toKey()];
             r || (r = new SortedMap(__PRIVATE_primitiveComparator));
-            r = r.insert(t, n), e.Iu[e.currentUser.toKey()] = r;
+            r = r.insert(t, n), e.Au[e.currentUser.toKey()] = r;
         }
         /**
  * Resolves or rejects the user callback for the given batch and then discards
@@ -16740,13 +16762,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.Pu.get(t);
+            const r = n.Eu.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, 22616), 
-            e.addedDocuments.size > 0 ? r._u = !0 : e.modifiedDocuments.size > 0 ? __PRIVATE_hardAssert(r._u, 14607) : e.removedDocuments.size > 0 && (__PRIVATE_hardAssert(r._u, 42227), 
-            r._u = !1));
+            e.addedDocuments.size > 0 ? r.cu = !0 : e.modifiedDocuments.size > 0 ? __PRIVATE_hardAssert(r.cu, 14607) : e.removedDocuments.size > 0 && (__PRIVATE_hardAssert(r.cu, 42227), 
+            r.cu = !1));
         })), await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(n, e, t);
     } catch (e) {
         await __PRIVATE_ignoreIfPrimaryLeaseLoss(e);
@@ -16764,19 +16786,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.uu.forEach(((n, r) => {
-            const i = r.view.Da(t);
+        r.hu.forEach(((n, r) => {
+            const i = r.view.Fa(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.ya) 
+                for (const e of n.ba) 
                 // Run global snapshot listeners if a consistent snapshot has been emitted.
-                e.Da(t) && (r = !0);
+                e.Fa(t) && (r = !0);
             })), r && __PRIVATE_raiseSnapshotsInSyncEvent(n);
-        }(r.eventManager, t), e.length && r.au.j_(e), r.onlineState = t, r.isPrimaryClient && r.sharedClientState.setOnlineState(t);
+        }(r.eventManager, t), e.length && r.lu.Y_(e), r.onlineState = t, r.isPrimaryClient && r.sharedClientState.setOnlineState(t);
     }
 }
 
@@ -16794,7 +16816,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.Pu.get(t), s = i && i.key;
+    const i = r.Eu.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.
@@ -16816,7 +16838,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.hu = r.hu.remove(s), r.Pu.delete(t), __PRIVATE_pumpEnqueuedLimboResolutions(r);
+        r.Iu = r.Iu.remove(s), r.Eu.delete(t), __PRIVATE_pumpEnqueuedLimboResolutions(r);
     } else await __PRIVATE_localStoreReleaseTarget(r.localStore, t, 
     /* keepPersistedTargetData */ !1).then((() => __PRIVATE_removeAndCleanupTarget(r, t, n))).catch(__PRIVATE_ignoreIfPrimaryLeaseLoss);
 }
@@ -16878,8 +16900,8 @@ async function __PRIVATE_syncEngineRejectFailedWrite(e, t, n) {
         if (e === j) 
         // Trigger the callback right away if there is no pending writes at the moment.
         return void t.resolve();
-        const r = n.Eu.get(e) || [];
-        r.push(t), n.Eu.set(e, r);
+        const r = n.Ru.get(e) || [];
+        r.push(t), n.Ru.set(e, r);
     } catch (e) {
         const n = __PRIVATE_wrapInUserErrorIfRecoverable(e, "Initialization of waitForPendingWrites() operation failed");
         t.reject(n);
@@ -16890,28 +16912,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.Eu.get(t) || []).forEach((e => {
+    (e.Ru.get(t) || []).forEach((e => {
         e.resolve();
-    })), e.Eu.delete(t);
+    })), e.Ru.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.Iu[r.currentUser.toKey()];
+    let i = r.Au[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.Iu[r.currentUser.toKey()] = i;
+        e && (n ? e.reject(n) : e.resolve(), i = i.remove(t)), r.Au[r.currentUser.toKey()] = i;
     }
 }
 
 function __PRIVATE_removeAndCleanupTarget(e, t, n = null) {
     e.sharedClientState.removeLocalQueryTarget(t);
-    for (const r of e.cu.get(t)) e.uu.delete(r), n && e.au.Vu(r, n);
-    if (e.cu.delete(t), e.isPrimaryClient) {
-        e.Tu.Hr(t).forEach((t => {
-            e.Tu.containsKey(t) || 
+    for (const r of e.Pu.get(t)) e.hu.delete(r), n && e.lu.gu(r, n);
+    if (e.Pu.delete(t), e.isPrimaryClient) {
+        e.du.Hr(t).forEach((t => {
+            e.du.containsKey(t) || 
             // We removed the last reference for this key
             __PRIVATE_removeLimboTarget(e, t);
         }));
@@ -16919,30 +16941,30 @@ function __PRIVATE_removeAndCleanupTarget(e, t, n = null) {
 }
 
 function __PRIVATE_removeLimboTarget(e, t) {
-    e.lu.delete(t.path.canonicalString());
+    e.Tu.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.hu.get(t);
-    null !== n && (__PRIVATE_remoteStoreUnlisten(e.remoteStore, n), e.hu = e.hu.remove(t), 
-    e.Pu.delete(n), __PRIVATE_pumpEnqueuedLimboResolutions(e));
+    const n = e.Iu.get(t);
+    null !== n && (__PRIVATE_remoteStoreUnlisten(e.remoteStore, n), e.Iu = e.Iu.remove(t), 
+    e.Eu.delete(n), __PRIVATE_pumpEnqueuedLimboResolutions(e));
 }
 
 function __PRIVATE_updateTrackedLimbos(e, t, n) {
-    for (const r of n) if (r instanceof __PRIVATE_AddedLimboDocument) e.Tu.addReference(r.key, t), 
+    for (const r of n) if (r instanceof __PRIVATE_AddedLimboDocument) e.du.addReference(r.key, t), 
     __PRIVATE_trackLimboChange(e, r); else if (r instanceof __PRIVATE_RemovedLimboDocument) {
-        __PRIVATE_logDebug(on, "Document no longer in limbo: " + r.key), e.Tu.removeReference(r.key, t);
-        e.Tu.containsKey(r.key) || 
+        __PRIVATE_logDebug(on, "Document no longer in limbo: " + r.key), e.du.removeReference(r.key, t);
+        e.du.containsKey(r.key) || 
         // We removed the last reference for this key
         __PRIVATE_removeLimboTarget(e, r.key);
     } else fail(19791, {
-        mu: r
+        pu: r
     });
 }
 
 function __PRIVATE_trackLimboChange(e, t) {
     const n = t.key, r = n.path.canonicalString();
-    e.hu.get(n) || e.lu.has(r) || (__PRIVATE_logDebug(on, "New document in limbo: " + n), 
-    e.lu.add(r), __PRIVATE_pumpEnqueuedLimboResolutions(e));
+    e.Iu.get(n) || e.Tu.has(r) || (__PRIVATE_logDebug(on, "New document in limbo: " + n), 
+    e.Tu.add(r), __PRIVATE_pumpEnqueuedLimboResolutions(e));
 }
 
 /**
@@ -16953,18 +16975,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.lu.size > 0 && e.hu.size < e.maxConcurrentLimboResolutions; ) {
-        const t = e.lu.values().next().value;
-        e.lu.delete(t);
-        const n = new DocumentKey(ResourcePath.fromString(t)), r = e.du.next();
-        e.Pu.set(r, new LimboResolution(n)), e.hu = e.hu.insert(n, r), __PRIVATE_remoteStoreListen(e.remoteStore, new TargetData(__PRIVATE_queryToTarget(__PRIVATE_newQueryForPath(n.path)), r, "TargetPurposeLimboResolution" /* TargetPurpose.LimboResolution */ , __PRIVATE_ListenSequence.le));
+    for (;e.Tu.size > 0 && e.Iu.size < e.maxConcurrentLimboResolutions; ) {
+        const t = e.Tu.values().next().value;
+        e.Tu.delete(t);
+        const n = new DocumentKey(ResourcePath.fromString(t)), r = e.Vu.next();
+        e.Eu.set(r, new LimboResolution(n)), e.Iu = e.Iu.insert(n, r), __PRIVATE_remoteStoreListen(e.remoteStore, new TargetData(__PRIVATE_queryToTarget(__PRIVATE_newQueryForPath(n.path)), r, "TargetPurposeLimboResolution" /* TargetPurpose.LimboResolution */ , __PRIVATE_ListenSequence.le));
     }
 }
 
 async function __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, t, n) {
     const r = __PRIVATE_debugCast(e), i = [], s = [], o = [];
-    r.uu.isEmpty() || (r.uu.forEach(((e, _) => {
-        o.push(r.Ru(_, t, n).then((e => {
+    r.hu.isEmpty() || (r.hu.forEach(((e, _) => {
+        o.push(r.fu(_, t, n).then((e => {
             var t;
             // If there are changes, or we are handling a global snapshot, notify
             // secondary clients to update query state.
@@ -16982,7 +17004,7 @@ async function __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, t, n) {
                 s.push(t);
             }
         })));
-    })), await Promise.all(o), r.au.j_(i), await async function __PRIVATE_localStoreNotifyLocalViewChanges(e, t) {
+    })), await Promise.all(o), r.lu.Y_(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.ds, (r => n.persistence.referenceDelegate.addReference(e, t.targetId, r))).next((() => PersistencePromise.forEach(t.As, (r => n.persistence.referenceDelegate.removeReference(e, t.targetId, r)))))))));
@@ -17013,11 +17035,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.Eu.forEach((e => {
+            e.Ru.forEach((e => {
                 e.forEach((e => {
                     e.reject(new FirestoreError(L.CANCELLED, t));
                 }));
-            })), e.Eu.clear();
+            })), e.Ru.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.ks);
@@ -17025,15 +17047,15 @@ async function __PRIVATE_syncEngineHandleCredentialChange(e, t) {
 }
 
 function __PRIVATE_syncEngineGetRemoteKeysForTarget(e, t) {
-    const n = __PRIVATE_debugCast(e), r = n.Pu.get(t);
-    if (r && r._u) return __PRIVATE_documentKeySet().add(r.key);
+    const n = __PRIVATE_debugCast(e), r = n.Eu.get(t);
+    if (r && r.cu) return __PRIVATE_documentKeySet().add(r.key);
     {
         let e = __PRIVATE_documentKeySet();
-        const r = n.cu.get(t);
+        const r = n.Pu.get(t);
         if (!r) return e;
         for (const t of r) {
-            const r = n.uu.get(t);
-            e = e.unionWith(r.view.Ya);
+            const r = n.hu.get(t);
+            e = e.unionWith(r.view.eu);
         }
         return e;
     }
@@ -17044,8 +17066,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.su(r);
-    return n.isPrimaryClient && __PRIVATE_updateTrackedLimbos(n, t.targetId, i.ru), 
+    /* usePreviousResults= */ !0), i = t.view.au(r);
+    return n.isPrimaryClient && __PRIVATE_updateTrackedLimbos(n, t.targetId, i.ou), 
     i;
 }
 
@@ -17081,7 +17103,7 @@ async function __PRIVATE_syncEngineApplyBatchState(e, t, n, r) {
     }
     // PORTING NOTE: Multi-Tab only.
     (i.localStore, t)) : fail(6720, "Unknown batchState", {
-        fu: n
+        yu: n
     }), await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(i, s)) : 
     // A throttled tab may not have seen the mutation before it was completed
     // and removed from the mutation queue, in which case we won't have cached
@@ -17098,7 +17120,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.Au) {
+    !0 === t && !0 !== n.mu) {
         // 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
@@ -17106,12 +17128,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.Au = !0, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !0);
+        n.mu = !0, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !0);
         for (const e of t) __PRIVATE_remoteStoreListen(n.remoteStore, e);
-    } else if (!1 === t && !1 !== n.Au) {
+    } else if (!1 === t && !1 !== n.mu) {
         const e = [];
         let t = Promise.resolve();
-        n.cu.forEach(((r, i) => {
+        n.Pu.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);
@@ -17119,9 +17141,9 @@ async function __PRIVATE_syncEngineApplyPrimaryState(e, t) {
         // PORTING NOTE: Multi-Tab only.
         function __PRIVATE_resetLimboDocuments(e) {
             const t = __PRIVATE_debugCast(e);
-            t.Pu.forEach(((e, n) => {
+            t.Eu.forEach(((e, n) => {
                 __PRIVATE_remoteStoreUnlisten(t.remoteStore, n);
-            })), t.Tu.Jr(), t.Pu = new Map, t.hu = new SortedMap(DocumentKey.comparator);
+            })), t.du.Jr(), t.Eu = new Map, t.Iu = new SortedMap(DocumentKey.comparator);
         }
         /**
  * Reconcile the query views of the provided query targets with the state from
@@ -17134,7 +17156,7 @@ async function __PRIVATE_syncEngineApplyPrimaryState(e, t) {
  * tab to a primary tab
  */
         // PORTING NOTE: Multi-Tab only.
-        (n), n.Au = !1, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !1);
+        (n), n.mu = !1, await __PRIVATE_remoteStoreApplyPrimaryState(n.remoteStore, !1);
     }
 }
 
@@ -17142,7 +17164,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.cu.get(e);
+        const n = r.Pu.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
@@ -17150,7 +17172,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.uu.get(e), n = await __PRIVATE_synchronizeViewAndComputeSnapshot(r, t);
+                const t = r.hu.get(e), n = await __PRIVATE_synchronizeViewAndComputeSnapshot(r, t);
                 n.snapshot && s.push(n.snapshot);
             }
         } else {
@@ -17162,7 +17184,7 @@ async function __PRIVATE_synchronizeQueryViewsAndRaiseSnapshots(e, t, n) {
         }
         i.push(t);
     }
-    return r.au.j_(s), i;
+    return r.lu.Y_(s), i;
 }
 
 /**
@@ -17192,11 +17214,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.Au) 
+    if (i.mu) 
     // 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(on, "Ignoring unexpected query state notification.");
-    const s = i.cu.get(t);
+    const s = i.Pu.get(t);
     if (s && s.length > 0) switch (n) {
       case "current":
       case "not-current":
@@ -17218,9 +17240,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.Au) {
+    if (r.mu) {
         for (const e of t) {
-            if (r.cu.has(e) && r.sharedClientState.isActiveQueryTarget(e)) {
+            if (r.Pu.has(e) && r.sharedClientState.isActiveQueryTarget(e)) {
                 __PRIVATE_logDebug(on, "Adding an already active target " + e);
                 continue;
             }
@@ -17231,7 +17253,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.cu.has(e) && 
+        r.Pu.has(e) && 
         // Release queries that are still active.
         await __PRIVATE_localStoreReleaseTarget(r.localStore, e, 
         /* keepPersistedTargetData */ !1).then((() => {
@@ -17245,7 +17267,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.au.j_ = __PRIVATE_eventManagerOnWatchChange.bind(null, t.eventManager), t.au.Vu = __PRIVATE_eventManagerOnWatchError.bind(null, t.eventManager), 
+    t.lu.Y_ = __PRIVATE_eventManagerOnWatchChange.bind(null, t.eventManager), t.lu.gu = __PRIVATE_eventManagerOnWatchError.bind(null, t.eventManager), 
     t;
 }
 
@@ -17288,13 +17310,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.gu();
+            let s = await t.wu();
             for (;s; ) {
-                const e = await i.$a(s);
-                e && n._updateProgress(e), s = await t.gu();
+                const e = await i.Wa(s);
+                e && n._updateProgress(e), s = await t.wu();
             }
             const o = await i.complete();
-            return await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, o.Wa, 
+            return await __PRIVATE_syncEngineEmitNewSnapsAndNotifyLocalStore(e, o.ja, 
             /* remoteEvent */ void 0), 
             // Save metadata, so loading the same bundle will skip.
             await function __PRIVATE_localStoreSaveBundle(e, t) {
@@ -17304,7 +17326,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.Ka);
+ */ (e.localStore, r), n._completeWith(o.progress), Promise.resolve(o.za);
         } catch (e) {
             return __PRIVATE_logWarn(on, `Loading bundle failed with ${e}`), n._failWith(e), 
             Promise.resolve(new Set);
@@ -17339,23 +17361,23 @@ class __PRIVATE_MemoryOfflineComponentProvider {
         this.kind = "memory", this.synchronizeTabs = !1;
     }
     async initialize(e) {
-        this.serializer = __PRIVATE_newSerializer(e.databaseInfo.databaseId), this.sharedClientState = this.pu(e), 
-        this.persistence = this.yu(e), await this.persistence.start(), this.localStore = this.wu(e), 
-        this.gcScheduler = this.Su(e, this.localStore), this.indexBackfillerScheduler = this.bu(e, this.localStore);
+        this.serializer = __PRIVATE_newSerializer(e.databaseInfo.databaseId), this.sharedClientState = this.Su(e), 
+        this.persistence = this.bu(e), await this.persistence.start(), this.localStore = this.Du(e), 
+        this.gcScheduler = this.vu(e, this.localStore), this.indexBackfillerScheduler = this.Cu(e, this.localStore);
     }
-    Su(e, t) {
+    vu(e, t) {
         return null;
     }
-    bu(e, t) {
+    Cu(e, t) {
         return null;
     }
-    wu(e) {
+    Du(e) {
         return __PRIVATE_newLocalStore(this.persistence, new __PRIVATE_QueryEngine, e.initialUser, this.serializer);
     }
-    yu(e) {
+    bu(e) {
         return new __PRIVATE_MemoryPersistence(__PRIVATE_MemoryEagerDelegate.fi, this.serializer);
     }
-    pu(e) {
+    Su(e) {
         return new __PRIVATE_MemorySharedClientState;
     }
     async terminate() {
@@ -17373,12 +17395,12 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends __PRIVATE_MemoryOffl
     constructor(e) {
         super(), this.cacheSizeBytes = e;
     }
-    Su(e, t) {
+    vu(e, t) {
         __PRIVATE_hardAssert(this.persistence.referenceDelegate instanceof __PRIVATE_MemoryLruDelegate, 46915);
         const n = this.persistence.referenceDelegate.garbageCollector;
         return new __PRIVATE_LruScheduler(n, e.asyncQueue, t);
     }
-    yu(e) {
+    bu(e) {
         const t = void 0 !== this.cacheSizeBytes ? LruParams.withCacheSize(this.cacheSizeBytes) : LruParams.DEFAULT;
         return new __PRIVATE_MemoryPersistence((e => __PRIVATE_MemoryLruDelegate.fi(e, t)), this.serializer);
     }
@@ -17388,35 +17410,35 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends __PRIVATE_MemoryOffl
  * Provides all components needed for Firestore with IndexedDB persistence.
  */ class __PRIVATE_IndexedDbOfflineComponentProvider extends __PRIVATE_MemoryOfflineComponentProvider {
     constructor(e, t, n) {
-        super(), this.Du = e, this.cacheSizeBytes = t, this.forceOwnership = n, this.kind = "persistent", 
+        super(), this.Fu = e, this.cacheSizeBytes = t, this.forceOwnership = n, this.kind = "persistent", 
         this.synchronizeTabs = !1;
     }
     async initialize(e) {
-        await super.initialize(e), await this.Du.initialize(this, e), 
+        await super.initialize(e), await this.Fu.initialize(this, e), 
         // Enqueue writes from a previous session
-        await __PRIVATE_syncEngineEnsureWriteCallbacks(this.Du.syncEngine), await __PRIVATE_fillWritePipeline(this.Du.remoteStore), 
+        await __PRIVATE_syncEngineEnsureWriteCallbacks(this.Fu.syncEngine), await __PRIVATE_fillWritePipeline(this.Fu.remoteStore), 
         // NOTE: This will immediately call the listener, so we make sure to
         // set it after localStore / remoteStore are started.
         await this.persistence.Ji((() => (this.gcScheduler && !this.gcScheduler.started && this.gcScheduler.start(), 
         this.indexBackfillerScheduler && !this.indexBackfillerScheduler.started && this.indexBackfillerScheduler.start(), 
         Promise.resolve())));
     }
-    wu(e) {
+    Du(e) {
         return __PRIVATE_newLocalStore(this.persistence, new __PRIVATE_QueryEngine, e.initialUser, this.serializer);
     }
-    Su(e, t) {
+    vu(e, t) {
         const n = this.persistence.referenceDelegate.garbageCollector;
         return new __PRIVATE_LruScheduler(n, e.asyncQueue, t);
     }
-    bu(e, t) {
+    Cu(e, t) {
         const n = new __PRIVATE_IndexBackfiller(t, this.persistence);
         return new __PRIVATE_IndexBackfillerScheduler(e.asyncQueue, n);
     }
-    yu(e) {
+    bu(e) {
         const t = __PRIVATE_indexedDbStoragePrefix(e.databaseInfo.databaseId, e.databaseInfo.persistenceKey), n = void 0 !== this.cacheSizeBytes ? LruParams.withCacheSize(this.cacheSizeBytes) : LruParams.DEFAULT;
         return new __PRIVATE_IndexedDbPersistence(this.synchronizeTabs, t, e.clientId, n, e.asyncQueue, __PRIVATE_getWindow(), getDocument(), this.serializer, this.sharedClientState, !!this.forceOwnership);
     }
-    pu(e) {
+    Su(e) {
         return new __PRIVATE_MemorySharedClientState;
     }
 }
@@ -17430,11 +17452,11 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends __PRIVATE_MemoryOffl
  * `synchronizeTabs` will be enabled.
  */ class __PRIVATE_MultiTabOfflineComponentProvider extends __PRIVATE_IndexedDbOfflineComponentProvider {
     constructor(e, t) {
-        super(e, t, /* forceOwnership= */ !1), this.Du = e, this.cacheSizeBytes = t, this.synchronizeTabs = !0;
+        super(e, t, /* forceOwnership= */ !1), this.Fu = e, this.cacheSizeBytes = t, this.synchronizeTabs = !0;
     }
     async initialize(e) {
         await super.initialize(e);
-        const t = this.Du.syncEngine;
+        const t = this.Fu.syncEngine;
         this.sharedClientState instanceof __PRIVATE_WebStorageSharedClientState && (this.sharedClientState.syncEngine = {
             Co: __PRIVATE_syncEngineApplyBatchState.bind(null, t),
             Fo: __PRIVATE_syncEngineApplyTargetState.bind(null, t),
@@ -17445,11 +17467,11 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends __PRIVATE_MemoryOffl
         // NOTE: This will immediately call the listener, so we make sure to
         // set it after localStore / remoteStore are started.
         await this.persistence.Ji((async e => {
-            await __PRIVATE_syncEngineApplyPrimaryState(this.Du.syncEngine, e), this.gcScheduler && (e && !this.gcScheduler.started ? this.gcScheduler.start() : e || this.gcScheduler.stop()), 
+            await __PRIVATE_syncEngineApplyPrimaryState(this.Fu.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());
         }));
     }
-    pu(e) {
+    Su(e) {
         const t = __PRIVATE_getWindow();
         if (!__PRIVATE_WebStorageSharedClientState.C(t)) throw new FirestoreError(L.UNIMPLEMENTED, "IndexedDB persistence is only available on platforms that support LocalStorage.");
         const n = __PRIVATE_indexedDbStoragePrefix(e.databaseInfo.databaseId, e.databaseInfo.persistenceKey);
@@ -17496,18 +17518,18 @@ class __PRIVATE_LruGcMemoryOfflineComponentProvider extends __PRIVATE_MemoryOffl
         // 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 && (_.Au = !0), _;
+            return o && (_.mu = !0), _;
         }(this.localStore, this.remoteStore, this.eventManager, this.sharedClientState, e.initialUser, e.maxConcurrentLimboResolutions, t);
     }
     async terminate() {
         var e, t;
         await async function __PRIVATE_remoteStoreShutdown(e) {
             const t = __PRIVATE_debugCast(e);
-            __PRIVATE_logDebug(nn, "RemoteStore shutting down."), t.Ta.add(5 /* OfflineCause.Shutdown */), 
-            await __PRIVATE_disableNetworkInternal(t), t.Ea.shutdown(), 
+            __PRIVATE_logDebug(nn, "RemoteStore shutting down."), t.da.add(5 /* OfflineCause.Shutdown */), 
+            await __PRIVATE_disableNetworkInternal(t), t.Ra.shutdown(), 
             // Set the OnlineState to Unknown (rather than Offline) to avoid potentially
             // triggering spurious listener events with cached data, etc.
-            t.da.set("Unknown" /* OnlineState.Unknown */);
+            t.Va.set("Unknown" /* OnlineState.Unknown */);
         }(this.remoteStore), null === (e = this.datastore) || void 0 === e || e.terminate(), 
         null === (t = this.eventManager) || void 0 === t || t.terminate();
     }
@@ -17599,15 +17621,15 @@ class __PRIVATE_AsyncObserver {
         this.muted = !1;
     }
     next(e) {
-        this.muted || this.observer.next && this.vu(this.observer.next, e);
+        this.muted || this.observer.next && this.Mu(this.observer.next, e);
     }
     error(e) {
-        this.muted || (this.observer.error ? this.vu(this.observer.error, e) : __PRIVATE_logError("Uncaught Error in snapshot listener:", e.toString()));
+        this.muted || (this.observer.error ? this.Mu(this.observer.error, e) : __PRIVATE_logError("Uncaught Error in snapshot listener:", e.toString()));
     }
-    Cu() {
+    xu() {
         this.muted = !0;
     }
-    vu(e, t) {
+    Mu(e, t) {
         setTimeout((() => {
             this.muted || e(t);
         }), 0);
@@ -17639,30 +17661,30 @@ class __PRIVATE_AsyncObserver {
     constructor(
     /** The reader to read from underlying binary bundle data source. */
     e, t) {
-        this.Fu = e, this.serializer = t, 
+        this.Ou = 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.Mu = function __PRIVATE_newTextDecoder() {
+        this.buffer = new Uint8Array, this.Nu = function __PRIVATE_newTextDecoder() {
             return new TextDecoder("utf-8");
         }(), 
         // Read the metadata (which is the first element).
-        this.xu().then((e => {
-            e && e.qa() ? this.metadata.resolve(e.ka.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.ka)}`));
+        this.Bu().then((e => {
+            e && e.Ua() ? this.metadata.resolve(e.$a.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.$a)}`));
         }), (e => this.metadata.reject(e)));
     }
     close() {
-        return this.Fu.cancel();
+        return this.Ou.cancel();
     }
     async getMetadata() {
         return this.metadata.promise;
     }
-    async gu() {
+    async wu() {
         // Makes sure metadata is read before proceeding.
-        return await this.getMetadata(), this.xu();
+        return await this.getMetadata(), this.Bu();
     }
     /**
      * Reads from the head of internal buffer, and pulling more data from
@@ -17673,15 +17695,15 @@ class __PRIVATE_AsyncObserver {
      *
      * Returns either the bundled element, or null if we have reached the end of
      * the stream.
-     */    async xu() {
-        const e = await this.Ou();
+     */    async Bu() {
+        const e = await this.Lu();
         if (null === e) return null;
-        const t = this.Mu.decode(e), n = Number(t);
-        isNaN(n) && this.Nu(`length string (${t}) is not valid number`);
-        const r = await this.Bu(n);
+        const t = this.Nu.decode(e), n = Number(t);
+        isNaN(n) && this.ku(`length string (${t}) is not valid number`);
+        const r = await this.qu(n);
         return new __PRIVATE_SizedBundleElement(JSON.parse(r), e.length + n);
     }
-    /** First index of '{' from the underlying buffer. */    Lu() {
+    /** First index of '{' from the underlying buffer. */    Qu() {
         return this.buffer.findIndex((e => e === "{".charCodeAt(0)));
     }
     /**
@@ -17689,17 +17711,17 @@ class __PRIVATE_AsyncObserver {
      * return the content.
      *
      * If reached end of the stream, returns a null.
-     */    async Ou() {
-        for (;this.Lu() < 0; ) {
-            if (await this.ku()) break;
+     */    async Lu() {
+        for (;this.Qu() < 0; ) {
+            if (await this.$u()) 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.Lu();
+        const e = this.Qu();
         // Broke out of the loop because underlying stream is closed, but still
         // cannot find an open bracket.
-                e < 0 && this.Nu("Reached the end of bundle when a length string is expected.");
+                e < 0 && this.ku("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;
@@ -17709,23 +17731,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 Bu(e) {
+     */    async qu(e) {
         for (;this.buffer.length < e; ) {
-            await this.ku() && this.Nu("Reached the end of bundle when more is expected.");
+            await this.$u() && this.ku("Reached the end of bundle when more is expected.");
         }
-        const t = this.Mu.decode(this.buffer.slice(0, e));
+        const t = this.Nu.decode(this.buffer.slice(0, e));
         // Update the internal buffer to drop the read json string.
                 return this.buffer = this.buffer.slice(e), t;
     }
-    Nu(e) {
+    ku(e) {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        throw this.Fu.cancel(), new Error(`Invalid bundle format: ${e}`);
+        throw this.Ou.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 ku() {
-        const e = await this.Fu.read();
+     */    async $u() {
+        const e = await this.Ou.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;
@@ -17830,7 +17852,7 @@ class Transaction$2 {
         let t;
         if (e.isFoundDocument()) t = e.version; else {
             if (!e.isNoDocument()) throw fail(50498, {
-                qu: e.constructor.name
+                Uu: e.constructor.name
             });
             // Represent a deleted doc using SnapshotVersion.min().
             t = SnapshotVersion.min();
@@ -17902,26 +17924,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.Qu = n.maxAttempts, this.C_ = new __PRIVATE_ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
+        this.deferred = i, this.Ku = n.maxAttempts, this.x_ = new __PRIVATE_ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
     }
-    /** Runs the transaction and sets the result on deferred. */    $u() {
-        this.Qu -= 1, this.Uu();
+    /** Runs the transaction and sets the result on deferred. */    Wu() {
+        this.Ku -= 1, this.Gu();
     }
-    Uu() {
-        this.C_.f_((async () => {
-            const e = new Transaction$2(this.datastore), t = this.Ku(e);
+    Gu() {
+        this.x_.y_((async () => {
+            const e = new Transaction$2(this.datastore), t = this.zu(e);
             t && t.then((t => {
                 this.asyncQueue.enqueueAndForget((() => e.commit().then((() => {
                     this.deferred.resolve(t);
                 })).catch((e => {
-                    this.Wu(e);
+                    this.ju(e);
                 }))));
             })).catch((e => {
-                this.Wu(e);
+                this.ju(e);
             }));
         }));
     }
-    Ku(e) {
+    zu(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")), 
@@ -17931,11 +17953,11 @@ class Transaction$2 {
             return this.deferred.reject(e), null;
         }
     }
-    Wu(e) {
-        this.Qu > 0 && this.Gu(e) ? (this.Qu -= 1, this.asyncQueue.enqueueAndForget((() => (this.Uu(), 
+    ju(e) {
+        this.Ku > 0 && this.Hu(e) ? (this.Ku -= 1, this.asyncQueue.enqueueAndForget((() => (this.Gu(), 
         Promise.resolve())))) : this.deferred.reject(e);
     }
-    Gu(e) {
+    Hu(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.
@@ -18113,7 +18135,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.Ta.delete(0 /* OfflineCause.UserDisabled */), __PRIVATE_enableNetworkInternal(t);
+            return t.da.delete(0 /* OfflineCause.UserDisabled */), __PRIVATE_enableNetworkInternal(t);
         }(n);
     }));
 }
@@ -18123,9 +18145,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.Ta.add(0 /* OfflineCause.UserDisabled */), await __PRIVATE_disableNetworkInternal(t), 
+            t.da.add(0 /* OfflineCause.UserDisabled */), await __PRIVATE_disableNetworkInternal(t), 
             // Set the OnlineState to Offline so get()s return from cache, etc.
-            t.da.set("Offline" /* OnlineState.Offline */);
+            t.Va.set("Offline" /* OnlineState.Offline */);
         }(n);
     }));
 }
@@ -18161,7 +18183,7 @@ function __PRIVATE_firestoreClientGetDocumentViaSnapshotListener(e, t, n = {}) {
             next: _ => {
                 // Mute and remove query first before passing event to user to avoid
                 // user actions affecting the now stale query.
-                s.Cu(), t.enqueueAndForget((() => __PRIVATE_eventManagerUnlisten(e, o)));
+                s.xu(), t.enqueueAndForget((() => __PRIVATE_eventManagerUnlisten(e, o)));
                 const a = _.docs.has(n);
                 !a && _.fromCache ? 
                 // TODO(dimond): If we're online and the document doesn't
@@ -18176,7 +18198,7 @@ function __PRIVATE_firestoreClientGetDocumentViaSnapshotListener(e, t, n = {}) {
             error: e => i.reject(e)
         }), o = new __PRIVATE_QueryListener(__PRIVATE_newQueryForPath(n.path), s, {
             includeMetadataChanges: !0,
-            La: !0
+            Qa: !0
         });
         return __PRIVATE_eventManagerListen(e, o);
     }(await __PRIVATE_getEventManager(e), e.asyncQueue, t, n, r))), r.promise;
@@ -18187,7 +18209,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.$s), s = i.Za(r.documents), o = i.applyChanges(s, 
+            /* usePreviousResults= */ !0), i = new __PRIVATE_View(t, r.$s), s = i.tu(r.documents), o = i.applyChanges(s, 
             /* limboResolutionEnabled= */ !1);
             n.resolve(o.snapshot);
         } catch (e) {
@@ -18208,12 +18230,12 @@ function __PRIVATE_firestoreClientGetDocumentsViaSnapshotListener(e, t, n = {})
             next: n => {
                 // Mute and remove query first before passing event to user to avoid
                 // user actions affecting the now stale query.
-                s.Cu(), t.enqueueAndForget((() => __PRIVATE_eventManagerUnlisten(e, o))), n.fromCache && "server" === r.source ? i.reject(new FirestoreError(L.UNAVAILABLE, 'Failed to get documents from server. (However, these documents may exist in the local cache. Run again without setting source to "server" to retrieve the cached documents.)')) : i.resolve(n);
+                s.xu(), t.enqueueAndForget((() => __PRIVATE_eventManagerUnlisten(e, o))), n.fromCache && "server" === r.source ? i.reject(new FirestoreError(L.UNAVAILABLE, 'Failed to get documents from server. (However, these documents may exist in the local cache. Run again without setting source to "server" to retrieve the cached documents.)')) : i.resolve(n);
             },
             error: e => i.reject(e)
         }), o = new __PRIVATE_QueryListener(n, s, {
             includeMetadataChanges: !0,
-            La: !0
+            Qa: !0
         });
         return __PRIVATE_eventManagerListen(e, o);
     }(await __PRIVATE_getEventManager(e), e.asyncQueue, t, n, r))), r.promise;
@@ -18251,13 +18273,13 @@ function __PRIVATE_firestoreClientRunAggregateQuery(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).ba.add(t), 
+        __PRIVATE_debugCast(e).Ca.add(t), 
         // Immediately fire an initial event, indicating all existing listeners
         // are in-sync.
         t.next();
     }(await __PRIVATE_getEventManager(e), n))), () => {
-        n.Cu(), e.asyncQueue.enqueueAndForget((async () => function __PRIVATE_removeSnapshotsInSyncListener(e, t) {
-            __PRIVATE_debugCast(e).ba.delete(t);
+        n.xu(), e.asyncQueue.enqueueAndForget((async () => function __PRIVATE_removeSnapshotsInSyncListener(e, t) {
+            __PRIVATE_debugCast(e).Ca.delete(t);
         }(await __PRIVATE_getEventManager(e), n)));
     };
 }
@@ -18945,37 +18967,37 @@ class __PRIVATE_AsyncQueueImpl {
     constructor(e = Promise.resolve()) {
         // A list of retryable operations. Retryable operations are run in order and
         // retried with backoff.
-        this.zu = [], 
+        this.Ju = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.ju = !1, 
+        this.Yu = !1, 
         // Operations scheduled to be queued in the future. Operations are
         // automatically removed after they are run or canceled.
-        this.Hu = [], 
+        this.Zu = [], 
         // visible for testing
-        this.Ju = null, 
+        this.Xu = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.Yu = !1, 
+        this.ec = !1, 
         // Enabled during shutdown on Safari to prevent future access to IndexedDB.
-        this.Zu = !1, 
+        this.tc = !1, 
         // List of TimerIds to fast-forward delays for.
-        this.Xu = [], 
+        this.nc = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.C_ = new __PRIVATE_ExponentialBackoff(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */), 
+        this.x_ = 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.ec = () => {
+        this.rc = () => {
             const e = getDocument();
             e && __PRIVATE_logDebug(ln, "Visibility state changed to " + e.visibilityState), 
-            this.C_.p_();
-        }, this.tc = e;
+            this.x_.S_();
+        }, this.sc = e;
         const t = getDocument();
-        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.ec);
+        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.rc);
     }
     get isShuttingDown() {
-        return this.ju;
+        return this.Yu;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -18985,44 +19007,44 @@ class __PRIVATE_AsyncQueueImpl {
         this.enqueue(e);
     }
     enqueueAndForgetEvenWhileRestricted(e) {
-        this.nc(), 
+        this.oc(), 
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.rc(e);
+        this._c(e);
     }
     enterRestrictedMode(e) {
-        if (!this.ju) {
-            this.ju = !0, this.Zu = e || !1;
+        if (!this.Yu) {
+            this.Yu = !0, this.tc = e || !1;
             const t = getDocument();
-            t && "function" == typeof t.removeEventListener && t.removeEventListener("visibilitychange", this.ec);
+            t && "function" == typeof t.removeEventListener && t.removeEventListener("visibilitychange", this.rc);
         }
     }
     enqueue(e) {
-        if (this.nc(), this.ju) 
+        if (this.oc(), this.Yu) 
         // 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.rc((() => this.ju && this.Zu ? Promise.resolve() : (e().then(t.resolve, t.reject), 
+        return this._c((() => this.Yu && this.tc ? Promise.resolve() : (e().then(t.resolve, t.reject), 
         t.promise))).then((() => t.promise));
     }
     enqueueRetryable(e) {
-        this.enqueueAndForget((() => (this.zu.push(e), this.sc())));
+        this.enqueueAndForget((() => (this.Ju.push(e), this.ac())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async sc() {
-        if (0 !== this.zu.length) {
+     */    async ac() {
+        if (0 !== this.Ju.length) {
             try {
-                await this.zu[0](), this.zu.shift(), this.C_.reset();
+                await this.Ju[0](), this.Ju.shift(), this.x_.reset();
             } catch (e) {
                 if (!__PRIVATE_isIndexedDbTransactionError(e)) throw e;
  // Failure will be handled by AsyncQueue
                                 __PRIVATE_logDebug(ln, "Operation failed with retryable error: " + e);
             }
-            this.zu.length > 0 && 
+            this.Ju.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
@@ -19033,51 +19055,51 @@ class __PRIVATE_AsyncQueueImpl {
             // 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.C_.f_((() => this.sc()));
+            this.x_.y_((() => this.ac()));
         }
     }
-    rc(e) {
-        const t = this.tc.then((() => (this.Yu = !0, e().catch((e => {
-            this.Ju = e, this.Yu = !1;
+    _c(e) {
+        const t = this.sc.then((() => (this.ec = !0, e().catch((e => {
+            this.Xu = e, this.ec = !1;
             // Re-throw the error so that this.tail becomes a rejected Promise and
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw __PRIVATE_logError("INTERNAL UNHANDLED ERROR: ", __PRIVATE_getMessageOrStack(e)), 
             e;
-        })).then((e => (this.Yu = !1, e))))));
-        return this.tc = t, t;
+        })).then((e => (this.ec = !1, e))))));
+        return this.sc = t, t;
     }
     enqueueAfterDelay(e, t, n) {
-        this.nc(), 
+        this.oc(), 
         // Fast-forward delays for timerIds that have been overridden.
-        this.Xu.indexOf(e) > -1 && (t = 0);
-        const r = DelayedOperation.createAndSchedule(this, e, t, n, (e => this.oc(e)));
-        return this.Hu.push(r), r;
+        this.nc.indexOf(e) > -1 && (t = 0);
+        const r = DelayedOperation.createAndSchedule(this, e, t, n, (e => this.uc(e)));
+        return this.Zu.push(r), r;
     }
-    nc() {
-        this.Ju && fail(47125, {
-            _c: __PRIVATE_getMessageOrStack(this.Ju)
+    oc() {
+        this.Xu && fail(47125, {
+            cc: __PRIVATE_getMessageOrStack(this.Xu)
         });
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async ac() {
+     */    async lc() {
         // 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.tc, await e;
-        } while (e !== this.tc);
+            e = this.sc, await e;
+        } while (e !== this.sc);
     }
     /**
      * For Tests: Determine if a delayed operation with a particular TimerId
      * exists.
-     */    uc(e) {
-        for (const t of this.Hu) if (t.timerId === e) return !0;
+     */    hc(e) {
+        for (const t of this.Zu) if (t.timerId === e) return !0;
         return !1;
     }
     /**
@@ -19086,25 +19108,25 @@ class __PRIVATE_AsyncQueueImpl {
      * @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.
-     */    cc(e) {
+     */    Pc(e) {
         // Note that draining may generate more delayed ops, so we do that first.
-        return this.ac().then((() => {
+        return this.lc().then((() => {
             // Run ops in the same order they'd run if they ran naturally.
             /* eslint-disable-next-line @typescript-eslint/no-floating-promises */
-            this.Hu.sort(((e, t) => e.targetTimeMs - t.targetTimeMs));
-            for (const t of this.Hu) if (t.skipDelay(), "all" /* TimerId.All */ !== e && t.timerId === e) break;
-            return this.ac();
+            this.Zu.sort(((e, t) => e.targetTimeMs - t.targetTimeMs));
+            for (const t of this.Zu) if (t.skipDelay(), "all" /* TimerId.All */ !== e && t.timerId === e) break;
+            return this.lc();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    lc(e) {
-        this.Xu.push(e);
+     */    Tc(e) {
+        this.nc.push(e);
     }
-    /** Called once a DelayedOperation is run or canceled. */    oc(e) {
+    /** Called once a DelayedOperation is run or canceled. */    uc(e) {
         // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.
-        const t = this.Hu.indexOf(e);
-        /* eslint-disable-next-line @typescript-eslint/no-floating-promises */        this.Hu.splice(t, 1);
+        const t = this.Zu.indexOf(e);
+        /* eslint-disable-next-line @typescript-eslint/no-floating-promises */        this.Zu.splice(t, 1);
     }
 }
 
@@ -19955,7 +19977,7 @@ function __PRIVATE_isWrite(e) {
 
       default:
         throw fail(40011, {
-            hc: e
+            Ic: e
         });
     }
 }
@@ -19983,55 +20005,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.Pc(), this.fieldTransforms = i || [], this.fieldMask = s || [];
+        void 0 === i && this.Ec(), this.fieldTransforms = i || [], this.fieldMask = s || [];
     }
     get path() {
         return this.settings.path;
     }
-    get hc() {
-        return this.settings.hc;
+    get Ic() {
+        return this.settings.Ic;
     }
-    /** Returns a new context with the specified settings overwritten. */    Tc(e) {
+    /** Returns a new context with the specified settings overwritten. */    dc(e) {
         return new __PRIVATE_ParseContextImpl(Object.assign(Object.assign({}, this.settings), e), this.databaseId, this.serializer, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
     }
-    Ic(e) {
+    Ac(e) {
         var t;
-        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.Tc({
+        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.dc({
             path: n,
-            Ec: !1
+            Rc: !1
         });
-        return r.dc(e), r;
+        return r.Vc(e), r;
     }
-    Ac(e) {
+    mc(e) {
         var t;
-        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.Tc({
+        const n = null === (t = this.path) || void 0 === t ? void 0 : t.child(e), r = this.dc({
             path: n,
-            Ec: !1
+            Rc: !1
         });
-        return r.Pc(), r;
+        return r.Ec(), r;
     }
-    Rc(e) {
+    fc(e) {
         // TODO(b/34871131): We don't support array paths right now; so make path
         // undefined.
-        return this.Tc({
+        return this.dc({
             path: void 0,
-            Ec: !0
+            Rc: !0
         });
     }
-    Vc(e) {
-        return __PRIVATE_createError(e, this.settings.methodName, this.settings.mc || !1, this.path, this.settings.fc);
+    gc(e) {
+        return __PRIVATE_createError(e, this.settings.methodName, this.settings.yc || !1, this.path, this.settings.wc);
     }
     /** 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)));
     }
-    Pc() {
+    Ec() {
         // 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.dc(this.path.get(e));
+        if (this.path) for (let e = 0; e < this.path.length; e++) this.Vc(this.path.get(e));
     }
-    dc(e) {
-        if (0 === e.length) throw this.Vc("Document fields must not be empty");
-        if (__PRIVATE_isWrite(this.hc) && Pn.test(e)) throw this.Vc('Document fields cannot begin and end with "__"');
+    Vc(e) {
+        if (0 === e.length) throw this.gc("Document fields must not be empty");
+        if (__PRIVATE_isWrite(this.Ic) && Pn.test(e)) throw this.gc('Document fields cannot begin and end with "__"');
     }
 }
 
@@ -20042,14 +20064,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. */    gc(e, t, n, r = !1) {
+    /** Creates a new top-level parse context. */    Sc(e, t, n, r = !1) {
         return new __PRIVATE_ParseContextImpl({
-            hc: e,
+            Ic: e,
             methodName: t,
-            fc: n,
+            wc: n,
             path: FieldPath$1.emptyPath(),
-            Ec: !1,
-            mc: r
+            Rc: !1,
+            yc: r
         }, this.databaseId, this.serializer, this.ignoreUndefinedProperties);
     }
 }
@@ -20060,7 +20082,7 @@ function __PRIVATE_newUserDataReader(e) {
 }
 
 /** Parse document data from a set() call. */ function __PRIVATE_parseSetData(e, t, n, r, i, s = {}) {
-    const o = e.gc(s.merge || s.mergeFields ? 2 /* UserDataSource.MergeSet */ : 0 /* UserDataSource.Set */ , t, n, i);
+    const o = e.Sc(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;
@@ -20078,7 +20100,7 @@ function __PRIVATE_newUserDataReader(e) {
 
 class __PRIVATE_DeleteFieldValueImpl extends FieldValue {
     _toFieldTransform(e) {
-        if (2 /* UserDataSource.MergeSet */ !== e.hc) throw 1 /* UserDataSource.Update */ === e.hc ? e.Vc(`${this._methodName}() can only appear at the top level of your update data`) : e.Vc(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
+        if (2 /* UserDataSource.MergeSet */ !== e.Ic) throw 1 /* UserDataSource.Update */ === e.Ic ? e.gc(`${this._methodName}() can only appear at the top level of your update data`) : e.gc(`${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;
@@ -20105,10 +20127,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({
-        hc: 3 /* UserDataSource.Argument */ ,
-        fc: t.settings.fc,
+        Ic: 3 /* UserDataSource.Argument */ ,
+        wc: t.settings.wc,
         methodName: e._methodName,
-        Ec: n
+        Rc: n
     }, t.databaseId, t.serializer, t.ignoreUndefinedProperties);
 }
 
@@ -20123,47 +20145,47 @@ class __PRIVATE_ServerTimestampFieldValueImpl extends FieldValue {
 
 class __PRIVATE_ArrayUnionFieldValueImpl extends FieldValue {
     constructor(e, t) {
-        super(e), this.yc = t;
+        super(e), this.bc = t;
     }
     _toFieldTransform(e) {
         const t = __PRIVATE_createSentinelChildContext(this, e, 
-        /*array=*/ !0), n = this.yc.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayUnionTransformOperation(n);
+        /*array=*/ !0), n = this.bc.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayUnionTransformOperation(n);
         return new FieldTransform(e.path, r);
     }
     isEqual(e) {
-        return e instanceof __PRIVATE_ArrayUnionFieldValueImpl && V(this.yc, e.yc);
+        return e instanceof __PRIVATE_ArrayUnionFieldValueImpl && V(this.bc, e.bc);
     }
 }
 
 class __PRIVATE_ArrayRemoveFieldValueImpl extends FieldValue {
     constructor(e, t) {
-        super(e), this.yc = t;
+        super(e), this.bc = t;
     }
     _toFieldTransform(e) {
         const t = __PRIVATE_createSentinelChildContext(this, e, 
-        /*array=*/ !0), n = this.yc.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayRemoveTransformOperation(n);
+        /*array=*/ !0), n = this.bc.map((e => __PRIVATE_parseData(e, t))), r = new __PRIVATE_ArrayRemoveTransformOperation(n);
         return new FieldTransform(e.path, r);
     }
     isEqual(e) {
-        return e instanceof __PRIVATE_ArrayRemoveFieldValueImpl && V(this.yc, e.yc);
+        return e instanceof __PRIVATE_ArrayRemoveFieldValueImpl && V(this.bc, e.bc);
     }
 }
 
 class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
     constructor(e, t) {
-        super(e), this.wc = t;
+        super(e), this.Dc = t;
     }
     _toFieldTransform(e) {
-        const t = new __PRIVATE_NumericIncrementTransformOperation(e.serializer, toNumber(e.serializer, this.wc));
+        const t = new __PRIVATE_NumericIncrementTransformOperation(e.serializer, toNumber(e.serializer, this.Dc));
         return new FieldTransform(e.path, t);
     }
     isEqual(e) {
-        return e instanceof __PRIVATE_NumericIncrementFieldValueImpl && this.wc === e.wc;
+        return e instanceof __PRIVATE_NumericIncrementFieldValueImpl && this.Dc === e.Dc;
     }
 }
 
 /** Parse update data from an update() call. */ function __PRIVATE_parseUpdateData(e, t, n, r) {
-    const i = e.gc(1 /* UserDataSource.Update */ , t, n);
+    const i = e.Sc(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) => {
@@ -20171,7 +20193,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 r = f(r);
-        const a = i.Ac(_);
+        const a = i.mc(_);
         if (r instanceof __PRIVATE_DeleteFieldValueImpl) 
         // Add it to the field mask, but don't add anything to updateData.
         s.push(_); else {
@@ -20184,7 +20206,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.gc(1 /* UserDataSource.Update */ , t, n), _ = [ __PRIVATE_fieldPathFromArgument$1(t, r, n) ], a = [ i ];
+    const o = e.Sc(1 /* UserDataSource.Update */ , t, n), _ = [ __PRIVATE_fieldPathFromArgument$1(t, r, n) ], a = [ i ];
     if (s.length % 2 != 0) throw new FirestoreError(L.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]);
@@ -20197,7 +20219,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = f(n);
-        const r = o.Ac(t);
+        const r = o.mc(t);
         if (n instanceof __PRIVATE_DeleteFieldValueImpl) 
         // Add it to the field mask, but don't add anything to updateData.
         u.push(t); else {
@@ -20216,7 +20238,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.gc(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , t));
+    return __PRIVATE_parseData(n, e.Sc(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , t));
 }
 
 /**
@@ -20245,8 +20267,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.hc)) throw t.Vc(`${e._methodName}() can only be used with update() and set()`);
-        if (!t.path) throw t.Vc(`${e._methodName}() is not currently supported inside arrays`);
+        if (!__PRIVATE_isWrite(t.Ic)) throw t.gc(`${e._methodName}() can only be used with update() and set()`);
+        if (!t.path) throw t.gc(`${e._methodName}() is not currently supported inside arrays`);
         const n = e._toFieldTransform(t);
         n && t.fieldTransforms.push(n);
     }
@@ -20270,12 +20292,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.Ec && 4 /* UserDataSource.ArrayArgument */ !== t.hc) throw t.Vc("Nested arrays are not supported");
+        if (t.settings.Rc && 4 /* UserDataSource.ArrayArgument */ !== t.Ic) throw t.gc("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.Rc(r));
+                let e = __PRIVATE_parseData(i, t.fc(r));
                 null == e && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -20327,7 +20349,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
         };
         if (e instanceof DocumentReference) {
             const n = t.databaseId, r = e.firestore._databaseId;
-            if (!r.isEqual(n)) throw t.Vc(`Document reference is for database ${r.projectId}/${r.database} but should be for database ${n.projectId}/${n.database}`);
+            if (!r.isEqual(n)) throw t.gc(`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)
             };
@@ -20345,7 +20367,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
                     [dt]: {
                         arrayValue: {
                             values: e.toArray().map((e => {
-                                if ("number" != typeof e) throw t.Vc("VectorValues must only contain numeric values.");
+                                if ("number" != typeof e) throw t.gc("VectorValues must only contain numeric values.");
                                 return __PRIVATE_toDouble(t.serializer, e);
                             }))
                         }
@@ -20363,7 +20385,7 @@ class __PRIVATE_NumericIncrementFieldValueImpl extends FieldValue {
  * GeoPoints, etc. are not considered to look like JSON objects since they map
  * to specific FieldValue types other than ObjectValue.
  */ (e, t);
-        throw t.Vc(`Unsupported field value: ${__PRIVATE_valueDescription(e)}`);
+        throw t.gc(`Unsupported field value: ${__PRIVATE_valueDescription(e)}`);
     }(e, t);
 }
 
@@ -20373,7 +20395,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.Ic(e));
+        const i = __PRIVATE_parseData(r, t.Ac(e));
         null != i && (n[e] = i);
     })), {
         mapValue: {
@@ -20391,7 +20413,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.Vc(e + " a custom object") : t.Vc(e + " " + r);
+        throw "an object" === r ? t.gc(e + " a custom object") : t.gc(e + " " + r);
     }
 }
 
@@ -21696,7 +21718,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.Cu(), e.asyncQueue.enqueueAndForget((async () => __PRIVATE_eventManagerUnlisten(await __PRIVATE_getEventManager(e), s)));
+            i.xu(), e.asyncQueue.enqueueAndForget((async () => __PRIVATE_eventManagerUnlisten(await __PRIVATE_getEventManager(e), s)));
         };
     }(ensureFirestoreConfigured(u), c, _, a);
 }
@@ -22205,7 +22227,7 @@ function __PRIVATE_validateReference(e, t) {
         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).$u();
+            new __PRIVATE_TransactionRunner(e.asyncQueue, i, n, t, r).Wu();
         })), r.promise;
     }(ensureFirestoreConfigured(e), (n => t(new Transaction(e, n))), r);
 }
@@ -22572,7 +22594,7 @@ function _internalQueryToProtoQueryTarget(e) {
  * The implementation of `TestingHooksSpi`.
  */ class __PRIVATE_TestingHooksSpiImpl {
     constructor() {
-        this.Sc = new Map;
+        this.vc = new Map;
     }
     static get instance() {
         return dn || (dn = new __PRIVATE_TestingHooksSpiImpl, function __PRIVATE_setTestingHooksSpi(e) {
@@ -22581,10 +22603,10 @@ function _internalQueryToProtoQueryTarget(e) {
         }(dn)), dn;
     }
     ht(e) {
-        this.Sc.forEach((t => t(e)));
+        this.vc.forEach((t => t(e)));
     }
     onExistenceFilterMismatch(e) {
-        const t = Symbol(), n = this.Sc;
+        const t = Symbol(), n = this.vc;
         return n.set(t, e), () => n.delete(t);
     }
 }