@firebase/firestore 1.14.0-canary.daf63c2c → 1.14.0

package/dist/index.memory.esm2017.js

@@ -10056,9 +10056,6 @@ class wi {
         this.dh = e(this), this.mh = new fi(this);
         this.Jn = new ci, this.Kn = new di(this.Jn, t => this.dh.p_(t));
     }
-    start() {
-        return Promise.resolve();
-    }
     ku() {
         // No durable state to ensure is closed on shutdown.
         return this.V_ = !1, Promise.resolve();
@@ -10199,47 +10196,23 @@ class mi {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
+ */ const Ei = "You are using the memory-only build of Firestore. Persistence support is only available via the @firebase/firestore bundle or the firebase-firestore.js build.";
+
 /**
  * Provides all components needed for Firestore with in-memory persistence.
- * Uses EagerGC garbage collection.
- */
-class Ei {
-    async initialize(t) {
-        this.Qc = this.q_(t), this.persistence = this.B_(t), await this.persistence.start(), 
-        this.x_ = this.Q_(t), this._u = this.W_(t), this.Lc = this.j_(t), this.Mu = this.G_(t), 
-        this.z_ = this.K_(t), this.Qc.iu = t => this.Mu.Dc(t, 1 /* SharedClientState */), 
-        this.Lc.Mu = this.Mu, this.Qc.Mu = this.Mu, await this.Qc.start(), await this.Lc.start(), 
-        await this._u.start(), 
-        // NOTE: This will immediately call the listener, so we make sure to
-        // set it after localStore / remoteStore are started.
-        await this.persistence.y_(async t => {
-            await this.Mu.Zu(t), this.x_ && (t && !this.x_.g_ ? this.x_.start(this._u) : t || this.x_.stop());
-        });
-    }
-    K_(t) {
-        return new oi(this.Mu);
+ */ class Ri {
+    constructor(t = mi.O_) {
+        this.q_ = t;
     }
-    Q_(t) {
-        return null;
+    async initialize(t, e, s, i, n, r, h, o) {
+        if (o.B_) throw new E(m.FAILED_PRECONDITION, Ei);
+        this.persistence = new wi(n, this.q_), this.x_ = null, this.Qc = new Ys, this._u = new Ke(this.persistence, new ui, r), 
+        this.Lc = new Hs(this._u, i, t, t => this.Mu.Dc(t, 0 /* RemoteStore */), s.Q_()), 
+        this.Mu = new ri(this._u, this.Lc, this.Qc, r, h), this.W_ = new oi(this.Mu), this.Lc.Mu = this.Mu, 
+        await this.Lc.start(), await this.Lc.Zu(!0), await this.Mu.Zu(!0);
     }
-    W_(t) {
-        return new Ke(this.persistence, new ui, t.H_);
-    }
-    B_(t) {
-        return new wi(t.clientId, mi.O_);
-    }
-    j_(t) {
-        return new Hs(this._u, t.Ha, t.Ar, t => this.Mu.Dc(t, 0 /* RemoteStore */), t.platform.J_());
-    }
-    q_(t) {
-        return new Ys;
-    }
-    G_(t) {
-        return new ri(this._u, this.Lc, this.Qc, t.H_, t.Wc);
-    }
-    clearPersistence(t) {
-        throw new E(m.FAILED_PRECONDITION, "You are using the memory-only build of Firestore. Persistence support is only available via the @firebase/firestore bundle or the firebase-firestore.js build.");
+    clearPersistence() {
+        throw new E(m.FAILED_PRECONDITION, Ei);
     }
 }
 
@@ -10264,7 +10237,7 @@ class Ei {
  * pieces of the client SDK architecture. It is responsible for creating the
  * async queue that is shared by all of the other components in the system.
  */
-class Ri {
+class Ii {
     constructor(t, e, s, 
     /**
      * Asynchronous queue responsible for all of our internal processing. When
@@ -10275,7 +10248,7 @@ class Ri {
      * an async I/O to complete).
      */
     i) {
-        this.platform = t, this.Y_ = e, this.credentials = s, this.Ar = i, this.clientId = Ce.Tn();
+        this.platform = t, this.j_ = e, this.credentials = s, this.Ar = i, this.clientId = Ce.Tn();
     }
     /**
      * Starts up the FirestoreClient, returning only whether or not enabling
@@ -10313,7 +10286,7 @@ class Ri {
      *     start for any reason. If usePersistence is false this is
      *     unconditionally resolved.
      */    start(t, e) {
-        this.X_();
+        this.G_();
         // We defer our initialization until we get the current user from
         // setChangeListener(). We block the async queue until we got the initial
         // user and the initialization is completed. This will prevent any scheduled
@@ -10332,14 +10305,14 @@ class Ri {
         // need to await the completion of initializationDone because the result of
         // this method should not reflect any other kind of failure to start.
         return this.credentials._(r => {
-            if (!n) return n = !0, ge("FirestoreClient", "Initializing. user=", r.uid), this.Z_(t, e, r, i).then(s.resolve, s.reject);
+            if (!n) return n = !0, ge("FirestoreClient", "Initializing. user=", r.uid), this.z_(t, e, r, i).then(s.resolve, s.reject);
             this.Ar.Cr(() => this.Xu(r));
         }), 
         // Block the async queue until initialization is done
         this.Ar.Cr(() => s.promise), i.promise;
     }
     /** Enables the network connection and requeues all pending operations. */    enableNetwork() {
-        return this.X_(), this.Ar.enqueue(() => this.Mu.enableNetwork());
+        return this.G_(), this.Ar.enqueue(() => this.Mu.enableNetwork());
     }
     /**
      * Initializes persistent storage, attempting to use IndexedDB if
@@ -10360,23 +10333,15 @@ class Ri {
      * @returns a Promise indicating whether or not initialization should
      *     continue, i.e. that one of the persistence implementations actually
      *     succeeded.
-     */    async Z_(t, e, s, i) {
+     */    async z_(t, e, s, i) {
         try {
             // TODO(mrschmidt): Ideally, ComponentProvider would also initialize
             // Datastore (without duplicating the initializing logic once per
             // provider).
-            const n = await this.platform.td(this.Y_), r = this.platform.ed(this.Y_.ci), h = new Gs(this.Ar, n, this.credentials, r);
-            await t.initialize({
-                Ar: this.Ar,
-                Y_: this.Y_,
-                platform: this.platform,
-                Ha: h,
-                clientId: this.clientId,
-                H_: s,
-                Wc: 100,
-                sd: e
-            }), this.persistence = t.persistence, this.Qc = t.Qc, this._u = t._u, this.Lc = t.Lc, 
-            this.Mu = t.Mu, this.x_ = t.x_, this.nd = t.z_, 
+            const n = await this.platform.K_(this.j_), r = this.platform.H_(this.j_.ci), h = new Gs(this.Ar, n, this.credentials, r);
+            await t.initialize(this.Ar, this.j_, this.platform, h, this.clientId, s, 100, e), 
+            this.persistence = t.persistence, this.Qc = t.Qc, this._u = t._u, this.Lc = t.Lc, 
+            this.Mu = t.Mu, this.x_ = t.x_, this.J_ = t.W_, 
             // When a user calls clearPersistence() in one client, all other clients
             // need to be terminated to allow the delete to succeed.
             this.persistence.b_(async () => {
@@ -10387,17 +10352,17 @@ class Ri {
             if (
             // Regardless of whether or not the retry succeeds, from an user
             // perspective, offline persistence has failed.
-            i.reject(t), !this.rd(t)) throw t;
+            i.reject(t), !this.Y_(t)) throw t;
             return console.warn("Error enabling offline persistence. Falling back to persistence disabled: " + t), 
-            this.Z_(new Ei, {
-                hd: !1
+            this.z_(new Ri, {
+                B_: !1
             }, s, i);
         }
     }
     /**
      * Decides whether the provided error allows us to gracefully disable
      * persistence (as opposed to crashing the client).
-     */    rd(t) {
+     */    Y_(t) {
         return "FirebaseError" === t.name ? t.code === m.FAILED_PRECONDITION || t.code === m.UNIMPLEMENTED : !("undefined" != typeof DOMException && t instanceof DOMException) || (
         // When the browser is out of quota we could get either quota exceeded
         // or an aborted error depending on whether the error happened during
@@ -10410,7 +10375,7 @@ class Ri {
     /**
      * Checks that the client has not been terminated. Ensures that other methods on
      * this class cannot be called after the client is terminated.
-     */    X_() {
+     */    G_() {
         if (this.Ar.Or) throw new E(m.FAILED_PRECONDITION, "The client has already been terminated.");
     }
     Xu(t) {
@@ -10418,7 +10383,7 @@ class Ri {
         this.Mu.Xu(t);
     }
     /** Disables the network connection. Pending operations will not complete. */    disableNetwork() {
-        return this.X_(), this.Ar.enqueue(() => this.Mu.disableNetwork());
+        return this.G_(), this.Ar.enqueue(() => this.Mu.disableNetwork());
     }
     terminate() {
         return this.Ar.xr(async () => {
@@ -10435,29 +10400,29 @@ class Ri {
      * method was called received server acknowledgement. An acknowledgement can be either acceptance
      * or rejection.
      */    waitForPendingWrites() {
-        this.X_();
+        this.G_();
         const t = new We;
         return this.Ar.Cr(() => this.Mu.fl(t)), t.promise;
     }
     listen(t, e, s) {
-        this.X_();
+        this.G_();
         const i = new ai(t, e, s);
-        return this.Ar.Cr(() => this.nd.listen(i)), i;
+        return this.Ar.Cr(() => this.J_.listen(i)), i;
     }
     $u(t) {
         // Checks for termination but does not raise error, allowing unlisten after
         // termination to be a no-op.
-        this.od || this.Ar.Cr(() => this.nd.$u(t));
+        this.X_ || this.Ar.Cr(() => this.J_.$u(t));
     }
-    ad(t) {
-        return this.X_(), this.Ar.enqueue(() => this._u.ro(t)).then(t => {
+    Z_(t) {
+        return this.G_(), this.Ar.enqueue(() => this._u.ro(t)).then(t => {
             if (t instanceof gt) return t;
             if (t instanceof yt) return null;
             throw new E(m.UNAVAILABLE, "Failed to get document from cache. (However, this document may exist on the server. Run again without setting 'source' in the GetOptions to attempt to retrieve the document from the server.)");
         });
     }
-    ud(t) {
-        return this.X_(), this.Ar.enqueue(async () => {
+    td(t) {
+        return this.G_(), this.Ar.enqueue(async () => {
             const e = await this._u.lo(t, 
             /* usePreviousResults= */ !0), s = new ei(t, e.do), i = s.Vc(e.documents);
             return s.bc(i, 
@@ -10465,29 +10430,29 @@ class Ri {
         });
     }
     write(t) {
-        this.X_();
+        this.G_();
         const e = new We;
         return this.Ar.Cr(() => this.Mu.write(t, e)), e.promise;
     }
     ci() {
-        return this.Y_.ci;
+        return this.j_.ci;
     }
     Fl(t) {
-        this.X_(), this.Ar.Cr(() => (this.nd.Fl(t), Promise.resolve()));
+        this.G_(), this.Ar.Cr(() => (this.J_.Fl(t), Promise.resolve()));
     }
     Nl(t) {
         // Checks for shutdown but does not raise error, allowing remove after
         // shutdown to be a no-op.
-        this.od || this.nd.Nl(t);
+        this.X_ || this.J_.Nl(t);
     }
-    get od() {
+    get X_() {
         // Technically, the asyncQueue is still running, but only accepting operations
         // related to termination or supposed to be run after termination. It is effectively
         // terminated to the eyes of users.
         return this.Ar.Or;
     }
     transaction(t) {
-        this.X_();
+        this.G_();
         const e = new We;
         return this.Ar.Cr(() => (this.Mu.runTransaction(this.Ar, t, e), Promise.resolve())), 
         e.promise;
@@ -10514,7 +10479,7 @@ class Ri {
  * A wrapper implementation of Observer<T> that will dispatch events
  * asynchronously. To allow immediate silencing, a mute call is added which
  * causes events scheduled to no longer be raised.
- */ class Ii {
+ */ class Ai {
     constructor(t) {
         this.observer = t, 
         /**
@@ -10524,15 +10489,15 @@ class Ri {
         this.muted = !1;
     }
     next(t) {
-        this.ld(this.observer.next, t);
+        this.ed(this.observer.next, t);
     }
     error(t) {
-        this.ld(this.observer.error, t);
+        this.ed(this.observer.error, t);
     }
-    _d() {
+    sd() {
         this.muted = !0;
     }
-    ld(t, e) {
+    ed(t, e) {
         this.muted || setTimeout(() => {
             this.muted || t(e);
         }, 0);
@@ -10554,7 +10519,7 @@ class Ri {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ function Ai(t) {
+ */ function Pi(t) {
     /**
  * Returns true if obj is an object and contains at least one of the specified
  * methods.
@@ -10587,11 +10552,11 @@ class Ri {
  */ (t, [ "next", "error", "complete" ]);
 }
 
-class Pi {
+class Vi {
     constructor(t, e, s, i) {
-        this.firestore = t, this.timestampsInSnapshots = e, this.dd = s, this.converter = i;
+        this.firestore = t, this.timestampsInSnapshots = e, this.nd = s, this.converter = i;
     }
-    fd(t) {
+    rd(t) {
         switch (j(t)) {
           case 0 /* NullValue */ :
             return null;
@@ -10603,10 +10568,10 @@ class Pi {
             return Z(t.integerValue || t.doubleValue);
 
           case 3 /* TimestampValue */ :
-            return this.wd(t.timestampValue);
+            return this.hd(t.timestampValue);
 
           case 4 /* ServerTimestampValue */ :
-            return this.Td(t);
+            return this.od(t);
 
           case 5 /* StringValue */ :
             return t.stringValue;
@@ -10615,58 +10580,58 @@ class Pi {
             return new Es(tt(t.bytesValue));
 
           case 7 /* RefValue */ :
-            return this.md(t.referenceValue);
+            return this.ad(t.referenceValue);
 
           case 8 /* GeoPointValue */ :
             return new Ss(t.geoPointValue.latitude, t.geoPointValue.longitude);
 
           case 9 /* ArrayValue */ :
-            return this.Ed(t.arrayValue);
+            return this.ud(t.arrayValue);
 
           case 10 /* ObjectValue */ :
-            return this.Rd(t.mapValue);
+            return this.ld(t.mapValue);
 
           default:
             throw ve("Invalid value type: " + JSON.stringify(t));
         }
     }
-    Rd(t) {
+    ld(t) {
         const e = {};
         return O(t.fields || {}, (t, s) => {
-            e[t] = this.fd(s);
+            e[t] = this.rd(s);
         }), e;
     }
-    Ed(t) {
-        return (t.values || []).map(t => this.fd(t));
+    ud(t) {
+        return (t.values || []).map(t => this.rd(t));
     }
-    Td(t) {
-        switch (this.dd) {
+    od(t) {
+        switch (this.nd) {
           case "previous":
             const e = function t(e) {
                 const s = e.mapValue.fields.__previous_value__;
                 return x(s) ? t(s) : s;
             }(t);
-            return null == e ? null : this.fd(e);
+            return null == e ? null : this.rd(e);
 
           case "estimate":
-            return this.wd(Q(t));
+            return this.hd(Q(t));
 
           default:
             return null;
         }
     }
-    wd(t) {
+    hd(t) {
         const e = X(t), s = new p(e.seconds, e.nanos);
         return this.timestampsInSnapshots ? s : s.toDate();
     }
-    md(t) {
+    ad(t) {
         const e = b.K(t);
         Se(Ie(e), "ReferenceValue is not valid " + t);
         const s = new ke(e.get(1), e.get(3)), i = new C(e.$(5));
-        return s.isEqual(this.firestore.Id) || 
+        return s.isEqual(this.firestore._d) || 
         // TODO(b/64130202): Somehow support foreign references.
-        ye(`Document ${i} contains a document ` + "reference within a different database (" + `${s.projectId}/${s.database}) which is not ` + "supported. It will be treated as a reference in the current " + `database (${this.firestore.Id.projectId}/${this.firestore.Id.database}) ` + "instead."), 
-        new vi(i, this.firestore, this.converter);
+        ye(`Document ${i} contains a document ` + "reference within a different database (" + `${s.projectId}/${s.database}) which is not ` + "supported. It will be treated as a reference in the current " + `database (${this.firestore._d.projectId}/${this.firestore._d.database}) ` + "instead."), 
+        new Si(i, this.firestore, this.converter);
     }
 }
 
@@ -10687,14 +10652,14 @@ class Pi {
  * limitations under the License.
  */
 // settings() defaults:
-const Vi = ze.sh;
+const pi = ze.sh;
 
 /**
  * A concrete type describing all the values that can be applied via a
  * user-supplied firestore.Settings object. This is a separate type so that
  * defaults can be supplied and the value can be checked for equality.
  */
-class pi {
+class gi {
     constructor(t) {
         var e, s;
         if (void 0 === t.host) {
@@ -10710,7 +10675,7 @@ class pi {
         !0 === t.timestampsInSnapshots ? ye("The setting 'timestampsInSnapshots: true' is no longer required and should be removed.") : !1 === t.timestampsInSnapshots && ye("Support for 'timestampsInSnapshots: false' will be removed soon. You must update your code to handle Timestamp objects."), 
         this.timestampsInSnapshots = null === (s = t.timestampsInSnapshots) || void 0 === s || s, 
         is("settings", "number", "cacheSizeBytes", t.cacheSizeBytes), void 0 === t.cacheSizeBytes) this.cacheSizeBytes = ze.nh; else {
-            if (t.cacheSizeBytes !== Vi && t.cacheSizeBytes < ze.ih) throw new E(m.INVALID_ARGUMENT, `cacheSizeBytes must be at least ${ze.ih}`);
+            if (t.cacheSizeBytes !== pi && t.cacheSizeBytes < ze.ih) throw new E(m.INVALID_ARGUMENT, `cacheSizeBytes must be at least ${ze.ih}`);
             this.cacheSizeBytes = t.cacheSizeBytes;
         }
         is("settings", "boolean", "experimentalForceLongPolling", t.experimentalForceLongPolling), 
@@ -10723,49 +10688,49 @@ class pi {
 
 /**
  * The root reference to the database.
- */ class gi {
+ */ class yi {
     // Note: We are using `MemoryComponentProvider` as a default
     // ComponentProvider to ensure backwards compatibility with the format
     // expected by the console build.
-    constructor(t, e, s = new Ei) {
-        if (this.Ad = null, 
+    constructor(t, e, s = new Ri) {
+        if (this.dd = null, 
         // Public for use in tests.
         // TODO(mikelehen): Use modularized initialization instead.
-        this.Pd = new Ge, this.INTERNAL = {
+        this.fd = new Ge, this.INTERNAL = {
             delete: async () => {
                 // The client must be initalized to ensure that all subsequent API usage
                 // throws an exception.
-                this.Vd(), await this.pd.terminate();
+                this.wd(), await this.Td.terminate();
             }
         }, "object" == typeof t.options) {
             // This is very likely a Firebase app object
             // TODO(b/34177605): Can we somehow use instanceof?
             const s = t;
-            this.Ad = s, this.Id = gi.gd(s), this.yd = s.name, this.bd = new A(e);
+            this.dd = s, this._d = yi.md(s), this.Ed = s.name, this.Rd = new A(e);
         } else {
             const e = t;
             if (!e.projectId) throw new E(m.INVALID_ARGUMENT, "Must provide projectId");
-            this.Id = new ke(e.projectId, e.database), 
+            this._d = new ke(e.projectId, e.database), 
             // Use a default persistenceKey that lines up with FirebaseApp.
-            this.yd = "[DEFAULT]", this.bd = new I;
+            this.Ed = "[DEFAULT]", this.Rd = new I;
         }
-        this.vd = s, this.Sd = new pi({}), this.Cd = this.Dd(this.Id);
+        this.Id = s, this.Ad = new gi({}), this.Pd = this.Vd(this._d);
     }
     settings(t) {
         Ye("Firestore.settings", arguments, 1), ts("Firestore.settings", "object", 1, t);
-        const e = new pi(t);
-        if (this.pd && !this.Sd.isEqual(e)) throw new E(m.FAILED_PRECONDITION, "Firestore has already been started and its settings can no longer be changed. You can only call settings() before calling any other methods on a Firestore object.");
-        this.Sd = e, void 0 !== e.credentials && (this.bd = function(t) {
+        const e = new gi(t);
+        if (this.Td && !this.Ad.isEqual(e)) throw new E(m.FAILED_PRECONDITION, "Firestore has already been started and its settings can no longer be changed. You can only call settings() before calling any other methods on a Firestore object.");
+        this.Ad = e, void 0 !== e.credentials && (this.Rd = function(t) {
             if (!t) return new I;
             switch (t.type) {
               case "gapi":
-                const e = t.Fd;
+                const e = t.pd;
                 // Make sure this really is a Gapi client.
                                 return Se(!("object" != typeof e || null === e || !e.auth || !e.auth.getAuthHeaderValueForFirstParty), "unexpected gapi interface"), 
                 new V(e, t.V || "0");
 
               case "provider":
-                return t.Fd;
+                return t.pd;
 
               default:
                 throw new E(m.INVALID_ARGUMENT, "makeCredentialsProvider failed due to invalid credential type");
@@ -10791,30 +10756,30 @@ class pi {
         (e.credentials));
     }
     enableNetwork() {
-        return this.Vd(), this.pd.enableNetwork();
+        return this.wd(), this.Td.enableNetwork();
     }
     disableNetwork() {
-        return this.Vd(), this.pd.disableNetwork();
+        return this.wd(), this.Td.disableNetwork();
     }
     enablePersistence(t) {
         var e, s;
-        if (this.pd) throw new E(m.FAILED_PRECONDITION, "Firestore has already been started and persistence can no longer be enabled. You can only call enablePersistence() before calling any other methods on a Firestore object.");
+        if (this.Td) throw new E(m.FAILED_PRECONDITION, "Firestore has already been started and persistence can no longer be enabled. You can only call enablePersistence() before calling any other methods on a Firestore object.");
         let i = !1;
         return t && (void 0 !== t.experimentalTabSynchronization && ye("The 'experimentalTabSynchronization' setting will be removed. Use 'synchronizeTabs' instead."), 
         i = null !== (s = null !== (e = t.synchronizeTabs) && void 0 !== e ? e : t.experimentalTabSynchronization) && void 0 !== s && s), 
-        this.Nd(this.vd, {
-            hd: !0,
-            cacheSizeBytes: this.Sd.cacheSizeBytes,
+        this.gd(this.Id, {
+            B_: !0,
+            cacheSizeBytes: this.Ad.cacheSizeBytes,
             synchronizeTabs: i
         });
     }
     async clearPersistence() {
-        if (void 0 !== this.pd && !this.pd.od) throw new E(m.FAILED_PRECONDITION, "Persistence cannot be cleared after this Firestore instance is initialized.");
+        if (void 0 !== this.Td && !this.Td.X_) throw new E(m.FAILED_PRECONDITION, "Persistence cannot be cleared after this Firestore instance is initialized.");
         const t = new We;
-        return this.Pd.Mr(async () => {
+        return this.fd.Mr(async () => {
             try {
-                const e = this.kd();
-                await this.vd.clearPersistence(e), t.resolve();
+                const e = this.yd();
+                await this.Id.clearPersistence(e), t.resolve();
             } catch (e) {
                 t.reject(e);
             }
@@ -10823,24 +10788,24 @@ class pi {
     terminate() {
         return this.app._removeServiceInstance("firestore"), this.INTERNAL.delete();
     }
-    get Ld() {
-        return this.Vd(), this.pd.od;
+    get bd() {
+        return this.wd(), this.Td.X_;
     }
     waitForPendingWrites() {
-        return this.Vd(), this.pd.waitForPendingWrites();
+        return this.wd(), this.Td.waitForPendingWrites();
     }
     onSnapshotsInSync(t) {
-        if (this.Vd(), Ai(t)) return this.$d(t);
+        if (this.wd(), Pi(t)) return this.vd(t);
         {
             ts("Firestore.onSnapshotsInSync", "function", 1, t);
             const e = {
                 next: t
             };
-            return this.$d(e);
+            return this.vd(e);
         }
     }
-    $d(t) {
-        const e = new Ii({
+    vd(t) {
+        const e = new Ai({
             next: () => {
                 t.next && t.next();
             },
@@ -10848,39 +10813,39 @@ class pi {
                 throw ve("Uncaught Error in onSnapshotsInSync");
             }
         });
-        return this.pd.Fl(e), () => {
-            e._d(), this.pd.Nl(e);
+        return this.Td.Fl(e), () => {
+            e.sd(), this.Td.Nl(e);
         };
     }
-    Vd() {
-        return this.pd || 
+    wd() {
+        return this.Td || 
         // Kick off starting the client but don't actually wait for it.
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.Nd(new Ei, {
-            hd: !1
-        }), this.pd;
+        this.gd(new Ri, {
+            B_: !1
+        }), this.Td;
     }
-    kd() {
-        return new Ne(this.Id, this.yd, this.Sd.host, this.Sd.ssl, this.Sd.forceLongPolling);
+    yd() {
+        return new Ne(this._d, this.Ed, this.Ad.host, this.Ad.ssl, this.Ad.forceLongPolling);
     }
-    Nd(t, e) {
-        const s = this.kd();
-        return this.pd = new Ri(Ae.Ot(), s, this.bd, this.Pd), this.pd.start(t, e);
+    gd(t, e) {
+        const s = this.yd();
+        return this.Td = new Ii(Ae.Ot(), s, this.Rd, this.fd), this.Td.start(t, e);
     }
-    Dd(t) {
+    Vd(t) {
         const e = new Re(t, {
             di: Ae.Ot().di
         });
         return new $s(e, e => {
-            if (e instanceof vi) {
-                const s = t, i = e.firestore.Id;
+            if (e instanceof Si) {
+                const s = t, i = e.firestore._d;
                 if (!i.isEqual(s)) throw new E(m.INVALID_ARGUMENT, "Document reference is for database " + `${i.projectId}/${i.database} but should be ` + `for database ${s.projectId}/${s.database}`);
-                return new Ls(t, e.Od);
+                return new Ls(t, e.Sd);
             }
             return e;
         });
     }
-    static gd(t) {
+    static md(t) {
         if (e = t.options, s = "projectId", !Object.prototype.hasOwnProperty.call(e, s)) throw new E(m.INVALID_ARGUMENT, '"projectId" not provided in firebase.initializeApp.');
         var e, s;
         // Export the classes with a private constructor (it will fail if invoked
@@ -10892,28 +10857,28 @@ class pi {
         return new ke(i);
     }
     get app() {
-        if (!this.Ad) throw new E(m.FAILED_PRECONDITION, "Firestore was not initialized using the Firebase SDK. 'app' is not available");
-        return this.Ad;
+        if (!this.dd) throw new E(m.FAILED_PRECONDITION, "Firestore was not initialized using the Firebase SDK. 'app' is not available");
+        return this.dd;
     }
     collection(t) {
         return Ye("Firestore.collection", arguments, 1), ts("Firestore.collection", "non-empty string", 1, t), 
-        this.Vd(), new ki(b.K(t), this);
+        this.wd(), new Li(b.K(t), this);
     }
     doc(t) {
         return Ye("Firestore.doc", arguments, 1), ts("Firestore.doc", "non-empty string", 1, t), 
-        this.Vd(), vi.Md(b.K(t), this);
+        this.wd(), Si.Cd(b.K(t), this);
     }
     collectionGroup(t) {
         if (Ye("Firestore.collectionGroup", arguments, 1), ts("Firestore.collectionGroup", "non-empty string", 1, t), 
         t.indexOf("/") >= 0) throw new E(m.INVALID_ARGUMENT, `Invalid collection ID '${t}' passed to function ` + "Firestore.collectionGroup(). Collection IDs must not contain '/'.");
-        return this.Vd(), new Fi(new St(b.H, t), this);
+        return this.wd(), new Ni(new St(b.H, t), this);
     }
     runTransaction(t) {
         return Ye("Firestore.runTransaction", arguments, 1), ts("Firestore.runTransaction", "function", 1, t), 
-        this.Vd().transaction(e => t(new yi(this, e)));
+        this.wd().transaction(e => t(new bi(this, e)));
     }
     batch() {
-        return this.Vd(), new bi(this);
+        return this.wd(), new vi(this);
     }
     static get logLevel() {
         switch (Ve()) {
@@ -10949,175 +10914,175 @@ class pi {
     }
     // Note: this is not a property because the minifier can't work correctly with
     // the way TypeScript compiler outputs properties.
-    Ud() {
-        return this.Sd.timestampsInSnapshots;
+    Dd() {
+        return this.Ad.timestampsInSnapshots;
     }
 }
 
 /**
  * A reference to a transaction.
- */ class yi {
+ */ class bi {
     constructor(t, e) {
-        this.qd = t, this.Bd = e;
+        this.Fd = t, this.Nd = e;
     }
     get(t) {
         Ye("Transaction.get", arguments, 1);
-        const e = Mi("Transaction.get", t, this.qd);
-        return this.Bd.za([ e.Od ]).then(t => {
+        const e = Ui("Transaction.get", t, this.Fd);
+        return this.Nd.za([ e.Sd ]).then(t => {
             if (!t || 1 !== t.length) return ve("Mismatch in docs returned from document lookup.");
             const s = t[0];
-            if (s instanceof yt) return new Ci(this.qd, e.Od, null, 
+            if (s instanceof yt) return new Di(this.Fd, e.Sd, null, 
             /* fromCache= */ !1, 
-            /* hasPendingWrites= */ !1, e.xd);
-            if (s instanceof gt) return new Ci(this.qd, e.Od, s, 
+            /* hasPendingWrites= */ !1, e.kd);
+            if (s instanceof gt) return new Di(this.Fd, e.Sd, s, 
             /* fromCache= */ !1, 
-            /* hasPendingWrites= */ !1, e.xd);
+            /* hasPendingWrites= */ !1, e.kd);
             throw ve(`BatchGetDocumentsRequest returned unexpected document type: ${s.constructor.name}`);
         });
     }
     set(t, e, s) {
         Ze("Transaction.set", arguments, 2, 3);
-        const i = Mi("Transaction.set", t, this.qd);
-        s = Li("Transaction.set", s);
-        const [n, r] = qi(i.xd, e, "Transaction.set"), h = s.merge || s.mergeFields ? this.qd.Cd.zo(r, n, s.mergeFields) : this.qd.Cd.jo(r, n);
-        return this.Bd.set(i.Od, h), this;
+        const i = Ui("Transaction.set", t, this.Fd);
+        s = $i("Transaction.set", s);
+        const [n, r] = Bi(i.kd, e, "Transaction.set"), h = s.merge || s.mergeFields ? this.Fd.Pd.zo(r, n, s.mergeFields) : this.Fd.Pd.jo(r, n);
+        return this.Nd.set(i.Sd, h), this;
     }
     update(t, e, s, ...i) {
         let n, r;
         return "string" == typeof e || e instanceof Is ? (Xe("Transaction.update", arguments, 3), 
-        n = Mi("Transaction.update", t, this.qd), r = this.qd.Cd.Yo("Transaction.update", e, s, i)) : (Ye("Transaction.update", arguments, 2), 
-        n = Mi("Transaction.update", t, this.qd), r = this.qd.Cd.Ko("Transaction.update", e)), 
-        this.Bd.update(n.Od, r), this;
+        n = Ui("Transaction.update", t, this.Fd), r = this.Fd.Pd.Yo("Transaction.update", e, s, i)) : (Ye("Transaction.update", arguments, 2), 
+        n = Ui("Transaction.update", t, this.Fd), r = this.Fd.Pd.Ko("Transaction.update", e)), 
+        this.Nd.update(n.Sd, r), this;
     }
     delete(t) {
         Ye("Transaction.delete", arguments, 1);
-        const e = Mi("Transaction.delete", t, this.qd);
-        return this.Bd.delete(e.Od), this;
+        const e = Ui("Transaction.delete", t, this.Fd);
+        return this.Nd.delete(e.Sd), this;
     }
 }
 
-class bi {
+class vi {
     constructor(t) {
-        this.qd = t, this.Qd = [], this.Wd = !1;
+        this.Fd = t, this.Ld = [], this.$d = !1;
     }
     set(t, e, s) {
-        Ze("WriteBatch.set", arguments, 2, 3), this.jd();
-        const i = Mi("WriteBatch.set", t, this.qd);
-        s = Li("WriteBatch.set", s);
-        const [n, r] = qi(i.xd, e, "WriteBatch.set"), h = s.merge || s.mergeFields ? this.qd.Cd.zo(r, n, s.mergeFields) : this.qd.Cd.jo(r, n);
-        return this.Qd = this.Qd.concat(h.Lo(i.Od, wt.NONE)), this;
+        Ze("WriteBatch.set", arguments, 2, 3), this.Od();
+        const i = Ui("WriteBatch.set", t, this.Fd);
+        s = $i("WriteBatch.set", s);
+        const [n, r] = Bi(i.kd, e, "WriteBatch.set"), h = s.merge || s.mergeFields ? this.Fd.Pd.zo(r, n, s.mergeFields) : this.Fd.Pd.jo(r, n);
+        return this.Ld = this.Ld.concat(h.Lo(i.Sd, wt.NONE)), this;
     }
     update(t, e, s, ...i) {
         let n, r;
-        return this.jd(), "string" == typeof e || e instanceof Is ? (Xe("WriteBatch.update", arguments, 3), 
-        n = Mi("WriteBatch.update", t, this.qd), r = this.qd.Cd.Yo("WriteBatch.update", e, s, i)) : (Ye("WriteBatch.update", arguments, 2), 
-        n = Mi("WriteBatch.update", t, this.qd), r = this.qd.Cd.Ko("WriteBatch.update", e)), 
-        this.Qd = this.Qd.concat(r.Lo(n.Od, wt.exists(!0))), this;
+        return this.Od(), "string" == typeof e || e instanceof Is ? (Xe("WriteBatch.update", arguments, 3), 
+        n = Ui("WriteBatch.update", t, this.Fd), r = this.Fd.Pd.Yo("WriteBatch.update", e, s, i)) : (Ye("WriteBatch.update", arguments, 2), 
+        n = Ui("WriteBatch.update", t, this.Fd), r = this.Fd.Pd.Ko("WriteBatch.update", e)), 
+        this.Ld = this.Ld.concat(r.Lo(n.Sd, wt.exists(!0))), this;
     }
     delete(t) {
-        Ye("WriteBatch.delete", arguments, 1), this.jd();
-        const e = Mi("WriteBatch.delete", t, this.qd);
-        return this.Qd = this.Qd.concat(new It(e.Od, wt.NONE)), this;
+        Ye("WriteBatch.delete", arguments, 1), this.Od();
+        const e = Ui("WriteBatch.delete", t, this.Fd);
+        return this.Ld = this.Ld.concat(new It(e.Sd, wt.NONE)), this;
     }
     commit() {
-        return this.jd(), this.Wd = !0, this.Qd.length > 0 ? this.qd.Vd().write(this.Qd) : Promise.resolve();
+        return this.Od(), this.$d = !0, this.Ld.length > 0 ? this.Fd.wd().write(this.Ld) : Promise.resolve();
     }
-    jd() {
-        if (this.Wd) throw new E(m.FAILED_PRECONDITION, "A write batch can no longer be used after commit() has been called.");
+    Od() {
+        if (this.$d) throw new E(m.FAILED_PRECONDITION, "A write batch can no longer be used after commit() has been called.");
     }
 }
 
 /**
  * A reference to a particular document in a collection in the database.
- */ class vi {
+ */ class Si {
     constructor(t, e, s) {
-        this.Od = t, this.firestore = e, this.xd = s, this.pd = this.firestore.Vd();
+        this.Sd = t, this.firestore = e, this.kd = s, this.Td = this.firestore.wd();
     }
-    static Md(t, e, s) {
+    static Cd(t, e, s) {
         if (t.length % 2 != 0) throw new E(m.INVALID_ARGUMENT, "Invalid document reference. Document references must have an even number of segments, but " + `${t.G()} has ${t.length}`);
-        return new vi(new C(t), e, s);
+        return new Si(new C(t), e, s);
     }
     get id() {
-        return this.Od.path.U();
+        return this.Sd.path.U();
     }
     get parent() {
-        return new ki(this.Od.path.O(), this.firestore, this.xd);
+        return new Li(this.Sd.path.O(), this.firestore, this.kd);
     }
     get path() {
-        return this.Od.path.G();
+        return this.Sd.path.G();
     }
     collection(t) {
         if (Ye("DocumentReference.collection", arguments, 1), ts("DocumentReference.collection", "non-empty string", 1, t), 
         !t) throw new E(m.INVALID_ARGUMENT, "Must provide a non-empty collection name to collection()");
         const e = b.K(t);
-        return new ki(this.Od.path.child(e), this.firestore);
+        return new Li(this.Sd.path.child(e), this.firestore);
     }
     isEqual(t) {
-        if (!(t instanceof vi)) throw ls("isEqual", "DocumentReference", 1, t);
-        return this.firestore === t.firestore && this.Od.isEqual(t.Od) && this.xd === t.xd;
+        if (!(t instanceof Si)) throw ls("isEqual", "DocumentReference", 1, t);
+        return this.firestore === t.firestore && this.Sd.isEqual(t.Sd) && this.kd === t.kd;
     }
     set(t, e) {
-        Ze("DocumentReference.set", arguments, 1, 2), e = Li("DocumentReference.set", e);
-        const [s, i] = qi(this.xd, t, "DocumentReference.set"), n = e.merge || e.mergeFields ? this.firestore.Cd.zo(i, s, e.mergeFields) : this.firestore.Cd.jo(i, s);
-        return this.pd.write(n.Lo(this.Od, wt.NONE));
+        Ze("DocumentReference.set", arguments, 1, 2), e = $i("DocumentReference.set", e);
+        const [s, i] = Bi(this.kd, t, "DocumentReference.set"), n = e.merge || e.mergeFields ? this.firestore.Pd.zo(i, s, e.mergeFields) : this.firestore.Pd.jo(i, s);
+        return this.Td.write(n.Lo(this.Sd, wt.NONE));
     }
     update(t, e, ...s) {
         let i;
         return "string" == typeof t || t instanceof Is ? (Xe("DocumentReference.update", arguments, 2), 
-        i = this.firestore.Cd.Yo("DocumentReference.update", t, e, s)) : (Ye("DocumentReference.update", arguments, 1), 
-        i = this.firestore.Cd.Ko("DocumentReference.update", t)), this.pd.write(i.Lo(this.Od, wt.exists(!0)));
+        i = this.firestore.Pd.Yo("DocumentReference.update", t, e, s)) : (Ye("DocumentReference.update", arguments, 1), 
+        i = this.firestore.Pd.Ko("DocumentReference.update", t)), this.Td.write(i.Lo(this.Sd, wt.exists(!0)));
     }
     delete() {
-        return Ye("DocumentReference.delete", arguments, 0), this.pd.write([ new It(this.Od, wt.NONE) ]);
+        return Ye("DocumentReference.delete", arguments, 0), this.Td.write([ new It(this.Sd, wt.NONE) ]);
     }
     onSnapshot(...t) {
         Ze("DocumentReference.onSnapshot", arguments, 1, 4);
         let e, s = {
             includeMetadataChanges: !1
         }, i = 0;
-        "object" != typeof t[i] || Ai(t[i]) || (s = t[i], cs("DocumentReference.onSnapshot", s, [ "includeMetadataChanges" ]), 
+        "object" != typeof t[i] || Pi(t[i]) || (s = t[i], cs("DocumentReference.onSnapshot", s, [ "includeMetadataChanges" ]), 
         is("DocumentReference.onSnapshot", "boolean", "includeMetadataChanges", s.includeMetadataChanges), 
         i++);
         const n = {
             includeMetadataChanges: s.includeMetadataChanges
         };
-        return Ai(t[i]) ? e = t[i] : (ts("DocumentReference.onSnapshot", "function", i, t[i]), 
+        return Pi(t[i]) ? e = t[i] : (ts("DocumentReference.onSnapshot", "function", i, t[i]), 
         es("DocumentReference.onSnapshot", "function", i + 1, t[i + 1]), es("DocumentReference.onSnapshot", "function", i + 2, t[i + 2]), 
         e = {
             next: t[i],
             error: t[i + 1],
             complete: t[i + 2]
-        }), this.Gd(n, e);
+        }), this.Md(n, e);
     }
-    Gd(t, e) {
+    Md(t, e) {
         let s = t => {
             console.error("Uncaught Error in onSnapshot:", t);
         };
         e.error && (s = e.error.bind(e));
-        const i = new Ii({
+        const i = new Ai({
             next: t => {
                 if (e.next) {
-                    const s = t.docs.get(this.Od);
-                    e.next(new Ci(this.firestore, this.Od, s, t.fromCache, t.hasPendingWrites, this.xd));
+                    const s = t.docs.get(this.Sd);
+                    e.next(new Di(this.firestore, this.Sd, s, t.fromCache, t.hasPendingWrites, this.kd));
                 }
             },
             error: s
-        }), n = this.pd.listen(St.ve(this.Od.path), i, t);
+        }), n = this.Td.listen(St.ve(this.Sd.path), i, t);
         return () => {
-            i._d(), this.pd.$u(n);
+            i.sd(), this.Td.$u(n);
         };
     }
     get(t) {
-        return Ze("DocumentReference.get", arguments, 0, 1), Oi("DocumentReference.get", t), 
+        return Ze("DocumentReference.get", arguments, 0, 1), Mi("DocumentReference.get", t), 
         new Promise((e, s) => {
-            t && "cache" === t.source ? this.firestore.Vd().ad(this.Od).then(t => {
-                e(new Ci(this.firestore, this.Od, t, 
-                /*fromCache=*/ !0, t instanceof gt && t.te, this.xd));
-            }, s) : this.zd(e, s, t);
+            t && "cache" === t.source ? this.firestore.wd().Z_(this.Sd).then(t => {
+                e(new Di(this.firestore, this.Sd, t, 
+                /*fromCache=*/ !0, t instanceof gt && t.te, this.kd));
+            }, s) : this.Ud(e, s, t);
         });
     }
-    zd(t, e, s) {
-        const i = this.Gd({
+    Ud(t, e, s) {
+        const i = this.Md({
             includeMetadataChanges: !0,
             ql: !0
         }, {
@@ -11138,11 +11103,11 @@ class bi {
         });
     }
     withConverter(t) {
-        return new vi(this.Od, this.firestore, t);
+        return new Si(this.Sd, this.firestore, t);
     }
 }
 
-class Si {
+class Ci {
     constructor(t, e) {
         this.hasPendingWrites = t, this.fromCache = e;
     }
@@ -11151,59 +11116,59 @@ class Si {
     }
 }
 
-class Ci {
+class Di {
     constructor(t, e, s, i, n, r) {
-        this.qd = t, this.Od = e, this.Kd = s, this.Hd = i, this.Jd = n, this.xd = r;
+        this.Fd = t, this.Sd = e, this.qd = s, this.Bd = i, this.xd = n, this.kd = r;
     }
     data(t) {
-        if (Ze("DocumentSnapshot.data", arguments, 0, 1), t = $i("DocumentSnapshot.data", t), 
-        this.Kd) {
+        if (Ze("DocumentSnapshot.data", arguments, 0, 1), t = Oi("DocumentSnapshot.data", t), 
+        this.qd) {
             // We only want to use the converter and create a new DocumentSnapshot
             // if a converter has been provided.
-            if (this.xd) {
-                const e = new Di(this.qd, this.Od, this.Kd, this.Hd, this.Jd);
-                return this.xd.fromFirestore(e, t);
+            if (this.kd) {
+                const e = new Fi(this.Fd, this.Sd, this.qd, this.Bd, this.xd);
+                return this.kd.fromFirestore(e, t);
             }
-            return new Pi(this.qd, this.qd.Ud(), t.serverTimestamps, 
-            /* converter= */ void 0).fd(this.Kd.Re());
+            return new Vi(this.Fd, this.Fd.Dd(), t.serverTimestamps, 
+            /* converter= */ void 0).rd(this.qd.Re());
         }
     }
     get(t, e) {
-        if (Ze("DocumentSnapshot.get", arguments, 1, 2), e = $i("DocumentSnapshot.get", e), 
-        this.Kd) {
-            const s = this.Kd.data().field(Us("DocumentSnapshot.get", t));
+        if (Ze("DocumentSnapshot.get", arguments, 1, 2), e = Oi("DocumentSnapshot.get", e), 
+        this.qd) {
+            const s = this.qd.data().field(Us("DocumentSnapshot.get", t));
             if (null !== s) {
-                return new Pi(this.qd, this.qd.Ud(), e.serverTimestamps, this.xd).fd(s);
+                return new Vi(this.Fd, this.Fd.Dd(), e.serverTimestamps, this.kd).rd(s);
             }
         }
     }
     get id() {
-        return this.Od.path.U();
+        return this.Sd.path.U();
     }
     get ref() {
-        return new vi(this.Od, this.qd, this.xd);
+        return new Si(this.Sd, this.Fd, this.kd);
     }
     get exists() {
-        return null !== this.Kd;
+        return null !== this.qd;
     }
     get metadata() {
-        return new Si(this.Jd, this.Hd);
+        return new Ci(this.xd, this.Bd);
     }
     isEqual(t) {
-        if (!(t instanceof Ci)) throw ls("isEqual", "DocumentSnapshot", 1, t);
-        return this.qd === t.qd && this.Hd === t.Hd && this.Od.isEqual(t.Od) && (null === this.Kd ? null === t.Kd : this.Kd.isEqual(t.Kd)) && this.xd === t.xd;
+        if (!(t instanceof Di)) throw ls("isEqual", "DocumentSnapshot", 1, t);
+        return this.Fd === t.Fd && this.Bd === t.Bd && this.Sd.isEqual(t.Sd) && (null === this.qd ? null === t.qd : this.qd.isEqual(t.qd)) && this.kd === t.kd;
     }
 }
 
-class Di extends Ci {
+class Fi extends Di {
     data(t) {
         return super.data(t);
     }
 }
 
-class Fi {
+class Ni {
     constructor(t, e, s) {
-        this.Yd = t, this.firestore = e, this.xd = s;
+        this.Qd = t, this.firestore = e, this.kd = s;
     }
     where(t, e, s) {
         Ye("Query.where", arguments, 3), us("Query.where", 3, s);
@@ -11215,20 +11180,20 @@ class Fi {
         if (n.Y()) {
             if (r === Ct.ARRAY_CONTAINS || r === Ct.ARRAY_CONTAINS_ANY) throw new E(m.INVALID_ARGUMENT, `Invalid Query. You can't perform '${r.toString()}' ` + "queries on FieldPath.documentId().");
             if (r === Ct.IN) {
-                this.Xd(s, r);
+                this.Wd(s, r);
                 const t = [];
-                for (const e of s) t.push(this.Zd(e));
+                for (const e of s) t.push(this.jd(e));
                 i = {
                     arrayValue: {
                         values: t
                     }
                 };
-            } else i = this.Zd(s);
-        } else r !== Ct.IN && r !== Ct.ARRAY_CONTAINS_ANY || this.Xd(s, r), i = this.firestore.Cd.Xo("Query.where", s, 
+            } else i = this.jd(s);
+        } else r !== Ct.IN && r !== Ct.ARRAY_CONTAINS_ANY || this.Wd(s, r), i = this.firestore.Pd.Xo("Query.where", s, 
         // We only allow nested arrays for IN queries.
         /** allowArrays = */ r === Ct.IN);
         const h = Dt.create(n, r, i);
-        return this.tf(h), new Fi(this.Yd.De(h), this.firestore, this.xd);
+        return this.Gd(h), new Ni(this.Qd.De(h), this.firestore, this.kd);
     }
     orderBy(t, e) {
         let s;
@@ -11237,60 +11202,60 @@ class Fi {
             if ("desc" !== e) throw new E(m.INVALID_ARGUMENT, `Function Query.orderBy() has unknown direction '${e}', ` + "expected 'asc' or 'desc'.");
             s = Ot.DESCENDING;
         }
-        if (null !== this.Yd.startAt) throw new E(m.INVALID_ARGUMENT, "Invalid query. You must not call Query.startAt() or Query.startAfter() before calling Query.orderBy().");
-        if (null !== this.Yd.endAt) throw new E(m.INVALID_ARGUMENT, "Invalid query. You must not call Query.endAt() or Query.endBefore() before calling Query.orderBy().");
+        if (null !== this.Qd.startAt) throw new E(m.INVALID_ARGUMENT, "Invalid query. You must not call Query.startAt() or Query.startAfter() before calling Query.orderBy().");
+        if (null !== this.Qd.endAt) throw new E(m.INVALID_ARGUMENT, "Invalid query. You must not call Query.endAt() or Query.endBefore() before calling Query.orderBy().");
         const i = Us("Query.orderBy", t), n = new Ut(i, s);
-        return this.ef(n), new Fi(this.Yd.Fe(n), this.firestore, this.xd);
+        return this.zd(n), new Ni(this.Qd.Fe(n), this.firestore, this.kd);
     }
     limit(t) {
         return Ye("Query.limit", arguments, 1), ts("Query.limit", "number", 1, t), _s("Query.limit", 1, t), 
-        new Fi(this.Yd.Ne(t), this.firestore, this.xd);
+        new Ni(this.Qd.Ne(t), this.firestore, this.kd);
     }
     limitToLast(t) {
         return Ye("Query.limitToLast", arguments, 1), ts("Query.limitToLast", "number", 1, t), 
-        _s("Query.limitToLast", 1, t), new Fi(this.Yd.ke(t), this.firestore, this.xd);
+        _s("Query.limitToLast", 1, t), new Ni(this.Qd.ke(t), this.firestore, this.kd);
     }
     startAt(t, ...e) {
         Xe("Query.startAt", arguments, 1);
-        const s = this.sf("Query.startAt", t, e, 
+        const s = this.Kd("Query.startAt", t, e, 
         /*before=*/ !0);
-        return new Fi(this.Yd.Le(s), this.firestore, this.xd);
+        return new Ni(this.Qd.Le(s), this.firestore, this.kd);
     }
     startAfter(t, ...e) {
         Xe("Query.startAfter", arguments, 1);
-        const s = this.sf("Query.startAfter", t, e, 
+        const s = this.Kd("Query.startAfter", t, e, 
         /*before=*/ !1);
-        return new Fi(this.Yd.Le(s), this.firestore, this.xd);
+        return new Ni(this.Qd.Le(s), this.firestore, this.kd);
     }
     endBefore(t, ...e) {
         Xe("Query.endBefore", arguments, 1);
-        const s = this.sf("Query.endBefore", t, e, 
+        const s = this.Kd("Query.endBefore", t, e, 
         /*before=*/ !0);
-        return new Fi(this.Yd.$e(s), this.firestore, this.xd);
+        return new Ni(this.Qd.$e(s), this.firestore, this.kd);
     }
     endAt(t, ...e) {
         Xe("Query.endAt", arguments, 1);
-        const s = this.sf("Query.endAt", t, e, 
+        const s = this.Kd("Query.endAt", t, e, 
         /*before=*/ !1);
-        return new Fi(this.Yd.$e(s), this.firestore, this.xd);
+        return new Ni(this.Qd.$e(s), this.firestore, this.kd);
     }
     isEqual(t) {
-        if (!(t instanceof Fi)) throw ls("isEqual", "Query", 1, t);
-        return this.firestore === t.firestore && this.Yd.isEqual(t.Yd);
+        if (!(t instanceof Ni)) throw ls("isEqual", "Query", 1, t);
+        return this.firestore === t.firestore && this.Qd.isEqual(t.Qd);
     }
     withConverter(t) {
-        return new Fi(this.Yd, this.firestore, t);
+        return new Ni(this.Qd, this.firestore, t);
     }
-    /** Helper function to create a bound from a document or fields */    sf(t, e, s, i) {
-        if (us(t, 1, e), e instanceof Ci) {
+    /** Helper function to create a bound from a document or fields */    Kd(t, e, s, i) {
+        if (us(t, 1, e), e instanceof Di) {
             if (s.length > 0) throw new E(m.INVALID_ARGUMENT, `Too many arguments provided to ${t}().`);
             const n = e;
             if (!n.exists) throw new E(m.NOT_FOUND, "Can't use a DocumentSnapshot that doesn't exist for " + `${t}().`);
-            return this.if(n.Kd, i);
+            return this.Hd(n.qd, i);
         }
         {
             const n = [ e ].concat(s);
-            return this.nf(t, n, i);
+            return this.Jd(t, n, i);
         }
     }
     /**
@@ -11303,7 +11268,7 @@ class Fi {
      * Will throw if the document does not contain all fields of the order by
      * of the query or if any of the fields in the order by are an uncommitted
      * server timestamp.
-     */    if(t, e) {
+     */    Hd(t, e) {
         const s = [];
         // Because people expect to continue/end a query at the exact document
         // provided, we need to use the implicit sort order rather than the explicit
@@ -11312,7 +11277,7 @@ class Fi {
         // the provided document. Without the key (by using the explicit sort
         // orders), multiple documents could match the position, yielding duplicate
         // results.
-                for (const e of this.Yd.orderBy) if (e.field.Y()) s.push(et(this.firestore.Id, t.key)); else {
+                for (const e of this.Qd.orderBy) if (e.field.Y()) s.push(et(this.firestore._d, t.key)); else {
             const i = t.field(e.field);
             if (x(i)) throw new E(m.INVALID_ARGUMENT, 'Invalid query. You are trying to start or end a query using a document for which the field "' + e.field + '" is an uncommitted server timestamp. (Since the value of this field is unknown, you cannot start/end a query with it.)');
             if (null === i) {
@@ -11325,22 +11290,22 @@ class Fi {
     }
     /**
      * Converts a list of field values to a Bound for the given query.
-     */    nf(t, e, s) {
+     */    Jd(t, e, s) {
         // Use explicit order by's because it has to match the query the user made
-        const i = this.Yd.Ve;
+        const i = this.Qd.Ve;
         if (e.length > i.length) throw new E(m.INVALID_ARGUMENT, `Too many arguments provided to ${t}(). ` + "The number of arguments must be less than or equal to the number of Query.orderBy() clauses");
         const n = [];
         for (let s = 0; s < e.length; s++) {
             const r = e[s];
             if (i[s].field.Y()) {
                 if ("string" != typeof r) throw new E(m.INVALID_ARGUMENT, "Invalid query. Expected a string for document ID in " + `${t}(), but got a ${typeof r}`);
-                if (!this.Yd.He() && -1 !== r.indexOf("/")) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying a collection and ordering by FieldPath.documentId(), " + `the value passed to ${t}() must be a plain document ID, but ` + `'${r}' contains a slash.`);
-                const e = this.Yd.path.child(b.K(r));
+                if (!this.Qd.He() && -1 !== r.indexOf("/")) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying a collection and ordering by FieldPath.documentId(), " + `the value passed to ${t}() must be a plain document ID, but ` + `'${r}' contains a slash.`);
+                const e = this.Qd.path.child(b.K(r));
                 if (!C.st(e)) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying a collection group and ordering by " + `FieldPath.documentId(), the value passed to ${t}() must result in a ` + `valid document path, but '${e}' is not because it contains an odd number ` + "of segments.");
                 const s = new C(e);
-                n.push(et(this.firestore.Id, s));
+                n.push(et(this.firestore._d, s));
             } else {
-                const e = this.firestore.Cd.Xo(t, r);
+                const e = this.firestore.Pd.Xo(t, r);
                 n.push(e);
             }
         }
@@ -11349,42 +11314,42 @@ class Fi {
     onSnapshot(...t) {
         Ze("Query.onSnapshot", arguments, 1, 4);
         let e, s = {}, i = 0;
-        return "object" != typeof t[i] || Ai(t[i]) || (s = t[i], cs("Query.onSnapshot", s, [ "includeMetadataChanges" ]), 
+        return "object" != typeof t[i] || Pi(t[i]) || (s = t[i], cs("Query.onSnapshot", s, [ "includeMetadataChanges" ]), 
         is("Query.onSnapshot", "boolean", "includeMetadataChanges", s.includeMetadataChanges), 
-        i++), Ai(t[i]) ? e = t[i] : (ts("Query.onSnapshot", "function", i, t[i]), es("Query.onSnapshot", "function", i + 1, t[i + 1]), 
+        i++), Pi(t[i]) ? e = t[i] : (ts("Query.onSnapshot", "function", i, t[i]), es("Query.onSnapshot", "function", i + 1, t[i + 1]), 
         es("Query.onSnapshot", "function", i + 2, t[i + 2]), e = {
             next: t[i],
             error: t[i + 1],
             complete: t[i + 2]
-        }), this.rf(this.Yd), this.Gd(s, e);
+        }), this.Yd(this.Qd), this.Md(s, e);
     }
-    Gd(t, e) {
+    Md(t, e) {
         let s = t => {
             console.error("Uncaught Error in onSnapshot:", t);
         };
         e.error && (s = e.error.bind(e));
-        const i = new Ii({
+        const i = new Ai({
             next: t => {
-                e.next && e.next(new Ni(this.firestore, this.Yd, t, this.xd));
+                e.next && e.next(new ki(this.firestore, this.Qd, t, this.kd));
             },
             error: s
-        }), n = this.firestore.Vd(), r = n.listen(this.Yd, i, t);
+        }), n = this.firestore.wd(), r = n.listen(this.Qd, i, t);
         return () => {
-            i._d(), n.$u(r);
+            i.sd(), n.$u(r);
         };
     }
-    rf(t) {
+    Yd(t) {
         if (t.Ge() && 0 === t.Ve.length) throw new E(m.UNIMPLEMENTED, "limitToLast() queries require specifying at least one orderBy() clause");
     }
     get(t) {
-        return Ze("Query.get", arguments, 0, 1), Oi("Query.get", t), this.rf(this.Yd), new Promise((e, s) => {
-            t && "cache" === t.source ? this.firestore.Vd().ud(this.Yd).then(t => {
-                e(new Ni(this.firestore, this.Yd, t, this.xd));
-            }, s) : this.zd(e, s, t);
+        return Ze("Query.get", arguments, 0, 1), Mi("Query.get", t), this.Yd(this.Qd), new Promise((e, s) => {
+            t && "cache" === t.source ? this.firestore.wd().td(this.Qd).then(t => {
+                e(new ki(this.firestore, this.Qd, t, this.kd));
+            }, s) : this.Ud(e, s, t);
         });
     }
-    zd(t, e, s) {
-        const i = this.Gd({
+    Ud(t, e, s) {
+        const i = this.Md({
             includeMetadataChanges: !0,
             ql: !0
         }, {
@@ -11400,88 +11365,88 @@ class Fi {
      * Parses the given documentIdValue into a ReferenceValue, throwing
      * appropriate errors if the value is anything other than a DocumentReference
      * or String, or if the string is malformed.
-     */    Zd(t) {
+     */    jd(t) {
         if ("string" == typeof t) {
             if ("" === t) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying with FieldPath.documentId(), you must provide a valid document ID, but it was an empty string.");
-            if (!this.Yd.He() && -1 !== t.indexOf("/")) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying a collection by FieldPath.documentId(), you must provide a plain document ID, but " + `'${t}' contains a '/' character.`);
-            const e = this.Yd.path.child(b.K(t));
+            if (!this.Qd.He() && -1 !== t.indexOf("/")) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying a collection by FieldPath.documentId(), you must provide a plain document ID, but " + `'${t}' contains a '/' character.`);
+            const e = this.Qd.path.child(b.K(t));
             if (!C.st(e)) throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying a collection group by FieldPath.documentId(), the value provided must result in a valid document path, " + `but '${e}' is not because it has an odd number of segments (${e.length}).`);
-            return et(this.firestore.Id, new C(e));
+            return et(this.firestore._d, new C(e));
         }
-        if (t instanceof vi) {
+        if (t instanceof Si) {
             const e = t;
-            return et(this.firestore.Id, e.Od);
+            return et(this.firestore._d, e.Sd);
         }
         throw new E(m.INVALID_ARGUMENT, "Invalid query. When querying with FieldPath.documentId(), you must provide a valid string or a DocumentReference, but it was: " + `${as(t)}.`);
     }
     /**
      * Validates that the value passed into a disjunctrive filter satisfies all
      * array requirements.
-     */    Xd(t, e) {
+     */    Wd(t, e) {
         if (!Array.isArray(t) || 0 === t.length) throw new E(m.INVALID_ARGUMENT, "Invalid Query. A non-empty array is required for " + `'${e.toString()}' filters.`);
         if (t.length > 10) throw new E(m.INVALID_ARGUMENT, `Invalid Query. '${e.toString()}' filters support a ` + "maximum of 10 elements in the value array.");
         if (t.indexOf(null) >= 0) throw new E(m.INVALID_ARGUMENT, `Invalid Query. '${e.toString()}' filters cannot contain 'null' ` + "in the value array.");
         if (t.filter(t => Number.isNaN(t)).length > 0) throw new E(m.INVALID_ARGUMENT, `Invalid Query. '${e.toString()}' filters cannot contain 'NaN' ` + "in the value array.");
     }
-    tf(t) {
+    Gd(t) {
         if (t instanceof Dt) {
             const e = [ Ct.ARRAY_CONTAINS, Ct.ARRAY_CONTAINS_ANY ], s = [ Ct.IN, Ct.ARRAY_CONTAINS_ANY ], i = e.indexOf(t.op) >= 0, n = s.indexOf(t.op) >= 0;
             if (t.ze()) {
-                const e = this.Yd.Se();
+                const e = this.Qd.Se();
                 if (null !== e && !e.isEqual(t.field)) throw new E(m.INVALID_ARGUMENT, "Invalid query. All where filters with an inequality (<, <=, >, or >=) must be on the same field. But you have" + ` inequality filters on '${e.toString()}'` + ` and '${t.field.toString()}'`);
-                const s = this.Yd.Ce();
-                null !== s && this.hf(t.field, s);
+                const s = this.Qd.Ce();
+                null !== s && this.Xd(t.field, s);
             } else if (n || i) {
                 // You can have at most 1 disjunctive filter and 1 array filter. Check if
                 // the new filter conflicts with an existing one.
                 let r = null;
-                if (n && (r = this.Yd.Ke(s)), null === r && i && (r = this.Yd.Ke(e)), null != r) 
+                if (n && (r = this.Qd.Ke(s)), null === r && i && (r = this.Qd.Ke(e)), null != r) 
                 // We special case when it's a duplicate op to give a slightly clearer error message.
                 throw r === t.op ? new E(m.INVALID_ARGUMENT, "Invalid query. You cannot use more than one " + `'${t.op.toString()}' filter.`) : new E(m.INVALID_ARGUMENT, `Invalid query. You cannot use '${t.op.toString()}' filters ` + `with '${r.toString()}' filters.`);
             }
         }
     }
-    ef(t) {
-        if (null === this.Yd.Ce()) {
+    zd(t) {
+        if (null === this.Qd.Ce()) {
             // This is the first order by. It must match any inequality.
-            const e = this.Yd.Se();
-            null !== e && this.hf(e, t.field);
+            const e = this.Qd.Se();
+            null !== e && this.Xd(e, t.field);
         }
     }
-    hf(t, e) {
+    Xd(t, e) {
         if (!e.isEqual(t)) throw new E(m.INVALID_ARGUMENT, "Invalid query. You have a where filter with an inequality " + `(<, <=, >, or >=) on field '${t.toString()}' ` + `and so you must also use '${t.toString()}' ` + "as your first Query.orderBy(), but your first Query.orderBy() " + `is on field '${e.toString()}' instead.`);
     }
 }
 
-class Ni {
+class ki {
     constructor(t, e, s, i) {
-        this.qd = t, this.af = e, this.uf = s, this.xd = i, this.cf = null, this.lf = null, 
-        this.metadata = new Si(s.hasPendingWrites, s.fromCache);
+        this.Fd = t, this.Zd = e, this.tf = s, this.kd = i, this.ef = null, this.sf = null, 
+        this.metadata = new Ci(s.hasPendingWrites, s.fromCache);
     }
     get docs() {
         const t = [];
         return this.forEach(e => t.push(e)), t;
     }
     get empty() {
-        return this.uf.docs.q();
+        return this.tf.docs.q();
     }
     get size() {
-        return this.uf.docs.size;
+        return this.tf.docs.size;
     }
     forEach(t, e) {
         Ze("QuerySnapshot.forEach", arguments, 1, 2), ts("QuerySnapshot.forEach", "function", 1, t), 
-        this.uf.docs.forEach(s => {
-            t.call(e, this._f(s));
+        this.tf.docs.forEach(s => {
+            t.call(e, this.if(s));
         });
     }
     get query() {
-        return new Fi(this.af, this.qd, this.xd);
+        return new Ni(this.Zd, this.Fd, this.kd);
     }
     docChanges(t) {
         t && (cs("QuerySnapshot.docChanges", t, [ "includeMetadataChanges" ]), is("QuerySnapshot.docChanges", "boolean", "includeMetadataChanges", t.includeMetadataChanges));
         const e = !(!t || !t.includeMetadataChanges);
-        if (e && this.uf.ds) throw new E(m.INVALID_ARGUMENT, "To include metadata changes with your document changes, you must also pass { includeMetadataChanges:true } to onSnapshot().");
-        return this.cf && this.lf === e || (this.cf = 
+        if (e && this.tf.ds) throw new E(m.INVALID_ARGUMENT, "To include metadata changes with your document changes, you must also pass { includeMetadataChanges:true } to onSnapshot().");
+        return this.ef && this.sf === e || (this.ef = 
         /**
  * Calculates the array of firestore.DocumentChange's for a given ViewSnapshot.
  *
@@ -11493,7 +11458,7 @@ class Ni {
                 // fast
                 let e, n = 0;
                 return s.docChanges.map(r => {
-                    const h = new Di(t, r.doc.key, r.doc, s.fromCache, s.ls.has(r.doc.key), i);
+                    const h = new Fi(t, r.doc.key, r.doc, s.fromCache, s.ls.has(r.doc.key), i);
                     return e = r.doc, {
                         type: "added",
                         doc: h,
@@ -11507,41 +11472,41 @@ class Ni {
                 // to lookup the index of a document.
                 let n = s.cs;
                 return s.docChanges.filter(t => e || 3 /* Metadata */ !== t.type).map(e => {
-                    const r = new Di(t, e.doc.key, e.doc, s.fromCache, s.ls.has(e.doc.key), i);
+                    const r = new Fi(t, e.doc.key, e.doc, s.fromCache, s.ls.has(e.doc.key), i);
                     let h = -1, o = -1;
                     return 0 /* Added */ !== e.type && (h = n.indexOf(e.doc.key), n = n.delete(e.doc.key)), 
                     1 /* Removed */ !== e.type && (n = n.add(e.doc), o = n.indexOf(e.doc.key)), {
-                        type: Ui(e.type),
+                        type: qi(e.type),
                         doc: r,
                         oldIndex: h,
                         newIndex: o
                     };
                 });
             }
-        }(this.qd, e, this.uf, this.xd), this.lf = e), this.cf;
+        }(this.Fd, e, this.tf, this.kd), this.sf = e), this.ef;
     }
     /** Check the equality. The call can be very expensive. */    isEqual(t) {
-        if (!(t instanceof Ni)) throw ls("isEqual", "QuerySnapshot", 1, t);
-        return this.qd === t.qd && this.af.isEqual(t.af) && this.uf.isEqual(t.uf) && this.xd === t.xd;
+        if (!(t instanceof ki)) throw ls("isEqual", "QuerySnapshot", 1, t);
+        return this.Fd === t.Fd && this.Zd.isEqual(t.Zd) && this.tf.isEqual(t.tf) && this.kd === t.kd;
     }
-    _f(t) {
-        return new Di(this.qd, t.key, t, this.metadata.fromCache, this.uf.ls.has(t.key), this.xd);
+    if(t) {
+        return new Fi(this.Fd, t.key, t, this.metadata.fromCache, this.tf.ls.has(t.key), this.kd);
     }
 }
 
-class ki extends Fi {
+class Li extends Ni {
     constructor(t, e, s) {
-        if (super(St.ve(t), e, s), this.df = t, t.length % 2 != 1) throw new E(m.INVALID_ARGUMENT, "Invalid collection reference. Collection references must have an odd number of segments, but " + `${t.G()} has ${t.length}`);
+        if (super(St.ve(t), e, s), this.nf = t, t.length % 2 != 1) throw new E(m.INVALID_ARGUMENT, "Invalid collection reference. Collection references must have an odd number of segments, but " + `${t.G()} has ${t.length}`);
     }
     get id() {
-        return this.Yd.path.U();
+        return this.Qd.path.U();
     }
     get parent() {
-        const t = this.Yd.path.O();
-        return t.q() ? null : new vi(new C(t), this.firestore);
+        const t = this.Qd.path.O();
+        return t.q() ? null : new Si(new C(t), this.firestore);
     }
     get path() {
-        return this.Yd.path.G();
+        return this.Qd.path.G();
     }
     doc(t) {
         if (Ze("CollectionReference.doc", arguments, 0, 1), 
@@ -11550,19 +11515,19 @@ class ki extends Fi {
         0 === arguments.length && (t = Ce.Tn()), ts("CollectionReference.doc", "non-empty string", 1, t), 
         "" === t) throw new E(m.INVALID_ARGUMENT, "Document path must be a non-empty string");
         const e = b.K(t);
-        return vi.Md(this.Yd.path.child(e), this.firestore, this.xd);
+        return Si.Cd(this.Qd.path.child(e), this.firestore, this.kd);
     }
     add(t) {
-        Ye("CollectionReference.add", arguments, 1), ts("CollectionReference.add", "object", 1, this.xd ? this.xd.toFirestore(t) : t);
+        Ye("CollectionReference.add", arguments, 1), ts("CollectionReference.add", "object", 1, this.kd ? this.kd.toFirestore(t) : t);
         const e = this.doc();
         return e.set(t).then(() => e);
     }
     withConverter(t) {
-        return new ki(this.df, this.firestore, t);
+        return new Li(this.nf, this.firestore, t);
     }
 }
 
-function Li(t, e) {
+function $i(t, e) {
     if (void 0 === e) return {
         merge: !1
     };
@@ -11571,24 +11536,24 @@ function Li(t, e) {
     return e;
 }
 
-function $i(t, e) {
+function Oi(t, e) {
     return void 0 === e ? {} : (cs(t, e, [ "serverTimestamps" ]), rs(t, 0, "serverTimestamps", e.serverTimestamps, [ "estimate", "previous", "none" ]), 
     e);
 }
 
-function Oi(t, e) {
+function Mi(t, e) {
     es(t, "object", 1, e), e && (cs(t, e, [ "source" ]), rs(t, 0, "source", e.source, [ "default", "server", "cache" ]));
 }
 
-function Mi(t, e, s) {
-    if (e instanceof vi) {
+function Ui(t, e, s) {
+    if (e instanceof Si) {
         if (e.firestore !== s) throw new E(m.INVALID_ARGUMENT, "Provided document reference is from a different Firestore instance.");
         return e;
     }
     throw ls(t, "DocumentReference", 1, e);
 }
 
-function Ui(t) {
+function qi(t) {
     switch (t) {
       case 0 /* Added */ :
         return "added";
@@ -11613,28 +11578,28 @@ function Ui(t) {
  * because we want to provide the user with a more specific error message if
  * their set() or fails due to invalid data originating from a toFirestore()
  * call.
- */ function qi(t, e, s) {
+ */ function Bi(t, e, s) {
     let i;
     return t ? (i = t.toFirestore(e), s = "toFirestore() in " + s) : i = e, [ i, s ];
 }
 
-const Bi = ws(gi, "Use firebase.firestore() instead."), xi = ws(yi, "Use firebase.firestore().runTransaction() instead."), Qi = ws(bi, "Use firebase.firestore().batch() instead."), Wi = ws(vi, "Use firebase.firestore().doc() instead."), ji = ws(Ci), Gi = ws(Di), zi = ws(Fi), Ki = ws(Ni), Hi = ws(ki, "Use firebase.firestore().collection() instead."), Ji = {
-    Firestore: Bi,
+const xi = ws(yi, "Use firebase.firestore() instead."), Qi = ws(bi, "Use firebase.firestore().runTransaction() instead."), Wi = ws(vi, "Use firebase.firestore().batch() instead."), ji = ws(Si, "Use firebase.firestore().doc() instead."), Gi = ws(Di), zi = ws(Fi), Ki = ws(Ni), Hi = ws(ki), Ji = ws(Li, "Use firebase.firestore().collection() instead."), Yi = {
+    Firestore: xi,
     GeoPoint: Ss,
     Timestamp: p,
     Blob: Rs,
-    Transaction: xi,
-    WriteBatch: Qi,
-    DocumentReference: Wi,
-    DocumentSnapshot: ji,
-    Query: zi,
-    QueryDocumentSnapshot: Gi,
-    QuerySnapshot: Ki,
-    CollectionReference: Hi,
+    Transaction: Qi,
+    WriteBatch: Wi,
+    DocumentReference: ji,
+    DocumentSnapshot: Gi,
+    Query: Ki,
+    QueryDocumentSnapshot: zi,
+    QuerySnapshot: Hi,
+    CollectionReference: Ji,
     FieldPath: Is,
     FieldValue: vs,
-    setLogLevel: gi.setLogLevel,
-    CACHE_SIZE_UNLIMITED: Vi
+    setLogLevel: yi.setLogLevel,
+    CACHE_SIZE_UNLIMITED: pi
 };
 
 /**
@@ -11653,7 +11618,7 @@ const Bi = ws(gi, "Use firebase.firestore() instead."), xi = ws(yi, "Use firebas
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class Yi {
+class Xi {
     mu(t) {
         // No-op.
     }
@@ -11681,31 +11646,31 @@ class Yi {
 /**
  * Browser implementation of ConnectivityMonitor.
  */
-class Xi {
+class Zi {
     constructor() {
-        this.ff = () => this.wf(), this.Tf = () => this.mf(), this.Ef = [], this.Rf();
+        this.rf = () => this.hf(), this.af = () => this.uf(), this.cf = [], this.lf();
     }
     mu(t) {
-        this.Ef.push(t);
+        this.cf.push(t);
     }
     ku() {
-        window.removeEventListener("online", this.ff), window.removeEventListener("offline", this.Tf);
+        window.removeEventListener("online", this.rf), window.removeEventListener("offline", this.af);
     }
-    Rf() {
-        window.addEventListener("online", this.ff), window.addEventListener("offline", this.Tf);
+    lf() {
+        window.addEventListener("online", this.rf), window.addEventListener("offline", this.af);
     }
-    wf() {
+    hf() {
         ge("ConnectivityMonitor", "Network connectivity changed: AVAILABLE");
-        for (const t of this.Ef) t(0 /* AVAILABLE */);
+        for (const t of this.cf) t(0 /* AVAILABLE */);
     }
-    mf() {
+    uf() {
         ge("ConnectivityMonitor", "Network connectivity changed: UNAVAILABLE");
-        for (const t of this.Ef) t(1 /* UNAVAILABLE */);
+        for (const t of this.cf) t(1 /* UNAVAILABLE */);
     }
     // TODO(chenbrian): Consider passing in window either into this component or
     // here for testing via FakeWindow.
     /** Checks that all used attributes of window are available. */
-    static If() {
+    static _f() {
         return "undefined" != typeof window && void 0 !== window.addEventListener && void 0 !== window.removeEventListener;
     }
 }
@@ -11730,33 +11695,33 @@ class Xi {
  * Provides a simple helper class that implements the Stream interface to
  * bridge to other implementations that are streams but do not implement the
  * interface. The stream callbacks are invoked with the callOn... methods.
- */ class Zi {
+ */ class tn {
     constructor(t) {
-        this.Af = t.Af, this.Pf = t.Pf;
+        this.df = t.df, this.ff = t.ff;
     }
     Na(t) {
-        this.Vf = t;
+        this.wf = t;
     }
     va(t) {
-        this.pf = t;
+        this.Tf = t;
     }
     onMessage(t) {
-        this.gf = t;
+        this.mf = t;
     }
     close() {
-        this.Pf();
+        this.ff();
     }
     send(t) {
-        this.Af(t);
+        this.df(t);
     }
-    yf() {
-        this.Vf();
+    Ef() {
+        this.wf();
     }
-    bf(t) {
-        this.pf(t);
+    Rf(t) {
+        this.Tf(t);
     }
-    vf(t) {
-        this.gf(t);
+    If(t) {
+        this.mf(t);
     }
 }
 
@@ -11775,26 +11740,26 @@ class Xi {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ const tn = {
+ */ const en = {
     BatchGetDocuments: "batchGet",
     Commit: "commit"
-}, en = "gl-js/ fire/" + w;
+}, sn = "gl-js/ fire/" + w;
 
-class sn {
+class nn {
     constructor(t) {
         this.ci = t.ci;
         const e = t.ssl ? "https" : "http";
-        this.Sf = e + "://" + t.host, this.forceLongPolling = t.forceLongPolling;
+        this.Af = e + "://" + t.host, this.forceLongPolling = t.forceLongPolling;
     }
     /**
      * Modifies the headers for a request, adding any authorization token if
      * present and any additional headers for the request.
-     */    Cf(t, e) {
+     */    Pf(t, e) {
         if (e) for (const s in e.o) e.o.hasOwnProperty(s) && (t[s] = e.o[s]);
-        t["X-Goog-Api-Client"] = en;
+        t["X-Goog-Api-Client"] = sn;
     }
     Ga(t, e, s) {
-        const i = this.Df(t);
+        const i = this.Vf(t);
         return new Promise((n, r) => {
             const h = new c;
             h.listenOnce(l.COMPLETE, () => {
@@ -11849,7 +11814,7 @@ class sn {
             const u = {
                 "Content-Type": "text/plain"
             };
-            this.Cf(u, s), h.send(i, "POST", a, u, 15);
+            this.Pf(u, s), h.send(i, "POST", a, u, 15);
         });
     }
     Ka(t, e, s) {
@@ -11858,7 +11823,7 @@ class sn {
         return this.Ga(t, e, s);
     }
     ka(t, e) {
-        const s = [ this.Sf, "/", "google.firestore.v1.Firestore", "/", t, "/channel" ], u = d(), c = {
+        const s = [ this.Af, "/", "google.firestore.v1.Firestore", "/", t, "/channel" ], u = d(), c = {
             // Required for backend stickiness, routing behavior is based on this
             // parameter.
             httpSessionIdParam: "gsessionid",
@@ -11881,7 +11846,7 @@ class sn {
             },
             forceLongPolling: this.forceLongPolling
         };
-        this.Cf(c.initMessageHeaders, e), 
+        this.Pf(c.initMessageHeaders, e), 
         // Sending the custom headers we just added to request.initMessageHeaders
         // (Authorization, etc.) will trigger the browser to make a CORS preflight
         // request because the XHR will no longer meet the criteria for a "simple"
@@ -11910,12 +11875,12 @@ class sn {
         // A flag to determine whether the stream was closed (by us or through an
         // error/close event) to avoid delivering multiple close events or sending
         // on a closed stream
-                const R = new Zi({
-            Af: t => {
+                const R = new tn({
+            df: t => {
                 T ? ge("Connection", "Not sending because WebChannel is closed:", t) : (w || (ge("Connection", "Opening WebChannel transport."), 
                 _.open(), w = !0), ge("Connection", "WebChannel sending:", t), _.send(t));
             },
-            Pf: () => _.close()
+            ff: () => _.close()
         }), I = (t, e) => {
             // TODO(dimond): closure typing seems broken because WebChannel does
             // not implement goog.events.Listenable
@@ -11936,9 +11901,9 @@ class sn {
                 return I(f.EventType.OPEN, () => {
             T || ge("Connection", "WebChannel transport opened.");
         }), I(f.EventType.CLOSE, () => {
-            T || (T = !0, ge("Connection", "WebChannel transport closed"), R.bf());
+            T || (T = !0, ge("Connection", "WebChannel transport closed"), R.Rf());
         }), I(f.EventType.ERROR, t => {
-            T || (T = !0, ge("Connection", "WebChannel transport errored:", t), R.bf(new E(m.UNAVAILABLE, "The operation could not be completed")));
+            T || (T = !0, ge("Connection", "WebChannel transport errored:", t), R.Rf(new E(m.UNAVAILABLE, "The operation could not be completed")));
         }), I(f.EventType.MESSAGE, t => {
             var e;
             if (!T) {
@@ -11962,21 +11927,21 @@ class sn {
                     }(t), s = n.message;
                     void 0 === e && (e = m.INTERNAL, s = "Unknown error status: " + t + " with message " + n.message), 
                     // Mark closed so no further events are propagated
-                    T = !0, R.bf(new E(e, s)), _.close();
-                } else ge("Connection", "WebChannel received:", s), R.vf(s);
+                    T = !0, R.Rf(new E(e, s)), _.close();
+                } else ge("Connection", "WebChannel received:", s), R.If(s);
             }
         }), setTimeout(() => {
             // Technically we could/should wait for the WebChannel opened event,
             // but because we want to send the first message with the WebChannel
             // handshake we pretend the channel opened here (asynchronously), and
             // then delay the actual open until the first message is sent.
-            R.yf();
+            R.Ef();
         }, 0), R;
     }
     // visible for testing
-    Df(t) {
-        const e = tn[t];
-        return this.Sf + "/v1/projects/" + this.ci.projectId + "/databases/" + this.ci.database + "/documents:" + e;
+    Vf(t) {
+        const e = en[t];
+        return this.Af + "/v1/projects/" + this.ci.projectId + "/databases/" + this.ci.database + "/documents:" + e;
     }
 }
 
@@ -12029,13 +11994,13 @@ Ae.fn(new class {
     get window() {
         return "undefined" != typeof window ? window : null;
     }
-    td(t) {
-        return Promise.resolve(new sn(t));
+    K_(t) {
+        return Promise.resolve(new nn(t));
     }
-    J_() {
-        return Xi.If() ? new Xi : new Yi;
+    Q_() {
+        return Zi._f() ? new Zi : new Xi;
     }
-    ed(t) {
+    H_(t) {
         return new Re(t, {
             di: !0
         });
@@ -12070,7 +12035,7 @@ Ae.fn(new class {
 /**
  * Registers the memory-only Firestore build with the components framework.
  */
-function nn(t) {
+function rn(t) {
     !
     /**
  * Configures Firestore as part of the Firebase SDK by calling registerService.
@@ -12083,11 +12048,11 @@ function nn(t) {
         t.INTERNAL.registerComponent(new u("firestore", t => {
             const s = t.getProvider("app").getImmediate();
             return e(s, t.getProvider("auth-internal"));
-        }, "PUBLIC" /* PUBLIC */).setServiceProps(Object.assign({}, Ji)));
-    }(t, (t, e) => new gi(t, e, new Ei)), t.registerVersion("@firebase/firestore", "1.14.0-canary.daf63c2c");
+        }, "PUBLIC" /* PUBLIC */).setServiceProps(Object.assign({}, Yi)));
+    }(t, (t, e) => new yi(t, e, new Ri)), t.registerVersion("@firebase/firestore", "1.14.0");
 }
 
-nn(t);
+rn(t);
 
-export { nn as __PRIVATE_registerFirestore };
+export { rn as __PRIVATE_registerFirestore };
 //# sourceMappingURL=index.memory.esm2017.js.map