@firebase/firestore 3.4.13 → 3.4.14-canary.6f4ba2525

package/dist/lite/index.rn.esm2017.js

@@ -66,7 +66,7 @@ f.MOCK_USER = new f("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let d = "9.9.1";
+let d = "9.9.2-canary.6f4ba2525";
 
 /**
  * @license
@@ -350,10 +350,22 @@ e) {
  * recover from unauthenticated errors (see b/33147818 for context), but it's
  * safer to keep the implementation as-is.
  */ class G {
-    constructor(t, e, n) {
-        this.type = "FirstParty", this.user = f.FIRST_PARTY, this.headers = new Map, this.headers.set("X-Goog-AuthUser", e);
-        const r = t.auth.getAuthHeaderValueForFirstParty([]);
-        r && this.headers.set("Authorization", r), n && this.headers.set("X-Goog-Iam-Authorization-Token", n);
+    constructor(t, e, n, r) {
+        this.t = t, this.i = e, this.o = n, this.u = r, this.type = "FirstParty", this.user = f.FIRST_PARTY, 
+        this.h = new Map;
+    }
+    /** Gets an authorization token, using a provided factory function, or falling back to First Party GAPI. */    l() {
+        return this.u ? this.u() : (
+        // Make sure this really is a Gapi client.
+        b(!("object" != typeof this.t || null === this.t || !this.t.auth || !this.t.auth.getAuthHeaderValueForFirstParty)), 
+        this.t.auth.getAuthHeaderValueForFirstParty([]));
+    }
+    get headers() {
+        this.h.set("X-Goog-AuthUser", this.i);
+        // Use array notation to prevent minification
+        const t = this.l();
+        return t && this.h.set("Authorization", t), this.o && this.h.set("X-Goog-Iam-Authorization-Token", this.o), 
+        this.h;
     }
 }
 
@@ -362,11 +374,11 @@ e) {
  * to authenticate the user, using technique that is only available
  * to applications hosted by Google.
  */ class K {
-    constructor(t, e, n) {
-        this.t = t, this.i = e, this.o = n;
+    constructor(t, e, n, r) {
+        this.t = t, this.i = e, this.o = n, this.u = r;
     }
     getToken() {
-        return Promise.resolve(new G(this.t, this.i, this.o));
+        return Promise.resolve(new G(this.t, this.i, this.o, this.u));
     }
     start(t, e) {
         // Fire with initial uid.
@@ -384,7 +396,7 @@ class Q {
 
 /** AppCheck token provider for the Lite SDK. */ class Y {
     constructor(t) {
-        this.u = t, this.appCheck = null, t.onInit((t => {
+        this.m = t, this.appCheck = null, t.onInit((t => {
             this.appCheck = t;
         }));
     }
@@ -1012,27 +1024,27 @@ class {
     constructor(t) {
         this.databaseInfo = t, this.databaseId = t.databaseId;
         const e = t.ssl ? "https" : "http";
-        this.h = e + "://" + t.host, this.l = "projects/" + this.databaseId.projectId + "/databases/" + this.databaseId.database + "/documents";
+        this.p = e + "://" + t.host, this.g = "projects/" + this.databaseId.projectId + "/databases/" + this.databaseId.database + "/documents";
     }
-    m(t, e, n, r, s) {
-        const i = this.p(t, e);
+    v(t, e, n, r, s) {
+        const i = this.T(t, e);
         p("RestConnection", "Sending: ", i, n);
         const o = {};
-        return this.g(o, r, s), this.v(t, i, o, n).then((t => (p("RestConnection", "Received: ", t), 
+        return this.I(o, r, s), this.A(t, i, o, n).then((t => (p("RestConnection", "Received: ", t), 
         t)), (e => {
             throw _("RestConnection", `${t} failed with error: `, e, "url: ", i, "request:", n), 
             e;
         }));
     }
-    T(t, e, n, r, s, i) {
+    R(t, e, n, r, s, i) {
         // The REST API automatically aggregates all of the streamed results, so we
         // can just use the normal invoke() method.
-        return this.m(t, e, n, r, s);
+        return this.v(t, e, n, r, s);
     }
     /**
      * Modifies the headers for a request, adding any authorization token if
      * present and any additional headers for the request.
-     */    g(t, e, n) {
+     */    I(t, e, n) {
         t["X-Goog-Api-Client"] = "gl-js/ fire/" + d, 
         // Content-Type: text/plain will avoid preflight requests which might
         // mess with CORS and redirects by proxies. If we add custom headers
@@ -1041,9 +1053,9 @@ class {
         t["Content-Type"] = "text/plain", this.databaseInfo.appId && (t["X-Firebase-GMPID"] = this.databaseInfo.appId), 
         e && e.headers.forEach(((e, n) => t[n] = e)), n && n.headers.forEach(((e, n) => t[n] = e));
     }
-    p(t, e) {
+    T(t, e) {
         const n = lt[t];
-        return `${this.h}/v1/${e}:${n}`;
+        return `${this.p}/v1/${e}:${n}`;
     }
 } {
     /**
@@ -1051,16 +1063,16 @@ class {
      * @param fetchImpl - `fetch` or a Polyfill that implements the fetch API.
      */
     constructor(t, e) {
-        super(t), this.I = e;
+        super(t), this.P = e;
     }
-    A(t, e) {
+    V(t, e) {
         throw new Error("Not supported by FetchConnection");
     }
-    async v(t, e, n, r) {
+    async A(t, e, n, r) {
         const s = JSON.stringify(r);
         let i;
         try {
-            i = await this.I(e, {
+            i = await this.P(e, {
                 method: "POST",
                 headers: n,
                 body: s
@@ -1138,7 +1150,7 @@ function pt(t) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */ class yt {
-    static R() {
+    static N() {
         // Alphanumeric characters
         const t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", e = Math.floor(256 / t.length) * t.length;
         // The largest byte value that is a multiple of `char.length`.
@@ -2620,7 +2632,7 @@ class Jt {
 class Zt {
     constructor(t, e = null, n = [], r = [], s = null, i = null, o = null) {
         this.path = t, this.collectionGroup = e, this.orderBy = n, this.filters = r, this.limit = s, 
-        this.startAt = i, this.endAt = o, this.P = null;
+        this.startAt = i, this.endAt = o, this.$ = null;
     }
 }
 
@@ -2642,18 +2654,18 @@ class ee extends class {} {
     /**
      * Creates a filter based on the provided arguments.
      */    static create(t, e, n) {
-        return t.isKeyField() ? "in" /* IN */ === e || "not-in" /* NOT_IN */ === e ? this.V(t, e, n) : new ne(t, e, n) : "array-contains" /* ARRAY_CONTAINS */ === e ? new oe(t, n) : "in" /* IN */ === e ? new ue(t, n) : "not-in" /* NOT_IN */ === e ? new ce(t, n) : "array-contains-any" /* ARRAY_CONTAINS_ANY */ === e ? new ae(t, n) : new ee(t, e, n);
+        return t.isKeyField() ? "in" /* IN */ === e || "not-in" /* NOT_IN */ === e ? this.D(t, e, n) : new ne(t, e, n) : "array-contains" /* ARRAY_CONTAINS */ === e ? new oe(t, n) : "in" /* IN */ === e ? new ue(t, n) : "not-in" /* NOT_IN */ === e ? new ce(t, n) : "array-contains-any" /* ARRAY_CONTAINS_ANY */ === e ? new ae(t, n) : new ee(t, e, n);
     }
-    static V(t, e, n) {
+    static D(t, e, n) {
         return "in" /* IN */ === e ? new re(t, n) : new se(t, n);
     }
     matches(t) {
         const e = t.data.field(this.field);
         // Types do not have to match in NOT_EQUAL filters.
-                return "!=" /* NOT_EQUAL */ === this.op ? null !== e && this.N(Bt(e, this.value)) : null !== e && Mt(this.value) === Mt(e) && this.N(Bt(e, this.value));
+                return "!=" /* NOT_EQUAL */ === this.op ? null !== e && this.S(Bt(e, this.value)) : null !== e && Mt(this.value) === Mt(e) && this.S(Bt(e, this.value));
         // Only compare types with matching backend order (such as double and int).
         }
-    N(t) {
+    S(t) {
         switch (this.op) {
           case "<" /* LESS_THAN */ :
             return t < 0;
@@ -2677,7 +2689,7 @@ class ee extends class {} {
             return v();
         }
     }
-    $() {
+    F() {
         return [ "<" /* LESS_THAN */ , "<=" /* LESS_THAN_OR_EQUAL */ , ">" /* GREATER_THAN */ , ">=" /* GREATER_THAN_OR_EQUAL */ , "!=" /* NOT_EQUAL */ , "not-in" /* NOT_IN */ ].indexOf(this.op) >= 0;
     }
 }
@@ -2689,7 +2701,7 @@ class ne extends ee {
     }
     matches(t) {
         const e = nt.comparator(t.key, this.key);
-        return this.N(e);
+        return this.S(e);
     }
 }
 
@@ -2829,9 +2841,9 @@ function de(t, e) {
      */
     constructor(t, e = null, n = [], r = [], s = null, i = "F" /* First */ , o = null, u = null) {
         this.path = t, this.collectionGroup = e, this.explicitOrderBy = n, this.filters = r, 
-        this.limit = s, this.limitType = i, this.startAt = o, this.endAt = u, this.D = null, 
+        this.limit = s, this.limitType = i, this.startAt = o, this.endAt = u, this.q = null, 
         // The corresponding `Target` of this `Query` instance.
-        this.S = null, this.startAt, this.endAt;
+        this.O = null, this.startAt, this.endAt;
     }
 }
 
@@ -2840,7 +2852,7 @@ function de(t, e) {
 }
 
 function pe(t) {
-    for (const e of t.filters) if (e.$()) return e.field;
+    for (const e of t.filters) if (e.F()) return e.field;
     return null;
 }
 
@@ -2862,32 +2874,32 @@ function ye(t) {
  * the SDK and backend always orders by `__name__`).
  */ function _e(t) {
     const e = E(t);
-    if (null === e.D) {
-        e.D = [];
+    if (null === e.q) {
+        e.q = [];
         const t = pe(e), n = me(e);
         if (null !== t && null === n) 
         // In order to implicitly add key ordering, we must also add the
         // inequality filter field for it to be a valid query.
         // Note that the default inequality field and key ordering is ascending.
-        t.isKeyField() || e.D.push(new le(t)), e.D.push(new le(et.keyField(), "asc" /* ASCENDING */)); else {
+        t.isKeyField() || e.q.push(new le(t)), e.q.push(new le(et.keyField(), "asc" /* ASCENDING */)); else {
             let t = !1;
-            for (const n of e.explicitOrderBy) e.D.push(n), n.field.isKeyField() && (t = !0);
+            for (const n of e.explicitOrderBy) e.q.push(n), n.field.isKeyField() && (t = !0);
             if (!t) {
                 // The order of the implicit key ordering always matches the last
                 // explicit order by
                 const t = e.explicitOrderBy.length > 0 ? e.explicitOrderBy[e.explicitOrderBy.length - 1].dir : "asc" /* ASCENDING */;
-                e.D.push(new le(et.keyField(), t));
+                e.q.push(new le(et.keyField(), t));
             }
         }
     }
-    return e.D;
+    return e.q;
 }
 
 /**
  * Converts this `Query` instance to it's corresponding `Target` representation.
  */ function ge(t) {
     const e = E(t);
-    if (!e.S) if ("F" /* First */ === e.limitType) e.S = te(e.path, e.collectionGroup, _e(e), e.filters, e.limit, e.startAt, e.endAt); else {
+    if (!e.O) if ("F" /* First */ === e.limitType) e.O = te(e.path, e.collectionGroup, _e(e), e.filters, e.limit, e.startAt, e.endAt); else {
         // Flip the orderBy directions since we want the last results
         const t = [];
         for (const n of _e(e)) {
@@ -2897,9 +2909,9 @@ function ye(t) {
         // We need to swap the cursors to match the now-flipped query ordering.
                 const n = e.endAt ? new he(e.endAt.position, e.endAt.inclusive) : null, r = e.startAt ? new he(e.startAt.position, e.startAt.inclusive) : null;
         // Now return as a LimitType.First query.
-        e.S = te(e.path, e.collectionGroup, t, e.filters, e.limit, n, r);
+        e.O = te(e.path, e.collectionGroup, t, e.filters, e.limit, n, r);
     }
-    return e.S;
+    return e.O;
 }
 
 function ve(t, e) {
@@ -2952,7 +2964,7 @@ function be(t, e) {
             integerValue: "" + t
         };
     }(e) : function(t, e) {
-        if (t.F) {
+        if (t.k) {
             if (isNaN(e)) return {
                 doubleValue: "NaN"
             };
@@ -3014,7 +3026,7 @@ function be(t, e) {
  * arithmetic is used and precision loss can occur for values greater than 2^53.
  */ class Re extends Ee {
     constructor(t, e) {
-        super(), this.q = t, this.O = e;
+        super(), this.C = t, this.L = e;
     }
 }
 
@@ -3222,7 +3234,7 @@ function be(t, e) {
  */
 class Oe {
     constructor(t, e) {
-        this.databaseId = t, this.F = e;
+        this.databaseId = t, this.k = e;
     }
 }
 
@@ -3238,7 +3250,7 @@ class Oe {
  * Returns a value for a Date that's appropriate to put into a proto.
  */
 function ke(t, e) {
-    if (t.F) {
+    if (t.k) {
         return `${new Date(1e3 * e.seconds).toISOString().replace(/\.\d*/, "").replace("Z", "")}.${("000000000" + e.nanoseconds).slice(-9)}Z`;
     }
     return {
@@ -3253,7 +3265,7 @@ function ke(t, e) {
  * Visible for testing.
  */
 function Ce(t, e) {
-    return t.F ? e.toBase64() : e.toUint8Array();
+    return t.k ? e.toBase64() : e.toUint8Array();
 }
 
 function Le(t, e) {
@@ -3354,7 +3366,7 @@ function Qe(t, e) {
         };
         if (n instanceof Re) return {
             fieldPath: e.field.canonicalString(),
-            increment: n.O
+            increment: n.L
         };
         throw v();
     }(0, t)))), e.precondition.isNone || (n.currentDocument = function(t, e) {
@@ -3439,7 +3451,7 @@ function Ye(t, e) {
     }(e.orderBy);
     i && (n.structuredQuery.orderBy = i);
     const o = function(t, e) {
-        return t.F || at(e) ? e : {
+        return t.k || at(e) ? e : {
             value: e
         };
     }(t, e.limit);
@@ -3553,9 +3565,9 @@ class nn {
      * Note that jitter will still be applied, so the actual delay could be as
      * much as 1.5*maxDelayMs.
      */ , s = 6e4) {
-        this.k = t, this.timerId = e, this.C = n, this.L = r, this.M = s, this.U = 0, this.j = null, 
+        this.M = t, this.timerId = e, this.U = n, this.j = r, this.B = s, this.W = 0, this.G = null, 
         /** The last backoff attempt, as epoch milliseconds. */
-        this.B = Date.now(), this.reset();
+        this.K = Date.now(), this.reset();
     }
     /**
      * Resets the backoff delay.
@@ -3564,40 +3576,40 @@ class nn {
      * (i.e. due to an error), initialDelayMs (plus jitter) will be used, and
      * subsequent ones will increase according to the backoffFactor.
      */    reset() {
-        this.U = 0;
+        this.W = 0;
     }
     /**
      * Resets the backoff delay to the maximum delay (e.g. for use after a
      * RESOURCE_EXHAUSTED error).
-     */    W() {
-        this.U = this.M;
+     */    Y() {
+        this.W = this.B;
     }
     /**
      * Returns a promise that resolves after currentDelayMs, and increases the
      * delay for any subsequent attempts. If there was a pending backoff operation
      * already, it will be canceled.
-     */    G(t) {
+     */    H(t) {
         // Cancel any pending backoff operation.
         this.cancel();
         // First schedule using the current base (which may be 0 and should be
         // honored as such).
-        const e = Math.floor(this.U + this.K()), n = Math.max(0, Date.now() - this.B), r = Math.max(0, e - n);
+        const e = Math.floor(this.W + this.J()), n = Math.max(0, Date.now() - this.K), r = Math.max(0, e - n);
         // Guard against lastAttemptTime being in the future due to a clock change.
-                r > 0 && p("ExponentialBackoff", `Backing off for ${r} ms (base delay: ${this.U} ms, delay with jitter: ${e} ms, last attempt: ${n} ms ago)`), 
-        this.j = this.k.enqueueAfterDelay(this.timerId, r, (() => (this.B = Date.now(), 
+                r > 0 && p("ExponentialBackoff", `Backing off for ${r} ms (base delay: ${this.W} ms, delay with jitter: ${e} ms, last attempt: ${n} ms ago)`), 
+        this.G = this.M.enqueueAfterDelay(this.timerId, r, (() => (this.K = Date.now(), 
         t()))), 
         // Apply backoff factor to determine next delay and ensure it is within
         // bounds.
-        this.U *= this.L, this.U < this.C && (this.U = this.C), this.U > this.M && (this.U = this.M);
+        this.W *= this.j, this.W < this.U && (this.W = this.U), this.W > this.B && (this.W = this.B);
     }
-    Y() {
-        null !== this.j && (this.j.skipDelay(), this.j = null);
+    X() {
+        null !== this.G && (this.G.skipDelay(), this.G = null);
     }
     cancel() {
-        null !== this.j && (this.j.cancel(), this.j = null);
+        null !== this.G && (this.G.cancel(), this.G = null);
     }
-    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */    K() {
-        return (Math.random() - .5) * this.U;
+    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */    J() {
+        return (Math.random() - .5) * this.W;
     }
 }
 
@@ -3628,44 +3640,44 @@ class nn {
  */
 class rn extends class {} {
     constructor(t, e, n, r) {
-        super(), this.authCredentials = t, this.appCheckCredentials = e, this.H = n, this.q = r, 
-        this.J = !1;
+        super(), this.authCredentials = t, this.appCheckCredentials = e, this.Z = n, this.C = r, 
+        this.tt = !1;
     }
-    X() {
-        if (this.J) throw new M(S, "The client has already been terminated.");
+    et() {
+        if (this.tt) throw new M(S, "The client has already been terminated.");
     }
-    /** Invokes the provided RPC with auth and AppCheck tokens. */    m(t, e, n) {
-        return this.X(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([r, s]) => this.H.m(t, e, n, r, s))).catch((t => {
+    /** Invokes the provided RPC with auth and AppCheck tokens. */    v(t, e, n) {
+        return this.et(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([r, s]) => this.Z.v(t, e, n, r, s))).catch((t => {
             throw "FirebaseError" === t.name ? (t.code === D && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), t) : new M(A, t.toString());
         }));
     }
-    /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */    T(t, e, n, r) {
-        return this.X(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, i]) => this.H.T(t, e, n, s, i, r))).catch((t => {
+    /** Invokes the provided RPC with streamed results with auth and AppCheck tokens. */    R(t, e, n, r) {
+        return this.et(), Promise.all([ this.authCredentials.getToken(), this.appCheckCredentials.getToken() ]).then((([s, i]) => this.Z.R(t, e, n, s, i, r))).catch((t => {
             throw "FirebaseError" === t.name ? (t.code === D && (this.authCredentials.invalidateToken(), 
             this.appCheckCredentials.invalidateToken()), t) : new M(A, t.toString());
         }));
     }
     terminate() {
-        this.J = !0;
+        this.tt = !0;
     }
 }
 
 // TODO(firestorexp): Make sure there is only one Datastore instance per
 // firestore-exp client.
 async function sn(t, e) {
-    const n = E(t), r = We(n.q) + "/documents", s = {
-        writes: e.map((t => Qe(n.q, t)))
+    const n = E(t), r = We(n.C) + "/documents", s = {
+        writes: e.map((t => Qe(n.C, t)))
     };
-    await n.m("Commit", r, s);
+    await n.v("Commit", r, s);
 }
 
 async function on(t, e) {
-    const n = E(t), r = We(n.q) + "/documents", s = {
-        documents: e.map((t => je(n.q, t)))
-    }, i = await n.T("BatchGetDocuments", r, s, e.length), o = new Map;
+    const n = E(t), r = We(n.C) + "/documents", s = {
+        documents: e.map((t => je(n.C, t)))
+    }, i = await n.R("BatchGetDocuments", r, s, e.length), o = new Map;
     i.forEach((t => {
-        const e = Ke(n.q, t);
+        const e = Ke(n.C, t);
         o.set(e.key.toString(), e);
     }));
     const u = [];
@@ -3676,8 +3688,8 @@ async function on(t, e) {
 }
 
 async function un(t, e) {
-    const n = E(t), r = Ye(n.q, ge(e));
-    return (await n.T("RunQuery", r.parent, {
+    const n = E(t), r = Ye(n.C, ge(e));
+    return (await n.R("RunQuery", r.parent, {
         structuredQuery: r.structuredQuery
     })).filter((t => !!t.document)).map((t => function(t, e, n) {
         const r = Be(t, e.name), s = Me(e.updateTime), i = new Jt({
@@ -3686,7 +3698,7 @@ async function un(t, e) {
             }
         }), o = Xt.newFoundDocument(r, s, i);
         return n && o.setHasCommittedMutations(), n ? o.setHasCommittedMutations() : o;
-    }(n.q, t.document, void 0)));
+    }(n.C, t.document, void 0)));
 }
 
 /**
@@ -3842,9 +3854,7 @@ class hn {
             switch (t.type) {
               case "gapi":
                 const e = t.client;
-                // Make sure this really is a Gapi client.
-                                return b(!("object" != typeof e || null === e || !e.auth || !e.auth.getAuthHeaderValueForFirstParty)), 
-                new K(e, t.sessionIndex || "0", t.iamToken || null);
+                return new K(e, t.sessionIndex || "0", t.iamToken || null, t.authTokenFactory || null);
 
               case "provider":
                 return t.client;
@@ -4126,7 +4136,7 @@ function bn(t, e, ...n) {
     if (t = l(t), 
     // We allow omission of 'pathString' but explicitly prohibit passing in both
     // 'undefined' and 'null'.
-    1 === arguments.length && (e = yt.R()), rt("doc", "path", e), t instanceof ln) {
+    1 === arguments.length && (e = yt.N()), rt("doc", "path", e), t instanceof ln) {
         const r = Z.fromString(e, ...n);
         return st(r), new pn(t, 
         /* converter= */ null, new nt(r));
@@ -4455,58 +4465,58 @@ function xn(t) {
      * compromised).
      */
     constructor(t, e, n, r, s, i) {
-        this.settings = t, this.databaseId = e, this.q = n, this.ignoreUndefinedProperties = r, 
+        this.settings = t, this.databaseId = e, this.C = n, this.ignoreUndefinedProperties = r, 
         // Minor hack: If fieldTransforms is undefined, we assume this is an
         // external call and we need to validate the entire path.
-        void 0 === s && this.Z(), this.fieldTransforms = s || [], this.fieldMask = i || [];
+        void 0 === s && this.nt(), this.fieldTransforms = s || [], this.fieldMask = i || [];
     }
     get path() {
         return this.settings.path;
     }
-    get tt() {
-        return this.settings.tt;
+    get rt() {
+        return this.settings.rt;
     }
-    /** Returns a new context with the specified settings overwritten. */    et(t) {
-        return new Sn(Object.assign(Object.assign({}, this.settings), t), this.databaseId, this.q, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
+    /** Returns a new context with the specified settings overwritten. */    st(t) {
+        return new Sn(Object.assign(Object.assign({}, this.settings), t), this.databaseId, this.C, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
     }
-    nt(t) {
+    it(t) {
         var e;
-        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), r = this.et({
+        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), r = this.st({
             path: n,
-            rt: !1
+            ot: !1
         });
-        return r.st(t), r;
+        return r.ut(t), r;
     }
-    it(t) {
+    ct(t) {
         var e;
-        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), r = this.et({
+        const n = null === (e = this.path) || void 0 === e ? void 0 : e.child(t), r = this.st({
             path: n,
-            rt: !1
+            ot: !1
         });
-        return r.Z(), r;
+        return r.nt(), r;
     }
-    ot(t) {
+    at(t) {
         // TODO(b/34871131): We don't support array paths right now; so make path
         // undefined.
-        return this.et({
+        return this.st({
             path: void 0,
-            rt: !0
+            ot: !0
         });
     }
-    ut(t) {
-        return Zn(t, this.settings.methodName, this.settings.ct || !1, this.path, this.settings.at);
+    ht(t) {
+        return Zn(t, this.settings.methodName, this.settings.lt || !1, this.path, this.settings.ft);
     }
     /** Returns 'true' if 'fieldPath' was traversed when creating this context. */    contains(t) {
         return void 0 !== this.fieldMask.find((e => t.isPrefixOf(e))) || void 0 !== this.fieldTransforms.find((e => t.isPrefixOf(e.field)));
     }
-    Z() {
+    nt() {
         // TODO(b/34871131): Remove null check once we have proper paths for fields
         // within arrays.
-        if (this.path) for (let t = 0; t < this.path.length; t++) this.st(this.path.get(t));
+        if (this.path) for (let t = 0; t < this.path.length; t++) this.ut(this.path.get(t));
     }
-    st(t) {
-        if (0 === t.length) throw this.ut("Document fields must not be empty");
-        if (xn(this.tt) && Nn.test(t)) throw this.ut('Document fields cannot begin and end with "__"');
+    ut(t) {
+        if (0 === t.length) throw this.ht("Document fields must not be empty");
+        if (xn(this.rt) && Nn.test(t)) throw this.ht('Document fields cannot begin and end with "__"');
     }
 }
 
@@ -4515,17 +4525,17 @@ function xn(t) {
  * classes.
  */ class Fn {
     constructor(t, e, n) {
-        this.databaseId = t, this.ignoreUndefinedProperties = e, this.q = n || en(t);
+        this.databaseId = t, this.ignoreUndefinedProperties = e, this.C = n || en(t);
     }
-    /** Creates a new top-level parse context. */    ht(t, e, n, r = !1) {
+    /** Creates a new top-level parse context. */    dt(t, e, n, r = !1) {
         return new Sn({
-            tt: t,
+            rt: t,
             methodName: e,
-            at: n,
+            ft: n,
             path: et.emptyPath(),
-            rt: !1,
-            ct: r
-        }, this.databaseId, this.q, this.ignoreUndefinedProperties);
+            ot: !1,
+            lt: r
+        }, this.databaseId, this.C, this.ignoreUndefinedProperties);
     }
 }
 
@@ -4535,7 +4545,7 @@ function qn(t) {
 }
 
 /** Parse document data from a set() call. */ function On(t, e, n, r, s, i = {}) {
-    const o = t.ht(i.merge || i.mergeFields ? 2 /* MergeSet */ : 0 /* Set */ , e, n, s);
+    const o = t.dt(i.merge || i.mergeFields ? 2 /* MergeSet */ : 0 /* Set */ , e, n, s);
     Yn("Data must be an object, but it was:", o, r);
     const u = Kn(r, o);
     let c, a;
@@ -4553,7 +4563,7 @@ function qn(t) {
 
 class kn extends Pn {
     _toFieldTransform(t) {
-        if (2 /* MergeSet */ !== t.tt) throw 1 /* Update */ === t.tt ? t.ut(`${this._methodName}() can only appear at the top level of your update data`) : t.ut(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
+        if (2 /* MergeSet */ !== t.rt) throw 1 /* Update */ === t.rt ? t.ht(`${this._methodName}() can only appear at the top level of your update data`) : t.ht(`${this._methodName}() cannot be used with set() unless you pass {merge:true}`);
         // No transform to add for a delete, but we need to add it to our
         // fieldMask so it gets deleted.
         return t.fieldMask.push(t.path), null;
@@ -4580,11 +4590,11 @@ class kn extends Pn {
  * @param arrayElement - Whether or not the FieldValue has an array.
  */ function Cn(t, e, n) {
     return new Sn({
-        tt: 3 /* Argument */ ,
-        at: e.settings.at,
+        rt: 3 /* Argument */ ,
+        ft: e.settings.ft,
         methodName: t._methodName,
-        rt: n
-    }, e.databaseId, e.q, e.ignoreUndefinedProperties);
+        ot: n
+    }, e.databaseId, e.C, e.ignoreUndefinedProperties);
 }
 
 class Ln extends Pn {
@@ -4598,11 +4608,11 @@ class Ln extends Pn {
 
 class Mn extends Pn {
     constructor(t, e) {
-        super(t), this.lt = e;
+        super(t), this.wt = e;
     }
     _toFieldTransform(t) {
         const e = Cn(this, t, 
-        /*array=*/ !0), n = this.lt.map((t => Gn(t, e))), r = new Ie(n);
+        /*array=*/ !0), n = this.wt.map((t => Gn(t, e))), r = new Ie(n);
         return new Pe(t.path, r);
     }
     isEqual(t) {
@@ -4613,11 +4623,11 @@ class Mn extends Pn {
 
 class Un extends Pn {
     constructor(t, e) {
-        super(t), this.lt = e;
+        super(t), this.wt = e;
     }
     _toFieldTransform(t) {
         const e = Cn(this, t, 
-        /*array=*/ !0), n = this.lt.map((t => Gn(t, e))), r = new Ae(n);
+        /*array=*/ !0), n = this.wt.map((t => Gn(t, e))), r = new Ae(n);
         return new Pe(t.path, r);
     }
     isEqual(t) {
@@ -4628,10 +4638,10 @@ class Un extends Pn {
 
 class jn extends Pn {
     constructor(t, e) {
-        super(t), this.ft = e;
+        super(t), this.yt = e;
     }
     _toFieldTransform(t) {
-        const e = new Re(t.q, be(t.q, this.ft));
+        const e = new Re(t.C, be(t.C, this.yt));
         return new Pe(t.path, e);
     }
     isEqual(t) {
@@ -4641,7 +4651,7 @@ class jn extends Pn {
 }
 
 /** Parse update data from an update() call. */ function Bn(t, e, n, r) {
-    const s = t.ht(1 /* Update */ , e, n);
+    const s = t.dt(1 /* Update */ , e, n);
     Yn("Data must be an object, but it was:", s, r);
     const i = [], o = Jt.empty();
     Tt(r, ((t, r) => {
@@ -4649,7 +4659,7 @@ class jn extends Pn {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 r = l(r);
-        const c = s.it(u);
+        const c = s.ct(u);
         if (r instanceof kn) 
         // Add it to the field mask, but don't add anything to updateData.
         i.push(u); else {
@@ -4662,7 +4672,7 @@ class jn extends Pn {
 }
 
 /** Parse update data from a list of field/value arguments. */ function zn(t, e, n, r, s, i) {
-    const o = t.ht(1 /* Update */ , e, n), u = [ Hn(e, r, n) ], c = [ s ];
+    const o = t.dt(1 /* Update */ , e, n), u = [ Hn(e, r, n) ], c = [ s ];
     if (i.length % 2 != 0) throw new M(R, `Function ${e}() needs to be called with an even number of arguments that alternate between field names and values.`);
     for (let t = 0; t < i.length; t += 2) u.push(Hn(e, i[t])), c.push(i[t + 1]);
     const a = [], h = Jt.empty();
@@ -4674,7 +4684,7 @@ class jn extends Pn {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = l(n);
-        const r = o.it(e);
+        const r = o.ct(e);
         if (n instanceof kn) 
         // Add it to the field mask, but don't add anything to updateData.
         a.push(e); else {
@@ -4693,7 +4703,7 @@ class jn extends Pn {
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
  */ function Wn(t, e, n, r = !1) {
-    return Gn(n, t.ht(r ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
+    return Gn(n, t.dt(r ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
 }
 
 /**
@@ -4721,8 +4731,8 @@ class jn extends Pn {
  */
     return function(t, e) {
         // Sentinels are only supported with writes, and not within arrays.
-        if (!xn(e.tt)) throw e.ut(`${t._methodName}() can only be used with update() and set()`);
-        if (!e.path) throw e.ut(`${t._methodName}() is not currently supported inside arrays`);
+        if (!xn(e.rt)) throw e.ht(`${t._methodName}() can only be used with update() and set()`);
+        if (!e.path) throw e.ht(`${t._methodName}() is not currently supported inside arrays`);
         const n = t._toFieldTransform(e);
         n && e.fieldTransforms.push(n);
     }
@@ -4746,12 +4756,12 @@ class jn extends Pn {
         // the set of values to be included for the IN query) that may directly
         // contain additional arrays (each representing an individual field
         // value), so we disable this validation.
-        if (e.settings.rt && 4 /* ArrayArgument */ !== e.tt) throw e.ut("Nested arrays are not supported");
+        if (e.settings.ot && 4 /* ArrayArgument */ !== e.rt) throw e.ht("Nested arrays are not supported");
         return function(t, e) {
             const n = [];
             let r = 0;
             for (const s of t) {
-                let t = Gn(s, e.ot(r));
+                let t = Gn(s, e.at(r));
                 null == t && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -4770,7 +4780,7 @@ class jn extends Pn {
         if (null === (t = l(t))) return {
             nullValue: "NULL_VALUE"
         };
-        if ("number" == typeof t) return be(e.q, t);
+        if ("number" == typeof t) return be(e.C, t);
         if ("boolean" == typeof t) return {
             booleanValue: t
         };
@@ -4780,7 +4790,7 @@ class jn extends Pn {
         if (t instanceof Date) {
             const n = vt.fromDate(t);
             return {
-                timestampValue: ke(e.q, n)
+                timestampValue: ke(e.C, n)
             };
         }
         if (t instanceof vt) {
@@ -4789,7 +4799,7 @@ class jn extends Pn {
             // truncation immediately without waiting for the backend to do that.
             const n = new vt(t.seconds, 1e3 * Math.floor(t.nanoseconds / 1e3));
             return {
-                timestampValue: ke(e.q, n)
+                timestampValue: ke(e.C, n)
             };
         }
         if (t instanceof Vn) return {
@@ -4799,16 +4809,16 @@ class jn extends Pn {
             }
         };
         if (t instanceof Rn) return {
-            bytesValue: Ce(e.q, t._byteString)
+            bytesValue: Ce(e.C, t._byteString)
         };
         if (t instanceof pn) {
             const n = e.databaseId, r = t.firestore._databaseId;
-            if (!r.isEqual(n)) throw e.ut(`Document reference is for database ${r.projectId}/${r.database} but should be for database ${n.projectId}/${n.database}`);
+            if (!r.isEqual(n)) throw e.ht(`Document reference is for database ${r.projectId}/${r.database} but should be for database ${n.projectId}/${n.database}`);
             return {
                 referenceValue: Ue(t.firestore._databaseId || e.databaseId, t._key.path)
             };
         }
-        throw e.ut(`Unsupported field value: ${ot(t)}`);
+        throw e.ht(`Unsupported field value: ${ot(t)}`);
     }
     /**
  * Checks whether an object looks like a JSON object that should be converted
@@ -4825,7 +4835,7 @@ function Kn(t, e) {
         for (const e in t) if (Object.prototype.hasOwnProperty.call(t, e)) return !1;
         return !0;
     }(t) ? Tt(t, ((t, r) => {
-        const s = Gn(r, e.nt(t));
+        const s = Gn(r, e.it(t));
         null != s && (n[t] = s);
     })) : 
     // If we encounter an empty object, we explicitly add it to the update
@@ -4846,7 +4856,7 @@ function Yn(t, e, n) {
         return "object" == typeof t && null !== t && (Object.getPrototypeOf(t) === Object.prototype || null === Object.getPrototypeOf(t));
     }(n)) {
         const r = ot(n);
-        throw "an object" === r ? e.ut(t + " a custom object") : e.ut(t + " " + r);
+        throw "an object" === r ? e.ht(t + " a custom object") : e.ht(t + " " + r);
     }
 }
 
@@ -5097,7 +5107,7 @@ class or {}
 
 class cr extends or {
     constructor(t, e, n) {
-        super(), this.dt = t, this.wt = e, this.yt = n, this.type = "where";
+        super(), this._t = t, this.gt = e, this.vt = n, this.type = "where";
     }
     _apply(t) {
         const e = qn(t.firestore), n = function(t, e, n, r, s, i, o) {
@@ -5119,7 +5129,7 @@ class cr extends or {
             /* allowArrays= */ "in" /* IN */ === i || "not-in" /* NOT_IN */ === i);
             const c = ee.create(s, i, u);
             return function(t, e) {
-                if (e.$()) {
+                if (e.F()) {
                     const n = pe(t);
                     if (null !== n && !n.isEqual(e.field)) throw new M(R, `Invalid query. All where filters with an inequality (<, <=, !=, not-in, >, or >=) must be on the same field. But you have inequality filters on '${n.toString()}' and '${e.field.toString()}'`);
                     const r = me(t);
@@ -5166,7 +5176,7 @@ class cr extends or {
                 // Special case when it's a duplicate op to give a slightly clearer error message.
                 throw n === e.op ? new M(R, `Invalid query. You cannot use more than one '${e.op.toString()}' filter.`) : new M(R, `Invalid query. You cannot use '${e.op.toString()}' filters with '${n.toString()}' filters.`);
             }(t, c), c;
-        }(t._query, "where", e, t.firestore._databaseId, this.dt, this.wt, this.yt);
+        }(t._query, "where", e, t.firestore._databaseId, this._t, this.gt, this.vt);
         return new yn(t.firestore, t.converter, function(t, e) {
             const n = t.filters.concat([ e ]);
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), n, t.limit, t.limitType, t.startAt, t.endAt);
@@ -5191,7 +5201,7 @@ class cr extends or {
 
 class hr extends or {
     constructor(t, e) {
-        super(), this.dt = t, this._t = e, this.type = "orderBy";
+        super(), this._t = t, this.bt = e, this.type = "orderBy";
     }
     _apply(t) {
         const e = function(t, e, n) {
@@ -5216,7 +5226,7 @@ class hr extends or {
  * Will throw if the document does not contain all fields of the order by
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
- */ (t._query, this.dt, this._t);
+ */ (t._query, this._t, this.bt);
         return new yn(t.firestore, t.converter, function(t, e) {
             // TODO(dimond): validate that orderBy does not list the same key twice.
             const n = t.explicitOrderBy.concat([ e ]);
@@ -5240,12 +5250,12 @@ class hr extends or {
 
 class fr extends or {
     constructor(t, e, n) {
-        super(), this.type = t, this.gt = e, this.vt = n;
+        super(), this.type = t, this.Et = e, this.Tt = n;
     }
     _apply(t) {
         return new yn(t.firestore, t.converter, function(t, e, n) {
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), e, n, t.startAt, t.endAt);
-        }(t._query, this.gt, this.vt));
+        }(t._query, this.Et, this.Tt));
     }
 }
 
@@ -5272,10 +5282,10 @@ class fr extends or {
 
 class mr extends or {
     constructor(t, e, n) {
-        super(), this.type = t, this.bt = e, this.Et = n;
+        super(), this.type = t, this.It = e, this.At = n;
     }
     _apply(t) {
-        const e = br(t, this.type, this.bt, this.Et);
+        const e = br(t, this.type, this.It, this.At);
         return new yn(t.firestore, t.converter, function(t, e) {
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, e, t.endAt);
         }(t._query, e));
@@ -5294,10 +5304,10 @@ function yr(...t) {
 
 class _r extends or {
     constructor(t, e, n) {
-        super(), this.type = t, this.bt = e, this.Et = n;
+        super(), this.type = t, this.It = e, this.At = n;
     }
     _apply(t) {
-        const e = br(t, this.type, this.bt, this.Et);
+        const e = br(t, this.type, this.It, this.At);
         return new yn(t.firestore, t.converter, function(t, e) {
             return new we(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, t.startAt, e);
         }(t._query, e));
@@ -5978,26 +5988,26 @@ function Lr(t, e) {
 class Br {
     constructor(t, e, n, r, s) {
         this.asyncQueue = t, this.datastore = e, this.options = n, this.updateFunction = r, 
-        this.deferred = s, this.Tt = n.maxAttempts, this.It = new nn(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.deferred = s, this.Rt = n.maxAttempts, this.Pt = new nn(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */    run() {
-        this.Tt -= 1, this.At();
+        this.Rt -= 1, this.Vt();
     }
-    At() {
-        this.It.G((async () => {
-            const t = new Ur(this.datastore), e = this.Rt(t);
+    Vt() {
+        this.Pt.H((async () => {
+            const t = new Ur(this.datastore), e = this.Nt(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
                     this.deferred.resolve(e);
                 })).catch((t => {
-                    this.Pt(t);
+                    this.$t(t);
                 }))));
             })).catch((t => {
-                this.Pt(t);
+                this.$t(t);
             }));
         }));
     }
-    Rt(t) {
+    Nt(t) {
         try {
             const e = this.updateFunction(t);
             return !at(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
@@ -6007,11 +6017,11 @@ class Br {
             return this.deferred.reject(t), null;
         }
     }
-    Pt(t) {
-        this.Tt > 0 && this.Vt(t) ? (this.Tt -= 1, this.asyncQueue.enqueueAndForget((() => (this.At(), 
+    $t(t) {
+        this.Rt > 0 && this.Dt(t) ? (this.Rt -= 1, this.asyncQueue.enqueueAndForget((() => (this.Vt(), 
         Promise.resolve())))) : this.deferred.reject(t);
     }
-    Vt(t) {
+    Dt(t) {
         if ("FirebaseError" === t.name) {
             // In transactions, the backend will fail outdated reads with FAILED_PRECONDITION and
             // non-matching document versions with ABORTED. These errors should be retried.
@@ -6182,39 +6192,39 @@ class Br {
  */ class Gr {
     constructor() {
         // The last promise in the queue.
-        this.Nt = Promise.resolve(), 
+        this.xt = Promise.resolve(), 
         // A list of retryable operations. Retryable operations are run in order and
         // retried with backoff.
-        this.$t = [], 
+        this.St = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.Dt = !1, 
+        this.Ft = !1, 
         // Operations scheduled to be queued in the future. Operations are
         // automatically removed after they are run or canceled.
-        this.xt = [], 
+        this.qt = [], 
         // visible for testing
-        this.St = null, 
+        this.Ot = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.Ft = !1, 
+        this.kt = !1, 
         // Enabled during shutdown on Safari to prevent future access to IndexedDB.
-        this.qt = !1, 
+        this.Ct = !1, 
         // List of TimerIds to fast-forward delays for.
-        this.Ot = [], 
+        this.Lt = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.It = new nn(this, "async_queue_retry" /* AsyncQueueRetry */), 
+        this.Pt = new nn(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.kt = () => {
+        this.Mt = () => {
             const t = zr();
-            t && p("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.It.Y();
+            t && p("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.Pt.X();
         };
         const t = zr();
-        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.kt);
+        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Mt);
     }
     get isShuttingDown() {
-        return this.Dt;
+        return this.Ft;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -6224,38 +6234,38 @@ class Br {
         this.enqueue(t);
     }
     enqueueAndForgetEvenWhileRestricted(t) {
-        this.Ct(), 
+        this.Ut(), 
         // eslint-disable-next-line @typescript-eslint/no-floating-promises
-        this.Lt(t);
+        this.jt(t);
     }
     enterRestrictedMode(t) {
-        if (!this.Dt) {
-            this.Dt = !0, this.qt = t || !1;
+        if (!this.Ft) {
+            this.Ft = !0, this.Ct = t || !1;
             const e = zr();
-            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.kt);
+            e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Mt);
         }
     }
     enqueue(t) {
-        if (this.Ct(), this.Dt) 
+        if (this.Ut(), this.Ft) 
         // Return a Promise which never resolves.
         return new Promise((() => {}));
         // Create a deferred Promise that we can return to the callee. This
         // allows us to return a "hanging Promise" only to the callee and still
         // advance the queue even when the operation is not run.
                 const e = new U;
-        return this.Lt((() => this.Dt && this.qt ? Promise.resolve() : (t().then(e.resolve, e.reject), 
+        return this.jt((() => this.Ft && this.Ct ? Promise.resolve() : (t().then(e.resolve, e.reject), 
         e.promise))).then((() => e.promise));
     }
     enqueueRetryable(t) {
-        this.enqueueAndForget((() => (this.$t.push(t), this.Mt())));
+        this.enqueueAndForget((() => (this.St.push(t), this.Bt())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async Mt() {
-        if (0 !== this.$t.length) {
+     */    async Bt() {
+        if (0 !== this.St.length) {
             try {
-                await this.$t[0](), this.$t.shift(), this.It.reset();
+                await this.St[0](), this.St.shift(), this.Pt.reset();
             } catch (t) {
                 if (!
                 /**
@@ -6299,7 +6309,7 @@ class Br {
  // Failure will be handled by AsyncQueue
                                 p("AsyncQueue", "Operation failed with retryable error: " + t);
             }
-            this.$t.length > 0 && 
+            this.St.length > 0 && 
             // If there are additional operations, we re-schedule `retryNextOp()`.
             // This is necessary to run retryable operations that failed during
             // their initial attempt since we don't know whether they are already
@@ -6310,12 +6320,12 @@ class Br {
             // 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.It.G((() => this.Mt()));
+            this.Pt.H((() => this.Bt()));
         }
     }
-    Lt(t) {
-        const e = this.Nt.then((() => (this.Ft = !0, t().catch((t => {
-            this.St = t, this.Ft = !1;
+    jt(t) {
+        const e = this.xt.then((() => (this.kt = !0, t().catch((t => {
+            this.Ot = t, this.kt = !1;
             const e = 
             /**
  * Chrome includes Error.message in Error.stack. Other browsers do not.
@@ -6356,38 +6366,38 @@ class Br {
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw y("INTERNAL UNHANDLED ERROR: ", e), t;
-        })).then((t => (this.Ft = !1, t))))));
-        return this.Nt = e, e;
+        })).then((t => (this.kt = !1, t))))));
+        return this.xt = e, e;
     }
     enqueueAfterDelay(t, e, n) {
-        this.Ct(), 
+        this.Ut(), 
         // Fast-forward delays for timerIds that have been overriden.
-        this.Ot.indexOf(t) > -1 && (e = 0);
-        const r = Wr.createAndSchedule(this, t, e, n, (t => this.Ut(t)));
-        return this.xt.push(r), r;
+        this.Lt.indexOf(t) > -1 && (e = 0);
+        const r = Wr.createAndSchedule(this, t, e, n, (t => this.zt(t)));
+        return this.qt.push(r), r;
     }
-    Ct() {
-        this.St && v();
+    Ut() {
+        this.Ot && v();
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async jt() {
+     */    async Wt() {
         // Operations in the queue prior to draining may have enqueued additional
         // operations. Keep draining the queue until the tail is no longer advanced,
         // which indicates that no more new operations were enqueued and that all
         // operations were executed.
         let t;
         do {
-            t = this.Nt, await t;
-        } while (t !== this.Nt);
+            t = this.xt, await t;
+        } while (t !== this.xt);
     }
     /**
      * For Tests: Determine if a delayed operation with a particular TimerId
      * exists.
-     */    Bt(t) {
-        for (const e of this.xt) if (e.timerId === t) return !0;
+     */    Gt(t) {
+        for (const e of this.qt) if (e.timerId === t) return !0;
         return !1;
     }
     /**
@@ -6396,24 +6406,24 @@ class Br {
      * @param lastTimerId - Delayed operations up to and including this TimerId
      * will be drained. Pass TimerId.All to run all delayed operations.
      * @returns a Promise that resolves once all operations have been run.
-     */    zt(t) {
+     */    Kt(t) {
         // Note that draining may generate more delayed ops, so we do that first.
-        return this.jt().then((() => {
+        return this.Wt().then((() => {
             // Run ops in the same order they'd run if they ran naturally.
-            this.xt.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
-            for (const e of this.xt) if (e.skipDelay(), "all" /* All */ !== t && e.timerId === t) break;
-            return this.jt();
+            this.qt.sort(((t, e) => t.targetTimeMs - e.targetTimeMs));
+            for (const e of this.qt) if (e.skipDelay(), "all" /* All */ !== t && e.timerId === t) break;
+            return this.Wt();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    Wt(t) {
-        this.Ot.push(t);
+     */    Qt(t) {
+        this.Lt.push(t);
     }
-    /** Called once a DelayedOperation is run or canceled. */    Ut(t) {
+    /** Called once a DelayedOperation is run or canceled. */    zt(t) {
         // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.
-        const e = this.xt.indexOf(t);
-        this.xt.splice(e, 1);
+        const e = this.qt.indexOf(t);
+        this.qt.splice(e, 1);
     }
 }
 
@@ -6501,7 +6511,7 @@ class Kr {
     return e && r._setSettings(e), r;
 }), "PUBLIC")), 
 // RUNTIME_ENV and BUILD_TARGET are replaced by real values during the compilation
-r("firestore-lite", "3.4.13", "rn"), r("firestore-lite", "3.4.13", "esm2017");
+r("firestore-lite", "3.4.14-canary.6f4ba2525", "rn"), r("firestore-lite", "3.4.14-canary.6f4ba2525", "esm2017");
 
 export { Rn as Bytes, _n as CollectionReference, pn as DocumentReference, er as DocumentSnapshot, In as FieldPath, Pn as FieldValue, ln as Firestore, M as FirestoreError, Vn as GeoPoint, yn as Query, or as QueryConstraint, nr as QueryDocumentSnapshot, rr as QuerySnapshot, vt as Timestamp, Kr as Transaction, Cr as WriteBatch, xr as addDoc, Or as arrayRemove, qr as arrayUnion, gn as collection, vn as collectionGroup, wn as connectFirestoreEmulator, Dr as deleteDoc, Sr as deleteField, bn as doc, An as documentId, vr as endAt, gr as endBefore, Pr as getDoc, Vr as getDocs, dn as getFirestore, kr as increment, fn as initializeFirestore, dr as limit, wr as limitToLast, lr as orderBy, ur as query, Tn as queryEqual, En as refEqual, Qr as runTransaction, Fr as serverTimestamp, Nr as setDoc, m as setLogLevel, sr as snapshotEqual, yr as startAfter, pr as startAt, mn as terminate, $r as updateDoc, ar as where, Mr as writeBatch };
 //# sourceMappingURL=index.rn.esm2017.js.map