@firebase/firestore 3.7.1 → 3.7.2

package/dist/index.esm2017.js

@@ -66,7 +66,7 @@ P.MOCK_USER = new P("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let v = "9.12.1";
+let v = "9.13.0";
 
 /**
  * @license
@@ -12883,14 +12883,14 @@ class tu {
  */
 class eu {
     constructor(t, e, n, s, i, r, o, u) {
-        this.Hs = t, this.vo = n, this.Vo = s, this.So = i, this.authCredentialsProvider = r, 
+        this.Hs = t, this.vo = n, this.Vo = s, this.connection = i, this.authCredentialsProvider = r, 
         this.appCheckCredentialsProvider = o, this.listener = u, 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.Do = 0, this.Co = null, this.xo = null, this.stream = null, this.No = new tu(t, e);
+        this.So = 0, this.Do = null, this.Co = null, this.stream = null, this.xo = new tu(t, e);
     }
     /**
      * Returns true if start() has been called and no error has occurred. True
@@ -12898,13 +12898,13 @@ class eu {
      * 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.
-     */    ko() {
-        return 1 /* Starting */ === this.state || 5 /* Backoff */ === this.state || this.Oo();
+     */    No() {
+        return 1 /* Starting */ === this.state || 5 /* Backoff */ === this.state || this.ko();
     }
     /**
      * Returns true if the underlying RPC is open (the onOpen() listener has been
      * called) and the stream is ready for outbound requests.
-     */    Oo() {
+     */    ko() {
         return 2 /* Open */ === this.state || 3 /* Healthy */ === this.state;
     }
     /**
@@ -12914,7 +12914,7 @@ class eu {
      *
      * When start returns, isStarted() will return true.
      */    start() {
-        4 /* Error */ !== this.state ? this.auth() : this.Mo();
+        4 /* Error */ !== this.state ? this.auth() : this.Oo();
     }
     /**
      * Stops the RPC. This call is idempotent and allowed regardless of the
@@ -12922,7 +12922,7 @@ class eu {
      *
      * When stop returns, isStarted() and isOpen() will both return false.
      */    async stop() {
-        this.ko() && await this.close(0 /* Initial */);
+        this.No() && await this.close(0 /* Initial */);
     }
     /**
      * After an error the stream will usually back off on the next attempt to
@@ -12931,8 +12931,8 @@ class eu {
      *
      * Each error will call the onClose() listener. That function can decide to
      * inhibit backoff if required.
-     */    Fo() {
-        this.state = 0 /* Initial */ , this.No.reset();
+     */    Mo() {
+        this.state = 0 /* Initial */ , this.xo.reset();
     }
     /**
      * Marks this stream as idle. If no further actions are performed on the
@@ -12943,25 +12943,25 @@ class eu {
      *
      * Only streams that are in state 'Open' can be marked idle, as all other
      * states imply pending network operations.
-     */    $o() {
+     */    Fo() {
         // 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.Oo() && null === this.Co && (this.Co = this.Hs.enqueueAfterDelay(this.vo, 6e4, (() => this.Bo())));
+        this.ko() && null === this.Do && (this.Do = this.Hs.enqueueAfterDelay(this.vo, 6e4, (() => this.$o())));
     }
-    /** Sends a message to the underlying stream. */    Lo(t) {
-        this.Uo(), this.stream.send(t);
+    /** Sends a message to the underlying stream. */    Bo(t) {
+        this.Lo(), this.stream.send(t);
     }
-    /** Called by the idle timer when the stream should close due to inactivity. */    async Bo() {
-        if (this.Oo()) 
+    /** Called by the idle timer when the stream should close due to inactivity. */    async $o() {
+        if (this.ko()) 
         // 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. */    Uo() {
-        this.Co && (this.Co.cancel(), this.Co = null);
+    /** Marks the stream as active again. */    Lo() {
+        this.Do && (this.Do.cancel(), this.Do = null);
     }
-    /** Cancels the health check delayed operation. */    qo() {
-        this.xo && (this.xo.cancel(), this.xo = null);
+    /** Cancels the health check delayed operation. */    Uo() {
+        this.Co && (this.Co.cancel(), this.Co = null);
     }
     /**
      * Closes the stream and cleans up as necessary:
@@ -12977,15 +12977,15 @@ class eu {
      * @param error - the error the connection was closed with.
      */    async close(t, e) {
         // Cancel any outstanding timers (they're guaranteed not to execute).
-        this.Uo(), this.qo(), this.No.cancel(), 
+        this.Lo(), this.Uo(), this.xo.cancel(), 
         // Invalidates any stream-related callbacks (e.g. from auth or the
         // underlying stream), guaranteeing they won't execute.
-        this.Do++, 4 /* Error */ !== t ? 
+        this.So++, 4 /* Error */ !== t ? 
         // If this is an intentional close ensure we don't delay our next connection attempt.
-        this.No.reset() : e && e.code === B.RESOURCE_EXHAUSTED ? (
+        this.xo.reset() : e && e.code === B.RESOURCE_EXHAUSTED ? (
         // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)
         x(e.toString()), x("Using maximum backoff delay to prevent overloading the backend."), 
-        this.No.Ao()) : e && e.code === B.UNAUTHENTICATED && 3 /* Healthy */ !== this.state && (
+        this.xo.Ao()) : e && e.code === B.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
@@ -12994,7 +12994,7 @@ class eu {
         // to ensure that we fetch a new token.
         this.authCredentialsProvider.invalidateToken(), this.appCheckCredentialsProvider.invalidateToken()), 
         // Clean up the underlying stream because we are no longer interested in events.
-        null !== this.stream && (this.Ko(), this.stream.close(), this.stream = null), 
+        null !== this.stream && (this.qo(), 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, 
@@ -13004,46 +13004,46 @@ class eu {
     /**
      * Can be overridden to perform additional cleanup before the stream is closed.
      * Calling super.tearDown() is not required.
-     */    Ko() {}
+     */    qo() {}
     auth() {
         this.state = 1 /* Starting */;
-        const t = this.Go(this.Do), e = this.Do;
+        const t = this.Ko(this.So), e = this.So;
         // TODO(mikelehen): Just use dispatchIfNotClosed, but see TODO below.
                 Promise.all([ this.authCredentialsProvider.getToken(), this.appCheckCredentialsProvider.getToken() ]).then((([t, n]) => {
             // Stream can be stopped while waiting for authentication.
             // TODO(mikelehen): We really should just use dispatchIfNotClosed
             // and let this dispatch onto the queue, but that opened a spec test can
             // of worms that I don't want to deal with in this PR.
-            this.Do === e && 
+            this.So === 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.Qo(t, n);
+            this.Go(t, n);
         }), (e => {
             t((() => {
                 const t = new L(B.UNKNOWN, "Fetching auth token failed: " + e.message);
-                return this.jo(t);
+                return this.Qo(t);
             }));
         }));
     }
-    Qo(t, e) {
-        const n = this.Go(this.Do);
-        this.stream = this.Wo(t, e), this.stream.Yr((() => {
-            n((() => (this.state = 2 /* Open */ , this.xo = this.Hs.enqueueAfterDelay(this.Vo, 1e4, (() => (this.Oo() && (this.state = 3 /* Healthy */), 
+    Go(t, e) {
+        const n = this.Ko(this.So);
+        this.stream = this.jo(t, e), this.stream.Yr((() => {
+            n((() => (this.state = 2 /* Open */ , this.Co = this.Hs.enqueueAfterDelay(this.Vo, 1e4, (() => (this.ko() && (this.state = 3 /* Healthy */), 
             Promise.resolve()))), this.listener.Yr())));
         })), this.stream.Zr((t => {
-            n((() => this.jo(t)));
+            n((() => this.Qo(t)));
         })), this.stream.onMessage((t => {
             n((() => this.onMessage(t)));
         }));
     }
-    Mo() {
-        this.state = 5 /* Backoff */ , this.No.Ro((async () => {
+    Oo() {
+        this.state = 5 /* Backoff */ , this.xo.Ro((async () => {
             this.state = 0 /* Initial */ , this.start();
         }));
     }
     // Visible for tests
-    jo(t) {
+    Qo(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
@@ -13055,9 +13055,9 @@ class eu {
      * 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.
-     */    Go(t) {
+     */    Ko(t) {
         return e => {
-            this.Hs.enqueueAndForget((() => this.Do === t ? e() : (C("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
+            this.Hs.enqueueAndForget((() => this.So === t ? e() : (C("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
             Promise.resolve())));
         };
     }
@@ -13074,12 +13074,12 @@ class eu {
         super(t, "listen_stream_connection_backoff" /* ListenStreamConnectionBackoff */ , "listen_stream_idle" /* ListenStreamIdle */ , "health_check_timeout" /* HealthCheckTimeout */ , e, n, s, r), 
         this.It = i;
     }
-    Wo(t, e) {
-        return this.So.wo("Listen", t, e);
+    jo(t, e) {
+        return this.connection.wo("Listen", t, e);
     }
     onMessage(t) {
         // A successful response means the stream is healthy
-        this.No.reset();
+        this.xo.reset();
         const e = qs(this.It, 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
@@ -13088,14 +13088,14 @@ class eu {
             const e = t.targetChange;
             return e.targetIds && e.targetIds.length ? st.min() : e.readTime ? Ds(e.readTime) : st.min();
         }(t);
-        return this.listener.zo(e, n);
+        return this.listener.Wo(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.
-     */    Ho(t) {
+     */    zo(t) {
         const e = {};
         e.database = Fs(this.It), e.addTarget = function(t, e) {
             let n;
@@ -13111,14 +13111,14 @@ class eu {
             n.readTime = vs(t, e.snapshotVersion.toTimestamp())), n;
         }(this.It, t);
         const n = Hs(this.It, t);
-        n && (e.labels = n), this.Lo(e);
+        n && (e.labels = n), this.Bo(e);
     }
     /**
      * Unregisters interest in the results of the target associated with the
      * given targetId.
-     */    Jo(t) {
+     */    Ho(t) {
         const e = {};
-        e.database = Fs(this.It), e.removeTarget = t, this.Lo(e);
+        e.database = Fs(this.It), e.removeTarget = t, this.Bo(e);
     }
 }
 
@@ -13141,54 +13141,54 @@ class eu {
  */ class su extends eu {
     constructor(t, e, n, s, i, r) {
         super(t, "write_stream_connection_backoff" /* WriteStreamConnectionBackoff */ , "write_stream_idle" /* WriteStreamIdle */ , "health_check_timeout" /* HealthCheckTimeout */ , e, n, s, r), 
-        this.It = i, this.Yo = !1;
+        this.It = i, this.Jo = !1;
     }
     /**
      * Tracks whether or not a handshake has been successfully exchanged and
      * the stream is ready to accept mutations.
-     */    get Xo() {
-        return this.Yo;
+     */    get Yo() {
+        return this.Jo;
     }
     // Override of PersistentStream.start
     start() {
-        this.Yo = !1, this.lastStreamToken = void 0, super.start();
+        this.Jo = !1, this.lastStreamToken = void 0, super.start();
     }
-    Ko() {
-        this.Yo && this.Zo([]);
+    qo() {
+        this.Jo && this.Xo([]);
     }
-    Wo(t, e) {
-        return this.So.wo("Write", t, e);
+    jo(t, e) {
+        return this.connection.wo("Write", t, e);
     }
     onMessage(t) {
         if (
         // Always capture the last stream token.
-        M(!!t.streamToken), this.lastStreamToken = t.streamToken, this.Yo) {
+        M(!!t.streamToken), this.lastStreamToken = t.streamToken, this.Jo) {
             // 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.No.reset();
+            this.xo.reset();
             const e = Qs(t.writeResults, t.commitTime), n = Ds(t.commitTime);
-            return this.listener.tu(n, e);
+            return this.listener.Zo(n, e);
         }
         // The first response is always the handshake response
-        return M(!t.writeResults || 0 === t.writeResults.length), this.Yo = !0, this.listener.eu();
+        return M(!t.writeResults || 0 === t.writeResults.length), this.Jo = !0, this.listener.tu();
     }
     /**
      * 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.
-     */    nu() {
+     */    eu() {
         // 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 = Fs(this.It), this.Lo(t);
+        t.database = Fs(this.It), this.Bo(t);
     }
-    /** Sends a group of mutations to the Firestore backend to apply. */    Zo(t) {
+    /** Sends a group of mutations to the Firestore backend to apply. */    Xo(t) {
         const e = {
             streamToken: this.lastStreamToken,
             writes: t.map((t => Ks(this.It, t)))
         };
-        this.Lo(e);
+        this.Bo(e);
     }
 }
 
@@ -13219,26 +13219,26 @@ class eu {
  */
 class iu extends class {} {
     constructor(t, e, n, s) {
-        super(), this.authCredentials = t, this.appCheckCredentials = e, this.So = n, this.It = s, 
-        this.su = !1;
+        super(), this.authCredentials = t, this.appCheckCredentials = e, this.connection = n, 
+        this.It = s, this.nu = !1;
     }
-    iu() {
-        if (this.su) throw new L(B.FAILED_PRECONDITION, "The client has already been terminated.");
+    su() {
+        if (this.nu) throw new L(B.FAILED_PRECONDITION, "The client has already been terminated.");
     }
     /** Invokes the provided RPC with auth and AppCheck tokens. */    ao(t, e, n) {
-        return this.iu(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, i]) => this.So.ao(t, e, n, s, i))).catch((t => {
+        return this.su(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, i]) => this.connection.ao(t, e, n, s, i))).catch((t => {
             throw "FirebaseError" === t.name ? (t.code === B.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), t) : new L(B.UNKNOWN, t.toString());
         }));
     }
     /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */    _o(t, e, n, s) {
-        return this.iu(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([i, r]) => this.So._o(t, e, n, i, r, s))).catch((t => {
+        return this.su(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([i, r]) => this.connection._o(t, e, n, i, r, s))).catch((t => {
             throw "FirebaseError" === t.name ? (t.code === B.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), t) : new L(B.UNKNOWN, t.toString());
         }));
     }
     terminate() {
-        this.su = !0;
+        this.nu = !0;
     }
 }
 
@@ -13258,7 +13258,7 @@ async function ru(t, e) {
             parent: n.parent
         };
     }(n.It, cn(e)), i = s.parent;
-    n.So.co || delete s.parent;
+    n.connection.co || delete s.parent;
     return (await n._o("RunAggregationQuery", i, s, /*expectedResponseCount=*/ 1)).filter((t => !!t.result)).map((t => t.result.aggregateFields));
 }
 
@@ -13283,19 +13283,19 @@ class ou {
          * maximum defined by MAX_WATCH_STREAM_FAILURES, we'll set the OnlineState to
          * Offline.
          */
-        this.ru = 0, 
+        this.iu = 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.ou = null, 
+        this.ru = 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.uu = !0;
+        this.ou = !0;
     }
     /**
      * Called by RemoteStore when a watch stream is started (including on each
@@ -13303,9 +13303,9 @@ class ou {
      *
      * If this is the first attempt, it sets the OnlineState to Unknown and starts
      * the onlineStateTimer.
-     */    cu() {
-        0 === this.ru && (this.au("Unknown" /* Unknown */), this.ou = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* OnlineStateTimeout */ , 1e4, (() => (this.ou = null, 
-        this.hu("Backend didn't respond within 10 seconds."), this.au("Offline" /* Offline */), 
+     */    uu() {
+        0 === this.iu && (this.cu("Unknown" /* Unknown */), this.ru = this.asyncQueue.enqueueAfterDelay("online_state_timeout" /* OnlineStateTimeout */ , 1e4, (() => (this.ru = null, 
+        this.au("Backend didn't respond within 10 seconds."), this.cu("Offline" /* Offline */), 
         Promise.resolve()))));
     }
     /**
@@ -13313,10 +13313,10 @@ class ou {
      * 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.
-     */    lu(t) {
-        "Online" /* Online */ === this.state ? this.au("Unknown" /* Unknown */) : (this.ru++, 
-        this.ru >= 1 && (this.fu(), this.hu(`Connection failed 1 times. Most recent error: ${t.toString()}`), 
-        this.au("Offline" /* Offline */)));
+     */    hu(t) {
+        "Online" /* Online */ === this.state ? this.cu("Unknown" /* Unknown */) : (this.iu++, 
+        this.iu >= 1 && (this.lu(), this.au(`Connection failed 1 times. Most recent error: ${t.toString()}`), 
+        this.cu("Offline" /* Offline */)));
     }
     /**
      * Explicitly sets the OnlineState to the specified state.
@@ -13325,20 +13325,20 @@ class ou {
      * Offline heuristics, so must not be used in place of
      * handleWatchStreamStart() and handleWatchStreamFailure().
      */    set(t) {
-        this.fu(), this.ru = 0, "Online" /* Online */ === t && (
+        this.lu(), this.iu = 0, "Online" /* Online */ === t && (
         // We've connected to watch at least once. Don't warn the developer
         // about being offline going forward.
-        this.uu = !1), this.au(t);
+        this.ou = !1), this.cu(t);
     }
-    au(t) {
+    cu(t) {
         t !== this.state && (this.state = t, this.onlineStateHandler(t));
     }
-    hu(t) {
+    au(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.uu ? (x(e), this.uu = !1) : C("OnlineStateTracker", e);
+        this.ou ? (x(e), this.ou = !1) : C("OnlineStateTracker", e);
     }
-    fu() {
-        null !== this.ou && (this.ou.cancel(), this.ou = null);
+    lu() {
+        null !== this.ru && (this.ru.cancel(), this.ru = null);
     }
 }
 
@@ -13383,7 +13383,7 @@ class ou {
          * purely based on order, and so we can just shift() writes from the front of
          * the writePipeline as we receive responses.
          */
-        this.du = [], 
+        this.fu = [], 
         /**
          * A mapping of watched targets that the client cares about tracking and the
          * user has explicitly called a 'listen' for this target.
@@ -13393,12 +13393,12 @@ class ou {
          * to the server. The targets removed with unlistens are removed eagerly
          * without waiting for confirmation from the listen stream.
          */
-        this._u = new Map, 
+        this.du = new Map, 
         /**
          * A set of reasons for why the RemoteStore may be offline. If empty, the
          * RemoteStore may start its network connections.
          */
-        this.wu = new Set, 
+        this._u = new Set, 
         /**
          * Event handlers that get called when the network is disabled or enabled.
          *
@@ -13406,7 +13406,7 @@ class ou {
          * underlying streams (to support tree-shakeable streams). On Android and iOS,
          * the streams are created during construction of RemoteStore.
          */
-        this.mu = [], this.gu = i, this.gu.qr((t => {
+        this.wu = [], this.mu = i, this.mu.qr((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
@@ -13414,23 +13414,23 @@ class ou {
                 mu(this) && (C("RemoteStore", "Restarting streams for network reachability change."), 
                 await async function(t) {
                     const e = $(t);
-                    e.wu.add(4 /* ConnectivityChange */), await au(e), e.yu.set("Unknown" /* Unknown */), 
-                    e.wu.delete(4 /* ConnectivityChange */), await cu(e);
+                    e._u.add(4 /* ConnectivityChange */), await au(e), e.gu.set("Unknown" /* Unknown */), 
+                    e._u.delete(4 /* ConnectivityChange */), await cu(e);
                 }(this));
             }));
-        })), this.yu = new ou(n, s);
+        })), this.gu = new ou(n, s);
     }
 }
 
 async function cu(t) {
-    if (mu(t)) for (const e of t.mu) await e(/* enabled= */ !0);
+    if (mu(t)) for (const e of t.wu) await e(/* enabled= */ !0);
 }
 
 /**
  * Temporarily disables the network. The network can be re-enabled using
  * enableNetwork().
  */ async function au(t) {
-    for (const e of t.mu) await e(/* enabled= */ !1);
+    for (const e of t.wu) await e(/* enabled= */ !1);
 }
 
 /**
@@ -13439,11 +13439,11 @@ async function cu(t) {
  */
 function hu(t, e) {
     const n = $(t);
-    n._u.has(e.targetId) || (
+    n.du.has(e.targetId) || (
     // Mark this as something the client is currently listening for.
-    n._u.set(e.targetId, e), wu(n) ? 
+    n.du.set(e.targetId, e), wu(n) ? 
     // The listen will be sent in onWatchStreamOpen
-    _u(n) : ku(n).Oo() && fu(n, e));
+    _u(n) : ku(n).ko() && fu(n, e));
 }
 
 /**
@@ -13451,18 +13451,18 @@ function hu(t, e) {
  * not being listened to.
  */ function lu(t, e) {
     const n = $(t), s = ku(n);
-    n._u.delete(e), s.Oo() && du(n, e), 0 === n._u.size && (s.Oo() ? s.$o() : mu(n) && 
+    n.du.delete(e), s.ko() && du(n, e), 0 === n.du.size && (s.ko() ? s.Fo() : mu(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.yu.set("Unknown" /* Unknown */));
+    n.gu.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 fu(t, e) {
-    t.pu.Mt(e.targetId), ku(t).Ho(e);
+    t.yu.Mt(e.targetId), ku(t).zo(e);
 }
 
 /**
@@ -13470,33 +13470,33 @@ function hu(t, e) {
  * from watch so we wait for the removal on the server before we process any
  * messages from this target.
  */ function du(t, e) {
-    t.pu.Mt(e), ku(t).Jo(e);
+    t.yu.Mt(e), ku(t).Ho(e);
 }
 
 function _u(t) {
-    t.pu = new Ts({
+    t.yu = new Ts({
         getRemoteKeysForTarget: e => t.remoteSyncer.getRemoteKeysForTarget(e),
-        se: e => t._u.get(e) || null
-    }), ku(t).start(), t.yu.cu();
+        se: e => t.du.get(e) || null
+    }), ku(t).start(), t.gu.uu();
 }
 
 /**
  * Returns whether the watch stream should be started because it's necessary
  * and has not yet been started.
  */ function wu(t) {
-    return mu(t) && !ku(t).ko() && t._u.size > 0;
+    return mu(t) && !ku(t).No() && t.du.size > 0;
 }
 
 function mu(t) {
-    return 0 === $(t).wu.size;
+    return 0 === $(t)._u.size;
 }
 
 function gu(t) {
-    t.pu = void 0;
+    t.yu = void 0;
 }
 
 async function yu(t) {
-    t._u.forEach(((e, n) => {
+    t.du.forEach(((e, n) => {
         fu(t, e);
     }));
 }
@@ -13504,17 +13504,17 @@ async function yu(t) {
 async function pu(t, e) {
     gu(t), 
     // If we still need the watch stream, retry the connection.
-    wu(t) ? (t.yu.lu(e), _u(t)) : 
+    wu(t) ? (t.gu.hu(e), _u(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.yu.set("Unknown" /* Unknown */);
+    t.gu.set("Unknown" /* Unknown */);
 }
 
 async function Iu(t, e, n) {
     if (
     // Mark the client as online since we got a message from the server
-    t.yu.set("Online" /* Online */), e instanceof ps && 2 /* Removed */ === e.state && e.cause) 
+    t.gu.set("Online" /* Online */), e instanceof ps && 2 /* Removed */ === e.state && e.cause) 
     // There was an error on a target, don't wait for a consistent snapshot
     // to raise events
     try {
@@ -13524,7 +13524,7 @@ async function Iu(t, e, n) {
             const n = e.cause;
             for (const s of e.targetIds) 
             // A watched target might have been removed already.
-            t._u.has(s) && (await t.remoteSyncer.rejectListen(s, n), t._u.delete(s), t.pu.removeTarget(s));
+            t.du.has(s) && (await t.remoteSyncer.rejectListen(s, n), t.du.delete(s), t.yu.removeTarget(s));
         }
         /**
  * Attempts to fill our write pipeline with writes from the LocalStore.
@@ -13537,7 +13537,7 @@ async function Iu(t, e, n) {
     } catch (n) {
         C("RemoteStore", "Failed to remove targets %s: %s ", e.targetIds.join(","), n), 
         await Tu(t, n);
-    } else if (e instanceof gs ? t.pu.Gt(e) : e instanceof ys ? t.pu.Yt(e) : t.pu.Wt(e), 
+    } else if (e instanceof gs ? t.yu.Gt(e) : e instanceof ys ? t.yu.Yt(e) : t.yu.Wt(e), 
     !n.isEqual(st.min())) try {
         const e = await Ro(t.localStore);
         n.compareTo(e) >= 0 && 
@@ -13550,26 +13550,26 @@ async function Iu(t, e, n) {
  * SyncEngine.
  */
         function(t, e) {
-            const n = t.pu.te(e);
+            const n = t.yu.te(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._u.get(s);
+                    const i = t.du.get(s);
                     // A watched target might have been removed already.
-                                        i && t._u.set(s, i.withResumeToken(n.resumeToken, e));
+                                        i && t.du.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._u.get(e);
+                const n = t.du.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._u.set(e, n.withResumeToken(Wt.EMPTY_BYTE_STRING, n.snapshotVersion)), 
+                                t.du.set(e, n.withResumeToken(Wt.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.
                 du(t, e);
@@ -13596,16 +13596,16 @@ async function Iu(t, e, n) {
  * any retry attempt.
  */ async function Tu(t, e, n) {
     if (!Vt(e)) throw e;
-    t.wu.add(1 /* IndexedDbFailed */), 
+    t._u.add(1 /* IndexedDbFailed */), 
     // Disable network and raise offline snapshots
-    await au(t), t.yu.set("Offline" /* Offline */), n || (
+    await au(t), t.gu.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 = () => Ro(t.localStore)), 
     // Probe IndexedDB periodically and re-enable network
     t.asyncQueue.enqueueRetryable((async () => {
-        C("RemoteStore", "Retrying IndexedDB access"), await n(), t.wu.delete(1 /* IndexedDbFailed */), 
+        C("RemoteStore", "Retrying IndexedDB access"), await n(), t._u.delete(1 /* IndexedDbFailed */), 
         await cu(t);
     }));
 }
@@ -13619,11 +13619,11 @@ async function Iu(t, e, n) {
 
 async function Au(t) {
     const e = $(t), n = Ou(e);
-    let s = e.du.length > 0 ? e.du[e.du.length - 1].batchId : -1;
+    let s = e.fu.length > 0 ? e.fu[e.fu.length - 1].batchId : -1;
     for (;Ru(e); ) try {
         const t = await vo(e.localStore, s);
         if (null === t) {
-            0 === e.du.length && n.$o();
+            0 === e.fu.length && n.Fo();
             break;
         }
         s = t.batchId, bu(e, t);
@@ -13637,20 +13637,20 @@ async function Au(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 Ru(t) {
-    return mu(t) && t.du.length < 10;
+    return mu(t) && t.fu.length < 10;
 }
 
 /**
  * Queues additional writes to be sent to the write stream, sending them
  * immediately if the write stream is established.
  */ function bu(t, e) {
-    t.du.push(e);
+    t.fu.push(e);
     const n = Ou(t);
-    n.Oo() && n.Xo && n.Zo(e.mutations);
+    n.ko() && n.Yo && n.Xo(e.mutations);
 }
 
 function Pu(t) {
-    return mu(t) && !Ou(t).ko() && t.du.length > 0;
+    return mu(t) && !Ou(t).No() && t.fu.length > 0;
 }
 
 function vu(t) {
@@ -13658,17 +13658,17 @@ function vu(t) {
 }
 
 async function Vu(t) {
-    Ou(t).nu();
+    Ou(t).eu();
 }
 
 async function Su(t) {
     const e = Ou(t);
     // Send the write pipeline now that the stream is established.
-        for (const n of t.du) e.Zo(n.mutations);
+        for (const n of t.fu) e.Xo(n.mutations);
 }
 
 async function Du(t, e, n) {
-    const s = t.du.shift(), i = Oi.from(s, e, n);
+    const s = t.fu.shift(), i = Oi.from(s, e, n);
     await Eu(t, (() => t.remoteSyncer.applySuccessfulWrite(i))), 
     // It's possible that with the completion of this mutation another
     // slot has freed up.
@@ -13678,7 +13678,7 @@ async function Du(t, e, n) {
 async function Cu(t, e) {
     // If the write stream closed after the write handshake completes, a write
     // operation failed and we fail the pending operation.
-    e && Ou(t).Xo && 
+    e && Ou(t).Yo && 
     // This error affects the actual write.
     await async function(t, e) {
         // Only handle permanent errors here. If it's transient, just let the retry
@@ -13686,11 +13686,11 @@ async function Cu(t, e) {
         if (n = e.code, Zn(n) && n !== B.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.du.shift();
+            const n = t.fu.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.
-                        Ou(t).Fo(), await Eu(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
+                        Ou(t).Mo(), await Eu(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
             // It's possible that with the completion of this mutation
             // another slot has freed up.
             await Au(t);
@@ -13709,18 +13709,18 @@ async function xu(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.wu.add(3 /* CredentialChange */), await au(n), s && 
+        n._u.add(3 /* CredentialChange */), await au(n), s && 
     // Don't set the network status to Unknown if we are offline.
-    n.yu.set("Unknown" /* Unknown */), await n.remoteSyncer.handleCredentialChange(e), 
-    n.wu.delete(3 /* CredentialChange */), await cu(n);
+    n.gu.set("Unknown" /* Unknown */), await n.remoteSyncer.handleCredentialChange(e), 
+    n._u.delete(3 /* CredentialChange */), await cu(n);
 }
 
 /**
  * Toggles the network state when the client gains or loses its primary lease.
  */ async function Nu(t, e) {
     const n = $(t);
-    e ? (n.wu.delete(2 /* IsSecondary */), await cu(n)) : e || (n.wu.add(2 /* IsSecondary */), 
-    await au(n), n.yu.set("Unknown" /* Unknown */));
+    e ? (n._u.delete(2 /* IsSecondary */), await cu(n)) : e || (n._u.add(2 /* IsSecondary */), 
+    await au(n), n.gu.set("Unknown" /* Unknown */));
 }
 
 /**
@@ -13731,11 +13731,11 @@ async function xu(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 ku(t) {
-    return t.Iu || (
+    return t.pu || (
     // Create stream (but note that it is not started yet).
-    t.Iu = function(t, e, n) {
+    t.pu = function(t, e, n) {
         const s = $(t);
-        return s.iu(), new nu(e, s.So, s.authCredentials, s.appCheckCredentials, s.It, n);
+        return s.su(), new nu(e, s.connection, s.authCredentials, s.appCheckCredentials, s.It, n);
     }
     /**
  * @license
@@ -13755,11 +13755,11 @@ async function xu(t, e) {
  */ (t.datastore, t.asyncQueue, {
         Yr: yu.bind(null, t),
         Zr: pu.bind(null, t),
-        zo: Iu.bind(null, t)
-    }), t.mu.push((async e => {
-        e ? (t.Iu.Fo(), wu(t) ? _u(t) : t.yu.set("Unknown" /* Unknown */)) : (await t.Iu.stop(), 
+        Wo: Iu.bind(null, t)
+    }), t.wu.push((async e => {
+        e ? (t.pu.Mo(), wu(t) ? _u(t) : t.gu.set("Unknown" /* Unknown */)) : (await t.pu.stop(), 
         gu(t));
-    }))), t.Iu;
+    }))), t.pu;
 }
 
 /**
@@ -13770,22 +13770,22 @@ async function xu(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 Ou(t) {
-    return t.Tu || (
+    return t.Iu || (
     // Create stream (but note that it is not started yet).
-    t.Tu = function(t, e, n) {
+    t.Iu = function(t, e, n) {
         const s = $(t);
-        return s.iu(), new su(e, s.So, s.authCredentials, s.appCheckCredentials, s.It, n);
+        return s.su(), new su(e, s.connection, s.authCredentials, s.appCheckCredentials, s.It, n);
     }(t.datastore, t.asyncQueue, {
         Yr: Vu.bind(null, t),
         Zr: Cu.bind(null, t),
-        eu: Su.bind(null, t),
-        tu: Du.bind(null, t)
-    }), t.mu.push((async e => {
-        e ? (t.Tu.Fo(), 
+        tu: Su.bind(null, t),
+        Zo: Du.bind(null, t)
+    }), t.wu.push((async e => {
+        e ? (t.Iu.Mo(), 
         // This will start the write stream if necessary.
-        await Au(t)) : (await t.Tu.stop(), t.du.length > 0 && (C("RemoteStore", `Stopping write stream with ${t.du.length} pending writes`), 
-        t.du = []));
-    }))), t.Tu;
+        await Au(t)) : (await t.Iu.stop(), t.fu.length > 0 && (C("RemoteStore", `Stopping write stream with ${t.fu.length} pending writes`), 
+        t.fu = []));
+    }))), t.Iu;
 }
 
 /**
@@ -13995,25 +13995,25 @@ class Mu {
  * duplicate events for the same doc.
  */ class Bu {
     constructor() {
-        this.Eu = new Bt(ct.comparator);
+        this.Tu = new Bt(ct.comparator);
     }
     track(t) {
-        const e = t.doc.key, n = this.Eu.get(e);
+        const e = t.doc.key, n = this.Tu.get(e);
         n ? 
         // Merge the new change with the existing change.
-        0 /* Added */ !== t.type && 3 /* Metadata */ === n.type ? this.Eu = this.Eu.insert(e, t) : 3 /* Metadata */ === t.type && 1 /* Removed */ !== n.type ? this.Eu = this.Eu.insert(e, {
+        0 /* Added */ !== t.type && 3 /* Metadata */ === n.type ? this.Tu = this.Tu.insert(e, t) : 3 /* Metadata */ === t.type && 1 /* Removed */ !== n.type ? this.Tu = this.Tu.insert(e, {
             type: n.type,
             doc: t.doc
-        }) : 2 /* Modified */ === t.type && 2 /* Modified */ === n.type ? this.Eu = this.Eu.insert(e, {
+        }) : 2 /* Modified */ === t.type && 2 /* Modified */ === n.type ? this.Tu = this.Tu.insert(e, {
             type: 2 /* Modified */ ,
             doc: t.doc
-        }) : 2 /* Modified */ === t.type && 0 /* Added */ === n.type ? this.Eu = this.Eu.insert(e, {
+        }) : 2 /* Modified */ === t.type && 0 /* Added */ === n.type ? this.Tu = this.Tu.insert(e, {
             type: 0 /* Added */ ,
             doc: t.doc
-        }) : 1 /* Removed */ === t.type && 0 /* Added */ === n.type ? this.Eu = this.Eu.remove(e) : 1 /* Removed */ === t.type && 2 /* Modified */ === n.type ? this.Eu = this.Eu.insert(e, {
+        }) : 1 /* Removed */ === t.type && 0 /* Added */ === n.type ? this.Tu = this.Tu.remove(e) : 1 /* Removed */ === t.type && 2 /* Modified */ === n.type ? this.Tu = this.Tu.insert(e, {
             type: 1 /* Removed */ ,
             doc: n.doc
-        }) : 0 /* Added */ === t.type && 1 /* Removed */ === n.type ? this.Eu = this.Eu.insert(e, {
+        }) : 0 /* Added */ === t.type && 1 /* Removed */ === n.type ? this.Tu = this.Tu.insert(e, {
             type: 2 /* Modified */ ,
             doc: t.doc
         }) : 
@@ -14024,11 +14024,11 @@ class Mu {
         // Removed->Modified
         // Metadata->Added
         // Removed->Metadata
-        O() : this.Eu = this.Eu.insert(e, t);
+        O() : this.Tu = this.Tu.insert(e, t);
     }
-    Au() {
+    Eu() {
         const t = [];
-        return this.Eu.inorderTraversal(((e, n) => {
+        return this.Tu.inorderTraversal(((e, n) => {
             t.push(n);
         })), t;
     }
@@ -14084,14 +14084,14 @@ class Lu {
  * tracked by EventManager.
  */ class Uu {
     constructor() {
-        this.Ru = void 0, this.listeners = [];
+        this.Au = void 0, this.listeners = [];
     }
 }
 
 class qu {
     constructor() {
         this.queries = new es((t => ln(t)), hn), this.onlineState = "Unknown" /* Unknown */ , 
-        this.bu = new Set;
+        this.Ru = new Set;
     }
 }
 
@@ -14099,15 +14099,15 @@ async function Ku(t, e) {
     const n = $(t), s = e.query;
     let i = !1, r = n.queries.get(s);
     if (r || (i = !0, r = new Uu), i) try {
-        r.Ru = await n.onListen(s);
+        r.Au = await n.onListen(s);
     } catch (t) {
         const n = Fu(t, `Initialization of query '${fn(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.Pu(n.onlineState), r.Ru) {
-        e.vu(r.Ru) && Wu(n);
+    e.bu(n.onlineState), r.Au) {
+        e.Pu(r.Au) && Wu(n);
     }
 }
 
@@ -14128,8 +14128,8 @@ function Qu(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.vu(t) && (s = !0);
-            i.Ru = t;
+            for (const e of i.listeners) e.Pu(t) && (s = !0);
+            i.Au = t;
         }
     }
     s && Wu(n);
@@ -14145,7 +14145,7 @@ function ju(t, e, n) {
 
 // Call all global snapshot listeners that have been set.
 function Wu(t) {
-    t.bu.forEach((t => {
+    t.Ru.forEach((t => {
         t.next();
     }));
 }
@@ -14157,19 +14157,19 @@ function Wu(t) {
  * It uses an Observer to dispatch events.
  */ class zu {
     constructor(t, e, n) {
-        this.query = t, this.Vu = e, 
+        this.query = t, this.vu = 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.Su = !1, this.Du = null, this.onlineState = "Unknown" /* Unknown */ , this.options = n || {};
+        this.Vu = !1, this.Su = 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.
-     */    vu(t) {
+     */    Pu(t) {
         if (!this.options.includeMetadataChanges) {
             // Remove the metadata only changes.
             const e = [];
@@ -14178,19 +14178,19 @@ function Wu(t) {
             /* excludesMetadataChanges= */ !0, t.hasCachedResults);
         }
         let e = !1;
-        return this.Su ? this.Cu(t) && (this.Vu.next(t), e = !0) : this.xu(t, this.onlineState) && (this.Nu(t), 
-        e = !0), this.Du = t, e;
+        return this.Vu ? this.Du(t) && (this.vu.next(t), e = !0) : this.Cu(t, this.onlineState) && (this.xu(t), 
+        e = !0), this.Su = t, e;
     }
     onError(t) {
-        this.Vu.error(t);
+        this.vu.error(t);
     }
-    /** Returns whether a snapshot was raised. */    Pu(t) {
+    /** Returns whether a snapshot was raised. */    bu(t) {
         this.onlineState = t;
         let e = !1;
-        return this.Du && !this.Su && this.xu(this.Du, t) && (this.Nu(this.Du), e = !0), 
+        return this.Su && !this.Vu && this.Cu(this.Su, t) && (this.xu(this.Su), e = !0), 
         e;
     }
-    xu(t, e) {
+    Cu(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
@@ -14198,25 +14198,25 @@ function Wu(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.ku || !n) && (!t.docs.isEmpty() || t.hasCachedResults || "Offline" /* Offline */ === e);
+                return (!this.options.Nu || !n) && (!t.docs.isEmpty() || t.hasCachedResults || "Offline" /* Offline */ === e);
         // Raise data from cache if we have any documents, have cached results before,
         // or we are offline.
         }
-    Cu(t) {
+    Du(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.Du && this.Du.hasPendingWrites !== t.hasPendingWrites;
+        const e = this.Su && this.Su.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.
         }
-    Nu(t) {
+    xu(t) {
         t = Lu.fromInitialDocuments(t.query, t.docs, t.mutatedKeys, t.fromCache, t.hasCachedResults), 
-        this.Su = !0, this.Vu.next(t);
+        this.Vu = !0, this.vu.next(t);
     }
 }
 
@@ -14243,10 +14243,10 @@ function Wu(t) {
     constructor(t, 
     // How many bytes this element takes to store in the bundle.
     e) {
-        this.payload = t, this.byteLength = e;
+        this.ku = t, this.byteLength = e;
     }
     Ou() {
-        return "metadata" in this.payload;
+        return "metadata" in this.ku;
     }
 }
 
@@ -14306,13 +14306,13 @@ function Wu(t) {
      */    Fu(t) {
         this.progress.bytesLoaded += t.byteLength;
         let e = this.progress.documentsLoaded;
-        if (t.payload.namedQuery) this.queries.push(t.payload.namedQuery); else if (t.payload.documentMetadata) {
+        if (t.ku.namedQuery) this.queries.push(t.ku.namedQuery); else if (t.ku.documentMetadata) {
             this.documents.push({
-                metadata: t.payload.documentMetadata
-            }), t.payload.documentMetadata.exists || ++e;
-            const n = rt.fromString(t.payload.documentMetadata.name);
+                metadata: t.ku.documentMetadata
+            }), t.ku.documentMetadata.exists || ++e;
+            const n = rt.fromString(t.ku.documentMetadata.name);
             this.collectionGroups.add(n.get(n.length - 2));
-        } else t.payload.document && (this.documents[this.documents.length - 1].document = t.payload.document, 
+        } else t.ku.document && (this.documents[this.documents.length - 1].document = t.ku.document, 
         ++e);
         return e !== this.progress.documentsLoaded ? (this.progress.documentsLoaded = e, 
         Object.assign({}, this.progress)) : null;
@@ -14505,7 +14505,7 @@ class tc {
         const s = this.Qu;
         this.Qu = t.Qu, this.mutatedKeys = t.mutatedKeys;
         // Sort changes based on type and query comparator
-        const i = t.zu.Au();
+        const i = t.zu.Eu();
         i.sort(((t, e) => function(t, e) {
             const n = t => {
                 switch (t) {
@@ -14560,7 +14560,7 @@ class tc {
     /**
      * Applies an OnlineState change to the view, potentially generating a
      * ViewChange if the view's syncState changes as a result.
-     */    Pu(t) {
+     */    bu(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
@@ -14911,7 +14911,7 @@ async function rc(t, e) {
         if (s.isPrimaryClient && 0 /* RemoteStore */ === n || !s.isPrimaryClient && 1 /* SharedClientState */ === n) {
         const t = [];
         s.ic.forEach(((n, s) => {
-            const i = s.view.Pu(e);
+            const i = s.view.bu(e);
             i.snapshot && t.push(i.snapshot);
         })), function(t, e) {
             const n = $(t);
@@ -14920,9 +14920,9 @@ async function rc(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.Pu(e) && (s = !0);
+                t.bu(e) && (s = !0);
             })), s && Wu(n);
-        }(s.eventManager, e), t.length && s.sc.zo(t), s.onlineState = e, s.isPrimaryClient && s.sharedClientState.setOnlineState(e);
+        }(s.eventManager, e), t.length && s.sc.Wo(t), s.onlineState = e, s.isPrimaryClient && s.sharedClientState.setOnlineState(e);
     }
 }
 
@@ -15118,7 +15118,7 @@ async function Ec(t, e, n) {
                 r.push(e);
             }
         })));
-    })), await Promise.all(o), s.sc.zo(i), await async function(t, e) {
+    })), await Promise.all(o), s.sc.Wo(i), await async function(t, e) {
         const n = $(t);
         try {
             await n.persistence.runTransaction("notifyLocalViewChanges", "readwrite", (t => At.forEach(e, (e => At.forEach(e.Si, (s => n.persistence.referenceDelegate.addReference(t, e.targetId, s))).next((() => At.forEach(e.Di, (s => n.persistence.referenceDelegate.removeReference(t, e.targetId, s)))))))));
@@ -15293,7 +15293,7 @@ async function Sc(t, e, n) {
         }
         i.push(e);
     }
-    return s.sc.zo(r), i;
+    return s.sc.Wo(r), i;
 }
 
 /**
@@ -15374,7 +15374,7 @@ async function xc(t, e, n, s) {
 function kc(t) {
     const e = $(t);
     return e.remoteStore.remoteSyncer.applyRemoteEvent = ac.bind(null, e), e.remoteStore.remoteSyncer.getRemoteKeysForTarget = Rc.bind(null, e), 
-    e.remoteStore.remoteSyncer.rejectListen = lc.bind(null, e), e.sc.zo = Qu.bind(null, e.eventManager), 
+    e.remoteStore.remoteSyncer.rejectListen = lc.bind(null, e), e.sc.Wo = Qu.bind(null, e.eventManager), 
     e.sc.wc = ju.bind(null, e.eventManager), e;
 }
 
@@ -15601,11 +15601,11 @@ class Fc {
     terminate() {
         return async function(t) {
             const e = $(t);
-            C("RemoteStore", "RemoteStore shutting down."), e.wu.add(5 /* Shutdown */), await au(e), 
-            e.gu.shutdown(), 
+            C("RemoteStore", "RemoteStore shutting down."), e._u.add(5 /* Shutdown */), await au(e), 
+            e.mu.shutdown(), 
             // Set the OnlineState to Unknown (rather than Offline) to avoid potentially
             // triggering spurious listener events with cached data, etc.
-            e.yu.set("Unknown" /* Unknown */);
+            e.gu.set("Unknown" /* Unknown */);
         }(this.remoteStore);
     }
 }
@@ -16215,7 +16215,7 @@ class ua {
         this.buffer = new Uint8Array, this.vc = new TextDecoder("utf-8"), 
         // Read the metadata (which is the first element).
         this.Vc().then((t => {
-            t && t.Ou() ? 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 && t.Ou() ? this.metadata.resolve(t.ku.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.ku)}`));
         }), (t => this.metadata.reject(t)));
     }
     close() {
@@ -16545,13 +16545,13 @@ class aa {
  */ class da {
     constructor(t, e, n, s, i) {
         this.asyncQueue = t, this.datastore = e, this.options = n, this.updateFunction = s, 
-        this.deferred = i, this.kc = n.maxAttempts, this.No = new tu(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.deferred = i, this.kc = n.maxAttempts, this.xo = new tu(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */    run() {
         this.kc -= 1, this.Oc();
     }
     Oc() {
-        this.No.Ro((async () => {
+        this.xo.Ro((async () => {
             const t = new fa(this.datastore), e = this.Mc(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
@@ -16736,7 +16736,7 @@ async function Ra(t) {
         const e = await pa(t), n = await Ta(t);
         return e.setNetworkEnabled(!0), function(t) {
             const e = $(t);
-            return e.wu.delete(0 /* UserDisabled */), cu(e);
+            return e._u.delete(0 /* UserDisabled */), cu(e);
         }(n);
     }));
 }
@@ -16746,9 +16746,9 @@ async function Ra(t) {
         const e = await pa(t), n = await Ta(t);
         return e.setNetworkEnabled(!1), async function(t) {
             const e = $(t);
-            e.wu.add(0 /* UserDisabled */), await au(e), 
+            e._u.add(0 /* UserDisabled */), await au(e), 
             // Set the OnlineState to Offline so get()s return from cache, etc.
-            e.yu.set("Offline" /* Offline */);
+            e.gu.set("Offline" /* Offline */);
         }(n);
     }));
 }
@@ -16799,7 +16799,7 @@ function Va(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new zu(en(n.path), r, {
             includeMetadataChanges: !0,
-            ku: !0
+            Nu: !0
         });
         return Ku(t, o);
     }(await Ra(t), t.asyncQueue, e, n, s))), s.promise;
@@ -16836,7 +16836,7 @@ function Da(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new zu(n, r, {
             includeMetadataChanges: !0,
-            ku: !0
+            Nu: !0
         });
         return Ku(t, o);
     }(await Ra(t), t.asyncQueue, e, n, s))), s.promise;
@@ -16845,13 +16845,13 @@ function Da(t, e, n = {}) {
 function Ca(t, e) {
     const n = new ua(e);
     return t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-        $(t).bu.add(e), 
+        $(t).Ru.add(e), 
         // Immediately fire an initial event, indicating all existing listeners
         // are in-sync.
         e.next();
     }(await Ra(t), n))), () => {
         n.bc(), t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-            $(t).bu.delete(e);
+            $(t).Ru.delete(e);
         }(await Ra(t), n)));
     };
 }
@@ -16934,13 +16934,13 @@ class ka {
         // List of TimerIds to fast-forward delays for.
         this.jc = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.No = new tu(this, "async_queue_retry" /* AsyncQueueRetry */), 
+        this.xo = new tu(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.Wc = () => {
             const t = Xo();
-            t && C("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.No.Po();
+            t && C("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.xo.Po();
         };
         const t = Xo();
         t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Wc);
@@ -16987,7 +16987,7 @@ class ka {
      */    async Jc() {
         if (0 !== this.Lc.length) {
             try {
-                await this.Lc[0](), this.Lc.shift(), this.No.reset();
+                await this.Lc[0](), this.Lc.shift(), this.xo.reset();
             } catch (t) {
                 if (!Vt(t)) throw t;
  // Failure will be handled by AsyncQueue
@@ -17004,7 +17004,7 @@ class ka {
             // 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.No.Ro((() => this.Jc()));
+            this.xo.Ro((() => this.Jc()));
         }
     }
     Hc(t) {
@@ -19117,12 +19117,15 @@ class nl extends tl {
         function(t, e) {
             if (t._snapshot.oldDocs.isEmpty()) {
                 let e = 0;
-                return t._snapshot.docChanges.map((n => ({
-                    type: "added",
-                    doc: new rl(t._firestore, t._userDataWriter, n.doc.key, n.doc, new sl(t._snapshot.mutatedKeys.has(n.doc.key), t._snapshot.fromCache), t.query.converter),
-                    oldIndex: -1,
-                    newIndex: e++
-                })));
+                return t._snapshot.docChanges.map((n => {
+                    const s = new rl(t._firestore, t._userDataWriter, n.doc.key, n.doc, new sl(t._snapshot.mutatedKeys.has(n.doc.key), t._snapshot.fromCache), t.query.converter);
+                    return n.doc, {
+                        type: "added",
+                        doc: s,
+                        oldIndex: -1,
+                        newIndex: e++
+                    };
+                }));
             }
             {
                 // A `DocumentSet` that is updated incrementally as changes are applied to use
@@ -19953,9 +19956,9 @@ function $l(t, e) {
         return s = Object.assign({
             useFetchStreams: e
         }, s), r._setSettings(s), r;
-    }), "PUBLIC").setMultipleInstances(!0)), registerVersion(b, "3.7.1", t), 
+    }), "PUBLIC").setMultipleInstances(!0)), registerVersion(b, "3.7.2", t), 
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    registerVersion(b, "3.7.1", "esm2017");
+    registerVersion(b, "3.7.2", "esm2017");
 }();
 
 export { tl as AbstractUserDataWriter, aa as AggregateField, ha as AggregateQuerySnapshot, th as Bytes, Fa as CACHE_SIZE_UNLIMITED, ta as CollectionReference, Xc as DocumentReference, il as DocumentSnapshot, eh as FieldPath, sh as FieldValue, $a as Firestore, L as FirestoreError, ih as GeoPoint, Ma as LoadBundleTask, Zc as Query, Oh as QueryConstraint, rl as QueryDocumentSnapshot, ol as QuerySnapshot, sl as SnapshotMetadata, nt as Timestamp, Sl as Transaction, vl as WriteBatch, ne as _DatabaseId, ct as _DocumentKey, J as _EmptyAppCheckTokenProvider, K as _EmptyAuthCredentialsProvider, ut as _FieldPath, jc as _cast, F as _debugAssert, jt as _isBase64Available, N as _logWarn, qc as _validateIsNotUsedTogether, pl as addDoc, Rl as aggregateQuerySnapshotEqual, kl as arrayRemove, Nl as arrayUnion, ja as clearIndexedDbPersistence, ea as collection, na as collectionGroup, Yc as connectFirestoreEmulator, yl as deleteDoc, Cl as deleteField, Ha as disableNetwork, sa as doc, nh as documentId, Ka as enableIndexedDbPersistence, Ga as enableMultiTabIndexedDbPersistence, za as enableNetwork, Hh as endAt, zh as endBefore, Ua as ensureFirestoreConfigured, El as executeWrite, bl as getCountFromServer, al as getDoc, ll as getDocFromCache, fl as getDocFromServer, dl as getDocs, _l as getDocsFromCache, wl as getDocsFromServer, La as getFirestore, Ol as increment, Ba as initializeFirestore, qh as limit, Kh as limitToLast, Ya as loadBundle, Xa as namedQuery, Il as onSnapshot, Tl as onSnapshotsInSync, Lh as orderBy, Mh as query, ra as queryEqual, ia as refEqual, Dl as runTransaction, xl as serverTimestamp, ml as setDoc, Fl as setIndexConfiguration, D as setLogLevel, cl as snapshotEqual, jh as startAfter, Qh as startAt, Ja as terminate, gl as updateDoc, Wa as waitForPendingWrites, $h as where, Ml as writeBatch };