@firebase/firestore 3.1.1 → 3.2.0-canary.477bdef13

package/dist/index.esm2017.js

@@ -66,7 +66,7 @@ D.MOCK_USER = new D("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let C = "9.1.3";
+let C = "9.2.0-canary.477bdef13";
 
 /**
  * @license
@@ -11072,15 +11072,15 @@ class Xr {
  *  ListenerType: The type of the listener that will be used for callbacks
  */
 class Zr {
-    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 Xr(t, e);
+        this.ir = 0, this.rr = null, this.ar = null, this.stream = null, this.cr = new Xr(t, e);
     }
     /**
      * Returns true if start() has been called and no error has occurred. True
@@ -11088,14 +11088,14 @@ class Zr {
      * 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.
-     */    ar() {
-        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.
-     */    cr() {
-        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
@@ -11104,7 +11104,7 @@ class Zr {
      *
      * 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
@@ -11112,7 +11112,7 @@ class Zr {
      *
      * When stop returns, isStarted() and isOpen() will both return false.
      */    async stop() {
-        this.ar() && 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
@@ -11121,8 +11121,8 @@ class Zr {
      *
      * 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.cr.reset();
     }
     /**
      * Marks this stream as idle. If no further actions are performed on the
@@ -11133,22 +11133,25 @@ class Zr {
      *
      * 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.cr() && 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.cr()) 
+    /** 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.ar && (this.ar.cancel(), this.ar = null);
     }
     /**
      * Closes the stream and cleans up as necessary:
@@ -11164,20 +11167,24 @@ class Zr {
      * @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.cr.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 === K.RESOURCE_EXHAUSTED ? (
+        this.cr.reset() : e && e.code === K.RESOURCE_EXHAUSTED ? (
         // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)
         O(e.toString()), O("Using maximum backoff delay to prevent overloading the backend."), 
-        this.rr.Yi()) : e && e.code === K.UNAUTHENTICATED && 
-        // "unauthenticated" error means the token was rejected. Try force refreshing it in case it
-        // just expired.
+        this.cr.Yi()) : e && e.code === K.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, 
@@ -11187,59 +11194,60 @@ class Zr {
     /**
      * 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 j(K.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.ar = 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.cr.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 $("PersistentStream", `close with error: ${t}`), this.stream = null, this.close(3 /* Error */ , t);
+        return $("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() : ($("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
+            this.Oe.enqueueAndForget((() => this.ir === t ? e() : ($("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
             Promise.resolve())));
         };
     }
@@ -11253,15 +11261,15 @@ class Zr {
  * sent from the server for ListenResponses.
  */ class to extends Zr {
     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.cr.reset();
         const e = ns(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
@@ -11270,14 +11278,14 @@ class Zr {
             const e = t.targetChange;
             return e.targetIds && e.targetIds.length ? rt.min() : e.readTime ? jn(e.readTime) : rt.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 = Yn(this.N), e.addTarget = function(t, e) {
             let n;
@@ -11293,14 +11301,14 @@ class Zr {
             n.readTime = Un(t, e.snapshotVersion.toTimestamp())), n;
         }(this.N, t);
         const n = us(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 = Yn(this.N), e.removeTarget = t, this.wr(e);
+        e.database = Yn(this.N), e.removeTarget = t, this.mr(e);
     }
 }
 
@@ -11322,55 +11330,55 @@ class Zr {
  * TODO(b/33271235): Use proto types
  */ class eo extends Zr {
     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.
-        B(!!t.streamToken), this.lastStreamToken = t.streamToken, this.Rr) {
+        B(!!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.cr.reset();
             const e = rs(t.writeResults, t.commitTime), n = jn(t.commitTime);
-            return this.listener.vr(n, e);
+            return this.listener.Dr(n, e);
         }
         // The first response is always the handshake response
-        return B(!t.writeResults || 0 === t.writeResults.length), this.Rr = !0, this.listener.Vr();
+        return B(!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 = Yn(this.N), this.wr(t);
+        t.database = Yn(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 => ss(this.N, t)))
         };
-        this.wr(e);
+        this.mr(e);
     }
 }
 
@@ -11401,25 +11409,25 @@ class Zr {
  */
 class no 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 j(K.FAILED_PRECONDITION, "The client has already been terminated.");
+    $r() {
+        if (this.kr) throw new j(K.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 === K.UNAUTHENTICATED && this.credentials.invalidateToken(), 
             t) : new j(K.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 === K.UNAUTHENTICATED && this.credentials.invalidateToken(), 
             t) : new j(K.UNKNOWN, t.toString());
         }));
     }
     terminate() {
-        this.Dr = !0;
+        this.kr = !0;
     }
 }
 
@@ -11446,19 +11454,19 @@ class so {
          * 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
@@ -11466,9 +11474,9 @@ class so {
      *
      * 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()))));
     }
     /**
@@ -11476,10 +11484,10 @@ class so {
      * 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.
@@ -11488,20 +11496,20 @@ class so {
      * 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 ? (O(e), this.$r = !1) : $("OnlineStateTracker", e);
+        this.Mr ? (O(e), this.Mr = !1) : $("OnlineStateTracker", e);
     }
-    Br() {
-        null !== this.kr && (this.kr.cancel(), this.kr = null);
+    Kr() {
+        null !== this.Fr && (this.Fr.cancel(), this.Fr = null);
     }
 }
 
@@ -11546,7 +11554,7 @@ class so {
          * 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.
@@ -11556,12 +11564,12 @@ class so {
          * 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.
          *
@@ -11569,7 +11577,7 @@ class so {
          * 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
@@ -11577,23 +11585,23 @@ class so {
                 wo(this) && ($("RemoteStore", "Restarting streams for network reachability change."), 
                 await async function(t) {
                     const e = q(t);
-                    e.Kr.add(4 /* ConnectivityChange */), await oo(e), e.Wr.set("Unknown" /* Unknown */), 
-                    e.Kr.delete(4 /* ConnectivityChange */), await ro(e);
+                    e.Wr.add(4 /* ConnectivityChange */), await oo(e), e.Hr.set("Unknown" /* Unknown */), 
+                    e.Wr.delete(4 /* ConnectivityChange */), await ro(e);
                 }(this));
             }));
-        })), this.Wr = new so(n, s);
+        })), this.Hr = new so(n, s);
     }
 }
 
 async function ro(t) {
-    if (wo(t)) for (const e of t.jr) await e(/* enabled= */ !0);
+    if (wo(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 oo(t) {
-    for (const e of t.jr) await e(/* enabled= */ !1);
+    for (const e of t.Gr) await e(/* enabled= */ !1);
 }
 
 /**
@@ -11602,11 +11610,11 @@ async function ro(t) {
  */
 function ao(t, e) {
     const n = q(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), fo(n) ? 
+    n.Qr.set(e.targetId, e), fo(n) ? 
     // The listen will be sent in onWatchStreamOpen
-    lo(n) : Co(n).cr() && uo(n, e));
+    lo(n) : Co(n).hr() && uo(n, e));
 }
 
 /**
@@ -11614,18 +11622,18 @@ function ao(t, e) {
  * not being listened to.
  */ function co(t, e) {
     const n = q(t), s = Co(n);
-    n.qr.delete(e), s.cr() && ho(n, e), 0 === n.qr.size && (s.cr() ? s.lr() : wo(n) && 
+    n.Qr.delete(e), s.hr() && ho(n, e), 0 === n.Qr.size && (s.hr() ? s.wr() : wo(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 uo(t, e) {
-    t.Gr.Y(e.targetId), Co(t).Ir(e);
+    t.Jr.Y(e.targetId), Co(t).br(e);
 }
 
 /**
@@ -11633,33 +11641,33 @@ function ao(t, e) {
  * from watch so we wait for the removal on the server before we process any
  * messages from this target.
  */ function ho(t, e) {
-    t.Gr.Y(e), Co(t).Ar(e);
+    t.Jr.Y(e), Co(t).Pr(e);
 }
 
 function lo(t) {
-    t.Gr = new $n({
+    t.Jr = new $n({
         getRemoteKeysForTarget: e => t.remoteSyncer.getRemoteKeysForTarget(e),
-        Tt: e => t.qr.get(e) || null
-    }), Co(t).start(), t.Wr.Or();
+        Tt: e => t.Qr.get(e) || null
+    }), Co(t).start(), t.Hr.Lr();
 }
 
 /**
  * Returns whether the watch stream should be started because it's necessary
  * and has not yet been started.
  */ function fo(t) {
-    return wo(t) && !Co(t).ar() && t.qr.size > 0;
+    return wo(t) && !Co(t).ur() && t.Qr.size > 0;
 }
 
 function wo(t) {
-    return 0 === q(t).Kr.size;
+    return 0 === q(t).Wr.size;
 }
 
 function _o(t) {
-    t.Gr = void 0;
+    t.Jr = void 0;
 }
 
 async function mo(t) {
-    t.qr.forEach(((e, n) => {
+    t.Qr.forEach(((e, n) => {
         uo(t, e);
     }));
 }
@@ -11667,17 +11675,17 @@ async function mo(t) {
 async function go(t, e) {
     _o(t), 
     // If we still need the watch stream, retry the connection.
-    fo(t) ? (t.Wr.Lr(e), lo(t)) : 
+    fo(t) ? (t.Hr.qr(e), lo(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 yo(t, e, n) {
     if (
     // Mark the client as online since we got a message from the server
-    t.Wr.set("Online" /* Online */), e instanceof xn && 2 /* Removed */ === e.state && e.cause) 
+    t.Hr.set("Online" /* Online */), e instanceof xn && 2 /* Removed */ === e.state && e.cause) 
     // There was an error on a target, don't wait for a consistent snapshot
     // to raise events
     try {
@@ -11687,7 +11695,7 @@ async function yo(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.
@@ -11700,7 +11708,7 @@ async function yo(t, e, n) {
     } catch (n) {
         $("RemoteStore", "Failed to remove targets %s: %s ", e.targetIds.join(","), n), 
         await po(t, n);
-    } else if (e instanceof Cn ? t.Gr.rt(e) : e instanceof Nn ? t.Gr.ft(e) : t.Gr.ct(e), 
+    } else if (e instanceof Cn ? t.Jr.rt(e) : e instanceof Nn ? t.Jr.ft(e) : t.Jr.ct(e), 
     !n.isEqual(rt.min())) try {
         const e = await fr(t.localStore);
         n.compareTo(e) >= 0 && 
@@ -11713,26 +11721,26 @@ async function yo(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(_t.EMPTY_BYTE_STRING, n.snapshotVersion)), 
+                                t.Qr.set(e, n.withResumeToken(_t.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.
                 ho(t, e);
@@ -11759,16 +11767,16 @@ async function yo(t, e, n) {
  * any retry attempt.
  */ async function po(t, e, n) {
     if (!Hs(e)) throw e;
-    t.Kr.add(1 /* IndexedDbFailed */), 
+    t.Wr.add(1 /* IndexedDbFailed */), 
     // Disable network and raise offline snapshots
-    await oo(t), t.Wr.set("Offline" /* Offline */), n || (
+    await oo(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 = () => fr(t.localStore)), 
     // Probe IndexedDB periodically and re-enable network
     t.asyncQueue.enqueueRetryable((async () => {
-        $("RemoteStore", "Retrying IndexedDB access"), await n(), t.Kr.delete(1 /* IndexedDbFailed */), 
+        $("RemoteStore", "Retrying IndexedDB access"), await n(), t.Wr.delete(1 /* IndexedDbFailed */), 
         await ro(t);
     }));
 }
@@ -11782,11 +11790,11 @@ async function yo(t, e, n) {
 
 async function Eo(t) {
     const e = q(t), n = No(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 (;Io(e); ) try {
         const t = await _r(e.localStore, s);
         if (null === t) {
-            0 === e.Ur.length && n.lr();
+            0 === e.jr.length && n.wr();
             break;
         }
         s = t.batchId, Ao(e, t);
@@ -11800,20 +11808,20 @@ async function Eo(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 Io(t) {
-    return wo(t) && t.Ur.length < 10;
+    return wo(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 Ao(t, e) {
-    t.Ur.push(e);
+    t.jr.push(e);
     const n = No(t);
-    n.cr() && n.br && n.Pr(e.mutations);
+    n.hr() && n.Vr && n.Sr(e.mutations);
 }
 
 function Ro(t) {
-    return wo(t) && !No(t).ar() && t.Ur.length > 0;
+    return wo(t) && !No(t).ur() && t.jr.length > 0;
 }
 
 function bo(t) {
@@ -11821,17 +11829,17 @@ function bo(t) {
 }
 
 async function Po(t) {
-    No(t).Sr();
+    No(t).Nr();
 }
 
 async function vo(t) {
     const e = No(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 Vo(t, e, n) {
-    const s = t.Ur.shift(), i = si.from(s, e, n);
+    const s = t.jr.shift(), i = si.from(s, e, n);
     await To(t, (() => t.remoteSyncer.applySuccessfulWrite(i))), 
     // It's possible that with the completion of this mutation another
     // slot has freed up.
@@ -11841,7 +11849,7 @@ async function Vo(t, e, n) {
 async function So(t, e) {
     // If the write stream closed after the write handshake completes, a write
     // operation failed and we fail the pending operation.
-    e && No(t).br && 
+    e && No(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
@@ -11849,11 +11857,11 @@ async function So(t, e) {
         if (n = e.code, fn(n) && n !== K.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.
-                        No(t).hr(), await To(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
+                        No(t).dr(), await To(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
             // It's possible that with the completion of this mutation
             // another slot has freed up.
             await Eo(t);
@@ -11870,8 +11878,8 @@ async function So(t, e) {
  */
 async function Do(t, e) {
     const n = q(t);
-    e ? (n.Kr.delete(2 /* IsSecondary */), await ro(n)) : e || (n.Kr.add(2 /* IsSecondary */), 
-    await oo(n), n.Wr.set("Unknown" /* Unknown */));
+    e ? (n.Wr.delete(2 /* IsSecondary */), await ro(n)) : e || (n.Wr.add(2 /* IsSecondary */), 
+    await oo(n), n.Hr.set("Unknown" /* Unknown */));
 }
 
 /**
@@ -11882,11 +11890,11 @@ async function Do(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 Co(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 = q(t);
-        return s.Cr(), new to(e, s.nr, s.credentials, s.N, n);
+        return s.$r(), new to(e, s.sr, s.credentials, s.N, n);
     }
     /**
  * @license
@@ -11906,11 +11914,11 @@ async function Do(t, e) {
  */ (t.datastore, t.asyncQueue, {
         Si: mo.bind(null, t),
         Ci: go.bind(null, t),
-        Er: yo.bind(null, t)
-    }), t.jr.push((async e => {
-        e ? (t.zr.hr(), fo(t) ? lo(t) : t.Wr.set("Unknown" /* Unknown */)) : (await t.zr.stop(), 
+        Rr: yo.bind(null, t)
+    }), t.Gr.push((async e => {
+        e ? (t.Yr.dr(), fo(t) ? lo(t) : t.Hr.set("Unknown" /* Unknown */)) : (await t.Yr.stop(), 
         _o(t));
-    }))), t.zr;
+    }))), t.Yr;
 }
 
 /**
@@ -11921,22 +11929,22 @@ async function Do(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 No(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 = q(t);
-        return s.Cr(), new eo(e, s.nr, s.credentials, s.N, n);
+        return s.$r(), new eo(e, s.sr, s.credentials, s.N, n);
     }(t.datastore, t.asyncQueue, {
         Si: Po.bind(null, t),
         Ci: So.bind(null, t),
-        Vr: vo.bind(null, t),
-        vr: Vo.bind(null, t)
-    }), t.jr.push((async e => {
-        e ? (t.Hr.hr(), 
+        Cr: vo.bind(null, t),
+        Dr: Vo.bind(null, t)
+    }), t.Gr.push((async e => {
+        e ? (t.Xr.dr(), 
         // This will start the write stream if necessary.
-        await Eo(t)) : (await t.Hr.stop(), t.Ur.length > 0 && ($("RemoteStore", `Stopping write stream with ${t.Ur.length} pending writes`), 
-        t.Ur = []));
-    }))), t.Hr;
+        await Eo(t)) : (await t.Xr.stop(), t.jr.length > 0 && ($("RemoteStore", `Stopping write stream with ${t.jr.length} pending writes`), 
+        t.jr = []));
+    }))), t.Xr;
 }
 
 /**
@@ -12146,25 +12154,25 @@ class xo {
  * duplicate events for the same doc.
  */ class Oo {
     constructor() {
-        this.Jr = new wn(Pt.comparator);
+        this.Zr = new wn(Pt.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
         }) : 
@@ -12175,11 +12183,11 @@ class xo {
         // Removed->Modified
         // Metadata->Added
         // Removed->Metadata
-        L() : this.Jr = this.Jr.insert(e, t);
+        L() : 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;
     }
@@ -12234,14 +12242,14 @@ class Fo {
  * tracked by EventManager.
  */ class Mo {
     constructor() {
-        this.Xr = void 0, this.listeners = [];
+        this.no = void 0, this.listeners = [];
     }
 }
 
 class Lo {
     constructor() {
         this.queries = new ji((t => Re(t)), Ae), this.onlineState = "Unknown" /* Unknown */ , 
-        this.Zr = new Set;
+        this.so = new Set;
     }
 }
 
@@ -12249,15 +12257,15 @@ async function Bo(t, e) {
     const n = q(t), s = e.query;
     let i = !1, r = n.queries.get(s);
     if (r || (i = !0, r = new Mo), i) try {
-        r.Xr = await n.onListen(s);
+        r.no = await n.onListen(s);
     } catch (t) {
         const n = ko(t, `Initialization of query '${be(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) && jo(n);
+    e.io(n.onlineState), r.no) {
+        e.ro(r.no) && jo(n);
     }
 }
 
@@ -12278,8 +12286,8 @@ function qo(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 && jo(n);
@@ -12295,7 +12303,7 @@ function Ko(t, e, n) {
 
 // Call all global snapshot listeners that have been set.
 function jo(t) {
-    t.Zr.forEach((t => {
+    t.so.forEach((t => {
         t.next();
     }));
 }
@@ -12307,19 +12315,19 @@ function jo(t) {
  * It uses an Observer to dispatch events.
  */ class Qo {
     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.ao = !1, this.co = 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 = [];
@@ -12328,19 +12336,19 @@ function jo(t) {
             /* excludesMetadataChanges= */ !0);
         }
         let e = !1;
-        return this.io ? this.oo(t) && (this.so.next(t), e = !0) : this.ao(t, this.onlineState) && (this.co(t), 
-        e = !0), this.ro = t, e;
+        return this.ao ? this.uo(t) && (this.oo.next(t), e = !0) : this.ho(t, this.onlineState) && (this.lo(t), 
+        e = !0), this.co = 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.ao(this.ro, t) && (this.co(this.ro), e = !0), 
+        return this.co && !this.ao && this.ho(this.co, t) && (this.lo(this.co), e = !0), 
         e;
     }
-    ao(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
@@ -12348,24 +12356,24 @@ function jo(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.co && this.co.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.
         }
-    co(t) {
-        t = Fo.fromInitialDocuments(t.query, t.docs, t.mutatedKeys, t.fromCache), this.io = !0, 
-        this.so.next(t);
+    lo(t) {
+        t = Fo.fromInitialDocuments(t.query, t.docs, t.mutatedKeys, t.fromCache), this.ao = !0, 
+        this.oo.next(t);
     }
 }
 
@@ -12394,7 +12402,7 @@ function jo(t) {
     e) {
         this.payload = t, this.byteLength = e;
     }
-    ho() {
+    wo() {
         return "metadata" in this.payload;
     }
 }
@@ -12439,7 +12447,7 @@ function jo(t) {
  * storage and provide progress update while loading.
  */ class zo {
     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 */
@@ -12450,7 +12458,7 @@ function jo(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({
@@ -12459,7 +12467,7 @@ function jo(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 Go(this.N);
         for (const s of t) if (s.metadata.queries) {
             const t = n.zn(s.metadata.name);
@@ -12473,7 +12481,7 @@ function jo(t) {
     /**
      * Update the progress to 'Success' and return the updated progress.
      */    async complete() {
-        const t = await Ir(this.localStore, new Go(this.N), this.documents, this.lo.id), e = this.wo(this.documents);
+        const t = await Ir(this.localStore, new Go(this.N), this.documents, this._o.id), e = this.yo(this.documents);
         for (const t of this.queries) await Ar(this.localStore, t, e.get(t.name));
         return this.progress.taskState = "Success", new ir(Object.assign({}, this.progress), t);
     }
@@ -12532,7 +12540,7 @@ class Yo {
     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
@@ -12541,15 +12549,15 @@ class Yo {
          */
         this.current = !1, 
         /** Documents in the view but not in the remote target */
-        this.yo = Pn(), 
+        this.Eo = Pn(), 
         /** Document Keys that have local changes */
-        this.mutatedKeys = Pn(), this.po = ve(t), this.To = new $o(this.po);
+        this.mutatedKeys = Pn(), this.Io = ve(t), this.Ao = new $o(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
@@ -12560,8 +12568,8 @@ class Yo {
      * @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 Oo, s = e ? e.To : this.To;
+     */    bo(t, e) {
+        const n = e ? e.Po : new Oo, 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
@@ -12584,10 +12592,10 @@ class Yo {
                 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, (a && this.po(h, a) > 0 || c && this.po(h, c) < 0) && (
+                }), d = !0, (a && this.Io(h, a) > 0 || c && this.Io(h, c) < 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.
@@ -12612,13 +12620,13 @@ class Yo {
             });
         }
         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.
@@ -12640,10 +12648,10 @@ class Yo {
      */
     // 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) {
@@ -12681,68 +12689,68 @@ class Yo {
  * 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 */ , a = o !== this.mo;
-        if (this.mo = o, 0 !== i.length || a) {
+ */ (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 */ , a = o !== this.To;
+        if (this.To = o, 0 !== i.length || a) {
             return {
-                snapshot: new Fo(this.query, t.To, s, i, t.mutatedKeys, 0 /* Local */ === o, a, 
+                snapshot: new Fo(this.query, t.Ao, s, i, t.mutatedKeys, 0 /* Local */ === o, a, 
                 /* 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 Oo,
+            Ao: this.Ao,
+            Po: new Oo,
             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 = Pn(), this.To.forEach((t => {
-            this.Vo(t.key) && (this.yo = this.yo.add(t.key));
+                const t = this.Eo;
+        this.Eo = Pn(), 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 Yo(t));
-        })), this.yo.forEach((n => {
+            this.Eo.has(t) || e.push(new Yo(t));
+        })), this.Eo.forEach((n => {
             t.has(n) || e.push(new Jo(n));
         })), e;
     }
@@ -12766,9 +12774,9 @@ class Yo {
      * @returns The ViewChange that resulted from this synchronization.
      */
     // PORTING NOTE: Multi-tab only.
-    So(t) {
-        this._o = t.Gn, this.yo = Pn();
-        const e = this.Io(t.documents);
+    No(t) {
+        this.po = t.Gn, this.Eo = Pn();
+        const e = this.bo(t.documents);
         return this.applyChanges(e, /*updateLimboDocuments=*/ !0);
     }
     /**
@@ -12777,8 +12785,8 @@ class Yo {
      * `hasPendingWrites` status of the already established view.
      */
     // PORTING NOTE: Multi-tab only.
-    Do() {
-        return Fo.fromInitialDocuments(this.query, this.To, this.mutatedKeys, 0 /* Local */ === this.mo);
+    xo() {
+        return Fo.fromInitialDocuments(this.query, this.Ao, this.mutatedKeys, 0 /* Local */ === this.To);
     }
 }
 
@@ -12817,7 +12825,7 @@ class Zo {
          * decide whether it needs to manufacture a delete event for the target once
          * the target is CURRENT.
          */
-        this.Co = !1;
+        this.ko = !1;
     }
 }
 
@@ -12838,8 +12846,8 @@ class Zo {
     // 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 ji((t => Re(t)), Ae), 
-        this.ko = new Map, 
+        this.currentUser = i, this.maxConcurrentLimboResolutions = r, this.$o = {}, this.Oo = new ji((t => Re(t)), Ae), 
+        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
@@ -12849,28 +12857,28 @@ class Zo {
          * 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 wn(Pt.comparator), 
+        this.Lo = new wn(Pt.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 br, 
+        this.Bo = new Map, this.Uo = new br, 
         /** 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 = Ni.ie(), this.onlineState = "Unknown" /* Unknown */ , 
+        this.Ko = new Map, this.jo = Ni.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;
     }
 }
 
@@ -12882,7 +12890,7 @@ class Zo {
 async function na(t, e) {
     const n = Ca(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
@@ -12890,7 +12898,7 @@ async function na(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 mr(n.localStore, Ee(e)), r = n.sharedClientState.addLocalQueryTarget(t.targetId);
         s = t.targetId, i = await sa(n, e, s, "current" === r), n.isPrimaryClient && ao(n.remoteStore, t);
     }
@@ -12904,29 +12912,29 @@ async function na(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 yr(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 ma(t, e.targetId, o.vo), o.snapshot;
+        return ma(t, e.targetId, o.Do), o.snapshot;
     }(t, e, n, s);
     const i = await yr(t.localStore, e, 
-    /* usePreviousResults= */ !0), r = new Xo(e, i.Gn), o = r.Io(i.documents), a = Dn.createSynthesizedTargetChangeForCurrentChange(n, s && "Offline" /* Offline */ !== t.onlineState), c = r.applyChanges(o, 
+    /* usePreviousResults= */ !0), r = new Xo(e, i.Gn), o = r.bo(i.documents), a = Dn.createSynthesizedTargetChangeForCurrentChange(n, s && "Offline" /* Offline */ !== t.onlineState), c = r.applyChanges(o, 
     /* updateLimboDocuments= */ t.isPrimaryClient, a);
-    ma(t, n, c.vo);
+    ma(t, n, c.Do);
     const u = new Zo(e, n, r);
-    return t.xo.set(e, u), t.ko.has(n) ? t.ko.get(n).push(e) : t.ko.set(n, [ e ]), c.snapshot;
+    return t.Oo.set(e, u), t.Fo.has(n) ? t.Fo.get(n).push(e) : t.Fo.set(n, [ e ]), c.snapshot;
 }
 
 /** Stops listening to the query. */ async function ia(t, e) {
-    const n = q(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 => !Ae(t, e)))), void n.xo.delete(e);
+    const n = q(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 => !Ae(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
@@ -12979,9 +12987,9 @@ async function na(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 wn(et));
-            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
@@ -13005,13 +13013,13 @@ async function na(t, e) {
         const t = await dr(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.
             B(t.addedDocuments.size + t.modifiedDocuments.size + t.removedDocuments.size <= 1), 
-            t.addedDocuments.size > 0 ? s.Co = !0 : t.modifiedDocuments.size > 0 ? B(s.Co) : t.removedDocuments.size > 0 && (B(s.Co), 
-            s.Co = !1));
+            t.addedDocuments.size > 0 ? s.ko = !0 : t.modifiedDocuments.size > 0 ? B(s.ko) : t.removedDocuments.size > 0 && (B(s.ko), 
+            s.ko = !1));
         })), await pa(n, t, e);
     } catch (t) {
         await Fi(t);
@@ -13029,8 +13037,8 @@ async function na(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 = q(t);
@@ -13039,9 +13047,9 @@ async function na(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 && jo(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);
     }
 }
 
@@ -13059,7 +13067,7 @@ async function na(t, e) {
     const s = q(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.
@@ -13078,7 +13086,7 @@ async function na(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), ya(s);
+        s.Lo = s.Lo.remove(r), s.Bo.delete(e), ya(s);
     } else await gr(s.localStore, e, 
     /* keepPersistedTargetData */ !1).then((() => wa(s, e, n))).catch(Fi);
 }
@@ -13139,8 +13147,8 @@ async function ha(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 = ko(t, "Initialization of waitForPendingWrites() operation failed");
         e.reject(n);
@@ -13151,28 +13159,28 @@ async function ha(t, e, n) {
  * Triggers the callbacks that are waiting for this batch id to get acknowledged by server,
  * if there are any.
  */ function fa(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 da(t, e, n) {
     const s = q(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 wa(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
             _a(t, e);
         }));
@@ -13180,17 +13188,17 @@ function wa(t, e, n = null) {
 }
 
 function _a(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 && (co(t.remoteStore, n), t.Oo = t.Oo.remove(e), t.Fo.delete(n), ya(t));
+    const n = t.Lo.get(e);
+    null !== n && (co(t.remoteStore, n), t.Lo = t.Lo.remove(e), t.Bo.delete(n), ya(t));
 }
 
 function ma(t, e, n) {
-    for (const s of n) if (s instanceof Jo) t.Mo.addReference(s.key, e), ga(t, s); else if (s instanceof Yo) {
-        $("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 Jo) t.Uo.addReference(s.key, e), ga(t, s); else if (s instanceof Yo) {
+        $("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
         _a(t, s.key);
     } else L();
@@ -13198,7 +13206,7 @@ function ma(t, e, n) {
 
 function ga(t, e) {
     const n = e.key, s = n.path.canonicalString();
-    t.Oo.get(n) || t.$o.has(s) || ($("SyncEngine", "New document in limbo: " + n), t.$o.add(s), 
+    t.Lo.get(n) || t.Mo.has(s) || ($("SyncEngine", "New document in limbo: " + n), t.Mo.add(s), 
     ya(t));
 }
 
@@ -13210,18 +13218,18 @@ function ga(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 ya(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 Pt(ht.fromString(e)), s = t.Uo.next();
-        t.Fo.set(s, new ta(n)), t.Oo = t.Oo.insert(n, s), ao(t.remoteStore, new ii(Ee(we(n.path)), s, 2 /* LimboResolution */ , X.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 Pt(ht.fromString(e)), s = t.jo.next();
+        t.Bo.set(s, new ta(n)), t.Lo = t.Lo.insert(n, s), ao(t.remoteStore, new ii(Ee(we(n.path)), s, 2 /* LimboResolution */ , X.T));
     }
 }
 
 async function pa(t, e, n) {
     const s = q(t), i = [], r = [], o = [];
-    s.xo.isEmpty() || (s.xo.forEach(((t, a) => {
-        o.push(s.Ko(a, e, n).then((t => {
+    s.Oo.isEmpty() || (s.Oo.forEach(((t, a) => {
+        o.push(s.Wo(a, e, n).then((t => {
             if (t) {
                 s.isPrimaryClient && s.sharedClientState.updateQueryState(a.targetId, t.fromCache ? "not-current" : "current"), 
                 i.push(t);
@@ -13229,7 +13237,7 @@ async function pa(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 = q(t);
         try {
             await n.persistence.runTransaction("notifyLocalViewChanges", "readwrite", (t => js.forEach(e, (e => js.forEach(e.Nn, (s => n.persistence.referenceDelegate.addReference(t, e.targetId, s))).next((() => js.forEach(e.xn, (s => n.persistence.referenceDelegate.removeReference(t, e.targetId, s)))))))));
@@ -13260,11 +13268,11 @@ async function Ta(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 j(K.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 pa(n, t.Wn);
@@ -13272,15 +13280,15 @@ async function Ta(t, e) {
 }
 
 function Ea(t, e) {
-    const n = q(t), s = n.Fo.get(e);
-    if (s && s.Co) return Pn().add(s.key);
+    const n = q(t), s = n.Bo.get(e);
+    if (s && s.ko) return Pn().add(s.key);
     {
         let t = Pn();
-        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;
     }
@@ -13291,8 +13299,8 @@ function Ea(t, e) {
  * from persistence.
  */ async function Ia(t, e) {
     const n = q(t), s = await yr(n.localStore, e.query, 
-    /* usePreviousResults= */ !0), i = e.view.So(s);
-    return n.isPrimaryClient && ma(n, e.targetId, i.vo), i;
+    /* usePreviousResults= */ !0), i = e.view.No(s);
+    return n.isPrimaryClient && ma(n, e.targetId, i.Do), i;
 }
 
 /**
@@ -13340,7 +13348,7 @@ async function Ra(t, e, n, s) {
 // PORTING NOTE: Multi-Tab only.
 async function ba(t, e) {
     const n = q(t);
-    if (Ca(n), Na(n), !0 === e && !0 !== n.qo) {
+    if (Ca(n), Na(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
@@ -13348,12 +13356,12 @@ async function ba(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 Pa(n, t.toArray());
-        n.qo = !0, await Do(n.remoteStore, !0);
+        n.Qo = !0, await Do(n.remoteStore, !0);
         for (const t of e) ao(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((() => (wa(n, i), 
             gr(n.localStore, i, 
             /*keepPersistedTargetData=*/ !0)))), co(n.remoteStore, i);
@@ -13361,9 +13369,9 @@ async function ba(t, e) {
         // PORTING NOTE: Multi-Tab only.
         function(t) {
             const e = q(t);
-            e.Fo.forEach(((t, n) => {
+            e.Bo.forEach(((t, n) => {
                 co(e.remoteStore, n);
-            })), e.Mo.us(), e.Fo = new Map, e.Oo = new wn(Pt.comparator);
+            })), e.Uo.us(), e.Bo = new Map, e.Lo = new wn(Pt.comparator);
         }
         /**
  * Reconcile the query views of the provided query targets with the state from
@@ -13376,7 +13384,7 @@ async function ba(t, e) {
  * tab to a primary tab
  */
         // PORTING NOTE: Multi-Tab only.
-        (n), n.qo = !1, await Do(n.remoteStore, !1);
+        (n), n.Qo = !1, await Do(n.remoteStore, !1);
     }
 }
 
@@ -13384,7 +13392,7 @@ async function Pa(t, e, n) {
     const s = q(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
@@ -13392,7 +13400,7 @@ async function Pa(t, e, n) {
             // state (the list of syncedDocuments may have gotten out of sync).
             e = await mr(s.localStore, Ee(n[0]));
             for (const t of n) {
-                const e = s.xo.get(t), n = await Ia(s, e);
+                const e = s.Oo.get(t), n = await Ia(s, e);
                 n.snapshot && r.push(n.snapshot);
             }
         } else {
@@ -13404,7 +13412,7 @@ async function Pa(t, e, n) {
         }
         i.push(e);
     }
-    return s.No.Er(r), i;
+    return s.$o.Rr(r), i;
 }
 
 /**
@@ -13433,10 +13441,10 @@ function Va(t) {
 // PORTING NOTE: Multi-Tab only.
 async function Sa(t, e, n, s) {
     const i = q(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.
-    $("SyncEngine", "Ignoring unexpected query state notification."); else if (i.ko.has(e)) switch (n) {
+    $("SyncEngine", "Ignoring unexpected query state notification."); else if (i.Fo.has(e)) switch (n) {
       case "current":
       case "not-current":
         {
@@ -13457,9 +13465,9 @@ async function Sa(t, e, n, s) {
 
 /** Adds or removes Watch targets for queries from different tabs. */ async function Da(t, e, n) {
     const s = Ca(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
                 $("SyncEngine", "Adding an already active target " + t);
                 continue;
@@ -13471,7 +13479,7 @@ async function Sa(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 gr(s.localStore, t, 
         /* keepPersistedTargetData */ !1).then((() => {
@@ -13483,8 +13491,8 @@ async function Sa(t, e, n, s) {
 function Ca(t) {
     const e = q(t);
     return e.remoteStore.remoteSyncer.applyRemoteEvent = oa.bind(null, e), e.remoteStore.remoteSyncer.getRemoteKeysForTarget = Ea.bind(null, e), 
-    e.remoteStore.remoteSyncer.rejectListen = ca.bind(null, e), e.No.Er = qo.bind(null, e.eventManager), 
-    e.No.jo = Ko.bind(null, e.eventManager), e;
+    e.remoteStore.remoteSyncer.rejectListen = ca.bind(null, e), e.$o.Rr = qo.bind(null, e.eventManager), 
+    e.$o.Go = Ko.bind(null, e.eventManager), e;
 }
 
 function Na(t) {
@@ -13523,10 +13531,10 @@ function Na(t) {
             }(s));
             n._updateProgress(Ho(s));
             const i = new zo(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
@@ -13576,19 +13584,19 @@ class ka {
         this.synchronizeTabs = !1;
     }
     async initialize(t) {
-        this.N = Yr(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 = Yr(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 ur(this.persistence, new ar, t.initialUser, this.N);
     }
-    Go(t) {
+    Jo(t) {
         return new Cr(xr.Ns, this.N);
     }
-    Wo(t) {
+    Ho(t) {
         return new Kr;
     }
     async terminate() {
@@ -13601,29 +13609,29 @@ class ka {
  * Provides all components needed for Firestore with IndexedDB persistence.
  */ class $a extends ka {
     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 Er(this.localStore), await this.Jo.initialize(this, t), 
+        await super.initialize(t), await Er(this.localStore), await this.Zo.initialize(this, t), 
         // Enqueue writes from a previous session
-        await Na(this.Jo.syncEngine), await Eo(this.Jo.remoteStore), 
+        await Na(this.Zo.syncEngine), await Eo(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 ur(this.persistence, new ar, t.initialUser, this.N);
     }
-    zo(t) {
+    Yo(t) {
         const e = this.persistence.referenceDelegate.garbageCollector;
         return new Bi(e, t.asyncQueue);
     }
-    Go(t) {
+    Jo(t) {
         const e = sr(t.databaseInfo.databaseId, t.databaseInfo.persistenceKey), n = void 0 !== this.cacheSizeBytes ? Ri.withCacheSize(this.cacheSizeBytes) : Ri.DEFAULT;
         return new tr(this.synchronizeTabs, e, t.clientId, n, t.asyncQueue, Hr(), Jr(), this.N, this.sharedClientState, !!this.forceOwnership);
     }
-    Wo(t) {
+    Ho(t) {
         return new Kr;
     }
 }
@@ -13637,11 +13645,11 @@ class ka {
  * `synchronizeTabs` will be enabled.
  */ class Oa extends $a {
     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 qr && (this.sharedClientState.syncEngine = {
             _i: Ra.bind(null, e),
             mi: Sa.bind(null, e),
@@ -13652,10 +13660,10 @@ class ka {
         // 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 ba(this.Jo.syncEngine, t), this.gcScheduler && (t && !this.gcScheduler.started ? this.gcScheduler.start(this.localStore) : t || this.gcScheduler.stop());
+            await ba(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 = Hr();
         if (!qr.bt(e)) throw new j(K.UNIMPLEMENTED, "IndexedDB persistence is only available on platforms that support LocalStorage.");
         const n = sr(t.databaseInfo.databaseId, t.databaseInfo.persistenceKey);
@@ -13695,17 +13703,17 @@ class ka {
         // PORTING NOTE: Manages state synchronization in multi-tab environments.
         s, i, r, o) {
             const a = new ea(t, e, n, s, i, r);
-            return o && (a.qo = !0), a;
+            return o && (a.Qo = !0), a;
         }(this.localStore, this.remoteStore, this.eventManager, this.sharedClientState, t.initialUser, t.maxConcurrentLimboResolutions, e);
     }
     terminate() {
         return async function(t) {
             const e = q(t);
-            $("RemoteStore", "RemoteStore shutting down."), e.Kr.add(5 /* Shutdown */), await oo(e), 
-            e.Qr.shutdown(), 
+            $("RemoteStore", "RemoteStore shutting down."), e.Wr.add(5 /* Shutdown */), await oo(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);
     }
 }
@@ -13813,15 +13821,15 @@ class La {
         this.muted = !1;
     }
     next(t) {
-        this.observer.next && this.Yo(this.observer.next, t);
+        this.observer.next && this.ta(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.ta(this.observer.error, t) : console.error("Uncaught Error in snapshot listener:", t);
     }
-    Xo() {
+    ea() {
         this.muted = !0;
     }
-    Yo(t, e) {
+    ta(t, e) {
         this.muted || setTimeout((() => {
             this.muted || t(e);
         }), 0);
@@ -13853,28 +13861,28 @@ class La {
     constructor(
     /** The reader to read from underlying binary bundle data source. */
     t, e) {
-        this.Zo = t, this.N = e, 
+        this.na = t, this.N = e, 
         /** Cached bundle metadata. */
         this.metadata = new Q, 
         /**
          * Internal buffer to hold bundle content, accumulating incomplete element
          * content.
          */
-        this.buffer = new Uint8Array, this.ta = new TextDecoder("utf-8"), 
+        this.buffer = new Uint8Array, this.sa = new TextDecoder("utf-8"), 
         // Read the metadata (which is the first element).
-        this.ea().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.ia().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.na.cancel();
     }
     async getMetadata() {
         return this.metadata.promise;
     }
-    async Qo() {
+    async zo() {
         // Makes sure metadata is read before proceeding.
-        return await this.getMetadata(), this.ea();
+        return await this.getMetadata(), this.ia();
     }
     /**
      * Reads from the head of internal buffer, and pulling more data from
@@ -13885,15 +13893,15 @@ class La {
      *
      * Returns either the bundled element, or null if we have reached the end of
      * the stream.
-     */    async ea() {
-        const t = await this.na();
+     */    async ia() {
+        const t = await this.ra();
         if (null === t) return null;
-        const e = this.ta.decode(t), n = Number(e);
-        isNaN(n) && this.sa(`length string (${e}) is not valid number`);
-        const s = await this.ia(n);
+        const e = this.sa.decode(t), n = Number(e);
+        isNaN(n) && this.oa(`length string (${e}) is not valid number`);
+        const s = await this.aa(n);
         return new Wo(JSON.parse(s), t.length + n);
     }
-    /** First index of '{' from the underlying buffer. */    ra() {
+    /** First index of '{' from the underlying buffer. */    ca() {
         return this.buffer.findIndex((t => t === "{".charCodeAt(0)));
     }
     /**
@@ -13901,17 +13909,17 @@ class La {
      * return the content.
      *
      * If reached end of the stream, returns a null.
-     */    async na() {
-        for (;this.ra() < 0; ) {
-            if (await this.oa()) break;
+     */    async ra() {
+        for (;this.ca() < 0; ) {
+            if (await this.ua()) 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.ra();
+        const t = this.ca();
         // Broke out of the loop because underlying stream is closed, but still
         // cannot find an open bracket.
-                t < 0 && this.sa("Reached the end of bundle when a length string is expected.");
+                t < 0 && this.oa("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;
@@ -13921,23 +13929,23 @@ class La {
      * number of bytes, pulling more data from the underlying stream if needed.
      *
      * Returns a string decoded from the read bytes.
-     */    async ia(t) {
+     */    async aa(t) {
         for (;this.buffer.length < t; ) {
-            await this.oa() && this.sa("Reached the end of bundle when more is expected.");
+            await this.ua() && this.oa("Reached the end of bundle when more is expected.");
         }
-        const e = this.ta.decode(this.buffer.slice(0, t));
+        const e = this.sa.decode(this.buffer.slice(0, t));
         // Update the internal buffer to drop the read json string.
                 return this.buffer = this.buffer.slice(t), e;
     }
-    sa(t) {
+    oa(t) {
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        throw this.Zo.cancel(), new Error(`Invalid bundle format: ${t}`);
+        throw this.na.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 oa() {
-        const t = await this.Zo.read();
+     */    async ua() {
+        const t = await this.na.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;
@@ -14110,26 +14118,26 @@ class Ua {
 class qa {
     constructor(t, e, n, s) {
         this.asyncQueue = t, this.datastore = e, this.updateFunction = n, this.deferred = s, 
-        this.aa = 5, this.rr = new Xr(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.ha = 5, this.cr = new Xr(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */    run() {
-        this.aa -= 1, this.ca();
+        this.ha -= 1, this.la();
     }
-    ca() {
-        this.rr.Xi((async () => {
-            const t = new Ua(this.datastore), e = this.ua(t);
+    la() {
+        this.cr.Xi((async () => {
+            const t = new Ua(this.datastore), e = this.fa(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
                     this.deferred.resolve(e);
                 })).catch((t => {
-                    this.ha(t);
+                    this.da(t);
                 }))));
             })).catch((t => {
-                this.ha(t);
+                this.da(t);
             }));
         }));
     }
-    ua(t) {
+    fa(t) {
         try {
             const e = this.updateFunction(t);
             return !At(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
@@ -14139,11 +14147,11 @@ class qa {
             return this.deferred.reject(t), null;
         }
     }
-    ha(t) {
-        this.aa > 0 && this.la(t) ? (this.aa -= 1, this.asyncQueue.enqueueAndForget((() => (this.ca(), 
+    da(t) {
+        this.ha > 0 && this.wa(t) ? (this.ha -= 1, this.asyncQueue.enqueueAndForget((() => (this.la(), 
         Promise.resolve())))) : this.deferred.reject(t);
     }
-    la(t) {
+    wa(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.
@@ -14257,10 +14265,10 @@ async function Qa(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 oo(n), s && 
+                n.Wr.add(3 /* CredentialChange */), await oo(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 ro(n);
+        n.Hr.set("Unknown" /* Unknown */), await n.remoteSyncer.handleCredentialChange(e), 
+        n.Wr.delete(3 /* CredentialChange */), await ro(n);
     }(e.remoteStore, t))), t.onlineComponents = e;
 }
 
@@ -14301,7 +14309,7 @@ async function Xa(t) {
         const e = await za(t), n = await Ja(t);
         return e.setNetworkEnabled(!0), function(t) {
             const e = q(t);
-            return e.Kr.delete(0 /* UserDisabled */), ro(e);
+            return e.Wr.delete(0 /* UserDisabled */), ro(e);
         }(n);
     }));
 }
@@ -14311,9 +14319,9 @@ async function Xa(t) {
         const e = await za(t), n = await Ja(t);
         return e.setNetworkEnabled(!1), async function(t) {
             const e = q(t);
-            e.Kr.add(0 /* UserDisabled */), await oo(e), 
+            e.Wr.add(0 /* UserDisabled */), await oo(e), 
             // Set the OnlineState to Offline so get()s return from cache, etc.
-            e.Wr.set("Offline" /* Offline */);
+            e.Hr.set("Offline" /* Offline */);
         }(n);
     }));
 }
@@ -14364,7 +14372,7 @@ function nc(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new Qo(we(n.path), r, {
             includeMetadataChanges: !0,
-            uo: !0
+            fo: !0
         });
         return Bo(t, o);
     }(await Xa(t), t.asyncQueue, e, n, s))), s.promise;
@@ -14375,7 +14383,7 @@ function sc(t, e) {
     return t.asyncQueue.enqueueAndForget((async () => async function(t, e, n) {
         try {
             const s = await yr(t, e, 
-            /* usePreviousResults= */ !0), i = new Xo(e, s.Gn), r = i.Io(s.documents), o = i.applyChanges(r, 
+            /* usePreviousResults= */ !0), i = new Xo(e, s.Gn), r = i.bo(s.documents), o = i.applyChanges(r, 
             /* updateLimboDocuments= */ !1);
             n.resolve(o.snapshot);
         } catch (t) {
@@ -14401,7 +14409,7 @@ function ic(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new Qo(n, r, {
             includeMetadataChanges: !0,
-            uo: !0
+            fo: !0
         });
         return Bo(t, o);
     }(await Xa(t), t.asyncQueue, e, n, s))), s.promise;
@@ -14410,13 +14418,13 @@ function ic(t, e, n = {}) {
 function rc(t, e) {
     const n = new La(e);
     return t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-        q(t).Zr.add(e), 
+        q(t).so.add(e), 
         // Immediately fire an initial event, indicating all existing listeners
         // are in-sync.
         e.next();
     }(await Xa(t), n))), () => {
-        n.Xo(), t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-            q(t).Zr.delete(e);
+        n.ea(), t.asyncQueue.enqueueAndForget((async () => function(t, e) {
+            q(t).so.delete(e);
         }(await Xa(t), n)));
     };
 }
@@ -15021,39 +15029,39 @@ function vc(t, e, ...n) {
  */ class Dc {
     constructor() {
         // The last promise in the queue.
-        this.fa = Promise.resolve(), 
+        this._a = Promise.resolve(), 
         // A list of retryable operations. Retryable operations are run in order and
         // retried with backoff.
-        this.da = [], 
+        this.ma = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.wa = !1, 
+        this.ga = !1, 
         // Operations scheduled to be queued in the future. Operations are
         // automatically removed after they are run or canceled.
-        this._a = [], 
+        this.ya = [], 
         // visible for testing
-        this.ma = null, 
+        this.pa = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.ga = !1, 
+        this.Ta = !1, 
         // Enabled during shutdown on Safari to prevent future access to IndexedDB.
-        this.ya = !1, 
+        this.Ea = !1, 
         // List of TimerIds to fast-forward delays for.
-        this.pa = [], 
+        this.Ia = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.rr = new Xr(this, "async_queue_retry" /* AsyncQueueRetry */), 
+        this.cr = new Xr(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.Ta = () => {
+        this.Aa = () => {
             const t = Jr();
-            t && $("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.rr.tr();
+            t && $("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.cr.tr();
         };
         const t = Jr();
-        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Ta);
+        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Aa);
     }
     get isShuttingDown() {
-        return this.wa;
+        return this.ga;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -15063,44 +15071,44 @@ function vc(t, e, ...n) {
         this.enqueue(t);
     }
     enqueueAndForgetEvenWhileRestricted(t) {
-        this.Ea(), 
+        this.Ra(), 
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.Ia(t);
+        this.ba(t);
     }
     enterRestrictedMode(t) {
-        if (!this.wa) {
-            this.wa = !0, this.ya = t || !1;
+        if (!this.ga) {
+            this.ga = !0, this.Ea = t || !1;
             const e = Jr();
-            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Ta);
+            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Aa);
         }
     }
     enqueue(t) {
-        if (this.Ea(), this.wa) 
+        if (this.Ra(), this.ga) 
         // 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 Q;
-        return this.Ia((() => this.wa && this.ya ? Promise.resolve() : (t().then(e.resolve, e.reject), 
+        return this.ba((() => this.ga && this.Ea ? Promise.resolve() : (t().then(e.resolve, e.reject), 
         e.promise))).then((() => e.promise));
     }
     enqueueRetryable(t) {
-        this.enqueueAndForget((() => (this.da.push(t), this.Aa())));
+        this.enqueueAndForget((() => (this.ma.push(t), this.Pa())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async Aa() {
-        if (0 !== this.da.length) {
+     */    async Pa() {
+        if (0 !== this.ma.length) {
             try {
-                await this.da[0](), this.da.shift(), this.rr.reset();
+                await this.ma[0](), this.ma.shift(), this.cr.reset();
             } catch (t) {
                 if (!Hs(t)) throw t;
  // Failure will be handled by AsyncQueue
                                 $("AsyncQueue", "Operation failed with retryable error: " + t);
             }
-            this.da.length > 0 && 
+            this.ma.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
@@ -15111,12 +15119,12 @@ function vc(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.Aa()));
+            this.cr.Xi((() => this.Pa()));
         }
     }
-    Ia(t) {
-        const e = this.fa.then((() => (this.ga = !0, t().catch((t => {
-            this.ma = t, this.ga = !1;
+    ba(t) {
+        const e = this._a.then((() => (this.Ta = !0, t().catch((t => {
+            this.pa = t, this.Ta = !1;
             const e = 
             /**
  * Chrome includes Error.message in Error.stack. Other browsers do not.
@@ -15148,38 +15156,38 @@ function vc(t, e, ...n) {
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw O("INTERNAL UNHANDLED ERROR: ", e), t;
-        })).then((t => (this.ga = !1, t))))));
-        return this.fa = e, e;
+        })).then((t => (this.Ta = !1, t))))));
+        return this._a = e, e;
     }
     enqueueAfterDelay(t, e, n) {
-        this.Ea(), 
+        this.Ra(), 
         // Fast-forward delays for timerIds that have been overriden.
-        this.pa.indexOf(t) > -1 && (e = 0);
-        const s = xo.createAndSchedule(this, t, e, n, (t => this.Ra(t)));
-        return this._a.push(s), s;
+        this.Ia.indexOf(t) > -1 && (e = 0);
+        const s = xo.createAndSchedule(this, t, e, n, (t => this.va(t)));
+        return this.ya.push(s), s;
     }
-    Ea() {
-        this.ma && L();
+    Ra() {
+        this.pa && L();
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async ba() {
+     */    async Va() {
         // 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.fa, await t;
-        } while (t !== this.fa);
+            t = this._a, await t;
+        } while (t !== this._a);
     }
     /**
      * For Tests: Determine if a delayed operation with a particular TimerId
      * exists.
-     */    Pa(t) {
-        for (const e of this._a) if (e.timerId === t) return !0;
+     */    Sa(t) {
+        for (const e of this.ya) if (e.timerId === t) return !0;
         return !1;
     }
     /**
@@ -15188,24 +15196,24 @@ function vc(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.
-     */    va(t) {
+     */    Da(t) {
         // Note that draining may generate more delayed ops, so we do that first.
-        return this.ba().then((() => {
+        return this.Va().then((() => {
             // Run ops in the same order they'd run if they ran naturally.
-            this._a.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
-            for (const e of this._a) if (e.skipDelay(), "all" /* All */ !== t && e.timerId === t) break;
-            return this.ba();
+            this.ya.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
+            for (const e of this.ya) if (e.skipDelay(), "all" /* All */ !== t && e.timerId === t) break;
+            return this.Va();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    Va(t) {
-        this.pa.push(t);
+     */    Ca(t) {
+        this.Ia.push(t);
     }
-    /** Called once a DelayedOperation is run or canceled. */    Ra(t) {
+    /** Called once a DelayedOperation is run or canceled. */    va(t) {
         // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.
-        const e = this._a.indexOf(t);
-        this._a.splice(e, 1);
+        const e = this.ya.indexOf(t);
+        this.ya.splice(e, 1);
     }
 }
 
@@ -15945,55 +15953,55 @@ function iu(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.Sa(), this.fieldTransforms = i || [], this.fieldMask = r || [];
+        void 0 === i && this.Na(), this.fieldTransforms = i || [], this.fieldMask = r || [];
     }
     get path() {
         return this.settings.path;
     }
-    get Da() {
-        return this.settings.Da;
+    get xa() {
+        return this.settings.xa;
     }
-    /** Returns a new context with the specified settings overwritten. */    Ca(t) {
+    /** Returns a new context with the specified settings overwritten. */    ka(t) {
         return new ru(Object.assign(Object.assign({}, this.settings), t), this.databaseId, this.N, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
     }
-    Na(t) {
+    $a(t) {
         var e;
-        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.Ca({
+        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.ka({
             path: n,
-            xa: !1
+            Oa: !1
         });
-        return s.ka(t), s;
+        return s.Fa(t), s;
     }
-    $a(t) {
+    Ma(t) {
         var e;
-        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.Ca({
+        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), s = this.ka({
             path: n,
-            xa: !1
+            Oa: !1
         });
-        return s.Sa(), s;
+        return s.Na(), s;
     }
-    Oa(t) {
+    La(t) {
         // TODO(b/34871131): We don't support array paths right now; so make path
         // undefined.
-        return this.Ca({
+        return this.ka({
             path: void 0,
-            xa: !0
+            Oa: !0
         });
     }
-    Fa(t) {
-        return bu(t, this.settings.methodName, this.settings.Ma || !1, this.path, this.settings.La);
+    Ba(t) {
+        return bu(t, this.settings.methodName, this.settings.Ua || !1, this.path, this.settings.qa);
     }
     /** 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)));
     }
-    Sa() {
+    Na() {
         // 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.ka(this.path.get(t));
+        if (this.path) for (let t = 0; t < this.path.length; t++) this.Fa(this.path.get(t));
     }
-    ka(t) {
-        if (0 === t.length) throw this.Fa("Document fields must not be empty");
-        if (iu(this.Da) && eu.test(t)) throw this.Fa('Document fields cannot begin and end with "__"');
+    Fa(t) {
+        if (0 === t.length) throw this.Ba("Document fields must not be empty");
+        if (iu(this.xa) && eu.test(t)) throw this.Ba('Document fields cannot begin and end with "__"');
     }
 }
 
@@ -16004,14 +16012,14 @@ function iu(t) {
     constructor(t, e, n) {
         this.databaseId = t, this.ignoreUndefinedProperties = e, this.N = n || Yr(t);
     }
-    /** Creates a new top-level parse context. */    Ba(t, e, n, s = !1) {
+    /** Creates a new top-level parse context. */    Ka(t, e, n, s = !1) {
         return new ru({
-            Da: t,
+            xa: t,
             methodName: e,
-            La: n,
+            qa: n,
             path: ft.emptyPath(),
-            xa: !1,
-            Ma: s
+            Oa: !1,
+            Ua: s
         }, this.databaseId, this.N, this.ignoreUndefinedProperties);
     }
 }
@@ -16022,7 +16030,7 @@ function au(t) {
 }
 
 /** Parse document data from a set() call. */ function cu(t, e, n, s, i, r = {}) {
-    const o = t.Ba(r.merge || r.mergeFields ? 2 /* MergeSet */ : 0 /* Set */ , e, n, i);
+    const o = t.Ka(r.merge || r.mergeFields ? 2 /* MergeSet */ : 0 /* Set */ , e, n, i);
     Eu("Data must be an object, but it was:", o, s);
     const a = pu(s, o);
     let c, u;
@@ -16040,7 +16048,7 @@ function au(t) {
 
 class uu extends Zc {
     _toFieldTransform(t) {
-        if (2 /* MergeSet */ !== t.Da) throw 1 /* Update */ === t.Da ? t.Fa(`${this._methodName}() can only appear at the top level of your update data`) : t.Fa(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
+        if (2 /* MergeSet */ !== t.xa) throw 1 /* Update */ === t.xa ? t.Ba(`${this._methodName}() can only appear at the top level of your update data`) : t.Ba(`${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;
@@ -16067,10 +16075,10 @@ class uu extends Zc {
  * @param arrayElement - Whether or not the FieldValue has an array.
  */ function hu(t, e, n) {
     return new ru({
-        Da: 3 /* Argument */ ,
-        La: e.settings.La,
+        xa: 3 /* Argument */ ,
+        qa: e.settings.qa,
         methodName: t._methodName,
-        xa: n
+        Oa: n
     }, e.databaseId, e.N, e.ignoreUndefinedProperties);
 }
 
@@ -16085,11 +16093,11 @@ class lu extends Zc {
 
 class fu extends Zc {
     constructor(t, e) {
-        super(t), this.Ua = e;
+        super(t), this.ja = e;
     }
     _toFieldTransform(t) {
         const e = hu(this, t, 
-        /*array=*/ !0), n = this.Ua.map((t => yu(t, e))), s = new Fe(n);
+        /*array=*/ !0), n = this.ja.map((t => yu(t, e))), s = new Fe(n);
         return new je(t.path, s);
     }
     isEqual(t) {
@@ -16100,11 +16108,11 @@ class fu extends Zc {
 
 class du extends Zc {
     constructor(t, e) {
-        super(t), this.Ua = e;
+        super(t), this.ja = e;
     }
     _toFieldTransform(t) {
         const e = hu(this, t, 
-        /*array=*/ !0), n = this.Ua.map((t => yu(t, e))), s = new Le(n);
+        /*array=*/ !0), n = this.ja.map((t => yu(t, e))), s = new Le(n);
         return new je(t.path, s);
     }
     isEqual(t) {
@@ -16115,10 +16123,10 @@ class du extends Zc {
 
 class wu extends Zc {
     constructor(t, e) {
-        super(t), this.qa = e;
+        super(t), this.Qa = e;
     }
     _toFieldTransform(t) {
-        const e = new Ue(t.N, Ce(t.N, this.qa));
+        const e = new Ue(t.N, Ce(t.N, this.Qa));
         return new je(t.path, e);
     }
     isEqual(t) {
@@ -16128,7 +16136,7 @@ class wu extends Zc {
 }
 
 /** Parse update data from an update() call. */ function _u(t, e, n, s) {
-    const i = t.Ba(1 /* Update */ , e, n);
+    const i = t.Ka(1 /* Update */ , e, n);
     Eu("Data must be an object, but it was:", i, s);
     const r = [], o = Ut.empty();
     at(s, ((t, s) => {
@@ -16136,7 +16144,7 @@ class wu extends Zc {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 s = getModularInstance(s);
-        const c = i.$a(a);
+        const c = i.Ma(a);
         if (s instanceof uu) 
         // Add it to the field mask, but don't add anything to updateData.
         r.push(a); else {
@@ -16149,7 +16157,7 @@ class wu extends Zc {
 }
 
 /** Parse update data from a list of field/value arguments. */ function mu(t, e, n, s, i, r) {
-    const o = t.Ba(1 /* Update */ , e, n), a = [ Iu(e, s, n) ], c = [ i ];
+    const o = t.Ka(1 /* Update */ , e, n), a = [ Iu(e, s, n) ], c = [ i ];
     if (r.length % 2 != 0) throw new j(K.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) a.push(Iu(e, r[t])), c.push(r[t + 1]);
     const u = [], h = Ut.empty();
@@ -16161,7 +16169,7 @@ class wu extends Zc {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = getModularInstance(n);
-        const s = o.$a(e);
+        const s = o.Ma(e);
         if (n instanceof uu) 
         // Add it to the field mask, but don't add anything to updateData.
         u.push(e); else {
@@ -16180,7 +16188,7 @@ class wu extends Zc {
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
  */ function gu(t, e, n, s = !1) {
-    return yu(n, t.Ba(s ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
+    return yu(n, t.Ka(s ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
 }
 
 /**
@@ -16208,8 +16216,8 @@ class wu extends Zc {
  */
     return function(t, e) {
         // Sentinels are only supported with writes, and not within arrays.
-        if (!iu(e.Da)) throw e.Fa(`${t._methodName}() can only be used with update() and set()`);
-        if (!e.path) throw e.Fa(`${t._methodName}() is not currently supported inside arrays`);
+        if (!iu(e.xa)) throw e.Ba(`${t._methodName}() can only be used with update() and set()`);
+        if (!e.path) throw e.Ba(`${t._methodName}() is not currently supported inside arrays`);
         const n = t._toFieldTransform(e);
         n && e.fieldTransforms.push(n);
     }
@@ -16233,12 +16241,12 @@ class wu extends Zc {
         // 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.xa && 4 /* ArrayArgument */ !== e.Da) throw e.Fa("Nested arrays are not supported");
+        if (e.settings.Oa && 4 /* ArrayArgument */ !== e.xa) throw e.Ba("Nested arrays are not supported");
         return function(t, e) {
             const n = [];
             let s = 0;
             for (const i of t) {
-                let t = yu(i, e.Oa(s));
+                let t = yu(i, e.La(s));
                 null == t && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -16290,12 +16298,12 @@ class wu extends Zc {
         };
         if (t instanceof Ic) {
             const n = e.databaseId, s = t.firestore._databaseId;
-            if (!s.isEqual(n)) throw e.Fa(`Document reference is for database ${s.projectId}/${s.database} but should be for database ${n.projectId}/${n.database}`);
+            if (!s.isEqual(n)) throw e.Ba(`Document reference is for database ${s.projectId}/${s.database} but should be for database ${n.projectId}/${n.database}`);
             return {
                 referenceValue: Qn(t.firestore._databaseId || e.databaseId, t._key.path)
             };
         }
-        throw e.Fa(`Unsupported field value: ${mc(t)}`);
+        throw e.Ba(`Unsupported field value: ${mc(t)}`);
     }
     /**
  * Checks whether an object looks like a JSON object that should be converted
@@ -16312,7 +16320,7 @@ function pu(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 = yu(s, e.Na(t));
+        const i = yu(s, e.$a(t));
         null != i && (n[t] = i);
     })), {
         mapValue: {
@@ -16330,7 +16338,7 @@ function Eu(t, e, n) {
         return "object" == typeof t && null !== t && (Object.getPrototypeOf(t) === Object.prototype || null === Object.getPrototypeOf(t));
     }(n)) {
         const s = mc(n);
-        throw "an object" === s ? e.Fa(t + " a custom object") : e.Fa(t + " " + s);
+        throw "an object" === s ? e.Ba(t + " a custom object") : e.Ba(t + " " + s);
     }
 }
 
@@ -16779,7 +16787,7 @@ function ku(t) {
 
 class Lu extends Fu {
     constructor(t, e, n) {
-        super(), this.Ka = t, this.ja = e, this.Qa = n, this.type = "where";
+        super(), this.Wa = t, this.Ga = e, this.za = n, this.type = "where";
     }
     _apply(t) {
         const e = au(t.firestore), n = function(t, e, n, s, i, r, o) {
@@ -16848,7 +16856,7 @@ class Lu extends Fu {
                 // Special case when it's a duplicate op to give a slightly clearer error message.
                 throw n === e.op ? new j(K.INVALID_ARGUMENT, `Invalid query. You cannot use more than one '${e.op.toString()}' filter.`) : new j(K.INVALID_ARGUMENT, `Invalid query. You cannot use '${e.op.toString()}' filters with '${n.toString()}' filters.`);
             }(t, c), c;
-        }(t._query, "where", e, t.firestore._databaseId, this.Ka, this.ja, this.Qa);
+        }(t._query, "where", e, t.firestore._databaseId, this.Wa, this.Ga, this.za);
         return new Ac(t.firestore, t.converter, function(t, e) {
             const n = t.filters.concat([ e ]);
             return new fe(t.path, t.collectionGroup, t.explicitOrderBy.slice(), n, t.limit, t.limitType, t.startAt, t.endAt);
@@ -16873,7 +16881,7 @@ class Lu extends Fu {
 
 class Uu extends Fu {
     constructor(t, e) {
-        super(), this.Ka = t, this.Wa = e, this.type = "orderBy";
+        super(), this.Wa = t, this.Ha = e, this.type = "orderBy";
     }
     _apply(t) {
         const e = function(t, e, n) {
@@ -16898,7 +16906,7 @@ class Uu extends Fu {
  * 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.Ka, this.Wa);
+ */ (t._query, this.Wa, this.Ha);
         return new Ac(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 ]);
@@ -16922,10 +16930,10 @@ class Uu extends Fu {
 
 class Ku extends Fu {
     constructor(t, e, n) {
-        super(), this.type = t, this.Ga = e, this.za = n;
+        super(), this.type = t, this.Ja = e, this.Ya = n;
     }
     _apply(t) {
-        return new Ac(t.firestore, t.converter, Ie(t._query, this.Ga, this.za));
+        return new Ac(t.firestore, t.converter, Ie(t._query, this.Ja, this.Ya));
     }
 }
 
@@ -16952,10 +16960,10 @@ class Ku extends Fu {
 
 class Wu extends Fu {
     constructor(t, e, n) {
-        super(), this.type = t, this.Ha = e, this.Ja = n;
+        super(), this.type = t, this.Xa = e, this.Za = n;
     }
     _apply(t) {
-        const e = Xu(t, this.type, this.Ha, this.Ja);
+        const e = Xu(t, this.type, this.Xa, this.Za);
         return new Ac(t.firestore, t.converter, function(t, e) {
             return new fe(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, e, t.endAt);
         }(t._query, e));
@@ -16973,10 +16981,10 @@ function zu(...t) {
 
 class Hu extends Fu {
     constructor(t, e, n) {
-        super(), this.type = t, this.Ha = e, this.Ja = n;
+        super(), this.type = t, this.Xa = e, this.Za = n;
     }
     _apply(t) {
-        const e = Xu(t, this.type, this.Ha, this.Ja);
+        const e = Xu(t, this.type, this.Xa, this.Za);
         return new Ac(t.firestore, t.converter, function(t, e) {
             return new fe(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, t.startAt, e);
         }(t._query, e));
@@ -17511,7 +17519,7 @@ function yh(t, ...e) {
     return function(t, e, n, s) {
         const i = new La(s), r = new Qo(e, i, n);
         return t.asyncQueue.enqueueAndForget((async () => Bo(await Xa(t), r))), () => {
-            i.Xo(), t.asyncQueue.enqueueAndForget((async () => Uo(await Xa(t), r)));
+            i.ea(), t.asyncQueue.enqueueAndForget((async () => Uo(await Xa(t), r)));
         };
     }(Fc(u), h, a, c);
 }
@@ -17640,7 +17648,7 @@ function ph(t, e) {
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
  */ function Ah(t, e) {
-    return oc(Fc(t), (n => e(new Ih(t, n))));
+    return oc(Fc(t = gc(t, kc)), (n => e(new Ih(t, n))));
 }
 
 /**
@@ -17762,18 +17770,18 @@ function ph(t, e) {
  * Cloud Firestore
  *
  * @packageDocumentation
- */ var Dh;
-
-!function(t) {
-    C = t;
-}(SDK_VERSION), _registerComponent(new Component("firestore", ((t, {options: e}) => {
-    const n = t.getProvider("app").getImmediate(), s = new kc(n, new H(t.getProvider("auth-internal")));
-    return e = Object.assign({
-        useFetchStreams: !0
-    }, e), s._setSettings(e), s;
-}), "PUBLIC" /* PUBLIC */)), registerVersion(S, "3.1.1", Dh), 
-// BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-registerVersion(S, "3.1.1", "esm2017");
+ */ !function(t, e = !0) {
+    !function(t) {
+        C = t;
+    }(SDK_VERSION), _registerComponent(new Component("firestore", ((t, {options: n}) => {
+        const s = t.getProvider("app").getImmediate(), i = new kc(s, new H(t.getProvider("auth-internal")));
+        return n = Object.assign({
+            useFetchStreams: e
+        }, n), i._setSettings(n), i;
+    }), "PUBLIC" /* PUBLIC */)), registerVersion(S, "3.2.0-canary.477bdef13", t), 
+    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
+    registerVersion(S, "3.2.0-canary.477bdef13", "esm2017");
+}();
 
 export { nh as AbstractUserDataWriter, Xc as Bytes, xc as CACHE_SIZE_UNLIMITED, Rc as CollectionReference, Ic as DocumentReference, Cu as DocumentSnapshot, Jc as FieldPath, Zc as FieldValue, kc as Firestore, j as FirestoreError, tu as GeoPoint, Nc as LoadBundleTask, Ac as Query, Fu as QueryConstraint, Nu as QueryDocumentSnapshot, xu as QuerySnapshot, Du as SnapshotMetadata, it as Timestamp, Ih as Transaction, rh as WriteBatch, hc as _DatabaseId, Pt as _DocumentKey, G as _EmptyCredentialsProvider, ft as _FieldPath, gc as _cast, U as _debugAssert, wt as _isBase64Available, F as _logWarn, dc as _validateIsNotUsedTogether, gh as addDoc, vh as arrayRemove, Ph as arrayUnion, qc as clearIndexedDbPersistence, bc as collection, Pc as collectionGroup, Ec as connectFirestoreEmulator, mh as deleteDoc, Rh as deleteField, Qc as disableNetwork, vc as doc, Yc as documentId, Lc as enableIndexedDbPersistence, Bc as enableMultiTabIndexedDbPersistence, jc as enableNetwork, Yu as endAt, Ju as endBefore, Fc as ensureFirestoreConfigured, Th as executeWrite, ah as getDoc, uh as getDocFromCache, hh as getDocFromServer, lh as getDocs, fh as getDocsFromCache, dh as getDocsFromServer, Oc as getFirestore, Vh as increment, $c as initializeFirestore, ju as limit, Qu as limitToLast, Gc as loadBundle, zc as namedQuery, yh as onSnapshot, ph as onSnapshotsInSync, qu as orderBy, Mu as query, Sc as queryEqual, Vc as refEqual, Ah as runTransaction, bh as serverTimestamp, wh as setDoc, k as setLogLevel, $u as snapshotEqual, zu as startAfter, Gu as startAt, Wc as terminate, _h as updateDoc, Kc as waitForPendingWrites, Bu as where, Sh as writeBatch };
 //# sourceMappingURL=index.esm2017.js.map