@firebase/firestore 3.7.1 → 3.7.2

package/dist/index.rn.js

@@ -70,7 +70,7 @@ v.MOCK_USER = new v("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
@@ -12900,14 +12900,14 @@ class nu {
  */
 class su {
     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 nu(t, e);
+        this.So = 0, this.Do = null, this.Co = null, this.stream = null, this.xo = new nu(t, e);
     }
     /**
      * Returns true if start() has been called and no error has occurred. True
@@ -12915,13 +12915,13 @@ class su {
      * 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;
     }
     /**
@@ -12931,7 +12931,7 @@ class su {
      *
      * 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
@@ -12939,7 +12939,7 @@ class su {
      *
      * 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
@@ -12948,8 +12948,8 @@ class su {
      *
      * 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
@@ -12960,25 +12960,25 @@ class su {
      *
      * 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:
@@ -12994,15 +12994,15 @@ class su {
      * @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 === L.RESOURCE_EXHAUSTED ? (
+        this.xo.reset() : e && e.code === L.RESOURCE_EXHAUSTED ? (
         // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)
         N(e.toString()), N("Using maximum backoff delay to prevent overloading the backend."), 
-        this.No.Ao()) : e && e.code === L.UNAUTHENTICATED && 3 /* Healthy */ !== this.state && (
+        this.xo.Ao()) : e && e.code === L.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
@@ -13011,7 +13011,7 @@ class su {
         // 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, 
@@ -13021,46 +13021,46 @@ class su {
     /**
      * 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 U(L.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
@@ -13072,9 +13072,9 @@ class su {
      * 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() : (x("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
+            this.Hs.enqueueAndForget((() => this.So === t ? e() : (x("PersistentStream", "stream callback skipped by getCloseGuardedDispatcher."), 
             Promise.resolve())));
         };
     }
@@ -13091,12 +13091,12 @@ class su {
         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 = Gs(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
@@ -13105,14 +13105,14 @@ class su {
             const e = t.targetChange;
             return e.targetIds && e.targetIds.length ? it.min() : e.readTime ? xs(e.readTime) : it.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 = Bs(this.It), e.addTarget = function(t, e) {
             let n;
@@ -13128,14 +13128,14 @@ class su {
             n.readTime = Ss(t, e.snapshotVersion.toTimestamp())), n;
         }(this.It, t);
         const n = Ys(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 = Bs(this.It), e.removeTarget = t, this.Lo(e);
+        e.database = Bs(this.It), e.removeTarget = t, this.Bo(e);
     }
 }
 
@@ -13158,54 +13158,54 @@ class su {
  */ class ru extends su {
     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.
-        F(!!t.streamToken), this.lastStreamToken = t.streamToken, this.Yo) {
+        F(!!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 = Ws(t.writeResults, t.commitTime), n = xs(t.commitTime);
-            return this.listener.tu(n, e);
+            return this.listener.Zo(n, e);
         }
         // The first response is always the handshake response
-        return F(!t.writeResults || 0 === t.writeResults.length), this.Yo = !0, this.listener.eu();
+        return F(!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 = Bs(this.It), this.Lo(t);
+        t.database = Bs(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 => Qs(this.It, t)))
         };
-        this.Lo(e);
+        this.Bo(e);
     }
 }
 
@@ -13236,26 +13236,26 @@ class su {
  */
 class ou 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 U(L.FAILED_PRECONDITION, "The client has already been terminated.");
+    su() {
+        if (this.nu) throw new U(L.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 === L.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), t) : new U(L.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 === L.UNAUTHENTICATED && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), t) : new U(L.UNKNOWN, t.toString());
         }));
     }
     terminate() {
-        this.su = !0;
+        this.nu = !0;
     }
 }
 
@@ -13275,7 +13275,7 @@ async function uu(t, e) {
             parent: n.parent
         };
     }(n.It, hn(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));
 }
 
@@ -13300,19 +13300,19 @@ class cu {
          * 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
@@ -13320,9 +13320,9 @@ class cu {
      *
      * 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()))));
     }
     /**
@@ -13330,10 +13330,10 @@ class cu {
      * 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.
@@ -13342,20 +13342,20 @@ class cu {
      * 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 ? (N(e), this.uu = !1) : x("OnlineStateTracker", e);
+        this.ou ? (N(e), this.ou = !1) : x("OnlineStateTracker", e);
     }
-    fu() {
-        null !== this.ou && (this.ou.cancel(), this.ou = null);
+    lu() {
+        null !== this.ru && (this.ru.cancel(), this.ru = null);
     }
 }
 
@@ -13400,7 +13400,7 @@ class cu {
          * 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.
@@ -13410,12 +13410,12 @@ class cu {
          * 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.
          *
@@ -13423,7 +13423,7 @@ class cu {
          * 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
@@ -13431,23 +13431,23 @@ class cu {
                 yu(this) && (x("RemoteStore", "Restarting streams for network reachability change."), 
                 await async function(t) {
                     const e = B(t);
-                    e.wu.add(4 /* ConnectivityChange */), await lu(e), e.yu.set("Unknown" /* Unknown */), 
-                    e.wu.delete(4 /* ConnectivityChange */), await hu(e);
+                    e._u.add(4 /* ConnectivityChange */), await lu(e), e.gu.set("Unknown" /* Unknown */), 
+                    e._u.delete(4 /* ConnectivityChange */), await hu(e);
                 }(this));
             }));
-        })), this.yu = new cu(n, s);
+        })), this.gu = new cu(n, s);
     }
 }
 
 async function hu(t) {
-    if (yu(t)) for (const e of t.mu) await e(/* enabled= */ !0);
+    if (yu(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 lu(t) {
-    for (const e of t.mu) await e(/* enabled= */ !1);
+    for (const e of t.wu) await e(/* enabled= */ !1);
 }
 
 /**
@@ -13456,11 +13456,11 @@ async function hu(t) {
  */
 function fu(t, e) {
     const n = B(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), gu(n) ? 
+    n.du.set(e.targetId, e), gu(n) ? 
     // The listen will be sent in onWatchStreamOpen
-    mu(n) : Mu(n).Oo() && _u(n, e));
+    mu(n) : Mu(n).ko() && _u(n, e));
 }
 
 /**
@@ -13468,18 +13468,18 @@ function fu(t, e) {
  * not being listened to.
  */ function du(t, e) {
     const n = B(t), s = Mu(n);
-    n._u.delete(e), s.Oo() && wu(n, e), 0 === n._u.size && (s.Oo() ? s.$o() : yu(n) && 
+    n.du.delete(e), s.ko() && wu(n, e), 0 === n.du.size && (s.ko() ? s.Fo() : yu(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 _u(t, e) {
-    t.pu.Mt(e.targetId), Mu(t).Ho(e);
+    t.yu.Mt(e.targetId), Mu(t).zo(e);
 }
 
 /**
@@ -13487,33 +13487,33 @@ function fu(t, e) {
  * from watch so we wait for the removal on the server before we process any
  * messages from this target.
  */ function wu(t, e) {
-    t.pu.Mt(e), Mu(t).Jo(e);
+    t.yu.Mt(e), Mu(t).Ho(e);
 }
 
 function mu(t) {
-    t.pu = new As({
+    t.yu = new As({
         getRemoteKeysForTarget: e => t.remoteSyncer.getRemoteKeysForTarget(e),
-        se: e => t._u.get(e) || null
-    }), Mu(t).start(), t.yu.cu();
+        se: e => t.du.get(e) || null
+    }), Mu(t).start(), t.gu.uu();
 }
 
 /**
  * Returns whether the watch stream should be started because it's necessary
  * and has not yet been started.
  */ function gu(t) {
-    return yu(t) && !Mu(t).ko() && t._u.size > 0;
+    return yu(t) && !Mu(t).No() && t.du.size > 0;
 }
 
 function yu(t) {
-    return 0 === B(t).wu.size;
+    return 0 === B(t)._u.size;
 }
 
 function pu(t) {
-    t.pu = void 0;
+    t.yu = void 0;
 }
 
 async function Iu(t) {
-    t._u.forEach(((e, n) => {
+    t.du.forEach(((e, n) => {
         _u(t, e);
     }));
 }
@@ -13521,17 +13521,17 @@ async function Iu(t) {
 async function Tu(t, e) {
     pu(t), 
     // If we still need the watch stream, retry the connection.
-    gu(t) ? (t.yu.lu(e), mu(t)) : 
+    gu(t) ? (t.gu.hu(e), mu(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 Eu(t, e, n) {
     if (
     // Mark the client as online since we got a message from the server
-    t.yu.set("Online" /* Online */), e instanceof Ts && 2 /* Removed */ === e.state && e.cause) 
+    t.gu.set("Online" /* Online */), e instanceof Ts && 2 /* Removed */ === e.state && e.cause) 
     // There was an error on a target, don't wait for a consistent snapshot
     // to raise events
     try {
@@ -13541,7 +13541,7 @@ async function Eu(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.
@@ -13554,7 +13554,7 @@ async function Eu(t, e, n) {
     } catch (n) {
         x("RemoteStore", "Failed to remove targets %s: %s ", e.targetIds.join(","), n), 
         await Au(t, n);
-    } else if (e instanceof ps ? t.pu.Gt(e) : e instanceof Is ? t.pu.Yt(e) : t.pu.Wt(e), 
+    } else if (e instanceof ps ? t.yu.Gt(e) : e instanceof Is ? t.yu.Yt(e) : t.yu.Wt(e), 
     !n.isEqual(it.min())) try {
         const e = await Po(t.localStore);
         n.compareTo(e) >= 0 && 
@@ -13567,26 +13567,26 @@ async function Eu(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(Ht.EMPTY_BYTE_STRING, n.snapshotVersion)), 
+                                t.du.set(e, n.withResumeToken(Ht.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.
                 wu(t, e);
@@ -13613,16 +13613,16 @@ async function Eu(t, e, n) {
  * any retry attempt.
  */ async function Au(t, e, n) {
     if (!St(e)) throw e;
-    t.wu.add(1 /* IndexedDbFailed */), 
+    t._u.add(1 /* IndexedDbFailed */), 
     // Disable network and raise offline snapshots
-    await lu(t), t.yu.set("Offline" /* Offline */), n || (
+    await lu(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 = () => Po(t.localStore)), 
     // Probe IndexedDB periodically and re-enable network
     t.asyncQueue.enqueueRetryable((async () => {
-        x("RemoteStore", "Retrying IndexedDB access"), await n(), t.wu.delete(1 /* IndexedDbFailed */), 
+        x("RemoteStore", "Retrying IndexedDB access"), await n(), t._u.delete(1 /* IndexedDbFailed */), 
         await hu(t);
     }));
 }
@@ -13636,11 +13636,11 @@ async function Eu(t, e, n) {
 
 async function bu(t) {
     const e = B(t), n = Fu(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 (;Pu(e); ) try {
         const t = await So(e.localStore, s);
         if (null === t) {
-            0 === e.du.length && n.$o();
+            0 === e.fu.length && n.Fo();
             break;
         }
         s = t.batchId, vu(e, t);
@@ -13654,20 +13654,20 @@ async function bu(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 Pu(t) {
-    return yu(t) && t.du.length < 10;
+    return yu(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 vu(t, e) {
-    t.du.push(e);
+    t.fu.push(e);
     const n = Fu(t);
-    n.Oo() && n.Xo && n.Zo(e.mutations);
+    n.ko() && n.Yo && n.Xo(e.mutations);
 }
 
 function Vu(t) {
-    return yu(t) && !Fu(t).ko() && t.du.length > 0;
+    return yu(t) && !Fu(t).No() && t.fu.length > 0;
 }
 
 function Su(t) {
@@ -13675,17 +13675,17 @@ function Su(t) {
 }
 
 async function Du(t) {
-    Fu(t).nu();
+    Fu(t).eu();
 }
 
 async function Cu(t) {
     const e = Fu(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 xu(t, e, n) {
-    const s = t.du.shift(), i = Fi.from(s, e, n);
+    const s = t.fu.shift(), i = Fi.from(s, e, n);
     await Ru(t, (() => t.remoteSyncer.applySuccessfulWrite(i))), 
     // It's possible that with the completion of this mutation another
     // slot has freed up.
@@ -13695,7 +13695,7 @@ async function xu(t, e, n) {
 async function Nu(t, e) {
     // If the write stream closed after the write handshake completes, a write
     // operation failed and we fail the pending operation.
-    e && Fu(t).Xo && 
+    e && Fu(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
@@ -13703,11 +13703,11 @@ async function Nu(t, e) {
         if (n = e.code, es(n) && n !== L.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.
-                        Fu(t).Fo(), await Ru(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
+                        Fu(t).Mo(), await Ru(t, (() => t.remoteSyncer.rejectFailedWrite(n.batchId, e))), 
             // It's possible that with the completion of this mutation
             // another slot has freed up.
             await bu(t);
@@ -13726,18 +13726,18 @@ async function ku(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 lu(n), s && 
+        n._u.add(3 /* CredentialChange */), await lu(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 hu(n);
+    n.gu.set("Unknown" /* Unknown */), await n.remoteSyncer.handleCredentialChange(e), 
+    n._u.delete(3 /* CredentialChange */), await hu(n);
 }
 
 /**
  * Toggles the network state when the client gains or loses its primary lease.
  */ async function Ou(t, e) {
     const n = B(t);
-    e ? (n.wu.delete(2 /* IsSecondary */), await hu(n)) : e || (n.wu.add(2 /* IsSecondary */), 
-    await lu(n), n.yu.set("Unknown" /* Unknown */));
+    e ? (n._u.delete(2 /* IsSecondary */), await hu(n)) : e || (n._u.add(2 /* IsSecondary */), 
+    await lu(n), n.gu.set("Unknown" /* Unknown */));
 }
 
 /**
@@ -13748,11 +13748,11 @@ async function ku(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 Mu(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 = B(t);
-        return s.iu(), new iu(e, s.So, s.authCredentials, s.appCheckCredentials, s.It, n);
+        return s.su(), new iu(e, s.connection, s.authCredentials, s.appCheckCredentials, s.It, n);
     }
     /**
  * @license
@@ -13772,11 +13772,11 @@ async function ku(t, e) {
  */ (t.datastore, t.asyncQueue, {
         Yr: Iu.bind(null, t),
         Zr: Tu.bind(null, t),
-        zo: Eu.bind(null, t)
-    }), t.mu.push((async e => {
-        e ? (t.Iu.Fo(), gu(t) ? mu(t) : t.yu.set("Unknown" /* Unknown */)) : (await t.Iu.stop(), 
+        Wo: Eu.bind(null, t)
+    }), t.wu.push((async e => {
+        e ? (t.pu.Mo(), gu(t) ? mu(t) : t.gu.set("Unknown" /* Unknown */)) : (await t.pu.stop(), 
         pu(t));
-    }))), t.Iu;
+    }))), t.pu;
 }
 
 /**
@@ -13787,22 +13787,22 @@ async function ku(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 Fu(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 = B(t);
-        return s.iu(), new ru(e, s.So, s.authCredentials, s.appCheckCredentials, s.It, n);
+        return s.su(), new ru(e, s.connection, s.authCredentials, s.appCheckCredentials, s.It, n);
     }(t.datastore, t.asyncQueue, {
         Yr: Du.bind(null, t),
         Zr: Nu.bind(null, t),
-        eu: Cu.bind(null, t),
-        tu: xu.bind(null, t)
-    }), t.mu.push((async e => {
-        e ? (t.Tu.Fo(), 
+        tu: Cu.bind(null, t),
+        Zo: xu.bind(null, t)
+    }), t.wu.push((async e => {
+        e ? (t.Iu.Mo(), 
         // This will start the write stream if necessary.
-        await bu(t)) : (await t.Tu.stop(), t.du.length > 0 && (x("RemoteStore", `Stopping write stream with ${t.du.length} pending writes`), 
-        t.du = []));
-    }))), t.Tu;
+        await bu(t)) : (await t.Iu.stop(), t.fu.length > 0 && (x("RemoteStore", `Stopping write stream with ${t.fu.length} pending writes`), 
+        t.fu = []));
+    }))), t.Iu;
 }
 
 /**
@@ -14012,25 +14012,25 @@ class $u {
  * duplicate events for the same doc.
  */ class Uu {
     constructor() {
-        this.Eu = new Lt(at.comparator);
+        this.Tu = new Lt(at.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
         }) : 
@@ -14041,11 +14041,11 @@ class $u {
         // Removed->Modified
         // Metadata->Added
         // Removed->Metadata
-        M() : this.Eu = this.Eu.insert(e, t);
+        M() : 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;
     }
@@ -14101,14 +14101,14 @@ class qu {
  * tracked by EventManager.
  */ class Ku {
     constructor() {
-        this.Ru = void 0, this.listeners = [];
+        this.Au = void 0, this.listeners = [];
     }
 }
 
 class Gu {
     constructor() {
         this.queries = new ss((t => dn(t)), fn), this.onlineState = "Unknown" /* Unknown */ , 
-        this.bu = new Set;
+        this.Ru = new Set;
     }
 }
 
@@ -14116,15 +14116,15 @@ async function Qu(t, e) {
     const n = B(t), s = e.query;
     let i = !1, r = n.queries.get(s);
     if (r || (i = !0, r = new Ku), i) try {
-        r.Ru = await n.onListen(s);
+        r.Au = await n.onListen(s);
     } catch (t) {
         const n = Bu(t, `Initialization of query '${_n(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) && Hu(n);
+    e.bu(n.onlineState), r.Au) {
+        e.Pu(r.Au) && Hu(n);
     }
 }
 
@@ -14145,8 +14145,8 @@ function Wu(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 && Hu(n);
@@ -14162,7 +14162,7 @@ function zu(t, e, n) {
 
 // Call all global snapshot listeners that have been set.
 function Hu(t) {
-    t.bu.forEach((t => {
+    t.Ru.forEach((t => {
         t.next();
     }));
 }
@@ -14174,19 +14174,19 @@ function Hu(t) {
  * It uses an Observer to dispatch events.
  */ class Ju {
     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 = [];
@@ -14195,19 +14195,19 @@ function Hu(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
@@ -14215,25 +14215,25 @@ function Hu(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 = qu.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);
     }
 }
 
@@ -14260,10 +14260,10 @@ function Hu(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;
     }
 }
 
@@ -14323,13 +14323,13 @@ function Hu(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 = ot.fromString(t.payload.documentMetadata.name);
+                metadata: t.ku.documentMetadata
+            }), t.ku.documentMetadata.exists || ++e;
+            const n = ot.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;
@@ -14522,7 +14522,7 @@ class nc {
         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) {
@@ -14577,7 +14577,7 @@ class nc {
     /**
      * 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
@@ -14928,7 +14928,7 @@ async function uc(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 = B(t);
@@ -14937,9 +14937,9 @@ async function uc(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 && Hu(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);
     }
 }
 
@@ -15135,7 +15135,7 @@ async function Rc(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 = B(t);
         try {
             await n.persistence.runTransaction("notifyLocalViewChanges", "readwrite", (t => Rt.forEach(e, (e => Rt.forEach(e.Si, (s => n.persistence.referenceDelegate.addReference(t, e.targetId, s))).next((() => Rt.forEach(e.Di, (s => n.persistence.referenceDelegate.removeReference(t, e.targetId, s)))))))));
@@ -15310,7 +15310,7 @@ async function Cc(t, e, n) {
         }
         i.push(e);
     }
-    return s.sc.zo(r), i;
+    return s.sc.Wo(r), i;
 }
 
 /**
@@ -15391,7 +15391,7 @@ async function kc(t, e, n, s) {
 function Mc(t) {
     const e = B(t);
     return e.remoteStore.remoteSyncer.applyRemoteEvent = lc.bind(null, e), e.remoteStore.remoteSyncer.getRemoteKeysForTarget = Pc.bind(null, e), 
-    e.remoteStore.remoteSyncer.rejectListen = dc.bind(null, e), e.sc.zo = Wu.bind(null, e.eventManager), 
+    e.remoteStore.remoteSyncer.rejectListen = dc.bind(null, e), e.sc.Wo = Wu.bind(null, e.eventManager), 
     e.sc.wc = zu.bind(null, e.eventManager), e;
 }
 
@@ -15618,11 +15618,11 @@ class Bc {
     terminate() {
         return async function(t) {
             const e = B(t);
-            x("RemoteStore", "RemoteStore shutting down."), e.wu.add(5 /* Shutdown */), await lu(e), 
-            e.gu.shutdown(), 
+            x("RemoteStore", "RemoteStore shutting down."), e._u.add(5 /* Shutdown */), await lu(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);
     }
 }
@@ -16232,7 +16232,7 @@ class aa {
         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() {
@@ -16562,13 +16562,13 @@ class la {
  */ class wa {
     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 nu(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.deferred = i, this.kc = n.maxAttempts, this.xo = new nu(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 _a(this.datastore), e = this.Mc(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
@@ -16753,7 +16753,7 @@ async function Pa(t) {
         const e = await Ta(t), n = await Aa(t);
         return e.setNetworkEnabled(!0), function(t) {
             const e = B(t);
-            return e.wu.delete(0 /* UserDisabled */), hu(e);
+            return e._u.delete(0 /* UserDisabled */), hu(e);
         }(n);
     }));
 }
@@ -16763,9 +16763,9 @@ async function Pa(t) {
         const e = await Ta(t), n = await Aa(t);
         return e.setNetworkEnabled(!1), async function(t) {
             const e = B(t);
-            e.wu.add(0 /* UserDisabled */), await lu(e), 
+            e._u.add(0 /* UserDisabled */), await lu(e), 
             // Set the OnlineState to Offline so get()s return from cache, etc.
-            e.yu.set("Offline" /* Offline */);
+            e.gu.set("Offline" /* Offline */);
         }(n);
     }));
 }
@@ -16816,7 +16816,7 @@ function Da(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new Ju(sn(n.path), r, {
             includeMetadataChanges: !0,
-            ku: !0
+            Nu: !0
         });
         return Qu(t, o);
     }(await Pa(t), t.asyncQueue, e, n, s))), s.promise;
@@ -16853,7 +16853,7 @@ function xa(t, e, n = {}) {
             error: t => i.reject(t)
         }), o = new Ju(n, r, {
             includeMetadataChanges: !0,
-            ku: !0
+            Nu: !0
         });
         return Qu(t, o);
     }(await Pa(t), t.asyncQueue, e, n, s))), s.promise;
@@ -16862,13 +16862,13 @@ function xa(t, e, n = {}) {
 function Na(t, e) {
     const n = new aa(e);
     return t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-        B(t).bu.add(e), 
+        B(t).Ru.add(e), 
         // Immediately fire an initial event, indicating all existing listeners
         // are in-sync.
         e.next();
     }(await Pa(t), n))), () => {
         n.bc(), t.asyncQueue.enqueueAndForget((async () => function(t, e) {
-            B(t).bu.delete(e);
+            B(t).Ru.delete(e);
         }(await Pa(t), n)));
     };
 }
@@ -16951,13 +16951,13 @@ class Ma {
         // List of TimerIds to fast-forward delays for.
         this.jc = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.No = new nu(this, "async_queue_retry" /* AsyncQueueRetry */), 
+        this.xo = new nu(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 = tu();
-            t && x("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.No.Po();
+            t && x("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.xo.Po();
         };
         const t = tu();
         t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Wc);
@@ -17004,7 +17004,7 @@ class Ma {
      */    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 (!St(t)) throw t;
  // Failure will be handled by AsyncQueue
@@ -17021,7 +17021,7 @@ class Ma {
             // 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) {
@@ -19134,12 +19134,15 @@ class il extends nl {
         function(t, e) {
             if (t._snapshot.oldDocs.isEmpty()) {
                 let e = 0;
-                return t._snapshot.docChanges.map((n => ({
-                    type: "added",
-                    doc: new ul(t._firestore, t._userDataWriter, n.doc.key, n.doc, new rl(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 ul(t._firestore, t._userDataWriter, n.doc.key, n.doc, new rl(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
@@ -19981,9 +19984,9 @@ function Ll(t, e) {
         return s = Object.assign({
             useFetchStreams: e
         }, s), r._setSettings(s), r;
-    }), "PUBLIC").setMultipleInstances(!0)), s(P, "3.7.1", t), 
+    }), "PUBLIC").setMultipleInstances(!0)), s(P, "3.7.2", t), 
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    s(P, "3.7.1", "esm2017");
+    s(P, "3.7.2", "esm2017");
 }("rn", /* useFetchStreams= */ !1);
 
 export { nl as AbstractUserDataWriter, la as AggregateField, fa as AggregateQuerySnapshot, nh as Bytes, Ba as CACHE_SIZE_UNLIMITED, na as CollectionReference, ta as DocumentReference, ol as DocumentSnapshot, sh as FieldPath, rh as FieldValue, La as Firestore, U as FirestoreError, oh as GeoPoint, $a as LoadBundleTask, ea as Query, Fh as QueryConstraint, ul as QueryDocumentSnapshot, cl as QuerySnapshot, rl as SnapshotMetadata, st as Timestamp, Cl as Transaction, Sl as WriteBatch, ie as _DatabaseId, at as _DocumentKey, Y as _EmptyAppCheckTokenProvider, G as _EmptyAuthCredentialsProvider, ct as _FieldPath, zc as _cast, $ as _debugAssert, zt as _isBase64Available, k as _logWarn, Gc as _validateIsNotUsedTogether, Tl as addDoc, Pl as aggregateQuerySnapshotEqual, Ml as arrayRemove, Ol as arrayUnion, za as clearIndexedDbPersistence, sa as collection, ia as collectionGroup, Zc as connectFirestoreEmulator, Il as deleteDoc, Nl as deleteField, Ya as disableNetwork, ra as doc, ih as documentId, Qa as enableIndexedDbPersistence, ja as enableMultiTabIndexedDbPersistence, Ja as enableNetwork, Yh as endAt, Jh as endBefore, Ka as ensureFirestoreConfigured, Rl as executeWrite, vl as getCountFromServer, ll as getDoc, dl as getDocFromCache, _l as getDocFromServer, wl as getDocs, ml as getDocsFromCache, gl as getDocsFromServer, qa as getFirestore, Fl as increment, Ua as initializeFirestore, Gh as limit, Qh as limitToLast, Za as loadBundle, th as namedQuery, El as onSnapshot, Al as onSnapshotsInSync, qh as orderBy, $h as query, ua as queryEqual, oa as refEqual, xl as runTransaction, kl as serverTimestamp, yl as setDoc, Bl as setIndexConfiguration, C as setLogLevel, hl as snapshotEqual, zh as startAfter, Wh as startAt, Xa as terminate, pl as updateDoc, Ha as waitForPendingWrites, Lh as where, $l as writeBatch };