@firebase/firestore 3.4.13 → 3.4.14-canary.47895fe5b

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

@@ -63,7 +63,7 @@ l.MOCK_USER = new l("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let f = "9.9.1";
+let f = "9.9.3-canary.47895fe5b";
 
 /**
  * @license
@@ -347,10 +347,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 = l.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 = l.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.
+        v(!("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;
     }
 }
 
@@ -359,11 +371,11 @@ e) {
  * to authenticate the user, using technique that is only available
  * to applications hosted by Google.
  */ class W {
-    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.
@@ -381,7 +393,7 @@ class K {
 
 /** AppCheck token provider for the Lite SDK. */ class Q {
     constructor(t) {
-        this.u = t, this.appCheck = null, t.onInit((t => {
+        this.m = t, this.appCheck = null, t.onInit((t => {
             this.appCheck = t;
         }));
     }
@@ -1009,27 +1021,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);
         m("RestConnection", "Sending: ", i, n);
         const o = {};
-        return this.g(o, r, s), this.v(t, i, o, n).then((t => (m("RestConnection", "Received: ", t), 
+        return this.I(o, r, s), this.A(t, i, o, n).then((t => (m("RestConnection", "Received: ", t), 
         t)), (e => {
             throw y("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/" + f, 
         // Content-Type: text/plain will avoid preflight requests which might
         // mess with CORS and redirects by proxies. If we add custom headers
@@ -1038,9 +1050,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 = ht[t];
-        return `${this.h}/v1/${e}:${n}`;
+        return `${this.p}/v1/${e}:${n}`;
     }
 } {
     /**
@@ -1048,16 +1060,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
@@ -1135,7 +1147,7 @@ function mt(t) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */ class pt {
-    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`.
@@ -2604,7 +2616,7 @@ class Yt {
 class Jt {
     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.D = null;
     }
 }
 
@@ -2626,18 +2638,18 @@ class Zt 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 te(t, e, n) : "array-contains" /* ARRAY_CONTAINS */ === e ? new se(t, n) : "in" /* IN */ === e ? new ie(t, n) : "not-in" /* NOT_IN */ === e ? new oe(t, n) : "array-contains-any" /* ARRAY_CONTAINS_ANY */ === e ? new ue(t, n) : new Zt(t, e, n);
+        return t.isKeyField() ? "in" /* IN */ === e || "not-in" /* NOT_IN */ === e ? this.$(t, e, n) : new te(t, e, n) : "array-contains" /* ARRAY_CONTAINS */ === e ? new se(t, n) : "in" /* IN */ === e ? new ie(t, n) : "not-in" /* NOT_IN */ === e ? new oe(t, n) : "array-contains-any" /* ARRAY_CONTAINS_ANY */ === e ? new ue(t, n) : new Zt(t, e, n);
     }
-    static V(t, e, n) {
+    static $(t, e, n) {
         return "in" /* IN */ === e ? new ee(t, n) : new ne(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(Ut(e, this.value)) : null !== e && Ct(this.value) === Ct(e) && this.N(Ut(e, this.value));
+                return "!=" /* NOT_EQUAL */ === this.op ? null !== e && this.F(Ut(e, this.value)) : null !== e && Ct(this.value) === Ct(e) && this.F(Ut(e, this.value));
         // Only compare types with matching backend order (such as double and int).
         }
-    N(t) {
+    F(t) {
         switch (this.op) {
           case "<" /* LESS_THAN */ :
             return t < 0;
@@ -2661,7 +2673,7 @@ class Zt extends class {} {
             return g();
         }
     }
-    D() {
+    S() {
         return [ "<" /* LESS_THAN */ , "<=" /* LESS_THAN_OR_EQUAL */ , ">" /* GREATER_THAN */ , ">=" /* GREATER_THAN_OR_EQUAL */ , "!=" /* NOT_EQUAL */ , "not-in" /* NOT_IN */ ].indexOf(this.op) >= 0;
     }
 }
@@ -2673,7 +2685,7 @@ class te extends Zt {
     }
     matches(t) {
         const e = et.comparator(t.key, this.key);
-        return this.N(e);
+        return this.F(e);
     }
 }
 
@@ -2813,9 +2825,9 @@ function le(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.$ = null, 
+        this.limit = s, this.limitType = i, this.startAt = o, this.endAt = u, this.q = null, 
         // The corresponding `Target` of this `Query` instance.
-        this.F = null, this.startAt, this.endAt;
+        this.O = null, this.startAt, this.endAt;
     }
 }
 
@@ -2824,7 +2836,7 @@ function le(t, e) {
 }
 
 function we(t) {
-    for (const e of t.filters) if (e.D()) return e.field;
+    for (const e of t.filters) if (e.S()) return e.field;
     return null;
 }
 
@@ -2846,32 +2858,32 @@ function me(t) {
  * the SDK and backend always orders by `__name__`).
  */ function pe(t) {
     const e = b(t);
-    if (null === e.$) {
-        e.$ = [];
+    if (null === e.q) {
+        e.q = [];
         const t = we(e), n = de(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.$.push(new ae(t)), e.$.push(new ae(tt.keyField(), "asc" /* ASCENDING */)); else {
+        t.isKeyField() || e.q.push(new ae(t)), e.q.push(new ae(tt.keyField(), "asc" /* ASCENDING */)); else {
             let t = !1;
-            for (const n of e.explicitOrderBy) e.$.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.$.push(new ae(tt.keyField(), t));
+                e.q.push(new ae(tt.keyField(), t));
             }
         }
     }
-    return e.$;
+    return e.q;
 }
 
 /**
  * Converts this `Query` instance to it's corresponding `Target` representation.
  */ function ye(t) {
     const e = b(t);
-    if (!e.F) if ("F" /* First */ === e.limitType) e.F = Xt(e.path, e.collectionGroup, pe(e), e.filters, e.limit, e.startAt, e.endAt); else {
+    if (!e.O) if ("F" /* First */ === e.limitType) e.O = Xt(e.path, e.collectionGroup, pe(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 pe(e)) {
@@ -2881,9 +2893,9 @@ function me(t) {
         // We need to swap the cursors to match the now-flipped query ordering.
                 const n = e.endAt ? new ce(e.endAt.position, e.endAt.inclusive) : null, r = e.startAt ? new ce(e.startAt.position, e.startAt.inclusive) : null;
         // Now return as a LimitType.First query.
-        e.F = Xt(e.path, e.collectionGroup, t, e.filters, e.limit, n, r);
+        e.O = Xt(e.path, e.collectionGroup, t, e.filters, e.limit, n, r);
     }
-    return e.F;
+    return e.O;
 }
 
 function _e(t, e) {
@@ -2936,7 +2948,7 @@ function ge(t, e) {
             integerValue: "" + t
         };
     }(e) : function(t, e) {
-        if (t.S) {
+        if (t.k) {
             if (isNaN(e)) return {
                 doubleValue: "NaN"
             };
@@ -2998,7 +3010,7 @@ function ge(t, e) {
  * arithmetic is used and precision loss can occur for values greater than 2^53.
  */ class Ie extends ve {
     constructor(t, e) {
-        super(), this.q = t, this.O = e;
+        super(), this.C = t, this.L = e;
     }
 }
 
@@ -3206,7 +3218,7 @@ function ge(t, e) {
  */
 class Se {
     constructor(t, e) {
-        this.databaseId = t, this.S = e;
+        this.databaseId = t, this.k = e;
     }
 }
 
@@ -3222,7 +3234,7 @@ class Se {
  * Returns a value for a Date that's appropriate to put into a proto.
  */
 function qe(t, e) {
-    if (t.S) {
+    if (t.k) {
         return `${new Date(1e3 * e.seconds).toISOString().replace(/\.\d*/, "").replace("Z", "")}.${("000000000" + e.nanoseconds).slice(-9)}Z`;
     }
     return {
@@ -3237,7 +3249,7 @@ function qe(t, e) {
  * Visible for testing.
  */
 function Oe(t, e) {
-    return t.S ? e.toBase64() : e.toUint8Array();
+    return t.k ? e.toBase64() : e.toUint8Array();
 }
 
 function ke(t, e) {
@@ -3338,7 +3350,7 @@ function We(t, e) {
         };
         if (n instanceof Ie) return {
             fieldPath: e.field.canonicalString(),
-            increment: n.O
+            increment: n.L
         };
         throw g();
     }(0, t)))), e.precondition.isNone || (n.currentDocument = function(t, e) {
@@ -3423,7 +3435,7 @@ function Ke(t, e) {
     }(e.orderBy);
     i && (n.structuredQuery.orderBy = i);
     const o = function(t, e) {
-        return t.S || ct(e) ? e : {
+        return t.k || ct(e) ? e : {
             value: e
         };
     }(t, e.limit);
@@ -3537,9 +3549,9 @@ class tn {
      * 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.G = 0, this.W = null, 
         /** The last backoff attempt, as epoch milliseconds. */
-        this.B = Date.now(), this.reset();
+        this.K = Date.now(), this.reset();
     }
     /**
      * Resets the backoff delay.
@@ -3548,40 +3560,40 @@ class tn {
      * (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.G = 0;
     }
     /**
      * Resets the backoff delay to the maximum delay (e.g. for use after a
      * RESOURCE_EXHAUSTED error).
-     */    G() {
-        this.U = this.M;
+     */    Y() {
+        this.G = 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.
-     */    W(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.G + 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 && m("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 && m("ExponentialBackoff", `Backing off for ${r} ms (base delay: ${this.G} ms, delay with jitter: ${e} ms, last attempt: ${n} ms ago)`), 
+        this.W = 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.G *= this.j, this.G < this.U && (this.G = this.U), this.G > this.B && (this.G = this.B);
     }
-    Y() {
-        null !== this.j && (this.j.skipDelay(), this.j = null);
+    X() {
+        null !== this.W && (this.W.skipDelay(), this.W = null);
     }
     cancel() {
-        null !== this.j && (this.j.cancel(), this.j = null);
+        null !== this.W && (this.W.cancel(), this.W = 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.G;
     }
 }
 
@@ -3612,44 +3624,44 @@ class tn {
  */
 class en 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 L(x, "The client has already been terminated.");
+    et() {
+        if (this.tt) throw new L(x, "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 L(I, 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 L(I, 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 nn(t, e) {
-    const n = b(t), r = Be(n.q) + "/documents", s = {
-        writes: e.map((t => We(n.q, t)))
+    const n = b(t), r = Be(n.C) + "/documents", s = {
+        writes: e.map((t => We(n.C, t)))
     };
-    await n.m("Commit", r, s);
+    await n.v("Commit", r, s);
 }
 
 async function rn(t, e) {
-    const n = b(t), r = Be(n.q) + "/documents", s = {
-        documents: e.map((t => Me(n.q, t)))
-    }, i = await n.T("BatchGetDocuments", r, s, e.length), o = new Map;
+    const n = b(t), r = Be(n.C) + "/documents", s = {
+        documents: e.map((t => Me(n.C, t)))
+    }, i = await n.R("BatchGetDocuments", r, s, e.length), o = new Map;
     i.forEach((t => {
-        const e = Ge(n.q, t);
+        const e = Ge(n.C, t);
         o.set(e.key.toString(), e);
     }));
     const u = [];
@@ -3660,8 +3672,8 @@ async function rn(t, e) {
 }
 
 async function sn(t, e) {
-    const n = b(t), r = Ke(n.q, ye(e));
-    return (await n.T("RunQuery", r.parent, {
+    const n = b(t), r = Ke(n.C, ye(e));
+    return (await n.R("RunQuery", r.parent, {
         structuredQuery: r.structuredQuery
     })).filter((t => !!t.document)).map((t => function(t, e, n) {
         const r = Ue(t, e.name), s = Ce(e.updateTime), i = new Yt({
@@ -3670,7 +3682,7 @@ async function sn(t, e) {
             }
         }), o = Ht.newFoundDocument(r, s, i);
         return n && o.setHasCommittedMutations(), n ? o.setHasCommittedMutations() : o;
-    }(n.q, t.document, void 0)));
+    }(n.C, t.document, void 0)));
 }
 
 /**
@@ -3826,9 +3838,7 @@ class cn {
             switch (t.type) {
               case "gapi":
                 const e = t.client;
-                // Make sure this really is a Gapi client.
-                                return v(!("object" != typeof e || null === e || !e.auth || !e.auth.getAuthHeaderValueForFirstParty)), 
-                new W(e, t.sessionIndex || "0", t.iamToken || null);
+                return new W(e, t.sessionIndex || "0", t.iamToken || null, t.authTokenFactory || null);
 
               case "provider":
                 return t.client;
@@ -4110,7 +4120,7 @@ function gn(t, e, ...n) {
     if (t = getModularInstance(t), 
     // We allow omission of 'pathString' but explicitly prohibit passing in both
     // 'undefined' and 'null'.
-    1 === arguments.length && (e = pt.R()), nt("doc", "path", e), t instanceof an) {
+    1 === arguments.length && (e = pt.N()), nt("doc", "path", e), t instanceof an) {
         const r = X.fromString(e, ...n);
         return rt(r), new wn(t, 
         /* converter= */ null, new et(r));
@@ -4439,58 +4449,58 @@ function Dn(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 $n(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 $n(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 Jn(t, this.settings.methodName, this.settings.ct || !1, this.path, this.settings.at);
+    ht(t) {
+        return Jn(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 (Dn(this.tt) && Pn.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 (Dn(this.rt) && Pn.test(t)) throw this.ht('Document fields cannot begin and end with "__"');
     }
 }
 
@@ -4499,17 +4509,17 @@ function Dn(t) {
  * classes.
  */ class xn {
     constructor(t, e, n) {
-        this.databaseId = t, this.ignoreUndefinedProperties = e, this.q = n || Ze(t);
+        this.databaseId = t, this.ignoreUndefinedProperties = e, this.C = n || Ze(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 $n({
-            tt: t,
+            rt: t,
             methodName: e,
-            at: n,
+            ft: n,
             path: tt.emptyPath(),
-            rt: !1,
-            ct: r
-        }, this.databaseId, this.q, this.ignoreUndefinedProperties);
+            ot: !1,
+            lt: r
+        }, this.databaseId, this.C, this.ignoreUndefinedProperties);
     }
 }
 
@@ -4519,7 +4529,7 @@ function Fn(t) {
 }
 
 /** Parse document data from a set() call. */ function Sn(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);
     Kn("Data must be an object, but it was:", o, r);
     const u = Gn(r, o);
     let c, a;
@@ -4537,7 +4547,7 @@ function Fn(t) {
 
 class qn extends An {
     _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;
@@ -4564,11 +4574,11 @@ class qn extends An {
  * @param arrayElement - Whether or not the FieldValue has an array.
  */ function On(t, e, n) {
     return new $n({
-        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 kn extends An {
@@ -4582,11 +4592,11 @@ class kn extends An {
 
 class Cn extends An {
     constructor(t, e) {
-        super(t), this.lt = e;
+        super(t), this.wt = e;
     }
     _toFieldTransform(t) {
         const e = On(this, t, 
-        /*array=*/ !0), n = this.lt.map((t => zn(t, e))), r = new Ee(n);
+        /*array=*/ !0), n = this.wt.map((t => zn(t, e))), r = new Ee(n);
         return new Ae(t.path, r);
     }
     isEqual(t) {
@@ -4597,11 +4607,11 @@ class Cn extends An {
 
 class Ln extends An {
     constructor(t, e) {
-        super(t), this.lt = e;
+        super(t), this.wt = e;
     }
     _toFieldTransform(t) {
         const e = On(this, t, 
-        /*array=*/ !0), n = this.lt.map((t => zn(t, e))), r = new Te(n);
+        /*array=*/ !0), n = this.wt.map((t => zn(t, e))), r = new Te(n);
         return new Ae(t.path, r);
     }
     isEqual(t) {
@@ -4612,10 +4622,10 @@ class Ln extends An {
 
 class Mn extends An {
     constructor(t, e) {
-        super(t), this.ft = e;
+        super(t), this.yt = e;
     }
     _toFieldTransform(t) {
-        const e = new Ie(t.q, ge(t.q, this.ft));
+        const e = new Ie(t.C, ge(t.C, this.yt));
         return new Ae(t.path, e);
     }
     isEqual(t) {
@@ -4625,7 +4635,7 @@ class Mn extends An {
 }
 
 /** Parse update data from an update() call. */ function Un(t, e, n, r) {
-    const s = t.ht(1 /* Update */ , e, n);
+    const s = t.dt(1 /* Update */ , e, n);
     Kn("Data must be an object, but it was:", s, r);
     const i = [], o = Yt.empty();
     Et(r, ((t, r) => {
@@ -4633,7 +4643,7 @@ class Mn extends An {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 r = getModularInstance(r);
-        const c = s.it(u);
+        const c = s.ct(u);
         if (r instanceof qn) 
         // Add it to the field mask, but don't add anything to updateData.
         i.push(u); else {
@@ -4646,7 +4656,7 @@ class Mn extends An {
 }
 
 /** Parse update data from a list of field/value arguments. */ function jn(t, e, n, r, s, i) {
-    const o = t.ht(1 /* Update */ , e, n), u = [ Qn(e, r, n) ], c = [ s ];
+    const o = t.dt(1 /* Update */ , e, n), u = [ Qn(e, r, n) ], c = [ s ];
     if (i.length % 2 != 0) throw new L(A, `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(Qn(e, i[t])), c.push(i[t + 1]);
     const a = [], l = Yt.empty();
@@ -4658,7 +4668,7 @@ class Mn extends An {
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = getModularInstance(n);
-        const r = o.it(e);
+        const r = o.ct(e);
         if (n instanceof qn) 
         // Add it to the field mask, but don't add anything to updateData.
         a.push(e); else {
@@ -4677,7 +4687,7 @@ class Mn extends An {
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
  */ function Bn(t, e, n, r = !1) {
-    return zn(n, t.ht(r ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
+    return zn(n, t.dt(r ? 4 /* ArrayArgument */ : 3 /* Argument */ , e));
 }
 
 /**
@@ -4705,8 +4715,8 @@ class Mn extends An {
  */
     return function(t, e) {
         // Sentinels are only supported with writes, and not within arrays.
-        if (!Dn(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 (!Dn(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);
     }
@@ -4730,12 +4740,12 @@ class Mn extends An {
         // 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 = zn(s, e.ot(r));
+                let t = zn(s, e.at(r));
                 null == t && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -4754,7 +4764,7 @@ class Mn extends An {
         if (null === (t = getModularInstance(t))) return {
             nullValue: "NULL_VALUE"
         };
-        if ("number" == typeof t) return ge(e.q, t);
+        if ("number" == typeof t) return ge(e.C, t);
         if ("boolean" == typeof t) return {
             booleanValue: t
         };
@@ -4764,7 +4774,7 @@ class Mn extends An {
         if (t instanceof Date) {
             const n = gt.fromDate(t);
             return {
-                timestampValue: qe(e.q, n)
+                timestampValue: qe(e.C, n)
             };
         }
         if (t instanceof gt) {
@@ -4773,7 +4783,7 @@ class Mn extends An {
             // truncation immediately without waiting for the backend to do that.
             const n = new gt(t.seconds, 1e3 * Math.floor(t.nanoseconds / 1e3));
             return {
-                timestampValue: qe(e.q, n)
+                timestampValue: qe(e.C, n)
             };
         }
         if (t instanceof Rn) return {
@@ -4783,16 +4793,16 @@ class Mn extends An {
             }
         };
         if (t instanceof In) return {
-            bytesValue: Oe(e.q, t._byteString)
+            bytesValue: Oe(e.C, t._byteString)
         };
         if (t instanceof wn) {
             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: Le(t.firestore._databaseId || e.databaseId, t._key.path)
             };
         }
-        throw e.ut(`Unsupported field value: ${it(t)}`);
+        throw e.ht(`Unsupported field value: ${it(t)}`);
     }
     /**
  * Checks whether an object looks like a JSON object that should be converted
@@ -4809,7 +4819,7 @@ function Gn(t, e) {
         for (const e in t) if (Object.prototype.hasOwnProperty.call(t, e)) return !1;
         return !0;
     }(t) ? Et(t, ((t, r) => {
-        const s = zn(r, e.nt(t));
+        const s = zn(r, e.it(t));
         null != s && (n[t] = s);
     })) : 
     // If we encounter an empty object, we explicitly add it to the update
@@ -4830,7 +4840,7 @@ function Kn(t, e, n) {
         return "object" == typeof t && null !== t && (Object.getPrototypeOf(t) === Object.prototype || null === Object.getPrototypeOf(t));
     }(n)) {
         const r = it(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);
     }
 }
 
@@ -5081,7 +5091,7 @@ class sr {}
 
 class or extends sr {
     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 = Fn(t.firestore), n = function(t, e, n, r, s, i, o) {
@@ -5103,7 +5113,7 @@ class or extends sr {
             /* allowArrays= */ "in" /* IN */ === i || "not-in" /* NOT_IN */ === i);
             const c = Zt.create(s, i, u);
             return function(t, e) {
-                if (e.D()) {
+                if (e.S()) {
                     const n = we(t);
                     if (null !== n && !n.isEqual(e.field)) throw new L(A, `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 = de(t);
@@ -5150,7 +5160,7 @@ class or extends sr {
                 // Special case when it's a duplicate op to give a slightly clearer error message.
                 throw n === e.op ? new L(A, `Invalid query. You cannot use more than one '${e.op.toString()}' filter.`) : new L(A, `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 mn(t.firestore, t.converter, function(t, e) {
             const n = t.filters.concat([ e ]);
             return new fe(t.path, t.collectionGroup, t.explicitOrderBy.slice(), n, t.limit, t.limitType, t.startAt, t.endAt);
@@ -5175,7 +5185,7 @@ class or extends sr {
 
 class cr extends sr {
     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) {
@@ -5200,7 +5210,7 @@ class cr extends sr {
  * 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 mn(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 ]);
@@ -5224,12 +5234,12 @@ class cr extends sr {
 
 class hr extends sr {
     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 mn(t.firestore, t.converter, function(t, e, n) {
             return new fe(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));
     }
 }
 
@@ -5256,10 +5266,10 @@ class hr extends sr {
 
 class dr extends sr {
     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 = gr(t, this.type, this.bt, this.Et);
+        const e = gr(t, this.type, this.It, this.At);
         return new mn(t.firestore, t.converter, function(t, e) {
             return new fe(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, e, t.endAt);
         }(t._query, e));
@@ -5278,10 +5288,10 @@ function mr(...t) {
 
 class pr extends sr {
     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 = gr(t, this.type, this.bt, this.Et);
+        const e = gr(t, this.type, this.It, this.At);
         return new mn(t.firestore, t.converter, function(t, e) {
             return new fe(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, t.startAt, e);
         }(t._query, e));
@@ -5962,26 +5972,26 @@ function kr(t, e) {
 class Ur {
     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 tn(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
+        this.deferred = s, this.Rt = n.maxAttempts, this.Pt = new tn(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.W((async () => {
-            const t = new Lr(this.datastore), e = this.Rt(t);
+    Vt() {
+        this.Pt.H((async () => {
+            const t = new Lr(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.Dt(t);
                 }))));
             })).catch((t => {
-                this.Pt(t);
+                this.Dt(t);
             }));
         }));
     }
-    Rt(t) {
+    Nt(t) {
         try {
             const e = this.updateFunction(t);
             return !ct(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
@@ -5991,11 +6001,11 @@ class Ur {
             return this.deferred.reject(t), null;
         }
     }
-    Pt(t) {
-        this.Tt > 0 && this.Vt(t) ? (this.Tt -= 1, this.asyncQueue.enqueueAndForget((() => (this.At(), 
+    Dt(t) {
+        this.Rt > 0 && this.$t(t) ? (this.Rt -= 1, this.asyncQueue.enqueueAndForget((() => (this.Vt(), 
         Promise.resolve())))) : this.deferred.reject(t);
     }
-    Vt(t) {
+    $t(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.
@@ -6166,39 +6176,39 @@ class Ur {
  */ class zr {
     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.Dt = [], 
+        this.Ft = [], 
         // Is this AsyncQueue being shut down? Once it is set to true, it will not
         // be changed again.
-        this.$t = !1, 
+        this.St = !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.Ft = null, 
+        this.Ot = null, 
         // Flag set while there's an outstanding AsyncQueue operation, used for
         // assertion sanity-checks.
-        this.St = !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 tn(this, "async_queue_retry" /* AsyncQueueRetry */), 
+        this.Pt = new tn(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 = jr();
-            t && m("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.It.Y();
+            t && m("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.Pt.X();
         };
         const t = jr();
-        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.kt);
+        t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Mt);
     }
     get isShuttingDown() {
-        return this.$t;
+        return this.St;
     }
     /**
      * Adds a new operation to the queue without waiting for it to complete (i.e.
@@ -6208,38 +6218,38 @@ class Ur {
         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.$t) {
-            this.$t = !0, this.qt = t || !1;
+        if (!this.St) {
+            this.St = !0, this.Ct = t || !1;
             const e = jr();
-            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.$t) 
+        if (this.Ut(), this.St) 
         // 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 M;
-        return this.Lt((() => this.$t && this.qt ? Promise.resolve() : (t().then(e.resolve, e.reject), 
+        return this.jt((() => this.St && this.Ct ? Promise.resolve() : (t().then(e.resolve, e.reject), 
         e.promise))).then((() => e.promise));
     }
     enqueueRetryable(t) {
-        this.enqueueAndForget((() => (this.Dt.push(t), this.Mt())));
+        this.enqueueAndForget((() => (this.Ft.push(t), this.Bt())));
     }
     /**
      * Runs the next operation from the retryable queue. If the operation fails,
      * reschedules with backoff.
-     */    async Mt() {
-        if (0 !== this.Dt.length) {
+     */    async Bt() {
+        if (0 !== this.Ft.length) {
             try {
-                await this.Dt[0](), this.Dt.shift(), this.It.reset();
+                await this.Ft[0](), this.Ft.shift(), this.Pt.reset();
             } catch (t) {
                 if (!
                 /**
@@ -6283,7 +6293,7 @@ class Ur {
  // Failure will be handled by AsyncQueue
                                 m("AsyncQueue", "Operation failed with retryable error: " + t);
             }
-            this.Dt.length > 0 && 
+            this.Ft.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
@@ -6294,12 +6304,12 @@ class Ur {
             // 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.W((() => this.Mt()));
+            this.Pt.H((() => this.Bt()));
         }
     }
-    Lt(t) {
-        const e = this.Nt.then((() => (this.St = !0, t().catch((t => {
-            this.Ft = t, this.St = !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.
@@ -6340,38 +6350,38 @@ class Ur {
             // all further attempts to chain (via .then) will just short-circuit
             // and return the rejected Promise.
             throw p("INTERNAL UNHANDLED ERROR: ", e), t;
-        })).then((t => (this.St = !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 = Br.createAndSchedule(this, t, e, n, (t => this.Ut(t)));
-        return this.xt.push(r), r;
+        this.Lt.indexOf(t) > -1 && (e = 0);
+        const r = Br.createAndSchedule(this, t, e, n, (t => this.zt(t)));
+        return this.qt.push(r), r;
     }
-    Ct() {
-        this.Ft && g();
+    Ut() {
+        this.Ot && g();
     }
     verifyOperationInProgress() {}
     /**
      * Waits until all currently queued tasks are finished executing. Delayed
      * operations are not run.
-     */    async jt() {
+     */    async Gt() {
         // 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;
+     */    Wt(t) {
+        for (const e of this.qt) if (e.timerId === t) return !0;
         return !1;
     }
     /**
@@ -6380,24 +6390,24 @@ class Ur {
      * @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.Gt().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.Gt();
         }));
     }
     /**
      * For Tests: Skip all subsequent delays for a timer id.
-     */    Gt(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);
     }
 }
 
@@ -6485,7 +6495,7 @@ class Gr {
     return e && r._setSettings(e), r;
 }), "PUBLIC")), 
 // RUNTIME_ENV and BUILD_TARGET are replaced by real values during the compilation
-registerVersion("firestore-lite", "3.4.13", ""), registerVersion("firestore-lite", "3.4.13", "esm2017");
+registerVersion("firestore-lite", "3.4.14-canary.47895fe5b", ""), registerVersion("firestore-lite", "3.4.14-canary.47895fe5b", "esm2017");
 
 export { In as Bytes, pn as CollectionReference, wn as DocumentReference, Zn as DocumentSnapshot, En as FieldPath, An as FieldValue, an as Firestore, L as FirestoreError, Rn as GeoPoint, mn as Query, sr as QueryConstraint, tr as QueryDocumentSnapshot, er as QuerySnapshot, gt as Timestamp, Gr as Transaction, Or as WriteBatch, Dr as addDoc, Sr as arrayRemove, Fr as arrayUnion, yn as collection, _n as collectionGroup, fn as connectFirestoreEmulator, Nr as deleteDoc, $r as deleteField, gn as doc, Tn as documentId, _r as endAt, yr as endBefore, Ar as getDoc, Rr as getDocs, ln as getFirestore, qr as increment, hn as initializeFirestore, lr as limit, fr as limitToLast, ar as orderBy, ir as query, bn as queryEqual, vn as refEqual, Wr as runTransaction, xr as serverTimestamp, Pr as setDoc, w as setLogLevel, nr as snapshotEqual, mr as startAfter, wr as startAt, dn as terminate, Vr as updateDoc, ur as where, Cr as writeBatch };
 //# sourceMappingURL=index.browser.esm2017.js.map