@firebase/firestore 3.1.1 → 3.2.0

package/dist/index.rn.js

@@ -70,7 +70,7 @@ C.MOCK_USER = new C("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let N = "9.1.3";
+let N = "9.2.0";
 
 /**
  * @license
@@ -11089,15 +11089,15 @@ class to {
  *  ListenerType: The type of the listener that will be used for callbacks
  */
 class eo {
-    constructor(t, e, n, s, i, r) {
-        this.Oe = t, this.er = n, this.nr = s, this.credentialsProvider = i, this.listener = r, 
-        this.state = 0 /* Initial */ , 
+    constructor(t, e, n, s, i, r, o) {
+        this.Oe = t, this.er = n, this.nr = s, this.sr = i, this.credentialsProvider = r, 
+        this.listener = o, this.state = 0 /* Initial */ , 
         /**
          * A close count that's incremented every time the stream is closed; used by
          * getCloseGuardedDispatcher() to invalidate callbacks that happen after
          * close.
          */
-        this.sr = 0, this.ir = null, this.stream = null, this.rr = new to(t, e);
+        this.ir = 0, this.rr = null, this.cr = null, this.stream = null, this.ar = new to(t, e);
     }
     /**
      * Returns true if start() has been called and no error has occurred. True
@@ -11105,14 +11105,14 @@ class eo {
      * 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.
-     */    cr() {
-        return 1 /* Starting */ === this.state || 2 /* Open */ === this.state || 4 /* Backoff */ === this.state;
+     */    ur() {
+        return 1 /* Starting */ === this.state || 5 /* Backoff */ === this.state || this.hr();
     }
     /**
      * Returns true if the underlying RPC is open (the onOpen() listener has been
      * called) and the stream is ready for outbound requests.
-     */    ar() {
-        return 2 /* Open */ === this.state;
+     */    hr() {
+        return 2 /* Open */ === this.state || 3 /* Healthy */ === this.state;
     }
     /**
      * Starts the RPC. Only allowed if isStarted() returns false. The stream is
@@ -11121,7 +11121,7 @@ class eo {
      *
      * When start returns, isStarted() will return true.
      */    start() {
-        3 /* Error */ !== this.state ? this.auth() : this.ur();
+        4 /* Error */ !== this.state ? this.auth() : this.lr();
     }
     /**
      * Stops the RPC. This call is idempotent and allowed regardless of the
@@ -11129,7 +11129,7 @@ class eo {
      *
      * When stop returns, isStarted() and isOpen() will both return false.
      */    async stop() {
-        this.cr() && await this.close(0 /* Initial */);
+        this.ur() && await this.close(0 /* Initial */);
     }
     /**
      * After an error the stream will usually back off on the next attempt to
@@ -11138,8 +11138,8 @@ class eo {
      *
      * Each error will call the onClose() listener. That function can decide to
      * inhibit backoff if required.
-     */    hr() {
-        this.state = 0 /* Initial */ , this.rr.reset();
+     */    dr() {
+        this.state = 0 /* Initial */ , this.ar.reset();
     }
     /**
      * Marks this stream as idle. If no further actions are performed on the
@@ -11150,22 +11150,25 @@ class eo {
      *
      * Only streams that are in state 'Open' can be marked idle, as all other
      * states imply pending network operations.
-     */    lr() {
+     */    wr() {
         // 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.ar() && null === this.ir && (this.ir = this.Oe.enqueueAfterDelay(this.er, 6e4, (() => this.dr())));
+        this.hr() && null === this.rr && (this.rr = this.Oe.enqueueAfterDelay(this.er, 6e4, (() => this._r())));
     }
-    /** Sends a message to the underlying stream. */    wr(t) {
-        this._r(), this.stream.send(t);
+    /** Sends a message to the underlying stream. */    mr(t) {
+        this.gr(), this.stream.send(t);
     }
-    /** Called by the idle timer when the stream should close due to inactivity. */    async dr() {
-        if (this.ar()) 
+    /** Called by the idle timer when the stream should close due to inactivity. */    async _r() {
+        if (this.hr()) 
         // 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 /* Initial */);
     }
-    /** Marks the stream as active again. */    _r() {
-        this.ir && (this.ir.cancel(), this.ir = null);
+    /** Marks the stream as active again. */    gr() {
+        this.rr && (this.rr.cancel(), this.rr = null);
+    }
+    /** Cancels the health check delayed operation. */    yr() {
+        this.cr && (this.cr.cancel(), this.cr = null);
     }
     /**
      * Closes the stream and cleans up as necessary:
@@ -11181,20 +11184,24 @@ class eo {
      * @param error - the error the connection was closed with.
      */    async close(t, e) {
         // Cancel any outstanding timers (they're guaranteed not to execute).
-        this._r(), this.rr.cancel(), 
+        this.gr(), this.yr(), this.ar.cancel(), 
         // Invalidates any stream-related callbacks (e.g. from auth or the
         // underlying stream), guaranteeing they won't execute.
-        this.sr++, 3 /* Error */ !== t ? 
+        this.ir++, 4 /* Error */ !== t ? 
         // If this is an intentional close ensure we don't delay our next connection attempt.
-        this.rr.reset() : e && e.code === j.RESOURCE_EXHAUSTED ? (
+        this.ar.reset() : e && e.code === j.RESOURCE_EXHAUSTED ? (
         // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)
         F(e.toString()), F("Using maximum backoff delay to prevent overloading the backend."), 
-        this.rr.Yi()) : e && e.code === j.UNAUTHENTICATED && 
-        // "unauthenticated" error means the token was rejected. Try force refreshing it in case it
-        // just expired.
+        this.ar.Yi()) : e && e.code === j.UNAUTHENTICATED && 3 /* 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
+        // fail, however. In this case, we should get a Code.UNAUTHENTICATED error
+        // before we received the first message and we need to invalidate the token
+        // to ensure that we fetch a new token.
         this.credentialsProvider.invalidateToken(), 
         // Clean up the underlying stream because we are no longer interested in events.
-        null !== this.stream && (this.mr(), this.stream.close(), this.stream = null), 
+        null !== this.stream && (this.pr(), 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 = t, 
@@ -11204,59 +11211,60 @@ class eo {
     /**
      * Can be overridden to perform additional cleanup before the stream is closed.
      * Calling super.tearDown() is not required.
-     */    mr() {}
+     */    pr() {}
     auth() {
         this.state = 1 /* Starting */;
-        const t = this.gr(this.sr), e = this.sr;
+        const t = this.Tr(this.ir), e = this.ir;
         // TODO(mikelehen): Just use dispatchIfNotClosed, but see TODO below.
                 this.credentialsProvider.getToken().then((t => {
             // 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.sr === e && 
+            this.ir === e && 
             // 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.yr(t);
+            this.Er(t);
         }), (e => {
             t((() => {
                 const t = new Q(j.UNKNOWN, "Fetching auth token failed: " + e.message);
-                return this.pr(t);
+                return this.Ir(t);
             }));
         }));
     }
-    yr(t) {
-        const e = this.gr(this.sr);
-        this.stream = this.Tr(t), this.stream.Si((() => {
-            e((() => (this.state = 2 /* Open */ , this.listener.Si())));
+    Er(t) {
+        const e = this.Tr(this.ir);
+        this.stream = this.Ar(t), this.stream.Si((() => {
+            e((() => (this.state = 2 /* Open */ , this.cr = this.Oe.enqueueAfterDelay(this.nr, 1e4, (() => (this.hr() && (this.state = 3 /* Healthy */), 
+            Promise.resolve()))), this.listener.Si())));
         })), this.stream.Ci((t => {
-            e((() => this.pr(t)));
+            e((() => this.Ir(t)));
         })), this.stream.onMessage((t => {
             e((() => this.onMessage(t)));
         }));
     }
-    ur() {
-        this.state = 4 /* Backoff */ , this.rr.Xi((async () => {
+    lr() {
+        this.state = 5 /* Backoff */ , this.ar.Xi((async () => {
             this.state = 0 /* Initial */ , this.start();
         }));
     }
     // Visible for tests
-    pr(t) {
+    Ir(t) {
         // 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
         // without a backoff accidentally, we set the stream to error in all cases.
-        return O("PersistentStream", `close with error: ${t}`), this.stream = null, this.close(3 /* Error */ , t);
+        return O("PersistentStream", `close with error: ${t}`), this.stream = null, this.close(4 /* Error */ , t);
     }
     /**
      * Returns a "dispatcher" function that dispatches operations onto the
      * 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.
-     */    gr(t) {
+     */    Tr(t) {
         return e => {
-            this.Oe.enqueueAndForget((() => this.sr === t ? e() : (O("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
+            this.Oe.enqueueAndForget((() => this.ir === t ? e() : (O("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
             Promise.resolve())));
         };
     }
@@ -11270,15 +11278,15 @@ class eo {
  * sent from the server for ListenResponses.
  */ class no extends eo {
     constructor(t, e, n, s, i) {
-        super(t, "listen_stream_connection_backoff" /* ListenStreamConnectionBackoff */ , "listen_stream_idle" /* ListenStreamIdle */ , e, n, i), 
+        super(t, "listen_stream_connection_backoff" /* ListenStreamConnectionBackoff */ , "listen_stream_idle" /* ListenStreamIdle */ , "health_check_timeout" /* HealthCheckTimeout */ , e, n, i), 
         this.N = s;
     }
-    Tr(t) {
-        return this.nr.ji("Listen", t);
+    Ar(t) {
+        return this.sr.ji("Listen", t);
     }
     onMessage(t) {
         // A successful response means the stream is healthy
-        this.rr.reset();
+        this.ar.reset();
         const e = is(this.N, t), n = function(t) {
             // 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
@@ -11287,14 +11295,14 @@ class eo {
             const e = t.targetChange;
             return e.targetIds && e.targetIds.length ? ot.min() : e.readTime ? Wn(e.readTime) : ot.min();
         }(t);
-        return this.listener.Er(e, n);
+        return this.listener.Rr(e, 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.
-     */    Ir(t) {
+     */    br(t) {
         const e = {};
         e.database = Zn(this.N), e.addTarget = function(t, e) {
             let n;
@@ -11310,14 +11318,14 @@ class eo {
             n.readTime = Kn(t, e.snapshotVersion.toTimestamp())), n;
         }(this.N, t);
         const n = ls(this.N, t);
-        n && (e.labels = n), this.wr(e);
+        n && (e.labels = n), this.mr(e);
     }
     /**
      * Unregisters interest in the results of the target associated with the
      * given targetId.
-     */    Ar(t) {
+     */    Pr(t) {
         const e = {};
-        e.database = Zn(this.N), e.removeTarget = t, this.wr(e);
+        e.database = Zn(this.N), e.removeTarget = t, this.mr(e);
     }
 }
 
@@ -11339,55 +11347,55 @@ class eo {
  * TODO(b/33271235): Use proto types
  */ class so extends eo {
     constructor(t, e, n, s, i) {
-        super(t, "write_stream_connection_backoff" /* WriteStreamConnectionBackoff */ , "write_stream_idle" /* WriteStreamIdle */ , e, n, i), 
-        this.N = s, this.Rr = !1;
+        super(t, "write_stream_connection_backoff" /* WriteStreamConnectionBackoff */ , "write_stream_idle" /* WriteStreamIdle */ , "health_check_timeout" /* HealthCheckTimeout */ , e, n, i), 
+        this.N = s, this.vr = !1;
     }
     /**
      * Tracks whether or not a handshake has been successfully exchanged and
      * the stream is ready to accept mutations.
-     */    get br() {
-        return this.Rr;
+     */    get Vr() {
+        return this.vr;
     }
     // Override of PersistentStream.start
     start() {
-        this.Rr = !1, this.lastStreamToken = void 0, super.start();
+        this.vr = !1, this.lastStreamToken = void 0, super.start();
     }
-    mr() {
-        this.Rr && this.Pr([]);
+    pr() {
+        this.vr && this.Sr([]);
     }
-    Tr(t) {
-        return this.nr.ji("Write", t);
+    Ar(t) {
+        return this.sr.ji("Write", t);
     }
     onMessage(t) {
         if (
         // Always capture the last stream token.
-        U(!!t.streamToken), this.lastStreamToken = t.streamToken, this.Rr) {
+        U(!!t.streamToken), this.lastStreamToken = t.streamToken, this.vr) {
             // 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.rr.reset();
+            this.ar.reset();
             const e = cs(t.writeResults, t.commitTime), n = Wn(t.commitTime);
-            return this.listener.vr(n, e);
+            return this.listener.Dr(n, e);
         }
         // The first response is always the handshake response
-        return U(!t.writeResults || 0 === t.writeResults.length), this.Rr = !0, this.listener.Vr();
+        return U(!t.writeResults || 0 === t.writeResults.length), this.vr = !0, this.listener.Cr();
     }
     /**
      * 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.
-     */    Sr() {
+     */    Nr() {
         // TODO(dimond): Support stream resumption. We intentionally do not set the
         // stream token on the handshake, ignoring any stream token we might have.
         const t = {};
-        t.database = Zn(this.N), this.wr(t);
+        t.database = Zn(this.N), this.mr(t);
     }
-    /** Sends a group of mutations to the Firestore backend to apply. */    Pr(t) {
+    /** Sends a group of mutations to the Firestore backend to apply. */    Sr(t) {
         const e = {
             streamToken: this.lastStreamToken,
             writes: t.map((t => rs(this.N, t)))
         };
-        this.wr(e);
+        this.mr(e);
     }
 }
 
@@ -11418,25 +11426,25 @@ class eo {
  */
 class io extends class {} {
     constructor(t, e, n) {
-        super(), this.credentials = t, this.nr = e, this.N = n, this.Dr = !1;
+        super(), this.credentials = t, this.sr = e, this.N = n, this.kr = !1;
     }
-    Cr() {
-        if (this.Dr) throw new Q(j.FAILED_PRECONDITION, "The client has already been terminated.");
+    $r() {
+        if (this.kr) throw new Q(j.FAILED_PRECONDITION, "The client has already been terminated.");
     }
     /** Gets an auth token and invokes the provided RPC. */    Li(t, e, n) {
-        return this.Cr(), this.credentials.getToken().then((s => this.nr.Li(t, e, n, s))).catch((t => {
+        return this.$r(), this.credentials.getToken().then((s => this.sr.Li(t, e, n, s))).catch((t => {
             throw "FirebaseError" === t.name ? (t.code === j.UNAUTHENTICATED && this.credentials.invalidateToken(), 
             t) : new Q(j.UNKNOWN, t.toString());
         }));
     }
     /** Gets an auth token and invokes the provided RPC with streamed results. */    Ki(t, e, n) {
-        return this.Cr(), this.credentials.getToken().then((s => this.nr.Ki(t, e, n, s))).catch((t => {
+        return this.$r(), this.credentials.getToken().then((s => this.sr.Ki(t, e, n, s))).catch((t => {
             throw "FirebaseError" === t.name ? (t.code === j.UNAUTHENTICATED && this.credentials.invalidateToken(), 
             t) : new Q(j.UNKNOWN, t.toString());
         }));
     }
     terminate() {
-        this.Dr = !0;
+        this.kr = !0;
     }
 }
 
@@ -11463,19 +11471,19 @@ class ro {
          * maximum defined by MAX_WATCH_STREAM_FAILURES, we'll set the OnlineState to
          * Offline.
          */
-        this.Nr = 0, 
+        this.Or = 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.kr = null, 
+        this.Fr = 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.$r = !0;
+        this.Mr = !0;
     }
     /**
      * Called by RemoteStore when a watch stream is started (including on each
@@ -11483,9 +11491,9 @@ class ro {
      *
      * If this is the first attempt, it sets the OnlineState to Unknown and starts
      * the onlineStateTimer.
-     */    Or() {
-        0 === this.Nr && (this.Fr("Unknown" /* Unknown */), this.kr = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* OnlineStateTimeout */ , 1e4, (() => (this.kr = null, 
-        this.Mr("Backend didn't respond within 10 seconds."), this.Fr("Offline" /* Offline */), 
+     */    Lr() {
+        0 === this.Or && (this.Br("Unknown" /* Unknown */), this.Fr = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* OnlineStateTimeout */ , 1e4, (() => (this.Fr = null, 
+        this.Ur("Backend didn't respond within 10 seconds."), this.Br("Offline" /* Offline */), 
         Promise.resolve()))));
     }
     /**
@@ -11493,10 +11501,10 @@ class ro {
      * 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.
-     */    Lr(t) {
-        "Online" /* Online */ === this.state ? this.Fr("Unknown" /* Unknown */) : (this.Nr++, 
-        this.Nr >= 1 && (this.Br(), this.Mr(`Connection failed 1 times. Most recent error: ${t.toString()}`), 
-        this.Fr("Offline" /* Offline */)));
+     */    qr(t) {
+        "Online" /* Online */ === this.state ? this.Br("Unknown" /* Unknown */) : (this.Or++, 
+        this.Or >= 1 && (this.Kr(), this.Ur(`Connection failed 1 times. Most recent error: ${t.toString()}`), 
+        this.Br("Offline" /* Offline */)));
     }
     /**
      * Explicitly sets the OnlineState to the specified state.
@@ -11505,20 +11513,20 @@ class ro {
      * Offline heuristics, so must not be used in place of
      * handleWatchStreamStart() and handleWatchStreamFailure().
      */    set(t) {
-        this.Br(), this.Nr = 0, "Online" /* Online */ === t && (
+        this.Kr(), this.Or = 0, "Online" /* Online */ === t && (
         // We've connected to watch at least once. Don't warn the developer
         // about being offline going forward.
-        this.$r = !1), this.Fr(t);
+        this.Mr = !1), this.Br(t);
     }
-    Fr(t) {
+    Br(t) {
         t !== this.state && (this.state = t, this.onlineStateHandler(t));
     }
-    Mr(t) {
+    Ur(t) {
         const e = `Could not reach Cloud Firestore backend. ${t}\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.$r ? (F(e), this.$r = !1) : O("OnlineStateTracker", e);
+        this.Mr ? (F(e), this.Mr = !1) : O("OnlineStateTracker", e);
     }
-    Br() {
-        null !== this.kr && (this.kr.cancel(), this.kr = null);
+    Kr() {
+        null !== this.Fr && (this.Fr.cancel(), this.Fr = null);
     }
 }
 
@@ -11563,7 +11571,7 @@ class ro {
          * purely based on order, and so we can just shift() writes from the front of
          * the writePipeline as we receive responses.
          */
-        this.Ur = [], 
+        this.jr = [], 
         /**
          * A mapping of watched targets that the client cares about tracking and the
          * user has explicitly called a 'listen' for this target.
@@ -11573,12 +11581,12 @@ class ro {
          * to the server. The targets removed with unlistens are removed eagerly
          * without waiting for confirmation from the listen stream.
          */
-        this.qr = new Map, 
+        this.Qr = new Map, 
         /**
          * A set of reasons for why the RemoteStore may be offline. If empty, the
          * RemoteStore may start its network connections.
          */
-        this.Kr = new Set, 
+        this.Wr = new Set, 
         /**
          * Event handlers that get called when the network is disabled or enabled.
          *
@@ -11586,7 +11594,7 @@ class ro {
          * underlying streams (to support tree-shakeable streams). On Android and iOS,
          * the streams are created during construction of RemoteStore.
          */
-        this.jr = [], this.Qr = i, this.Qr.Ti((t => {
+        this.Gr = [], this.zr = i, this.zr.Ti((t => {
             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
@@ -11594,23 +11602,23 @@ class ro {
                 mo(this) && (O("RemoteStore", "Restarting streams for network reachability change."), 
                 await async function(t) {
                     const e = K(t);
-                    e.Kr.add(4 /* ConnectivityChange */), await ao(e), e.Wr.set("Unknown" /* Unknown */), 
-                    e.Kr.delete(4 /* ConnectivityChange */), await co(e);
+                    e.Wr.add(4 /* ConnectivityChange */), await ao(e), e.Hr.set("Unknown" /* Unknown */), 
+                    e.Wr.delete(4 /* ConnectivityChange */), await co(e);
                 }(this));
             }));
-        })), this.Wr = new ro(n, s);
+        })), this.Hr = new ro(n, s);
     }
 }
 
 async function co(t) {
-    if (mo(t)) for (const e of t.jr) await e(/* enabled= */ !0);
+    if (mo(t)) for (const e of t.Gr) await e(/* enabled= */ !0);
 }
 
 /**
  * Temporarily disables the network. The network can be re-enabled using
  * enableNetwork().
  */ async function ao(t) {
-    for (const e of t.jr) await e(/* enabled= */ !1);
+    for (const e of t.Gr) await e(/* enabled= */ !1);
 }
 
 /**
@@ -11619,11 +11627,11 @@ async function co(t) {
  */
 function uo(t, e) {
     const n = K(t);
-    n.qr.has(e.targetId) || (
+    n.Qr.has(e.targetId) || (
     // Mark this as something the client is currently listening for.
-    n.qr.set(e.targetId, e), _o(n) ? 
+    n.Qr.set(e.targetId, e), _o(n) ? 
     // The listen will be sent in onWatchStreamOpen
-    wo(n) : xo(n).ar() && lo(n, e));
+    wo(n) : xo(n).hr() && lo(n, e));
 }
 
 /**
@@ -11631,18 +11639,18 @@ function uo(t, e) {
  * not being listened to.
  */ function ho(t, e) {
     const n = K(t), s = xo(n);
-    n.qr.delete(e), s.ar() && fo(n, e), 0 === n.qr.size && (s.ar() ? s.lr() : mo(n) && 
+    n.Qr.delete(e), s.hr() && fo(n, e), 0 === n.Qr.size && (s.hr() ? s.wr() : mo(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.Wr.set("Unknown" /* Unknown */));
+    n.Hr.set("Unknown" /* Unknown */));
 }
 
 /**
  * We need to increment the the expected number of pending responses we're due
  * from watch so we wait for the ack to process any messages from this target.
  */ function lo(t, e) {
-    t.Gr.Y(e.targetId), xo(t).Ir(e);
+    t.Jr.Y(e.targetId), xo(t).br(e);
 }
 
 /**
@@ -11650,33 +11658,33 @@ function uo(t, e) {
  * from watch so we wait for the removal on the server before we process any
  * messages from this target.
  */ function fo(t, e) {
-    t.Gr.Y(e), xo(t).Ar(e);
+    t.Jr.Y(e), xo(t).Pr(e);
 }
 
 function wo(t) {
-    t.Gr = new Fn({
+    t.Jr = new Fn({
         getRemoteKeysForTarget: e => t.remoteSyncer.getRemoteKeysForTarget(e),
-        Tt: e => t.qr.get(e) || null
-    }), xo(t).start(), t.Wr.Or();
+        Tt: e => t.Qr.get(e) || null
+    }), xo(t).start(), t.Hr.Lr();
 }
 
 /**
  * Returns whether the watch stream should be started because it's necessary
  * and has not yet been started.
  */ function _o(t) {
-    return mo(t) && !xo(t).cr() && t.qr.size > 0;
+    return mo(t) && !xo(t).ur() && t.Qr.size > 0;
 }
 
 function mo(t) {
-    return 0 === K(t).Kr.size;
+    return 0 === K(t).Wr.size;
 }
 
 function go(t) {
-    t.Gr = void 0;
+    t.Jr = void 0;
 }
 
 async function yo(t) {
-    t.qr.forEach(((e, n) => {
+    t.Qr.forEach(((e, n) => {
         lo(t, e);
     }));
 }
@@ -11684,17 +11692,17 @@ async function yo(t) {
 async function po(t, e) {
     go(t), 
     // If we still need the watch stream, retry the connection.
-    _o(t) ? (t.Wr.Lr(e), wo(t)) : 
+    _o(t) ? (t.Hr.qr(e), wo(t)) : 
     // 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
-    t.Wr.set("Unknown" /* Unknown */);
+    t.Hr.set("Unknown" /* Unknown */);
 }
 
 async function To(t, e, n) {
     if (
     // Mark the client as online since we got a message from the server
-    t.Wr.set("Online" /* Online */), e instanceof $n && 2 /* Removed */ === e.state && e.cause) 
+    t.Hr.set("Online" /* Online */), e instanceof $n && 2 /* Removed */ === e.state && e.cause) 
     // There was an error on a target, don't wait for a consistent snapshot
     // to raise events
     try {
@@ -11704,7 +11712,7 @@ async function To(t, e, n) {
             const n = e.cause;
             for (const s of e.targetIds) 
             // A watched target might have been removed already.
-            t.qr.has(s) && (await t.remoteSyncer.rejectListen(s, n), t.qr.delete(s), t.Gr.removeTarget(s));
+            t.Qr.has(s) && (await t.remoteSyncer.rejectListen(s, n), t.Qr.delete(s), t.Jr.removeTarget(s));
         }
         /**
  * Attempts to fill our write pipeline with writes from the LocalStore.
@@ -11717,7 +11725,7 @@ async function To(t, e, n) {
     } catch (n) {
         O("RemoteStore", "Failed to remove targets %s: %s ", e.targetIds.join(","), n), 
         await Eo(t, n);
-    } else if (e instanceof xn ? t.Gr.rt(e) : e instanceof kn ? t.Gr.ft(e) : t.Gr.at(e), 
+    } else if (e instanceof xn ? t.Jr.rt(e) : e instanceof kn ? t.Jr.ft(e) : t.Jr.at(e), 
     !n.isEqual(ot.min())) try {
         const e = await wr(t.localStore);
         n.compareTo(e) >= 0 && 
@@ -11730,26 +11738,26 @@ async function To(t, e, n) {
  * SyncEngine.
  */
         function(t, e) {
-            const n = t.Gr._t(e);
+            const n = t.Jr._t(e);
             // Update in-memory resume tokens. LocalStore will update the
             // persistent view of these when applying the completed RemoteEvent.
                         return n.targetChanges.forEach(((n, s) => {
                 if (n.resumeToken.approximateByteSize() > 0) {
-                    const i = t.qr.get(s);
+                    const i = t.Qr.get(s);
                     // A watched target might have been removed already.
-                                        i && t.qr.set(s, i.withResumeToken(n.resumeToken, e));
+                                        i && t.Qr.set(s, i.withResumeToken(n.resumeToken, e));
                 }
             })), 
             // Re-establish listens for the targets that have been invalidated by
             // existence filter mismatches.
             n.targetMismatches.forEach((e => {
-                const n = t.qr.get(e);
+                const n = t.Qr.get(e);
                 if (!n) 
                 // A watched target might have been removed already.
                 return;
                 // Clear the resume token for the target, since we're in a known mismatch
                 // state.
-                                t.qr.set(e, n.withResumeToken(gt.EMPTY_BYTE_STRING, n.snapshotVersion)), 
+                                t.Qr.set(e, n.withResumeToken(gt.EMPTY_BYTE_STRING, n.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.
                 fo(t, e);
@@ -11776,16 +11784,16 @@ async function To(t, e, n) {
  * any retry attempt.
  */ async function Eo(t, e, n) {
     if (!Ys(e)) throw e;
-    t.Kr.add(1 /* IndexedDbFailed */), 
+    t.Wr.add(1 /* IndexedDbFailed */), 
     // Disable network and raise offline snapshots
-    await ao(t), t.Wr.set("Offline" /* Offline */), n || (
+    await ao(t), t.Hr.set("Offline" /* Offline */), n || (
     // Use a simple read operation to determine if IndexedDB recovered.
     // Ideally, we would expose a health check directly on SimpleDb, but
     // RemoteStore only has access to persistence through LocalStore.
     n = () => wr(t.localStore)), 
     // Probe IndexedDB periodically and re-enable network
     t.asyncQueue.enqueueRetryable((async () => {
-        O("RemoteStore", "Retrying IndexedDB access"), await n(), t.Kr.delete(1 /* IndexedDbFailed */), 
+        O("RemoteStore", "Retrying IndexedDB access"), await n(), t.Wr.delete(1 /* IndexedDbFailed */), 
         await co(t);
     }));
 }
@@ -11799,11 +11807,11 @@ async function To(t, e, n) {
 
 async function Ao(t) {
     const e = K(t), n = ko(e);
-    let s = e.Ur.length > 0 ? e.Ur[e.Ur.length - 1].batchId : -1;
+    let s = e.jr.length > 0 ? e.jr[e.jr.length - 1].batchId : -1;
     for (;Ro(e); ) try {
         const t = await gr(e.localStore, s);
         if (null === t) {
-            0 === e.Ur.length && n.lr();
+            0 === e.jr.length && n.wr();
             break;
         }
         s = t.batchId, bo(e, t);
@@ -11817,20 +11825,20 @@ async function Ao(t) {
  * Returns true if we can add to the write pipeline (i.e. the network is
  * enabled and the write pipeline is not full).
  */ function Ro(t) {
-    return mo(t) && t.Ur.length < 10;
+    return mo(t) && t.jr.length < 10;
 }
 
 /**
  * Queues additional writes to be sent to the write stream, sending them
  * immediately if the write stream is established.
  */ function bo(t, e) {
-    t.Ur.push(e);
+    t.jr.push(e);
     const n = ko(t);
-    n.ar() && n.br && n.Pr(e.mutations);
+    n.hr() && n.Vr && n.Sr(e.mutations);
 }
 
 function Po(t) {
-    return mo(t) && !ko(t).cr() && t.Ur.length > 0;
+    return mo(t) && !ko(t).ur() && t.jr.length > 0;
 }
 
 function vo(t) {
@@ -11838,17 +11846,17 @@ function vo(t) {
 }
 
 async function Vo(t) {
-    ko(t).Sr();
+    ko(t).Nr();
 }
 
 async function So(t) {
     const e = ko(t);
     // Send the write pipeline now that the stream is established.
-        for (const n of t.Ur) e.Pr(n.mutations);
+        for (const n of t.jr) e.Sr(n.mutations);
 }
 
 async function Do(t, e, n) {
-    const s = t.Ur.shift(), i = ri.from(s, e, n);
+    const s = t.jr.shift(), i = ri.from(s, e, n);
     await Io(t, (() => t.remoteSyncer.applySuccessfulWrite(i))), 
     // It's possible that with the completion of this mutation another
     // slot has freed up.
@@ -11858,7 +11866,7 @@ async function Do(t, e, n) {
 async function Co(t, e) {
     // If the write stream closed after the write handshake completes, a write
     // operation failed and we fail the pending operation.
-    e && ko(t).br && 
+    e && ko(t).Vr && 
     // This error affects the actual write.
     await async function(t, e) {
         // Only handle permanent errors here. If it's transient, just let the retry
@@ -11866,11 +11874,11 @@ async function Co(t, e) {
         if (n = e.code, wn(n) && n !== j.ABORTED) {
             // This was a permanent error, the request itself was the problem
             // so it's not going to succeed if we resend it.
-            const n = t.Ur.shift();
+            const n = t.jr.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.
-                        ko(t).hr(), await Io(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
+                        ko(t).dr(), await Io(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
             // It's possible that with the completion of this mutation
             // another slot has freed up.
             await Ao(t);
@@ -11887,8 +11895,8 @@ async function Co(t, e) {
  */
 async function No(t, e) {
     const n = K(t);
-    e ? (n.Kr.delete(2 /* IsSecondary */), await co(n)) : e || (n.Kr.add(2 /* IsSecondary */), 
-    await ao(n), n.Wr.set("Unknown" /* Unknown */));
+    e ? (n.Wr.delete(2 /* IsSecondary */), await co(n)) : e || (n.Wr.add(2 /* IsSecondary */), 
+    await ao(n), n.Hr.set("Unknown" /* Unknown */));
 }
 
 /**
@@ -11899,11 +11907,11 @@ async function No(t, e) {
  * 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 xo(t) {
-    return t.zr || (
+    return t.Yr || (
     // Create stream (but note that it is not started yet).
-    t.zr = function(t, e, n) {
+    t.Yr = function(t, e, n) {
         const s = K(t);
-        return s.Cr(), new no(e, s.nr, s.credentials, s.N, n);
+        return s.$r(), new no(e, s.sr, s.credentials, s.N, n);
     }
     /**
  * @license
@@ -11923,11 +11931,11 @@ async function No(t, e) {
  */ (t.datastore, t.asyncQueue, {
         Si: yo.bind(null, t),
         Ci: po.bind(null, t),
-        Er: To.bind(null, t)
-    }), t.jr.push((async e => {
-        e ? (t.zr.hr(), _o(t) ? wo(t) : t.Wr.set("Unknown" /* Unknown */)) : (await t.zr.stop(), 
+        Rr: To.bind(null, t)
+    }), t.Gr.push((async e => {
+        e ? (t.Yr.dr(), _o(t) ? wo(t) : t.Hr.set("Unknown" /* Unknown */)) : (await t.Yr.stop(), 
         go(t));
-    }))), t.zr;
+    }))), t.Yr;
 }
 
 /**
@@ -11938,22 +11946,22 @@ async function No(t, e) {
  * 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 ko(t) {
-    return t.Hr || (
+    return t.Xr || (
     // Create stream (but note that it is not started yet).
-    t.Hr = function(t, e, n) {
+    t.Xr = function(t, e, n) {
         const s = K(t);
-        return s.Cr(), new so(e, s.nr, s.credentials, s.N, n);
+        return s.$r(), new so(e, s.sr, s.credentials, s.N, n);
     }(t.datastore, t.asyncQueue, {
         Si: Vo.bind(null, t),
         Ci: Co.bind(null, t),
-        Vr: So.bind(null, t),
-        vr: Do.bind(null, t)
-    }), t.jr.push((async e => {
-        e ? (t.Hr.hr(), 
+        Cr: So.bind(null, t),
+        Dr: Do.bind(null, t)
+    }), t.Gr.push((async e => {
+        e ? (t.Xr.dr(), 
         // This will start the write stream if necessary.
-        await Ao(t)) : (await t.Hr.stop(), t.Ur.length > 0 && (O("RemoteStore", `Stopping write stream with ${t.Ur.length} pending writes`), 
-        t.Ur = []));
-    }))), t.Hr;
+        await Ao(t)) : (await t.Xr.stop(), t.jr.length > 0 && (O("RemoteStore", `Stopping write stream with ${t.jr.length} pending writes`), 
+        t.jr = []));
+    }))), t.Xr;
 }
 
 /**
@@ -12163,25 +12171,25 @@ class $o {
  * duplicate events for the same doc.
  */ class Mo {
     constructor() {
-        this.Jr = new mn(Vt.comparator);
+        this.Zr = new mn(Vt.comparator);
     }
     track(t) {
-        const e = t.doc.key, n = this.Jr.get(e);
+        const e = t.doc.key, n = this.Zr.get(e);
         n ? 
         // Merge the new change with the existing change.
-        0 /* Added */ !== t.type && 3 /* Metadata */ === n.type ? this.Jr = this.Jr.insert(e, t) : 3 /* Metadata */ === t.type && 1 /* Removed */ !== n.type ? this.Jr = this.Jr.insert(e, {
+        0 /* Added */ !== t.type && 3 /* Metadata */ === n.type ? this.Zr = this.Zr.insert(e, t) : 3 /* Metadata */ === t.type && 1 /* Removed */ !== n.type ? this.Zr = this.Zr.insert(e, {
             type: n.type,
             doc: t.doc
-        }) : 2 /* Modified */ === t.type && 2 /* Modified */ === n.type ? this.Jr = this.Jr.insert(e, {
+        }) : 2 /* Modified */ === t.type && 2 /* Modified */ === n.type ? this.Zr = this.Zr.insert(e, {
             type: 2 /* Modified */ ,
             doc: t.doc
-        }) : 2 /* Modified */ === t.type && 0 /* Added */ === n.type ? this.Jr = this.Jr.insert(e, {
+        }) : 2 /* Modified */ === t.type && 0 /* Added */ === n.type ? this.Zr = this.Zr.insert(e, {
             type: 0 /* Added */ ,
             doc: t.doc
-        }) : 1 /* Removed */ === t.type && 0 /* Added */ === n.type ? this.Jr = this.Jr.remove(e) : 1 /* Removed */ === t.type && 2 /* Modified */ === n.type ? this.Jr = this.Jr.insert(e, {
+        }) : 1 /* Removed */ === t.type && 0 /* Added */ === n.type ? this.Zr = this.Zr.remove(e) : 1 /* Removed */ === t.type && 2 /* Modified */ === n.type ? this.Zr = this.Zr.insert(e, {
             type: 1 /* Removed */ ,
             doc: n.doc
-        }) : 0 /* Added */ === t.type && 1 /* Removed */ === n.type ? this.Jr = this.Jr.insert(e, {
+        }) : 0 /* Added */ === t.type && 1 /* Removed */ === n.type ? this.Zr = this.Zr.insert(e, {
             type: 2 /* Modified */ ,
             doc: t.doc
         }) : 
@@ -12192,11 +12200,11 @@ class $o {
         // Removed->Modified
         // Metadata->Added
         // Removed->Metadata
-        B() : this.Jr = this.Jr.insert(e, t);
+        B() : this.Zr = this.Zr.insert(e, t);
     }
-    Yr() {
+    eo() {
         const t = [];
-        return this.Jr.inorderTraversal(((e, n) => {
+        return this.Zr.inorderTraversal(((e, n) => {
             t.push(n);
         })), t;
     }
@@ -12251,14 +12259,14 @@ class Lo {
  * tracked by EventManager.
  */ class Bo {
     constructor() {
-        this.Xr = void 0, this.listeners = [];
+        this.no = void 0, this.listeners = [];
     }
 }
 
 class Uo {
     constructor() {
         this.queries = new Wi((t => Pe(t)), be), this.onlineState = "Unknown" /* Unknown */ , 
-        this.Zr = new Set;
+        this.so = new Set;
     }
 }
 
@@ -12266,15 +12274,15 @@ async function qo(t, e) {
     const n = K(t), s = e.query;
     let i = !1, r = n.queries.get(s);
     if (r || (i = !0, r = new Bo), i) try {
-        r.Xr = await n.onListen(s);
+        r.no = await n.onListen(s);
     } catch (t) {
         const n = Oo(t, `Initialization of query '${ve(e.query)}' failed`);
         return void e.onError(n);
     }
     if (n.queries.set(s, r), r.listeners.push(e), 
     // Run global snapshot listeners if a consistent snapshot has been emitted.
-    e.eo(n.onlineState), r.Xr) {
-        e.no(r.Xr) && Wo(n);
+    e.io(n.onlineState), r.no) {
+        e.ro(r.no) && Wo(n);
     }
 }
 
@@ -12295,8 +12303,8 @@ function jo(t, e) {
     for (const t of e) {
         const e = t.query, i = n.queries.get(e);
         if (i) {
-            for (const e of i.listeners) e.no(t) && (s = !0);
-            i.Xr = t;
+            for (const e of i.listeners) e.ro(t) && (s = !0);
+            i.no = t;
         }
     }
     s && Wo(n);
@@ -12312,7 +12320,7 @@ function Qo(t, e, n) {
 
 // Call all global snapshot listeners that have been set.
 function Wo(t) {
-    t.Zr.forEach((t => {
+    t.so.forEach((t => {
         t.next();
     }));
 }
@@ -12324,19 +12332,19 @@ function Wo(t) {
  * It uses an Observer to dispatch events.
  */ class Go {
     constructor(t, e, n) {
-        this.query = t, this.so = e, 
+        this.query = t, this.oo = e, 
         /**
          * 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.io = !1, this.ro = null, this.onlineState = "Unknown" /* Unknown */ , this.options = n || {};
+        this.co = !1, this.ao = null, this.onlineState = "Unknown" /* Unknown */ , this.options = n || {};
     }
     /**
      * Applies the new ViewSnapshot to this listener, raising a user-facing event
      * 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.
-     */    no(t) {
+     */    ro(t) {
         if (!this.options.includeMetadataChanges) {
             // Remove the metadata only changes.
             const e = [];
@@ -12345,19 +12353,19 @@ function Wo(t) {
             /* excludesMetadataChanges= */ !0);
         }
         let e = !1;
-        return this.io ? this.oo(t) && (this.so.next(t), e = !0) : this.co(t, this.onlineState) && (this.ao(t), 
-        e = !0), this.ro = t, e;
+        return this.co ? this.uo(t) && (this.oo.next(t), e = !0) : this.ho(t, this.onlineState) && (this.lo(t), 
+        e = !0), this.ao = t, e;
     }
     onError(t) {
-        this.so.error(t);
+        this.oo.error(t);
     }
-    /** Returns whether a snapshot was raised. */    eo(t) {
+    /** Returns whether a snapshot was raised. */    io(t) {
         this.onlineState = t;
         let e = !1;
-        return this.ro && !this.io && this.co(this.ro, t) && (this.ao(this.ro), e = !0), 
+        return this.ao && !this.co && this.ho(this.ao, t) && (this.lo(this.ao), e = !0), 
         e;
     }
-    co(t, e) {
+    ho(t, e) {
         // Always raise the first event when we're synced
         if (!t.fromCache) return !0;
         // NOTE: We consider OnlineState.Unknown as online (it should become Offline
@@ -12365,24 +12373,24 @@ function Wo(t) {
                 const n = "Offline" /* Offline */ !== e;
         // Don't raise the event if we're online, aren't synced yet (checked
         // above) and are waiting for a sync.
-                return (!this.options.uo || !n) && (!t.docs.isEmpty() || "Offline" /* Offline */ === e);
+                return (!this.options.fo || !n) && (!t.docs.isEmpty() || "Offline" /* Offline */ === e);
         // Raise data from cache if we have any documents or we are offline
         }
-    oo(t) {
+    uo(t) {
         // 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 (t.docChanges.length > 0) return !0;
-        const e = this.ro && this.ro.hasPendingWrites !== t.hasPendingWrites;
+        const e = this.ao && this.ao.hasPendingWrites !== t.hasPendingWrites;
         return !(!t.syncStateChanged && !e) && !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.
         }
-    ao(t) {
-        t = Lo.fromInitialDocuments(t.query, t.docs, t.mutatedKeys, t.fromCache), this.io = !0, 
-        this.so.next(t);
+    lo(t) {
+        t = Lo.fromInitialDocuments(t.query, t.docs, t.mutatedKeys, t.fromCache), this.co = !0, 
+        this.oo.next(t);
     }
 }
 
@@ -12411,7 +12419,7 @@ function Wo(t) {
     e) {
         this.payload = t, this.byteLength = e;
     }
-    ho() {
+    wo() {
         return "metadata" in this.payload;
     }
 }
@@ -12456,7 +12464,7 @@ function Wo(t) {
  * storage and provide progress update while loading.
  */ class Jo {
     constructor(t, e, n) {
-        this.lo = t, this.localStore = e, this.N = n, 
+        this._o = t, this.localStore = e, this.N = n, 
         /** Batched queries to be saved into storage */
         this.queries = [], 
         /** Batched documents to be saved into storage */
@@ -12467,7 +12475,7 @@ function Wo(t) {
      *
      * Returns a new progress if adding the element leads to a new progress,
      * otherwise returns null.
-     */    fo(t) {
+     */    mo(t) {
         this.progress.bytesLoaded += t.byteLength;
         let e = this.progress.documentsLoaded;
         return t.payload.namedQuery ? this.queries.push(t.payload.namedQuery) : t.payload.documentMetadata ? (this.documents.push({
@@ -12476,7 +12484,7 @@ function Wo(t) {
         ++e), e !== this.progress.documentsLoaded ? (this.progress.documentsLoaded = e, 
         Object.assign({}, this.progress)) : null;
     }
-    wo(t) {
+    yo(t) {
         const e = new Map, n = new Ho(this.N);
         for (const s of t) if (s.metadata.queries) {
             const t = n.zn(s.metadata.name);
@@ -12490,7 +12498,7 @@ function Wo(t) {
     /**
      * Update the progress to 'Success' and return the updated progress.
      */    async complete() {
-        const t = await Rr(this.localStore, new Ho(this.N), this.documents, this.lo.id), e = this.wo(this.documents);
+        const t = await Rr(this.localStore, new Ho(this.N), this.documents, this._o.id), e = this.yo(this.documents);
         for (const t of this.queries) await br(this.localStore, t, e.get(t.name));
         return this.progress.taskState = "Success", new or(Object.assign({}, this.progress), t);
     }
@@ -12549,7 +12557,7 @@ class Zo {
     constructor(t, 
     /** Documents included in the remote target */
     e) {
-        this.query = t, this._o = e, this.mo = null, 
+        this.query = t, this.po = e, this.To = null, 
         /**
          * 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
@@ -12558,15 +12566,15 @@ class Zo {
          */
         this.current = !1, 
         /** Documents in the view but not in the remote target */
-        this.yo = Vn(), 
+        this.Eo = Vn(), 
         /** Document Keys that have local changes */
-        this.mutatedKeys = Vn(), this.po = Se(t), this.To = new Fo(this.po);
+        this.mutatedKeys = Vn(), this.Io = Se(t), this.Ao = new Fo(this.Io);
     }
     /**
      * The set of remote documents that the server has told us belongs to the target associated with
      * this view.
-     */    get Eo() {
-        return this._o;
+     */    get Ro() {
+        return this.po;
     }
     /**
      * Iterates over a set of doc changes, applies the query limit, and computes
@@ -12577,8 +12585,8 @@ class Zo {
      * @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.
-     */    Io(t, e) {
-        const n = e ? e.Ao : new Mo, s = e ? e.To : this.To;
+     */    bo(t, e) {
+        const n = e ? e.Po : new Mo, s = e ? e.Ao : this.Ao;
         let i = e ? e.mutatedKeys : this.mutatedKeys, r = s, 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
@@ -12601,10 +12609,10 @@ class Zo {
                 u.data.isEqual(h.data) ? l !== f && (n.track({
                     type: 3 /* Metadata */ ,
                     doc: h
-                }), d = !0) : this.Ro(u, h) || (n.track({
+                }), d = !0) : this.vo(u, h) || (n.track({
                     type: 2 /* Modified */ ,
                     doc: h
-                }), d = !0, (c && this.po(h, c) > 0 || a && this.po(h, a) < 0) && (
+                }), d = !0, (c && this.Io(h, c) > 0 || a && this.Io(h, 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.
@@ -12629,13 +12637,13 @@ class Zo {
             });
         }
         return {
-            To: r,
-            Ao: n,
+            Ao: r,
+            Po: n,
             Ln: o,
             mutatedKeys: i
         };
     }
-    Ro(t, e) {
+    vo(t, e) {
         // 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.
@@ -12657,10 +12665,10 @@ class Zo {
      */
     // PORTING NOTE: The iOS/Android clients always compute limbo document changes.
     applyChanges(t, e, n) {
-        const s = this.To;
-        this.To = t.To, this.mutatedKeys = t.mutatedKeys;
+        const s = this.Ao;
+        this.Ao = t.Ao, this.mutatedKeys = t.mutatedKeys;
         // Sort changes based on type and query comparator
-        const i = t.Ao.Yr();
+        const i = t.Po.eo();
         i.sort(((t, e) => function(t, e) {
             const n = t => {
                 switch (t) {
@@ -12698,68 +12706,68 @@ class Zo {
  * 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.
- */ (t.type, e.type) || this.po(t.doc, e.doc))), this.bo(n);
-        const r = e ? this.Po() : [], o = 0 === this.yo.size && this.current ? 1 /* Synced */ : 0 /* Local */ , c = o !== this.mo;
-        if (this.mo = o, 0 !== i.length || c) {
+ */ (t.type, e.type) || this.Io(t.doc, e.doc))), this.Vo(n);
+        const r = e ? this.So() : [], o = 0 === this.Eo.size && this.current ? 1 /* Synced */ : 0 /* Local */ , c = o !== this.To;
+        if (this.To = o, 0 !== i.length || c) {
             return {
-                snapshot: new Lo(this.query, t.To, s, i, t.mutatedKeys, 0 /* Local */ === o, c, 
+                snapshot: new Lo(this.query, t.Ao, s, i, t.mutatedKeys, 0 /* Local */ === o, c, 
                 /* excludesMetadataChanges= */ !1),
-                vo: r
+                Do: r
             };
         }
         // no changes
         return {
-            vo: r
+            Do: r
         };
     }
     /**
      * Applies an OnlineState change to the view, potentially generating a
      * ViewChange if the view's syncState changes as a result.
-     */    eo(t) {
+     */    io(t) {
         return this.current && "Offline" /* Offline */ === t ? (
         // 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({
-            To: this.To,
-            Ao: new Mo,
+            Ao: this.Ao,
+            Po: new Mo,
             mutatedKeys: this.mutatedKeys,
             Ln: !1
         }, 
         /* updateLimboDocuments= */ !1)) : {
-            vo: []
+            Do: []
         };
     }
     /**
      * Returns whether the doc for the given key should be in limbo.
-     */    Vo(t) {
+     */    Co(t) {
         // If the remote end says it's part of this query, it's not in limbo.
-        return !this._o.has(t) && (
+        return !this.po.has(t) && (
         // The local store doesn't think it's a result, so it shouldn't be in limbo.
-        !!this.To.has(t) && !this.To.get(t).hasLocalMutations);
+        !!this.Ao.has(t) && !this.Ao.get(t).hasLocalMutations);
     }
     /**
      * Updates syncedDocuments, current, and limbo docs based on the given change.
      * Returns the list of changes to which docs are in limbo.
-     */    bo(t) {
-        t && (t.addedDocuments.forEach((t => this._o = this._o.add(t))), t.modifiedDocuments.forEach((t => {})), 
-        t.removedDocuments.forEach((t => this._o = this._o.delete(t))), this.current = t.current);
+     */    Vo(t) {
+        t && (t.addedDocuments.forEach((t => this.po = this.po.add(t))), t.modifiedDocuments.forEach((t => {})), 
+        t.removedDocuments.forEach((t => this.po = this.po.delete(t))), this.current = t.current);
     }
-    Po() {
+    So() {
         // 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 t = this.yo;
-        this.yo = Vn(), this.To.forEach((t => {
-            this.Vo(t.key) && (this.yo = this.yo.add(t.key));
+                const t = this.Eo;
+        this.Eo = Vn(), this.Ao.forEach((t => {
+            this.Co(t.key) && (this.Eo = this.Eo.add(t.key));
         }));
         // Diff the new limbo docs with the old limbo docs.
         const e = [];
         return t.forEach((t => {
-            this.yo.has(t) || e.push(new Zo(t));
-        })), this.yo.forEach((n => {
+            this.Eo.has(t) || e.push(new Zo(t));
+        })), this.Eo.forEach((n => {
             t.has(n) || e.push(new Xo(n));
         })), e;
     }
@@ -12783,9 +12791,9 @@ class Zo {
      * @returns The ViewChange that resulted from this synchronization.
      */
     // PORTING NOTE: Multi-tab only.
-    So(t) {
-        this._o = t.Gn, this.yo = Vn();
-        const e = this.Io(t.documents);
+    No(t) {
+        this.po = t.Gn, this.Eo = Vn();
+        const e = this.bo(t.documents);
         return this.applyChanges(e, /*updateLimboDocuments=*/ !0);
     }
     /**
@@ -12794,8 +12802,8 @@ class Zo {
      * `hasPendingWrites` status of the already established view.
      */
     // PORTING NOTE: Multi-tab only.
-    Do() {
-        return Lo.fromInitialDocuments(this.query, this.To, this.mutatedKeys, 0 /* Local */ === this.mo);
+    xo() {
+        return Lo.fromInitialDocuments(this.query, this.Ao, this.mutatedKeys, 0 /* Local */ === this.To);
     }
 }
 
@@ -12834,7 +12842,7 @@ class ec {
          * decide whether it needs to manufacture a delete event for the target once
          * the target is CURRENT.
          */
-        this.Co = !1;
+        this.ko = !1;
     }
 }
 
@@ -12855,8 +12863,8 @@ class ec {
     // PORTING NOTE: Manages state synchronization in multi-tab environments.
     s, i, r) {
         this.localStore = t, this.remoteStore = e, this.eventManager = n, this.sharedClientState = s, 
-        this.currentUser = i, this.maxConcurrentLimboResolutions = r, this.No = {}, this.xo = new Wi((t => Pe(t)), be), 
-        this.ko = new Map, 
+        this.currentUser = i, this.maxConcurrentLimboResolutions = r, this.$o = {}, this.Oo = new Wi((t => Pe(t)), be), 
+        this.Fo = 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
@@ -12866,28 +12874,28 @@ class ec {
          * of arbitrary elements and it also maintains insertion order, providing the
          * desired queue-like FIFO semantics.
          */
-        this.$o = new Set, 
+        this.Mo = new Set, 
         /**
          * Keeps track of the target ID for each document that is in limbo with an
          * active target.
          */
-        this.Oo = new mn(Vt.comparator), 
+        this.Lo = new mn(Vt.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.Fo = new Map, this.Mo = new vr, 
+        this.Bo = new Map, this.Uo = new vr, 
         /** Stores user completion handlers, indexed by User and BatchId. */
-        this.Lo = {}, 
+        this.qo = {}, 
         /** Stores user callbacks waiting for all pending writes to be acknowledged. */
-        this.Bo = new Map, this.Uo = ki.ie(), this.onlineState = "Unknown" /* Unknown */ , 
+        this.Ko = new Map, this.jo = ki.ie(), this.onlineState = "Unknown" /* 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.qo = void 0;
+        this.Qo = void 0;
     }
     get isPrimaryClient() {
-        return !0 === this.qo;
+        return !0 === this.Qo;
     }
 }
 
@@ -12899,7 +12907,7 @@ class ec {
 async function ic(t, e) {
     const n = xc(t);
     let s, i;
-    const r = n.xo.get(e);
+    const r = n.Oo.get(e);
     if (r) 
     // PORTING NOTE: With Multi-Tab Web, it is possible that a query view
     // already exists when EventManager calls us for the first time. This
@@ -12907,7 +12915,7 @@ async function ic(t, e) {
     // 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.
-    s = r.targetId, n.sharedClientState.addLocalQueryTarget(s), i = r.view.Do(); else {
+    s = r.targetId, n.sharedClientState.addLocalQueryTarget(s), i = r.view.xo(); else {
         const t = await yr(n.localStore, Ae(e)), r = n.sharedClientState.addLocalQueryTarget(t.targetId);
         s = t.targetId, i = await rc(n, e, s, "current" === r), n.isPrimaryClient && uo(n.remoteStore, t);
     }
@@ -12921,29 +12929,29 @@ async function ic(t, e) {
     // 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.
-    t.Ko = (e, n, s) => async function(t, e, n, s) {
-        let i = e.view.Io(n);
+    t.Wo = (e, n, s) => async function(t, e, n, s) {
+        let i = e.view.bo(n);
         i.Ln && (
         // 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 Tr(t.localStore, e.query, 
-        /* usePreviousResults= */ !1).then((({documents: t}) => e.view.Io(t, i))));
+        /* usePreviousResults= */ !1).then((({documents: t}) => e.view.bo(t, i))));
         const r = s && s.targetChanges.get(e.targetId), o = e.view.applyChanges(i, 
         /* updateLimboDocuments= */ t.isPrimaryClient, r);
-        return yc(t, e.targetId, o.vo), o.snapshot;
+        return yc(t, e.targetId, o.Do), o.snapshot;
     }(t, e, n, s);
     const i = await Tr(t.localStore, e, 
-    /* usePreviousResults= */ !0), r = new tc(e, i.Gn), o = r.Io(i.documents), c = Nn.createSynthesizedTargetChangeForCurrentChange(n, s && "Offline" /* Offline */ !== t.onlineState), a = r.applyChanges(o, 
+    /* usePreviousResults= */ !0), r = new tc(e, i.Gn), o = r.bo(i.documents), c = Nn.createSynthesizedTargetChangeForCurrentChange(n, s && "Offline" /* Offline */ !== t.onlineState), a = r.applyChanges(o, 
     /* updateLimboDocuments= */ t.isPrimaryClient, c);
-    yc(t, n, a.vo);
+    yc(t, n, a.Do);
     const u = new ec(e, n, r);
-    return t.xo.set(e, u), t.ko.has(n) ? t.ko.get(n).push(e) : t.ko.set(n, [ e ]), a.snapshot;
+    return t.Oo.set(e, u), t.Fo.has(n) ? t.Fo.get(n).push(e) : t.Fo.set(n, [ e ]), a.snapshot;
 }
 
 /** Stops listening to the query. */ async function oc(t, e) {
-    const n = K(t), s = n.xo.get(e), i = n.ko.get(s.targetId);
-    if (i.length > 1) return n.ko.set(s.targetId, i.filter((t => !be(t, e)))), void n.xo.delete(e);
+    const n = K(t), s = n.Oo.get(e), i = n.Fo.get(s.targetId);
+    if (i.length > 1) return n.Fo.set(s.targetId, i.filter((t => !be(t, e)))), void n.Oo.delete(e);
     // No other queries are mapped to the target, clean up the query and the target.
         if (n.isPrimaryClient) {
         // We need to remove the local query target first to allow us to verify
@@ -12996,9 +13004,9 @@ async function ic(t, e) {
             })));
         }(s.localStore, e);
         s.sharedClientState.addPendingMutation(t.batchId), function(t, e, n) {
-            let s = t.Lo[t.currentUser.toKey()];
+            let s = t.qo[t.currentUser.toKey()];
             s || (s = new mn(nt));
-            s = s.insert(e, n), t.Lo[t.currentUser.toKey()] = s;
+            s = s.insert(e, n), t.qo[t.currentUser.toKey()] = s;
         }
         /**
  * Resolves or rejects the user callback for the given batch and then discards
@@ -13022,13 +13030,13 @@ async function ic(t, e) {
         const t = await _r(n.localStore, e);
         // Update `receivedDocument` as appropriate for any limbo targets.
                 e.targetChanges.forEach(((t, e) => {
-            const s = n.Fo.get(e);
+            const s = n.Bo.get(e);
             s && (
             // 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.
             U(t.addedDocuments.size + t.modifiedDocuments.size + t.removedDocuments.size <= 1), 
-            t.addedDocuments.size > 0 ? s.Co = !0 : t.modifiedDocuments.size > 0 ? U(s.Co) : t.removedDocuments.size > 0 && (U(s.Co), 
-            s.Co = !1));
+            t.addedDocuments.size > 0 ? s.ko = !0 : t.modifiedDocuments.size > 0 ? U(s.ko) : t.removedDocuments.size > 0 && (U(s.ko), 
+            s.ko = !1));
         })), await Ec(n, t, e);
     } catch (t) {
         await Li(t);
@@ -13046,8 +13054,8 @@ async function ic(t, e) {
     // SharedClientState.
         if (s.isPrimaryClient && 0 /* RemoteStore */ === n || !s.isPrimaryClient && 1 /* SharedClientState */ === n) {
         const t = [];
-        s.xo.forEach(((n, s) => {
-            const i = s.view.eo(e);
+        s.Oo.forEach(((n, s) => {
+            const i = s.view.io(e);
             i.snapshot && t.push(i.snapshot);
         })), function(t, e) {
             const n = K(t);
@@ -13056,9 +13064,9 @@ async function ic(t, e) {
             n.queries.forEach(((t, n) => {
                 for (const t of n.listeners) 
                 // Run global snapshot listeners if a consistent snapshot has been emitted.
-                t.eo(e) && (s = !0);
+                t.io(e) && (s = !0);
             })), s && Wo(n);
-        }(s.eventManager, e), t.length && s.No.Er(t), s.onlineState = e, s.isPrimaryClient && s.sharedClientState.setOnlineState(e);
+        }(s.eventManager, e), t.length && s.$o.Rr(t), s.onlineState = e, s.isPrimaryClient && s.sharedClientState.setOnlineState(e);
     }
 }
 
@@ -13076,7 +13084,7 @@ async function ic(t, e) {
     const s = K(t);
     // PORTING NOTE: Multi-tab only.
         s.sharedClientState.updateQueryState(e, "rejected", n);
-    const i = s.Fo.get(e), r = i && i.key;
+    const i = s.Bo.get(e), r = i && i.key;
     if (r) {
         // TODO(klimt): We really only should do the following on permission
         // denied errors, but we don't have the cause code here.
@@ -13095,7 +13103,7 @@ async function ic(t, e) {
         // 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.
-        s.Oo = s.Oo.remove(r), s.Fo.delete(e), Tc(s);
+        s.Lo = s.Lo.remove(r), s.Bo.delete(e), Tc(s);
     } else await pr(s.localStore, e, 
     /* keepPersistedTargetData */ !1).then((() => mc(s, e, n))).catch(Li);
 }
@@ -13156,8 +13164,8 @@ async function fc(t, e, n) {
         if (-1 === t) 
         // Trigger the callback right away if there is no pending writes at the moment.
         return void e.resolve();
-        const s = n.Bo.get(t) || [];
-        s.push(e), n.Bo.set(t, s);
+        const s = n.Ko.get(t) || [];
+        s.push(e), n.Ko.set(t, s);
     } catch (t) {
         const n = Oo(t, "Initialization of waitForPendingWrites() operation failed");
         e.reject(n);
@@ -13168,28 +13176,28 @@ async function fc(t, e, n) {
  * Triggers the callbacks that are waiting for this batch id to get acknowledged by server,
  * if there are any.
  */ function wc(t, e) {
-    (t.Bo.get(e) || []).forEach((t => {
+    (t.Ko.get(e) || []).forEach((t => {
         t.resolve();
-    })), t.Bo.delete(e);
+    })), t.Ko.delete(e);
 }
 
 /** Reject all outstanding callbacks waiting for pending writes to complete. */ function _c(t, e, n) {
     const s = K(t);
-    let i = s.Lo[s.currentUser.toKey()];
+    let i = s.qo[s.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 t = i.get(e);
-        t && (n ? t.reject(n) : t.resolve(), i = i.remove(e)), s.Lo[s.currentUser.toKey()] = i;
+        t && (n ? t.reject(n) : t.resolve(), i = i.remove(e)), s.qo[s.currentUser.toKey()] = i;
     }
 }
 
 function mc(t, e, n = null) {
     t.sharedClientState.removeLocalQueryTarget(e);
-    for (const s of t.ko.get(e)) t.xo.delete(s), n && t.No.jo(s, n);
-    if (t.ko.delete(e), t.isPrimaryClient) {
-        t.Mo.cs(e).forEach((e => {
-            t.Mo.containsKey(e) || 
+    for (const s of t.Fo.get(e)) t.Oo.delete(s), n && t.$o.Go(s, n);
+    if (t.Fo.delete(e), t.isPrimaryClient) {
+        t.Uo.cs(e).forEach((e => {
+            t.Uo.containsKey(e) || 
             // We removed the last reference for this key
             gc(t, e);
         }));
@@ -13197,17 +13205,17 @@ function mc(t, e, n = null) {
 }
 
 function gc(t, e) {
-    t.$o.delete(e.path.canonicalString());
+    t.Mo.delete(e.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 = t.Oo.get(e);
-    null !== n && (ho(t.remoteStore, n), t.Oo = t.Oo.remove(e), t.Fo.delete(n), Tc(t));
+    const n = t.Lo.get(e);
+    null !== n && (ho(t.remoteStore, n), t.Lo = t.Lo.remove(e), t.Bo.delete(n), Tc(t));
 }
 
 function yc(t, e, n) {
-    for (const s of n) if (s instanceof Xo) t.Mo.addReference(s.key, e), pc(t, s); else if (s instanceof Zo) {
-        O("SyncEngine", "Document no longer in limbo: " + s.key), t.Mo.removeReference(s.key, e);
-        t.Mo.containsKey(s.key) || 
+    for (const s of n) if (s instanceof Xo) t.Uo.addReference(s.key, e), pc(t, s); else if (s instanceof Zo) {
+        O("SyncEngine", "Document no longer in limbo: " + s.key), t.Uo.removeReference(s.key, e);
+        t.Uo.containsKey(s.key) || 
         // We removed the last reference for this key
         gc(t, s.key);
     } else B();
@@ -13215,7 +13223,7 @@ function yc(t, e, n) {
 
 function pc(t, e) {
     const n = e.key, s = n.path.canonicalString();
-    t.Oo.get(n) || t.$o.has(s) || (O("SyncEngine", "New document in limbo: " + n), t.$o.add(s), 
+    t.Lo.get(n) || t.Mo.has(s) || (O("SyncEngine", "New document in limbo: " + n), t.Mo.add(s), 
     Tc(t));
 }
 
@@ -13227,18 +13235,18 @@ function pc(t, e) {
  * with "resource exhausted" errors which can lead to pathological client
  * behavior as seen in https://github.com/firebase/firebase-js-sdk/issues/2683.
  */ function Tc(t) {
-    for (;t.$o.size > 0 && t.Oo.size < t.maxConcurrentLimboResolutions; ) {
-        const e = t.$o.values().next().value;
-        t.$o.delete(e);
-        const n = new Vt(lt.fromString(e)), s = t.Uo.next();
-        t.Fo.set(s, new nc(n)), t.Oo = t.Oo.insert(n, s), uo(t.remoteStore, new oi(Ae(me(n.path)), s, 2 /* LimboResolution */ , Z.T));
+    for (;t.Mo.size > 0 && t.Lo.size < t.maxConcurrentLimboResolutions; ) {
+        const e = t.Mo.values().next().value;
+        t.Mo.delete(e);
+        const n = new Vt(lt.fromString(e)), s = t.jo.next();
+        t.Bo.set(s, new nc(n)), t.Lo = t.Lo.insert(n, s), uo(t.remoteStore, new oi(Ae(me(n.path)), s, 2 /* LimboResolution */ , Z.T));
     }
 }
 
 async function Ec(t, e, n) {
     const s = K(t), i = [], r = [], o = [];
-    s.xo.isEmpty() || (s.xo.forEach(((t, c) => {
-        o.push(s.Ko(c, e, n).then((t => {
+    s.Oo.isEmpty() || (s.Oo.forEach(((t, c) => {
+        o.push(s.Wo(c, e, n).then((t => {
             if (t) {
                 s.isPrimaryClient && s.sharedClientState.updateQueryState(c.targetId, t.fromCache ? "not-current" : "current"), 
                 i.push(t);
@@ -13246,7 +13254,7 @@ async function Ec(t, e, n) {
                 r.push(e);
             }
         })));
-    })), await Promise.all(o), s.No.Er(i), await async function(t, e) {
+    })), await Promise.all(o), s.$o.Rr(i), await async function(t, e) {
         const n = K(t);
         try {
             await n.persistence.runTransaction("notifyLocalViewChanges", "readwrite", (t => Ws.forEach(e, (e => Ws.forEach(e.Nn, (s => n.persistence.referenceDelegate.addReference(t, e.targetId, s))).next((() => Ws.forEach(e.xn, (s => n.persistence.referenceDelegate.removeReference(t, e.targetId, s)))))))));
@@ -13277,11 +13285,11 @@ async function Ic(t, e) {
         n.currentUser = e, 
         // Fails tasks waiting for pending writes requested by previous user.
         function(t, e) {
-            t.Bo.forEach((t => {
+            t.Ko.forEach((t => {
                 t.forEach((t => {
                     t.reject(new Q(j.CANCELLED, e));
                 }));
-            })), t.Bo.clear();
+            })), t.Ko.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(e, t.removedBatchIds, t.addedBatchIds), await Ec(n, t.Wn);
@@ -13289,15 +13297,15 @@ async function Ic(t, e) {
 }
 
 function Ac(t, e) {
-    const n = K(t), s = n.Fo.get(e);
-    if (s && s.Co) return Vn().add(s.key);
+    const n = K(t), s = n.Bo.get(e);
+    if (s && s.ko) return Vn().add(s.key);
     {
         let t = Vn();
-        const s = n.ko.get(e);
+        const s = n.Fo.get(e);
         if (!s) return t;
         for (const e of s) {
-            const s = n.xo.get(e);
-            t = t.unionWith(s.view.Eo);
+            const s = n.Oo.get(e);
+            t = t.unionWith(s.view.Ro);
         }
         return t;
     }
@@ -13308,8 +13316,8 @@ function Ac(t, e) {
  * from persistence.
  */ async function Rc(t, e) {
     const n = K(t), s = await Tr(n.localStore, e.query, 
-    /* usePreviousResults= */ !0), i = e.view.So(s);
-    return n.isPrimaryClient && yc(n, e.targetId, i.vo), i;
+    /* usePreviousResults= */ !0), i = e.view.No(s);
+    return n.isPrimaryClient && yc(n, e.targetId, i.Do), i;
 }
 
 /**
@@ -13357,7 +13365,7 @@ async function Pc(t, e, n, s) {
 // PORTING NOTE: Multi-Tab only.
 async function vc(t, e) {
     const n = K(t);
-    if (xc(n), kc(n), !0 === e && !0 !== n.qo) {
+    if (xc(n), kc(n), !0 === e && !0 !== n.Qo) {
         // 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
@@ -13365,12 +13373,12 @@ async function vc(t, e) {
         // primary, we need to need to make sure that all views for all targets
         // match the state on disk.
         const t = n.sharedClientState.getAllActiveQueryTargets(), e = await Vc(n, t.toArray());
-        n.qo = !0, await No(n.remoteStore, !0);
+        n.Qo = !0, await No(n.remoteStore, !0);
         for (const t of e) uo(n.remoteStore, t);
-    } else if (!1 === e && !1 !== n.qo) {
+    } else if (!1 === e && !1 !== n.Qo) {
         const t = [];
         let e = Promise.resolve();
-        n.ko.forEach(((s, i) => {
+        n.Fo.forEach(((s, i) => {
             n.sharedClientState.isLocalQueryTarget(i) ? t.push(i) : e = e.then((() => (mc(n, i), 
             pr(n.localStore, i, 
             /*keepPersistedTargetData=*/ !0)))), ho(n.remoteStore, i);
@@ -13378,9 +13386,9 @@ async function vc(t, e) {
         // PORTING NOTE: Multi-Tab only.
         function(t) {
             const e = K(t);
-            e.Fo.forEach(((t, n) => {
+            e.Bo.forEach(((t, n) => {
                 ho(e.remoteStore, n);
-            })), e.Mo.us(), e.Fo = new Map, e.Oo = new mn(Vt.comparator);
+            })), e.Uo.us(), e.Bo = new Map, e.Lo = new mn(Vt.comparator);
         }
         /**
  * Reconcile the query views of the provided query targets with the state from
@@ -13393,7 +13401,7 @@ async function vc(t, e) {
  * tab to a primary tab
  */
         // PORTING NOTE: Multi-Tab only.
-        (n), n.qo = !1, await No(n.remoteStore, !1);
+        (n), n.Qo = !1, await No(n.remoteStore, !1);
     }
 }
 
@@ -13401,7 +13409,7 @@ async function Vc(t, e, n) {
     const s = K(t), i = [], r = [];
     for (const t of e) {
         let e;
-        const n = s.ko.get(t);
+        const n = s.Fo.get(t);
         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
@@ -13409,7 +13417,7 @@ async function Vc(t, e, n) {
             // state (the list of syncedDocuments may have gotten out of sync).
             e = await yr(s.localStore, Ae(n[0]));
             for (const t of n) {
-                const e = s.xo.get(t), n = await Rc(s, e);
+                const e = s.Oo.get(t), n = await Rc(s, e);
                 n.snapshot && r.push(n.snapshot);
             }
         } else {
@@ -13421,7 +13429,7 @@ async function Vc(t, e, n) {
         }
         i.push(e);
     }
-    return s.No.Er(r), i;
+    return s.$o.Rr(r), i;
 }
 
 /**
@@ -13450,10 +13458,10 @@ function Dc(t) {
 // PORTING NOTE: Multi-Tab only.
 async function Cc(t, e, n, s) {
     const i = K(t);
-    if (i.qo) 
+    if (i.Qo) 
     // If we receive a target state notification via WebStorage, we are
     // either already secondary or another tab has taken the primary lease.
-    O("SyncEngine", "Ignoring unexpected query state notification."); else if (i.ko.has(e)) switch (n) {
+    O("SyncEngine", "Ignoring unexpected query state notification."); else if (i.Fo.has(e)) switch (n) {
       case "current":
       case "not-current":
         {
@@ -13474,9 +13482,9 @@ async function Cc(t, e, n, s) {
 
 /** Adds or removes Watch targets for queries from different tabs. */ async function Nc(t, e, n) {
     const s = xc(t);
-    if (s.qo) {
+    if (s.Qo) {
         for (const t of e) {
-            if (s.ko.has(t)) {
+            if (s.Fo.has(t)) {
                 // A target might have been added in a previous attempt
                 O("SyncEngine", "Adding an already active target " + t);
                 continue;
@@ -13488,7 +13496,7 @@ async function Cc(t, e, n, s) {
         for (const t of n) 
         // Check that the target is still active since the target might have been
         // removed if it has been rejected by the backend.
-        s.ko.has(t) && 
+        s.Fo.has(t) && 
         // Release queries that are still active.
         await pr(s.localStore, t, 
         /* keepPersistedTargetData */ !1).then((() => {
@@ -13500,8 +13508,8 @@ async function Cc(t, e, n, s) {
 function xc(t) {
     const e = K(t);
     return e.remoteStore.remoteSyncer.applyRemoteEvent = ac.bind(null, e), e.remoteStore.remoteSyncer.getRemoteKeysForTarget = Ac.bind(null, e), 
-    e.remoteStore.remoteSyncer.rejectListen = hc.bind(null, e), e.No.Er = jo.bind(null, e.eventManager), 
-    e.No.jo = Qo.bind(null, e.eventManager), e;
+    e.remoteStore.remoteSyncer.rejectListen = hc.bind(null, e), e.$o.Rr = jo.bind(null, e.eventManager), 
+    e.$o.Go = Qo.bind(null, e.eventManager), e;
 }
 
 function kc(t) {
@@ -13540,10 +13548,10 @@ function kc(t) {
             }(s));
             n._updateProgress(Yo(s));
             const i = new Jo(s, t.localStore, e.N);
-            let r = await e.Qo();
+            let r = await e.zo();
             for (;r; ) {
-                const t = await i.fo(r);
-                t && n._updateProgress(t), r = await e.Qo();
+                const t = await i.mo(r);
+                t && n._updateProgress(t), r = await e.zo();
             }
             const o = await i.complete();
             // TODO(b/160876443): This currently raises snapshots with
@@ -13593,19 +13601,19 @@ class Oc {
         this.synchronizeTabs = !1;
     }
     async initialize(t) {
-        this.N = Zr(t.databaseInfo.databaseId), this.sharedClientState = this.Wo(t), this.persistence = this.Go(t), 
-        await this.persistence.start(), this.gcScheduler = this.zo(t), this.localStore = this.Ho(t);
+        this.N = Zr(t.databaseInfo.databaseId), this.sharedClientState = this.Ho(t), this.persistence = this.Jo(t), 
+        await this.persistence.start(), this.gcScheduler = this.Yo(t), this.localStore = this.Xo(t);
     }
-    zo(t) {
+    Yo(t) {
         return null;
     }
-    Ho(t) {
+    Xo(t) {
         return lr(this.persistence, new ur, t.initialUser, this.N);
     }
-    Go(t) {
+    Jo(t) {
         return new xr($r.Ns, this.N);
     }
-    Wo(t) {
+    Ho(t) {
         return new Qr;
     }
     async terminate() {
@@ -13618,29 +13626,29 @@ class Oc {
  * Provides all components needed for Firestore with IndexedDB persistence.
  */ class Fc extends Oc {
     constructor(t, e, n) {
-        super(), this.Jo = t, this.cacheSizeBytes = e, this.forceOwnership = n, this.synchronizeTabs = !1;
+        super(), this.Zo = t, this.cacheSizeBytes = e, this.forceOwnership = n, this.synchronizeTabs = !1;
     }
     async initialize(t) {
-        await super.initialize(t), await Ar(this.localStore), await this.Jo.initialize(this, t), 
+        await super.initialize(t), await Ar(this.localStore), await this.Zo.initialize(this, t), 
         // Enqueue writes from a previous session
-        await kc(this.Jo.syncEngine), await Ao(this.Jo.remoteStore), 
+        await kc(this.Zo.syncEngine), await Ao(this.Zo.remoteStore), 
         // NOTE: This will immediately call the listener, so we make sure to
         // set it after localStore / remoteStore are started.
         await this.persistence.nn((() => (this.gcScheduler && !this.gcScheduler.started && this.gcScheduler.start(this.localStore), 
         Promise.resolve())));
     }
-    Ho(t) {
+    Xo(t) {
         return lr(this.persistence, new ur, t.initialUser, this.N);
     }
-    zo(t) {
+    Yo(t) {
         const e = this.persistence.referenceDelegate.garbageCollector;
         return new qi(e, t.asyncQueue);
     }
-    Go(t) {
+    Jo(t) {
         const e = rr(t.databaseInfo.databaseId, t.databaseInfo.persistenceKey), n = void 0 !== this.cacheSizeBytes ? Pi.withCacheSize(this.cacheSizeBytes) : Pi.DEFAULT;
         return new nr(this.synchronizeTabs, e, t.clientId, n, t.asyncQueue, Yr(), Xr(), this.N, this.sharedClientState, !!this.forceOwnership);
     }
-    Wo(t) {
+    Ho(t) {
         return new Qr;
     }
 }
@@ -13654,11 +13662,11 @@ class Oc {
  * `synchronizeTabs` will be enabled.
  */ class Mc extends Fc {
     constructor(t, e) {
-        super(t, e, /* forceOwnership= */ !1), this.Jo = t, this.cacheSizeBytes = e, this.synchronizeTabs = !0;
+        super(t, e, /* forceOwnership= */ !1), this.Zo = t, this.cacheSizeBytes = e, this.synchronizeTabs = !0;
     }
     async initialize(t) {
         await super.initialize(t);
-        const e = this.Jo.syncEngine;
+        const e = this.Zo.syncEngine;
         this.sharedClientState instanceof jr && (this.sharedClientState.syncEngine = {
             _i: Pc.bind(null, e),
             mi: Cc.bind(null, e),
@@ -13669,10 +13677,10 @@ class Oc {
         // NOTE: This will immediately call the listener, so we make sure to
         // set it after localStore / remoteStore are started.
         await this.persistence.nn((async t => {
-            await vc(this.Jo.syncEngine, t), this.gcScheduler && (t && !this.gcScheduler.started ? this.gcScheduler.start(this.localStore) : t || this.gcScheduler.stop());
+            await vc(this.Zo.syncEngine, t), this.gcScheduler && (t && !this.gcScheduler.started ? this.gcScheduler.start(this.localStore) : t || this.gcScheduler.stop());
         }));
     }
-    Wo(t) {
+    Ho(t) {
         const e = Yr();
         if (!jr.bt(e)) throw new Q(j.UNIMPLEMENTED, "IndexedDB persistence is only available on platforms that support LocalStorage.");
         const n = rr(t.databaseInfo.databaseId, t.databaseInfo.persistenceKey);
@@ -13712,17 +13720,17 @@ class Oc {
         // PORTING NOTE: Manages state synchronization in multi-tab environments.
         s, i, r, o) {
             const c = new sc(t, e, n, s, i, r);
-            return o && (c.qo = !0), c;
+            return o && (c.Qo = !0), c;
         }(this.localStore, this.remoteStore, this.eventManager, this.sharedClientState, t.initialUser, t.maxConcurrentLimboResolutions, e);
     }
     terminate() {
         return async function(t) {
             const e = K(t);
-            O("RemoteStore", "RemoteStore shutting down."), e.Kr.add(5 /* Shutdown */), await ao(e), 
-            e.Qr.shutdown(), 
+            O("RemoteStore", "RemoteStore shutting down."), e.Wr.add(5 /* Shutdown */), await ao(e), 
+            e.zr.shutdown(), 
             // Set the OnlineState to Unknown (rather than Offline) to avoid potentially
             // triggering spurious listener events with cached data, etc.
-            e.Wr.set("Unknown" /* Unknown */);
+            e.Hr.set("Unknown" /* Unknown */);
         }(this.remoteStore);
     }
 }
@@ -13830,15 +13838,15 @@ class Uc {
         this.muted = !1;
     }
     next(t) {
-        this.observer.next && this.Yo(this.observer.next, t);
+        this.observer.next && this.tc(this.observer.next, t);
     }
     error(t) {
-        this.observer.error ? this.Yo(this.observer.error, t) : console.error("Uncaught Error in snapshot listener:", t);
+        this.observer.error ? this.tc(this.observer.error, t) : console.error("Uncaught Error in snapshot listener:", t);
     }
-    Xo() {
+    ec() {
         this.muted = !0;
     }
-    Yo(t, e) {
+    tc(t, e) {
         this.muted || setTimeout((() => {
             this.muted || t(e);
         }), 0);
@@ -13870,28 +13878,28 @@ class Uc {
     constructor(
     /** The reader to read from underlying binary bundle data source. */
     t, e) {
-        this.Zo = t, this.N = e, 
+        this.nc = t, this.N = e, 
         /** Cached bundle metadata. */
         this.metadata = new W, 
         /**
          * Internal buffer to hold bundle content, accumulating incomplete element
          * content.
          */
-        this.buffer = new Uint8Array, this.tc = new TextDecoder("utf-8"), 
+        this.buffer = new Uint8Array, this.sc = new TextDecoder("utf-8"), 
         // Read the metadata (which is the first element).
-        this.ec().then((t => {
-            t && t.ho() ? this.metadata.resolve(t.payload.metadata) : this.metadata.reject(new Error(`The first element of the bundle is not a metadata, it is\n             ${JSON.stringify(null == t ? void 0 : t.payload)}`));
+        this.ic().then((t => {
+            t && t.wo() ? this.metadata.resolve(t.payload.metadata) : this.metadata.reject(new Error(`The first element of the bundle is not a metadata, it is\n             ${JSON.stringify(null == t ? void 0 : t.payload)}`));
         }), (t => this.metadata.reject(t)));
     }
     close() {
-        return this.Zo.cancel();
+        return this.nc.cancel();
     }
     async getMetadata() {
         return this.metadata.promise;
     }
-    async Qo() {
+    async zo() {
         // Makes sure metadata is read before proceeding.
-        return await this.getMetadata(), this.ec();
+        return await this.getMetadata(), this.ic();
     }
     /**
      * Reads from the head of internal buffer, and pulling more data from
@@ -13902,15 +13910,15 @@ class Uc {
      *
      * Returns either the bundled element, or null if we have reached the end of
      * the stream.
-     */    async ec() {
-        const t = await this.nc();
+     */    async ic() {
+        const t = await this.rc();
         if (null === t) return null;
-        const e = this.tc.decode(t), n = Number(e);
-        isNaN(n) && this.sc(`length string (${e}) is not valid number`);
-        const s = await this.ic(n);
+        const e = this.sc.decode(t), n = Number(e);
+        isNaN(n) && this.oc(`length string (${e}) is not valid number`);
+        const s = await this.cc(n);
         return new zo(JSON.parse(s), t.length + n);
     }
-    /** First index of '{' from the underlying buffer. */    rc() {
+    /** First index of '{' from the underlying buffer. */    ac() {
         return this.buffer.findIndex((t => t === "{".charCodeAt(0)));
     }
     /**
@@ -13918,17 +13926,17 @@ class Uc {
      * return the content.
      *
      * If reached end of the stream, returns a null.
-     */    async nc() {
-        for (;this.rc() < 0; ) {
-            if (await this.oc()) break;
+     */    async rc() {
+        for (;this.ac() < 0; ) {
+            if (await this.uc()) 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 t = this.rc();
+        const t = this.ac();
         // Broke out of the loop because underlying stream is closed, but still
         // cannot find an open bracket.
-                t < 0 && this.sc("Reached the end of bundle when a length string is expected.");
+                t < 0 && this.oc("Reached the end of bundle when a length string is expected.");
         const e = this.buffer.slice(0, t);
         // Update the internal buffer to drop the read length.
                 return this.buffer = this.buffer.slice(t), e;
@@ -13938,23 +13946,23 @@ class Uc {
      * number of bytes, pulling more data from the underlying stream if needed.
      *
      * Returns a string decoded from the read bytes.
-     */    async ic(t) {
+     */    async cc(t) {
         for (;this.buffer.length < t; ) {
-            await this.oc() && this.sc("Reached the end of bundle when more is expected.");
+            await this.uc() && this.oc("Reached the end of bundle when more is expected.");
         }
-        const e = this.tc.decode(this.buffer.slice(0, t));
+        const e = this.sc.decode(this.buffer.slice(0, t));
         // Update the internal buffer to drop the read json string.
                 return this.buffer = this.buffer.slice(t), e;
     }
-    sc(t) {
+    oc(t) {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        throw this.Zo.cancel(), new Error(`Invalid bundle format: ${t}`);
+        throw this.nc.cancel(), new Error(`Invalid bundle format: ${t}`);
     }
     /**
      * Pulls more data from underlying stream to internal buffer.
      * Returns a boolean indicating whether the stream is finished.
-     */    async oc() {
-        const t = await this.Zo.read();
+     */    async uc() {
+        const t = await this.nc.read();
         if (!t.done) {
             const e = new Uint8Array(this.buffer.length + t.value.length);
             e.set(this.buffer), e.set(t.value, this.buffer.length), this.buffer = e;
@@ -14127,26 +14135,26 @@ class Kc {
 class jc {
     constructor(t, e, n, s) {
         this.asyncQueue = t, this.datastore = e, this.updateFunction = n, this.deferred = s, 
-        this.cc = 5, this.rr = new to(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.hc = 5, this.ar = new to(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */    run() {
-        this.cc -= 1, this.ac();
+        this.hc -= 1, this.lc();
     }
-    ac() {
-        this.rr.Xi((async () => {
-            const t = new Kc(this.datastore), e = this.uc(t);
+    lc() {
+        this.ar.Xi((async () => {
+            const t = new Kc(this.datastore), e = this.fc(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
                     this.deferred.resolve(e);
                 })).catch((t => {
-                    this.hc(t);
+                    this.dc(t);
                 }))));
             })).catch((t => {
-                this.hc(t);
+                this.dc(t);
             }));
         }));
     }
-    uc(t) {
+    fc(t) {
         try {
             const e = this.updateFunction(t);
             return !bt(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
@@ -14156,11 +14164,11 @@ class jc {
             return this.deferred.reject(t), null;
         }
     }
-    hc(t) {
-        this.cc > 0 && this.lc(t) ? (this.cc -= 1, this.asyncQueue.enqueueAndForget((() => (this.ac(), 
+    dc(t) {
+        this.hc > 0 && this.wc(t) ? (this.hc -= 1, this.asyncQueue.enqueueAndForget((() => (this.lc(), 
         Promise.resolve())))) : this.deferred.reject(t);
     }
-    lc(t) {
+    wc(t) {
         if ("FirebaseError" === t.name) {
             // In transactions, the backend will fail outdated reads with FAILED_PRECONDITION and
             // non-matching document versions with ABORTED. These errors should be retried.
@@ -14274,10 +14282,10 @@ async function Gc(t, e) {
         // 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.Kr.add(3 /* CredentialChange */), await ao(n), s && 
+                n.Wr.add(3 /* CredentialChange */), await ao(n), s && 
         // Don't set the network status to Unknown if we are offline.
-        n.Wr.set("Unknown" /* Unknown */), await n.remoteSyncer.handleCredentialChange(e), 
-        n.Kr.delete(3 /* CredentialChange */), await co(n);
+        n.Hr.set("Unknown" /* Unknown */), await n.remoteSyncer.handleCredentialChange(e), 
+        n.Wr.delete(3 /* CredentialChange */), await co(n);
     }(e.remoteStore, t))), t.onlineComponents = e;
 }
 
@@ -14318,7 +14326,7 @@ async function ta(t) {
         const e = await Jc(t), n = await Xc(t);
         return e.setNetworkEnabled(!0), function(t) {
             const e = K(t);
-            return e.Kr.delete(0 /* UserDisabled */), co(e);
+            return e.Wr.delete(0 /* UserDisabled */), co(e);
         }(n);
     }));
 }
@@ -14328,9 +14336,9 @@ async function ta(t) {
         const e = await Jc(t), n = await Xc(t);
         return e.setNetworkEnabled(!1), async function(t) {
             const e = K(t);
-            e.Kr.add(0 /* UserDisabled */), await ao(e), 
+            e.Wr.add(0 /* UserDisabled */), await ao(e), 
             // Set the OnlineState to Offline so get()s return from cache, etc.
-            e.Wr.set("Offline" /* Offline */);
+            e.Hr.set("Offline" /* Offline */);
         }(n);
     }));
 }
@@ -14381,7 +14389,7 @@ function ia(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new Go(me(n.path), r, {
             includeMetadataChanges: !0,
-            uo: !0
+            fo: !0
         });
         return qo(t, o);
     }(await ta(t), t.asyncQueue, e, n, s))), s.promise;
@@ -14392,7 +14400,7 @@ function ra(t, e) {
     return t.asyncQueue.enqueueAndForget((async () => async function(t, e, n) {
         try {
             const s = await Tr(t, e, 
-            /* usePreviousResults= */ !0), i = new tc(e, s.Gn), r = i.Io(s.documents), o = i.applyChanges(r, 
+            /* usePreviousResults= */ !0), i = new tc(e, s.Gn), r = i.bo(s.documents), o = i.applyChanges(r, 
             /* updateLimboDocuments= */ !1);
             n.resolve(o.snapshot);
         } catch (t) {
@@ -14418,7 +14426,7 @@ function oa(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new Go(n, r, {
             includeMetadataChanges: !0,
-            uo: !0
+            fo: !0
         });
         return qo(t, o);
     }(await ta(t), t.asyncQueue, e, n, s))), s.promise;
@@ -14427,13 +14435,13 @@ function oa(t, e, n = {}) {
 function ca(t, e) {
     const n = new Uc(e);
     return t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-        K(t).Zr.add(e), 
+        K(t).so.add(e), 
         // Immediately fire an initial event, indicating all existing listeners
         // are in-sync.
         e.next();
     }(await ta(t), n))), () => {
-        n.Xo(), t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-            K(t).Zr.delete(e);
+        n.ec(), t.asyncQueue.enqueueAndForget((async () => function(t, e) {
+            K(t).so.delete(e);
         }(await ta(t), n)));
     };
 }
@@ -15038,39 +15046,39 @@ function Sa(t, e, ...n) {
  */ class Na {
     constructor() {
         // The last promise in the queue.
-        this.fc = Promise.resolve(), 
+        this._c = Promise.resolve(), 
         // A list of retryable operations. Retryable operations are run in order and
         // retried with backoff.
-        this.dc = [], 
+        this.mc = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.wc = !1, 
+        this.gc = !1, 
         // Operations scheduled to be queued in the future. Operations are
         // automatically removed after they are run or canceled.
-        this._c = [], 
+        this.yc = [], 
         // visible for testing
-        this.mc = null, 
+        this.Tc = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.gc = !1, 
+        this.Ec = !1, 
         // Enabled during shutdown on Safari to prevent future access to IndexedDB.
-        this.yc = !1, 
+        this.Ic = !1, 
         // List of TimerIds to fast-forward delays for.
-        this.Tc = [], 
+        this.Ac = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.rr = new to(this, "async_queue_retry" /* AsyncQueueRetry */), 
+        this.ar = new to(this, "async_queue_retry" /* 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 t = Xr();
-            t && O("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.rr.tr();
+            t && O("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.ar.tr();
         };
         const t = Xr();
-        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Ec);
+        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Rc);
     }
     get isShuttingDown() {
-        return this.wc;
+        return this.gc;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -15080,44 +15088,44 @@ function Sa(t, e, ...n) {
         this.enqueue(t);
     }
     enqueueAndForgetEvenWhileRestricted(t) {
-        this.Ic(), 
+        this.bc(), 
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.Ac(t);
+        this.Pc(t);
     }
     enterRestrictedMode(t) {
-        if (!this.wc) {
-            this.wc = !0, this.yc = t || !1;
+        if (!this.gc) {
+            this.gc = !0, this.Ic = t || !1;
             const e = Xr();
-            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Ec);
+            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Rc);
         }
     }
     enqueue(t) {
-        if (this.Ic(), this.wc) 
+        if (this.bc(), this.gc) 
         // 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 e = new W;
-        return this.Ac((() => this.wc && this.yc ? Promise.resolve() : (t().then(e.resolve, e.reject), 
+        return this.Pc((() => this.gc && this.Ic ? Promise.resolve() : (t().then(e.resolve, e.reject), 
         e.promise))).then((() => e.promise));
     }
     enqueueRetryable(t) {
-        this.enqueueAndForget((() => (this.dc.push(t), this.Rc())));
+        this.enqueueAndForget((() => (this.mc.push(t), this.vc())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async Rc() {
-        if (0 !== this.dc.length) {
+     */    async vc() {
+        if (0 !== this.mc.length) {
             try {
-                await this.dc[0](), this.dc.shift(), this.rr.reset();
+                await this.mc[0](), this.mc.shift(), this.ar.reset();
             } catch (t) {
                 if (!Ys(t)) throw t;
  // Failure will be handled by AsyncQueue
                                 O("AsyncQueue", "Operation failed with retryable error: " + t);
             }
-            this.dc.length > 0 && 
+            this.mc.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
@@ -15128,12 +15136,12 @@ function Sa(t, e, ...n) {
             // Since `backoffAndRun()` cancels an existing backoff and schedules a
             // new backoff on every call, there is only ever a single additional
             // operation in the queue.
-            this.rr.Xi((() => this.Rc()));
+            this.ar.Xi((() => this.vc()));
         }
     }
-    Ac(t) {
-        const e = this.fc.then((() => (this.gc = !0, t().catch((t => {
-            this.mc = t, this.gc = !1;
+    Pc(t) {
+        const e = this._c.then((() => (this.Ec = !0, t().catch((t => {
+            this.Tc = t, this.Ec = !1;
             const e = 
             /**
  * Chrome includes Error.message in Error.stack. Other browsers do not.
@@ -15165,38 +15173,38 @@ function Sa(t, e, ...n) {
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw F("INTERNAL UNHANDLED ERROR: ", e), t;
-        })).then((t => (this.gc = !1, t))))));
-        return this.fc = e, e;
+        })).then((t => (this.Ec = !1, t))))));
+        return this._c = e, e;
     }
     enqueueAfterDelay(t, e, n) {
-        this.Ic(), 
+        this.bc(), 
         // Fast-forward delays for timerIds that have been overriden.
-        this.Tc.indexOf(t) > -1 && (e = 0);
-        const s = $o.createAndSchedule(this, t, e, n, (t => this.bc(t)));
-        return this._c.push(s), s;
+        this.Ac.indexOf(t) > -1 && (e = 0);
+        const s = $o.createAndSchedule(this, t, e, n, (t => this.Vc(t)));
+        return this.yc.push(s), s;
     }
-    Ic() {
-        this.mc && B();
+    bc() {
+        this.Tc && B();
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async Pc() {
+     */    async Sc() {
         // 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 t;
         do {
-            t = this.fc, await t;
-        } while (t !== this.fc);
+            t = this._c, await t;
+        } while (t !== this._c);
     }
     /**
      * For Tests: Determine if a delayed operation with a particular TimerId
      * exists.
-     */    vc(t) {
-        for (const e of this._c) if (e.timerId === t) return !0;
+     */    Dc(t) {
+        for (const e of this.yc) if (e.timerId === t) return !0;
         return !1;
     }
     /**
@@ -15205,24 +15213,24 @@ function Sa(t, e, ...n) {
      * @param lastTimerId - Delayed operations up to and including this TimerId
      * will be drained. Pass TimerId.All to run all delayed operations.
      * @returns a Promise that resolves once all operations have been run.
-     */    Vc(t) {
+     */    Cc(t) {
         // Note that draining may generate more delayed ops, so we do that first.
-        return this.Pc().then((() => {
+        return this.Sc().then((() => {
             // Run ops in the same order they'd run if they ran naturally.
-            this._c.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
-            for (const e of this._c) if (e.skipDelay(), "all" /* All */ !== t && e.timerId === t) break;
-            return this.Pc();
+            this.yc.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
+            for (const e of this.yc) if (e.skipDelay(), "all" /* All */ !== t && e.timerId === t) break;
+            return this.Sc();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    Sc(t) {
-        this.Tc.push(t);
+     */    Nc(t) {
+        this.Ac.push(t);
     }
-    /** Called once a DelayedOperation is run or canceled. */    bc(t) {
+    /** Called once a DelayedOperation is run or canceled. */    Vc(t) {
         // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.
-        const e = this._c.indexOf(t);
-        this._c.splice(e, 1);
+        const e = this.yc.indexOf(t);
+        this.yc.splice(e, 1);
     }
 }
 
@@ -15962,55 +15970,55 @@ function ou(t) {
         this.settings = t, this.databaseId = e, this.N = n, this.ignoreUndefinedProperties = s, 
         // 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.Dc(), this.fieldTransforms = i || [], this.fieldMask = r || [];
+        void 0 === i && this.xc(), this.fieldTransforms = i || [], this.fieldMask = r || [];
     }
     get path() {
         return this.settings.path;
     }
-    get Cc() {
-        return this.settings.Cc;
+    get kc() {
+        return this.settings.kc;
     }
-    /** Returns a new context with the specified settings overwritten. */    Nc(t) {
+    /** Returns a new context with the specified settings overwritten. */    $c(t) {
         return new cu(Object.assign(Object.assign({}, this.settings), t), this.databaseId, this.N, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
     }
-    xc(t) {
+    Oc(t) {
         var e;
-        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.Nc({
+        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.$c({
             path: n,
-            kc: !1
+            Fc: !1
         });
-        return s.$c(t), s;
+        return s.Mc(t), s;
     }
-    Oc(t) {
+    Lc(t) {
         var e;
-        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.Nc({
+        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.$c({
             path: n,
-            kc: !1
+            Fc: !1
         });
-        return s.Dc(), s;
+        return s.xc(), s;
     }
-    Fc(t) {
+    Bc(t) {
         // TODO(b/34871131): We don't support array paths right now; so make path
         // undefined.
-        return this.Nc({
+        return this.$c({
             path: void 0,
-            kc: !0
+            Fc: !0
         });
     }
-    Mc(t) {
-        return vu(t, this.settings.methodName, this.settings.Lc || !1, this.path, this.settings.Bc);
+    Uc(t) {
+        return vu(t, this.settings.methodName, this.settings.qc || !1, this.path, this.settings.Kc);
     }
     /** Returns 'true' if 'fieldPath' was traversed when creating this context. */    contains(t) {
         return void 0 !== this.fieldMask.find((e => t.isPrefixOf(e))) || void 0 !== this.fieldTransforms.find((e => t.isPrefixOf(e.field)));
     }
-    Dc() {
+    xc() {
         // TODO(b/34871131): Remove null check once we have proper paths for fields
         // within arrays.
-        if (this.path) for (let t = 0; t < this.path.length; t++) this.$c(this.path.get(t));
+        if (this.path) for (let t = 0; t < this.path.length; t++) this.Mc(this.path.get(t));
     }
-    $c(t) {
-        if (0 === t.length) throw this.Mc("Document fields must not be empty");
-        if (ou(this.Cc) && su.test(t)) throw this.Mc('Document fields cannot begin and end with "__"');
+    Mc(t) {
+        if (0 === t.length) throw this.Uc("Document fields must not be empty");
+        if (ou(this.kc) && su.test(t)) throw this.Uc('Document fields cannot begin and end with "__"');
     }
 }
 
@@ -16021,14 +16029,14 @@ function ou(t) {
     constructor(t, e, n) {
         this.databaseId = t, this.ignoreUndefinedProperties = e, this.N = n || Zr(t);
     }
-    /** Creates a new top-level parse context. */    Uc(t, e, n, s = !1) {
+    /** Creates a new top-level parse context. */    jc(t, e, n, s = !1) {
         return new cu({
-            Cc: t,
+            kc: t,
             methodName: e,
-            Bc: n,
+            Kc: n,
             path: dt.emptyPath(),
-            kc: !1,
-            Lc: s
+            Fc: !1,
+            qc: s
         }, this.databaseId, this.N, this.ignoreUndefinedProperties);
     }
 }
@@ -16039,7 +16047,7 @@ function uu(t) {
 }
 
 /** Parse document data from a set() call. */ function hu(t, e, n, s, i, r = {}) {
-    const o = t.Uc(r.merge || r.mergeFields ? 2 /* MergeSet */ : 0 /* Set */ , e, n, i);
+    const o = t.jc(r.merge || r.mergeFields ? 2 /* MergeSet */ : 0 /* Set */ , e, n, i);
     Au("Data must be an object, but it was:", o, s);
     const c = Eu(s, o);
     let a, u;
@@ -16057,7 +16065,7 @@ function uu(t) {
 
 class lu extends eu {
     _toFieldTransform(t) {
-        if (2 /* MergeSet */ !== t.Cc) throw 1 /* Update */ === t.Cc ? t.Mc(`${this._methodName}() can only appear at the top level of your update data`) : t.Mc(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
+        if (2 /* MergeSet */ !== t.kc) throw 1 /* Update */ === t.kc ? t.Uc(`${this._methodName}() can only appear at the top level of your update data`) : t.Uc(`${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 t.fieldMask.push(t.path), null;
@@ -16084,10 +16092,10 @@ class lu extends eu {
  * @param arrayElement - Whether or not the FieldValue has an array.
  */ function fu(t, e, n) {
     return new cu({
-        Cc: 3 /* Argument */ ,
-        Bc: e.settings.Bc,
+        kc: 3 /* Argument */ ,
+        Kc: e.settings.Kc,
         methodName: t._methodName,
-        kc: n
+        Fc: n
     }, e.databaseId, e.N, e.ignoreUndefinedProperties);
 }
 
@@ -16102,11 +16110,11 @@ class du extends eu {
 
 class wu extends eu {
     constructor(t, e) {
-        super(t), this.qc = e;
+        super(t), this.Qc = e;
     }
     _toFieldTransform(t) {
         const e = fu(this, t, 
-        /*array=*/ !0), n = this.qc.map((t => Tu(t, e))), s = new Le(n);
+        /*array=*/ !0), n = this.Qc.map((t => Tu(t, e))), s = new Le(n);
         return new We(t.path, s);
     }
     isEqual(t) {
@@ -16117,11 +16125,11 @@ class wu extends eu {
 
 class _u extends eu {
     constructor(t, e) {
-        super(t), this.qc = e;
+        super(t), this.Qc = e;
     }
     _toFieldTransform(t) {
         const e = fu(this, t, 
-        /*array=*/ !0), n = this.qc.map((t => Tu(t, e))), s = new Ue(n);
+        /*array=*/ !0), n = this.Qc.map((t => Tu(t, e))), s = new Ue(n);
         return new We(t.path, s);
     }
     isEqual(t) {
@@ -16132,10 +16140,10 @@ class _u extends eu {
 
 class mu extends eu {
     constructor(t, e) {
-        super(t), this.Kc = e;
+        super(t), this.Wc = e;
     }
     _toFieldTransform(t) {
-        const e = new Ke(t.N, xe(t.N, this.Kc));
+        const e = new Ke(t.N, xe(t.N, this.Wc));
         return new We(t.path, e);
     }
     isEqual(t) {
@@ -16145,7 +16153,7 @@ class mu extends eu {
 }
 
 /** Parse update data from an update() call. */ function gu(t, e, n, s) {
-    const i = t.Uc(1 /* Update */ , e, n);
+    const i = t.jc(1 /* Update */ , e, n);
     Au("Data must be an object, but it was:", i, s);
     const r = [], o = Kt.empty();
     at(s, ((t, s) => {
@@ -16153,7 +16161,7 @@ class mu extends eu {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 s = p(s);
-        const a = i.Oc(c);
+        const a = i.Lc(c);
         if (s instanceof lu) 
         // Add it to the field mask, but don't add anything to updateData.
         r.push(c); else {
@@ -16166,7 +16174,7 @@ class mu extends eu {
 }
 
 /** Parse update data from a list of field/value arguments. */ function yu(t, e, n, s, i, r) {
-    const o = t.Uc(1 /* Update */ , e, n), c = [ Ru(e, s, n) ], a = [ i ];
+    const o = t.jc(1 /* Update */ , e, n), c = [ Ru(e, s, n) ], a = [ i ];
     if (r.length % 2 != 0) throw new Q(j.INVALID_ARGUMENT, `Function ${e}() needs to be called with an even number of arguments that alternate between field names and values.`);
     for (let t = 0; t < r.length; t += 2) c.push(Ru(e, r[t])), a.push(r[t + 1]);
     const u = [], h = Kt.empty();
@@ -16178,7 +16186,7 @@ class mu extends eu {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = p(n);
-        const s = o.Oc(e);
+        const s = o.Lc(e);
         if (n instanceof lu) 
         // Add it to the field mask, but don't add anything to updateData.
         u.push(e); else {
@@ -16197,7 +16205,7 @@ class mu extends eu {
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
  */ function pu(t, e, n, s = !1) {
-    return Tu(n, t.Uc(s ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
+    return Tu(n, t.jc(s ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
 }
 
 /**
@@ -16225,8 +16233,8 @@ class mu extends eu {
  */
     return function(t, e) {
         // Sentinels are only supported with writes, and not within arrays.
-        if (!ou(e.Cc)) throw e.Mc(`${t._methodName}() can only be used with update() and set()`);
-        if (!e.path) throw e.Mc(`${t._methodName}() is not currently supported inside arrays`);
+        if (!ou(e.kc)) throw e.Uc(`${t._methodName}() can only be used with update() and set()`);
+        if (!e.path) throw e.Uc(`${t._methodName}() is not currently supported inside arrays`);
         const n = t._toFieldTransform(e);
         n && e.fieldTransforms.push(n);
     }
@@ -16250,12 +16258,12 @@ class mu extends eu {
         // 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 (e.settings.kc && 4 /* ArrayArgument */ !== e.Cc) throw e.Mc("Nested arrays are not supported");
+        if (e.settings.Fc && 4 /* ArrayArgument */ !== e.kc) throw e.Uc("Nested arrays are not supported");
         return function(t, e) {
             const n = [];
             let s = 0;
             for (const i of t) {
-                let t = Tu(i, e.Fc(s));
+                let t = Tu(i, e.Bc(s));
                 null == t && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -16307,12 +16315,12 @@ class mu extends eu {
         };
         if (t instanceof Ra) {
             const n = e.databaseId, s = t.firestore._databaseId;
-            if (!s.isEqual(n)) throw e.Mc(`Document reference is for database ${s.projectId}/${s.database} but should be for database ${n.projectId}/${n.database}`);
+            if (!s.isEqual(n)) throw e.Uc(`Document reference is for database ${s.projectId}/${s.database} but should be for database ${n.projectId}/${n.database}`);
             return {
                 referenceValue: Gn(t.firestore._databaseId || e.databaseId, t._key.path)
             };
         }
-        throw e.Mc(`Unsupported field value: ${ya(t)}`);
+        throw e.Uc(`Unsupported field value: ${ya(t)}`);
     }
     /**
  * Checks whether an object looks like a JSON object that should be converted
@@ -16329,7 +16337,7 @@ function Eu(t, e) {
     // If we encounter an empty object, we explicitly add it to the update
     // mask to ensure that the server creates a map entry.
     e.path && e.path.length > 0 && e.fieldMask.push(e.path) : at(t, ((t, s) => {
-        const i = Tu(s, e.xc(t));
+        const i = Tu(s, e.Oc(t));
         null != i && (n[t] = i);
     })), {
         mapValue: {
@@ -16347,7 +16355,7 @@ function Au(t, e, n) {
         return "object" == typeof t && null !== t && (Object.getPrototypeOf(t) === Object.prototype || null === Object.getPrototypeOf(t));
     }(n)) {
         const s = ya(n);
-        throw "an object" === s ? e.Mc(t + " a custom object") : e.Mc(t + " " + s);
+        throw "an object" === s ? e.Uc(t + " a custom object") : e.Uc(t + " " + s);
     }
 }
 
@@ -16796,7 +16804,7 @@ function Ou(t) {
 
 class Uu extends Lu {
     constructor(t, e, n) {
-        super(), this.jc = t, this.Qc = e, this.Wc = n, this.type = "where";
+        super(), this.Gc = t, this.zc = e, this.Hc = n, this.type = "where";
     }
     _apply(t) {
         const e = uu(t.firestore), n = function(t, e, n, s, i, r, o) {
@@ -16865,7 +16873,7 @@ class Uu extends Lu {
                 // Special case when it's a duplicate op to give a slightly clearer error message.
                 throw n === e.op ? new Q(j.INVALID_ARGUMENT, `Invalid query. You cannot use more than one '${e.op.toString()}' filter.`) : new Q(j.INVALID_ARGUMENT, `Invalid query. You cannot use '${e.op.toString()}' filters with '${n.toString()}' filters.`);
             }(t, a), a;
-        }(t._query, "where", e, t.firestore._databaseId, this.jc, this.Qc, this.Wc);
+        }(t._query, "where", e, t.firestore._databaseId, this.Gc, this.zc, this.Hc);
         return new ba(t.firestore, t.converter, function(t, e) {
             const n = t.filters.concat([ e ]);
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), n, t.limit, t.limitType, t.startAt, t.endAt);
@@ -16890,7 +16898,7 @@ class Uu extends Lu {
 
 class Ku extends Lu {
     constructor(t, e) {
-        super(), this.jc = t, this.Gc = e, this.type = "orderBy";
+        super(), this.Gc = t, this.Jc = e, this.type = "orderBy";
     }
     _apply(t) {
         const e = function(t, e, n) {
@@ -16915,7 +16923,7 @@ class Ku extends Lu {
  * Will throw if the document does not contain all fields of the order by
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
- */ (t._query, this.jc, this.Gc);
+ */ (t._query, this.Gc, this.Jc);
         return new ba(t.firestore, t.converter, function(t, e) {
             // TODO(dimond): validate that orderBy does not list the same key twice.
             const n = t.explicitOrderBy.concat([ e ]);
@@ -16939,10 +16947,10 @@ class Ku extends Lu {
 
 class Qu extends Lu {
     constructor(t, e, n) {
-        super(), this.type = t, this.zc = e, this.Hc = n;
+        super(), this.type = t, this.Yc = e, this.Xc = n;
     }
     _apply(t) {
-        return new ba(t.firestore, t.converter, Re(t._query, this.zc, this.Hc));
+        return new ba(t.firestore, t.converter, Re(t._query, this.Yc, this.Xc));
     }
 }
 
@@ -16969,10 +16977,10 @@ class Qu extends Lu {
 
 class zu extends Lu {
     constructor(t, e, n) {
-        super(), this.type = t, this.Jc = e, this.Yc = n;
+        super(), this.type = t, this.Zc = e, this.ta = n;
     }
     _apply(t) {
-        const e = th(t, this.type, this.Jc, this.Yc);
+        const e = th(t, this.type, this.Zc, this.ta);
         return new ba(t.firestore, t.converter, function(t, e) {
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, e, t.endAt);
         }(t._query, e));
@@ -16990,10 +16998,10 @@ function Ju(...t) {
 
 class Yu extends Lu {
     constructor(t, e, n) {
-        super(), this.type = t, this.Jc = e, this.Yc = n;
+        super(), this.type = t, this.Zc = e, this.ta = n;
     }
     _apply(t) {
-        const e = th(t, this.type, this.Jc, this.Yc);
+        const e = th(t, this.type, this.Zc, this.ta);
         return new ba(t.firestore, t.converter, function(t, e) {
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, t.startAt, e);
         }(t._query, e));
@@ -17528,7 +17536,7 @@ function Th(t, ...e) {
     return function(t, e, n, s) {
         const i = new Uc(s), r = new Go(e, i, n);
         return t.asyncQueue.enqueueAndForget((async () => qo(await ta(t), r))), () => {
-            i.Xo(), t.asyncQueue.enqueueAndForget((async () => Ko(await ta(t), r)));
+            i.ec(), t.asyncQueue.enqueueAndForget((async () => Ko(await ta(t), r)));
         };
     }(La(u), h, c, a);
 }
@@ -17657,7 +17665,7 @@ function Eh(t, e) {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */ function bh(t, e) {
-    return aa(La(t), (n => e(new Rh(t, n))));
+    return aa(La(t = pa(t, Oa)), (n => e(new Rh(t, n))));
 }
 
 /**
@@ -17790,18 +17798,18 @@ function Eh(t, e) {
  * 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.
- */ var Nh;
-
-Nh = "rn", function(t) {
-    N = t;
-}(i), n(new r("firestore", ((t, {options: e}) => {
-    const n = t.getProvider("app").getImmediate(), s = new Oa(n, new J(t.getProvider("auth-internal")));
-    return e = Object.assign({
-        useFetchStreams: !0
-    }, e), s._setSettings(e), s;
-}), "PUBLIC" /* PUBLIC */)), s(D, "3.1.1", Nh), 
-// BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-s(D, "3.1.1", "esm2017");
+ */ !function(t, e = !0) {
+    !function(t) {
+        N = t;
+    }(i), n(new r("firestore", ((t, {options: n}) => {
+        const s = t.getProvider("app").getImmediate(), i = new Oa(s, new J(t.getProvider("auth-internal")));
+        return n = Object.assign({
+            useFetchStreams: e
+        }, n), i._setSettings(n), i;
+    }), "PUBLIC" /* PUBLIC */)), s(D, "3.2.0", t), 
+    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
+    s(D, "3.2.0", "esm2017");
+}("rn", /* useFetchStreams= */ !1);
 
 export { ih as AbstractUserDataWriter, tu as Bytes, $a as CACHE_SIZE_UNLIMITED, Pa as CollectionReference, Ra as DocumentReference, xu as DocumentSnapshot, Xa as FieldPath, eu as FieldValue, Oa as Firestore, Q as FirestoreError, nu as GeoPoint, ka as LoadBundleTask, ba as Query, Lu as QueryConstraint, ku as QueryDocumentSnapshot, $u as QuerySnapshot, Nu as SnapshotMetadata, rt as Timestamp, Rh as Transaction, ch as WriteBatch, fa as _DatabaseId, Vt as _DocumentKey, z as _EmptyCredentialsProvider, dt as _FieldPath, pa as _cast, q as _debugAssert, mt as _isBase64Available, M as _logWarn, _a as _validateIsNotUsedTogether, ph as addDoc, Sh as arrayRemove, Vh as arrayUnion, ja as clearIndexedDbPersistence, va as collection, Va as collectionGroup, Aa as connectFirestoreEmulator, yh as deleteDoc, Ph as deleteField, Ga as disableNetwork, Sa as doc, Za as documentId, Ua as enableIndexedDbPersistence, qa as enableMultiTabIndexedDbPersistence, Wa as enableNetwork, Zu as endAt, Xu as endBefore, La as ensureFirestoreConfigured, Ih as executeWrite, uh as getDoc, lh as getDocFromCache, fh as getDocFromServer, dh as getDocs, wh as getDocsFromCache, _h as getDocsFromServer, Ma as getFirestore, Dh as increment, Fa as initializeFirestore, Wu as limit, Gu as limitToLast, Ha as loadBundle, Ja as namedQuery, Th as onSnapshot, Eh as onSnapshotsInSync, ju as orderBy, Bu as query, Ca as queryEqual, Da as refEqual, bh as runTransaction, vh as serverTimestamp, mh as setDoc, $ as setLogLevel, Fu as snapshotEqual, Ju as startAfter, Hu as startAt, za as terminate, gh as updateDoc, Qa as waitForPendingWrites, qu as where, Ch as writeBatch };
 //# sourceMappingURL=index.rn.js.map