@firebase/firestore 3.11.0 → 3.12.0-20230511201449

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

@@ -66,7 +66,7 @@ m.MOCK_USER = new m("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let p = "9.21.0";
+let p = "9.22.0-20230511201449";
 
 /**
  * @license
@@ -444,12 +444,14 @@ class Z {
      * when using WebChannel as the network transport.
      * @param autoDetectLongPolling - Whether to use the detectBufferingProxy
      * option when using WebChannel as the network transport.
+     * @param longPollingOptions Options that configure long-polling.
      * @param useFetchStreams Whether to use the Fetch API instead of
      * XMLHTTPRequest
      */
-    constructor(t, e, n, r, s, i, o, u) {
+    constructor(t, e, n, r, s, i, o, u, c) {
         this.databaseId = t, this.appId = e, this.persistenceKey = n, this.host = r, this.ssl = s, 
-        this.forceLongPolling = i, this.autoDetectLongPolling = o, this.useFetchStreams = u;
+        this.forceLongPolling = i, this.autoDetectLongPolling = o, this.longPollingOptions = u, 
+        this.useFetchStreams = c;
     }
 }
 
@@ -803,6 +805,34 @@ function lt(t, e) {
     if (e <= 0) throw new B($, `Function ${t}() requires a positive number, but it was: ${e}.`);
 }
 
+/**
+ * @license
+ * Copyright 2023 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Compares two `ExperimentalLongPollingOptions` objects for equality.
+ */
+/**
+ * Creates and returns a new `ExperimentalLongPollingOptions` with the same
+ * option values as the given instance.
+ */
+function ft(t) {
+    const e = {};
+    return void 0 !== t.timeoutSeconds && (e.timeoutSeconds = t.timeoutSeconds), e;
+}
+
 /**
  * @license
  * Copyright 2023 Google LLC
@@ -822,7 +852,7 @@ function lt(t, e) {
 /**
  * The value returned from the most recent invocation of
  * `generateUniqueDebugId()`, or null if it has never been invoked.
- */ let ft = null;
+ */ let dt = null;
 
 /**
  * Generates and returns an initial value for `lastUniqueDebugId`.
@@ -846,9 +876,9 @@ function lt(t, e) {
  *
  * @return the 10-character generated ID (e.g. "0xa1b2c3d4").
  */
-function dt() {
-    return null === ft ? ft = 268435456 + Math.round(2147483648 * Math.random()) : ft++, 
-    "0x" + ft.toString(16);
+function wt() {
+    return null === dt ? dt = 268435456 + Math.round(2147483648 * Math.random()) : dt++, 
+    "0x" + dt.toString(16);
 }
 
 /**
@@ -869,11 +899,11 @@ function dt() {
  */
 /**
  * Returns whether a variable is either undefined or null.
- */ function wt(t) {
+ */ function mt(t) {
     return null == t;
 }
 
-/** Returns whether the value represents -0. */ function mt(t) {
+/** Returns whether the value represents -0. */ function pt(t) {
     // Detect if the value is -0.0. Based on polyfill from
     // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
     return 0 === t && 1 / t == -1 / 0;
@@ -899,7 +929,7 @@ function dt() {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const pt = {
+const yt = {
     BatchGetDocuments: "batchGet",
     Commit: "commit",
     RunQuery: "runQuery",
@@ -937,7 +967,7 @@ const pt = {
  * are used for reverse lookups from the webchannel stream. Do NOT change the
  * names of these identifiers or change this into a const enum.
  */
-var yt, gt;
+var gt, _t;
 
 /**
  * Converts an HTTP Status Code to the equivalent error code.
@@ -946,7 +976,7 @@ var yt, gt;
  * @returns The equivalent Code. Unknown status codes are mapped to
  *     Code.UNKNOWN.
  */
-function _t(t) {
+function vt(t) {
     if (void 0 === t) return v("RPC_ERROR", "HTTP error has no status"), V;
     // The canonical error codes for Google APIs [1] specify mapping onto HTTP
     // status codes but the mapping is not bijective. In each case of ambiguity
@@ -1039,16 +1069,16 @@ function _t(t) {
 /**
  * A Rest-based connection that relies on the native HTTP stack
  * (e.g. `fetch` or a polyfill).
- */ (gt = yt || (yt = {}))[gt.OK = 0] = "OK", gt[gt.CANCELLED = 1] = "CANCELLED", 
-gt[gt.UNKNOWN = 2] = "UNKNOWN", gt[gt.INVALID_ARGUMENT = 3] = "INVALID_ARGUMENT", 
-gt[gt.DEADLINE_EXCEEDED = 4] = "DEADLINE_EXCEEDED", gt[gt.NOT_FOUND = 5] = "NOT_FOUND", 
-gt[gt.ALREADY_EXISTS = 6] = "ALREADY_EXISTS", gt[gt.PERMISSION_DENIED = 7] = "PERMISSION_DENIED", 
-gt[gt.UNAUTHENTICATED = 16] = "UNAUTHENTICATED", gt[gt.RESOURCE_EXHAUSTED = 8] = "RESOURCE_EXHAUSTED", 
-gt[gt.FAILED_PRECONDITION = 9] = "FAILED_PRECONDITION", gt[gt.ABORTED = 10] = "ABORTED", 
-gt[gt.OUT_OF_RANGE = 11] = "OUT_OF_RANGE", gt[gt.UNIMPLEMENTED = 12] = "UNIMPLEMENTED", 
-gt[gt.INTERNAL = 13] = "INTERNAL", gt[gt.UNAVAILABLE = 14] = "UNAVAILABLE", gt[gt.DATA_LOSS = 15] = "DATA_LOSS";
+ */ (_t = gt || (gt = {}))[_t.OK = 0] = "OK", _t[_t.CANCELLED = 1] = "CANCELLED", 
+_t[_t.UNKNOWN = 2] = "UNKNOWN", _t[_t.INVALID_ARGUMENT = 3] = "INVALID_ARGUMENT", 
+_t[_t.DEADLINE_EXCEEDED = 4] = "DEADLINE_EXCEEDED", _t[_t.NOT_FOUND = 5] = "NOT_FOUND", 
+_t[_t.ALREADY_EXISTS = 6] = "ALREADY_EXISTS", _t[_t.PERMISSION_DENIED = 7] = "PERMISSION_DENIED", 
+_t[_t.UNAUTHENTICATED = 16] = "UNAUTHENTICATED", _t[_t.RESOURCE_EXHAUSTED = 8] = "RESOURCE_EXHAUSTED", 
+_t[_t.FAILED_PRECONDITION = 9] = "FAILED_PRECONDITION", _t[_t.ABORTED = 10] = "ABORTED", 
+_t[_t.OUT_OF_RANGE = 11] = "OUT_OF_RANGE", _t[_t.UNIMPLEMENTED = 12] = "UNIMPLEMENTED", 
+_t[_t.INTERNAL = 13] = "INTERNAL", _t[_t.UNAVAILABLE = 14] = "UNAVAILABLE", _t[_t.DATA_LOSS = 15] = "DATA_LOSS";
 
-class vt extends 
+class bt extends 
 /**
  * Base class for all Rest-based connections to the backend (WebChannel and
  * HTTP).
@@ -1065,7 +1095,7 @@ class {
         return !1;
     }
     v(t, e, n, r, s) {
-        const i = dt(), o = this.I(t, e);
+        const i = wt(), o = this.I(t, e);
         _("RestConnection", `Sending RPC '${t}' ${i}:`, o, n);
         const u = {};
         return this.A(u, r, s), this.T(t, o, u, n).then((e => (_("RestConnection", `Received RPC '${t}' ${i}: `, e), 
@@ -1092,7 +1122,7 @@ class {
         e && e.headers.forEach(((e, n) => t[n] = e)), n && n.headers.forEach(((e, n) => t[n] = e));
     }
     I(t, e) {
-        const n = pt[t];
+        const n = yt[t];
         return `${this.m}/v1/${e}:${n}`;
     }
 } {
@@ -1118,13 +1148,13 @@ class {
             });
         } catch (t) {
             const e = t;
-            throw new B(_t(e.status), "Request failed with error: " + e.statusText);
+            throw new B(vt(e.status), "Request failed with error: " + e.statusText);
         }
         if (!o.ok) {
             let t = await o.json();
             Array.isArray(t) && (t = t[0]);
             const e = null === (s = null == t ? void 0 : t.error) || void 0 === s ? void 0 : s.message;
-            throw new B(_t(o.status), `Request failed with error: ${null != e ? e : o.statusText}`);
+            throw new B(vt(o.status), `Request failed with error: ${null != e ? e : o.statusText}`);
         }
         return o.json();
     }
@@ -1166,7 +1196,7 @@ class {
 /**
  * Concrete implementation of the Aggregate type.
  */
-class bt {
+class Et {
     constructor(t, e, n) {
         this.alias = t, this.$ = e, this.fieldPath = n;
     }
@@ -1192,7 +1222,7 @@ class bt {
  * Generates `nBytes` of random bytes.
  *
  * If `nBytes < 0` , an error will be thrown.
- */ function Et(t) {
+ */ function It(t) {
     // Polyfills for IE and WebWorker by using `self` and `msCrypto` when `crypto` is not available.
     const e = 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1218,14 +1248,14 @@ class bt {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ class It {
+ */ class At {
     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`.
                 let n = "";
         for (;n.length < 20; ) {
-            const r = Et(40);
+            const r = It(40);
             for (let s = 0; s < r.length; ++s) 
             // Only accept values that are [0, maxMultiple), this ensures they can
             // be evenly mapped to indices of `chars` via a modulo operation.
@@ -1235,11 +1265,11 @@ class bt {
     }
 }
 
-function At(t, e) {
+function Tt(t, e) {
     return t < e ? -1 : t > e ? 1 : 0;
 }
 
-/** Helper to compare arrays using isEqual(). */ function Tt(t, e, n) {
+/** Helper to compare arrays using isEqual(). */ function Rt(t, e, n) {
     return t.length === e.length && t.every(((t, r) => n(t, e[r])));
 }
 
@@ -1258,13 +1288,13 @@ function At(t, e) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ function Rt(t) {
+ */ function Pt(t) {
     let e = 0;
     for (const n in t) Object.prototype.hasOwnProperty.call(t, n) && e++;
     return e;
 }
 
-function Pt(t, e) {
+function Vt(t, e) {
     for (const n in t) Object.prototype.hasOwnProperty.call(t, n) && e(n, t[n]);
 }
 
@@ -1287,7 +1317,7 @@ function Pt(t, e) {
 /**
  * An error encountered while decoding base64 string.
  */
-class Vt extends Error {
+class $t extends Error {
     constructor() {
         super(...arguments), this.name = "Base64DecodeError";
     }
@@ -1312,7 +1342,7 @@ class Vt extends Error {
 // WebSafe uses a different URL-encoding safe alphabet that doesn't match
 // the encoding used on the backend.
 /** Converts a Base64 encoded string to a binary string. */
-function $t(t) {
+function Nt(t) {
     try {
         return String.fromCharCode.apply(null, 
         // We use `decodeStringToByteArray()` instead of `decodeString()` since
@@ -1320,7 +1350,7 @@ function $t(t) {
         // returned by `atob()`'s Latin1 representation.
         a.decodeStringToByteArray(t, false));
     } catch (t) {
-        throw t instanceof h ? new Vt("Invalid base64 string: " + t) : t;
+        throw t instanceof h ? new $t("Invalid base64 string: " + t) : t;
     }
 }
 
@@ -1350,13 +1380,13 @@ function $t(t) {
  * before being sent as a proto.
  * @internal
  */
-class Nt {
+class Dt {
     constructor(t) {
         this.binaryString = t;
     }
     static fromBase64String(t) {
-        const e = $t(t);
-        return new Nt(e);
+        const e = Nt(t);
+        return new Dt(e);
     }
     static fromUint8Array(t) {
         // TODO(indexing); Remove the copy of the byte string here as this method
@@ -1373,7 +1403,7 @@ class Nt {
         /**
  * Helper function to convert a binary string to an Uint8Array.
  */ (t);
-        return new Nt(e);
+        return new Dt(e);
     }
     [Symbol.iterator]() {
         let t = 0;
@@ -1423,21 +1453,21 @@ class Nt {
         return 2 * this.binaryString.length;
     }
     compareTo(t) {
-        return At(this.binaryString, t.binaryString);
+        return Tt(this.binaryString, t.binaryString);
     }
     isEqual(t) {
         return this.binaryString === t.binaryString;
     }
 }
 
-Nt.EMPTY_BYTE_STRING = new Nt("");
+Dt.EMPTY_BYTE_STRING = new Dt("");
 
-const Dt = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
+const Ft = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
 
 /**
  * Converts the possible Proto values for a timestamp value into a "seconds and
  * nanos" representation.
- */ function Ft(t) {
+ */ function xt(t) {
     // The json interface (for the browser) will return an iso timestamp string,
     // while the proto js library (for node) will return a
     // google.protobuf.Timestamp instance.
@@ -1446,7 +1476,7 @@ const Dt = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
         // (millis), so we do some custom parsing here.
         // Parse the nanos right out of the string.
         let e = 0;
-        const n = Dt.exec(t);
+        const n = Ft.exec(t);
         if (A(!!n), n[1]) {
             // Pad the fraction out to 9 digits (nanos).
             let t = n[1];
@@ -1460,21 +1490,21 @@ const Dt = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
         };
     }
     return {
-        seconds: xt(t.seconds),
-        nanos: xt(t.nanos)
+        seconds: St(t.seconds),
+        nanos: St(t.nanos)
     };
 }
 
 /**
  * Converts the possible Proto types for numbers into a JavaScript number.
  * Returns 0 if the value is not numeric.
- */ function xt(t) {
+ */ function St(t) {
     // TODO(bjornick): Handle int64 greater than 53 bits.
     return "number" == typeof t ? t : "string" == typeof t ? Number(t) : 0;
 }
 
-/** Converts the possible Proto types for Blobs into a ByteString. */ function St(t) {
-    return "string" == typeof t ? Nt.fromBase64String(t) : Nt.fromUint8Array(t);
+/** Converts the possible Proto types for Blobs into a ByteString. */ function qt(t) {
+    return "string" == typeof t ? Dt.fromBase64String(t) : Dt.fromUint8Array(t);
 }
 
 /**
@@ -1508,7 +1538,7 @@ const Dt = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
  * For examples and further specifications, refer to the
  * {@link https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto | Timestamp definition}.
  */
-class qt {
+class Ot {
     /**
      * Creates a new timestamp.
      *
@@ -1540,7 +1570,7 @@ class qt {
      *
      * @returns a new timestamp representing the current date.
      */    static now() {
-        return qt.fromMillis(Date.now());
+        return Ot.fromMillis(Date.now());
     }
     /**
      * Creates a new timestamp from the given date.
@@ -1549,7 +1579,7 @@ class qt {
      * @returns A new `Timestamp` representing the same point in time as the given
      *     date.
      */    static fromDate(t) {
-        return qt.fromMillis(t.getTime());
+        return Ot.fromMillis(t.getTime());
     }
     /**
      * Creates a new timestamp from the given number of milliseconds.
@@ -1560,7 +1590,7 @@ class qt {
      *     number of milliseconds.
      */    static fromMillis(t) {
         const e = Math.floor(t / 1e3), n = Math.floor(1e6 * (t - 1e3 * e));
-        return new qt(e, n);
+        return new Ot(e, n);
     }
     /**
      * Converts a `Timestamp` to a JavaScript `Date` object. This conversion
@@ -1582,7 +1612,7 @@ class qt {
         return 1e3 * this.seconds + this.nanoseconds / 1e6;
     }
     _compareTo(t) {
-        return this.seconds === t.seconds ? At(this.nanoseconds, t.nanoseconds) : At(this.seconds, t.seconds);
+        return this.seconds === t.seconds ? Tt(this.nanoseconds, t.nanoseconds) : Tt(this.seconds, t.seconds);
     }
     /**
      * Returns true if this `Timestamp` is equal to the provided one.
@@ -1652,7 +1682,7 @@ class qt {
  *   FieldValueOptions to value().
  * - With respect to other ServerTimestampValues, they sort by their
  *   localWriteTime.
- */ function Ot(t) {
+ */ function kt(t) {
     var e, n;
     return "server_timestamp" === (null === (n = ((null === (e = null == t ? void 0 : t.mapValue) || void 0 === e ? void 0 : e.fields) || {}).__type__) || void 0 === n ? void 0 : n.stringValue);
 }
@@ -1662,16 +1692,16 @@ class qt {
  *
  * Preserving the previous values allows the user to display the last resoled
  * value until the backend responds with the timestamp.
- */ function kt(t) {
+ */ function Ct(t) {
     const e = t.mapValue.fields.__previous_value__;
-    return Ot(e) ? kt(e) : e;
+    return kt(e) ? Ct(e) : e;
 }
 
 /**
  * Returns the local time at which this timestamp was first set.
- */ function Ct(t) {
-    const e = Ft(t.mapValue.fields.__local_write_time__.timestampValue);
-    return new qt(e.seconds, e.nanos);
+ */ function Mt(t) {
+    const e = xt(t.mapValue.fields.__local_write_time__.timestampValue);
+    return new Ot(e.seconds, e.nanos);
 }
 
 /**
@@ -1689,7 +1719,7 @@ class qt {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ const Mt = {
+ */ const Lt = {
     fields: {
         __type__: {
             stringValue: "__max__"
@@ -1698,8 +1728,8 @@ class qt {
 };
 
 /** Extracts the backend's type order for the provided value. */
-function Lt(t) {
-    return "nullValue" in t ? 0 /* TypeOrder.NullValue */ : "booleanValue" in t ? 1 /* TypeOrder.BooleanValue */ : "integerValue" in t || "doubleValue" in t ? 2 /* TypeOrder.NumberValue */ : "timestampValue" in t ? 3 /* TypeOrder.TimestampValue */ : "stringValue" in t ? 5 /* TypeOrder.StringValue */ : "bytesValue" in t ? 6 /* TypeOrder.BlobValue */ : "referenceValue" in t ? 7 /* TypeOrder.RefValue */ : "geoPointValue" in t ? 8 /* TypeOrder.GeoPointValue */ : "arrayValue" in t ? 9 /* TypeOrder.ArrayValue */ : "mapValue" in t ? Ot(t) ? 4 /* TypeOrder.ServerTimestampValue */ : 
+function jt(t) {
+    return "nullValue" in t ? 0 /* TypeOrder.NullValue */ : "booleanValue" in t ? 1 /* TypeOrder.BooleanValue */ : "integerValue" in t || "doubleValue" in t ? 2 /* TypeOrder.NumberValue */ : "timestampValue" in t ? 3 /* TypeOrder.TimestampValue */ : "stringValue" in t ? 5 /* TypeOrder.StringValue */ : "bytesValue" in t ? 6 /* TypeOrder.BlobValue */ : "referenceValue" in t ? 7 /* TypeOrder.RefValue */ : "geoPointValue" in t ? 8 /* TypeOrder.GeoPointValue */ : "arrayValue" in t ? 9 /* TypeOrder.ArrayValue */ : "mapValue" in t ? kt(t) ? 4 /* TypeOrder.ServerTimestampValue */ : 
     /** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
     function(t) {
         return "__max__" === (((t.mapValue || {}).fields || {}).__type__ || {}).stringValue;
@@ -1736,10 +1766,10 @@ function Lt(t) {
  */ (t) ? 9007199254740991 /* TypeOrder.MaxValue */ : 10 /* TypeOrder.ObjectValue */ : I();
 }
 
-/** Tests `left` and `right` for equality based on the backend semantics. */ function jt(t, e) {
+/** Tests `left` and `right` for equality based on the backend semantics. */ function Ut(t, e) {
     if (t === e) return !0;
-    const n = Lt(t);
-    if (n !== Lt(e)) return !1;
+    const n = jt(t);
+    if (n !== jt(e)) return !1;
     switch (n) {
       case 0 /* TypeOrder.NullValue */ :
       case 9007199254740991 /* TypeOrder.MaxValue */ :
@@ -1749,14 +1779,14 @@ function Lt(t) {
         return t.booleanValue === e.booleanValue;
 
       case 4 /* TypeOrder.ServerTimestampValue */ :
-        return Ct(t).isEqual(Ct(e));
+        return Mt(t).isEqual(Mt(e));
 
       case 3 /* TypeOrder.TimestampValue */ :
         return function(t, e) {
             if ("string" == typeof t.timestampValue && "string" == typeof e.timestampValue && t.timestampValue.length === e.timestampValue.length) 
             // Use string equality for ISO 8601 timestamps
             return t.timestampValue === e.timestampValue;
-            const n = Ft(t.timestampValue), r = Ft(e.timestampValue);
+            const n = xt(t.timestampValue), r = xt(e.timestampValue);
             return n.seconds === r.seconds && n.nanos === r.nanos;
         }(t, e);
 
@@ -1765,7 +1795,7 @@ function Lt(t) {
 
       case 6 /* TypeOrder.BlobValue */ :
         return function(t, e) {
-            return St(t.bytesValue).isEqual(St(e.bytesValue));
+            return qt(t.bytesValue).isEqual(qt(e.bytesValue));
         }(t, e);
 
       case 7 /* TypeOrder.RefValue */ :
@@ -1773,27 +1803,27 @@ function Lt(t) {
 
       case 8 /* TypeOrder.GeoPointValue */ :
         return function(t, e) {
-            return xt(t.geoPointValue.latitude) === xt(e.geoPointValue.latitude) && xt(t.geoPointValue.longitude) === xt(e.geoPointValue.longitude);
+            return St(t.geoPointValue.latitude) === St(e.geoPointValue.latitude) && St(t.geoPointValue.longitude) === St(e.geoPointValue.longitude);
         }(t, e);
 
       case 2 /* TypeOrder.NumberValue */ :
         return function(t, e) {
-            if ("integerValue" in t && "integerValue" in e) return xt(t.integerValue) === xt(e.integerValue);
+            if ("integerValue" in t && "integerValue" in e) return St(t.integerValue) === St(e.integerValue);
             if ("doubleValue" in t && "doubleValue" in e) {
-                const n = xt(t.doubleValue), r = xt(e.doubleValue);
-                return n === r ? mt(n) === mt(r) : isNaN(n) && isNaN(r);
+                const n = St(t.doubleValue), r = St(e.doubleValue);
+                return n === r ? pt(n) === pt(r) : isNaN(n) && isNaN(r);
             }
             return !1;
         }(t, e);
 
       case 9 /* TypeOrder.ArrayValue */ :
-        return Tt(t.arrayValue.values || [], e.arrayValue.values || [], jt);
+        return Rt(t.arrayValue.values || [], e.arrayValue.values || [], Ut);
 
       case 10 /* TypeOrder.ObjectValue */ :
         return function(t, e) {
             const n = t.mapValue.fields || {}, r = e.mapValue.fields || {};
-            if (Rt(n) !== Rt(r)) return !1;
-            for (const t in n) if (n.hasOwnProperty(t) && (void 0 === r[t] || !jt(n[t], r[t]))) return !1;
+            if (Pt(n) !== Pt(r)) return !1;
+            for (const t in n) if (n.hasOwnProperty(t) && (void 0 === r[t] || !Ut(n[t], r[t]))) return !1;
             return !0;
         }
         /** Returns true if the ArrayValue contains the specified element. */ (t, e);
@@ -1803,42 +1833,42 @@ function Lt(t) {
     }
 }
 
-function Ut(t, e) {
-    return void 0 !== (t.values || []).find((t => jt(t, e)));
+function Bt(t, e) {
+    return void 0 !== (t.values || []).find((t => Ut(t, e)));
 }
 
-function Bt(t, e) {
+function Qt(t, e) {
     if (t === e) return 0;
-    const n = Lt(t), r = Lt(e);
-    if (n !== r) return At(n, r);
+    const n = jt(t), r = jt(e);
+    if (n !== r) return Tt(n, r);
     switch (n) {
       case 0 /* TypeOrder.NullValue */ :
       case 9007199254740991 /* TypeOrder.MaxValue */ :
         return 0;
 
       case 1 /* TypeOrder.BooleanValue */ :
-        return At(t.booleanValue, e.booleanValue);
+        return Tt(t.booleanValue, e.booleanValue);
 
       case 2 /* TypeOrder.NumberValue */ :
         return function(t, e) {
-            const n = xt(t.integerValue || t.doubleValue), r = xt(e.integerValue || e.doubleValue);
+            const n = St(t.integerValue || t.doubleValue), r = St(e.integerValue || e.doubleValue);
             return n < r ? -1 : n > r ? 1 : n === r ? 0 : 
             // one or both are NaN.
             isNaN(n) ? isNaN(r) ? 0 : -1 : 1;
         }(t, e);
 
       case 3 /* TypeOrder.TimestampValue */ :
-        return Qt(t.timestampValue, e.timestampValue);
+        return zt(t.timestampValue, e.timestampValue);
 
       case 4 /* TypeOrder.ServerTimestampValue */ :
-        return Qt(Ct(t), Ct(e));
+        return zt(Mt(t), Mt(e));
 
       case 5 /* TypeOrder.StringValue */ :
-        return At(t.stringValue, e.stringValue);
+        return Tt(t.stringValue, e.stringValue);
 
       case 6 /* TypeOrder.BlobValue */ :
         return function(t, e) {
-            const n = St(t), r = St(e);
+            const n = qt(t), r = qt(e);
             return n.compareTo(r);
         }(t.bytesValue, e.bytesValue);
 
@@ -1846,34 +1876,34 @@ function Bt(t, e) {
         return function(t, e) {
             const n = t.split("/"), r = e.split("/");
             for (let t = 0; t < n.length && t < r.length; t++) {
-                const e = At(n[t], r[t]);
+                const e = Tt(n[t], r[t]);
                 if (0 !== e) return e;
             }
-            return At(n.length, r.length);
+            return Tt(n.length, r.length);
         }(t.referenceValue, e.referenceValue);
 
       case 8 /* TypeOrder.GeoPointValue */ :
         return function(t, e) {
-            const n = At(xt(t.latitude), xt(e.latitude));
+            const n = Tt(St(t.latitude), St(e.latitude));
             if (0 !== n) return n;
-            return At(xt(t.longitude), xt(e.longitude));
+            return Tt(St(t.longitude), St(e.longitude));
         }(t.geoPointValue, e.geoPointValue);
 
       case 9 /* TypeOrder.ArrayValue */ :
         return function(t, e) {
             const n = t.values || [], r = e.values || [];
             for (let t = 0; t < n.length && t < r.length; ++t) {
-                const e = Bt(n[t], r[t]);
+                const e = Qt(n[t], r[t]);
                 if (e) return e;
             }
-            return At(n.length, r.length);
+            return Tt(n.length, r.length);
         }(t.arrayValue, e.arrayValue);
 
       case 10 /* TypeOrder.ObjectValue */ :
         return function(t, e) {
-            if (t === Mt && e === Mt) return 0;
-            if (t === Mt) return 1;
-            if (e === Mt) return -1;
+            if (t === Lt && e === Lt) return 0;
+            if (t === Lt) return 1;
+            if (e === Lt) return -1;
             const n = t.fields || {}, r = Object.keys(n), s = e.fields || {}, i = Object.keys(s);
             // Even though MapValues are likely sorted correctly based on their insertion
             // order (e.g. when received from the backend), local modifications can bring
@@ -1881,12 +1911,12 @@ function Bt(t, e) {
             // canonical IDs are independent of insertion order.
             r.sort(), i.sort();
             for (let t = 0; t < r.length && t < i.length; ++t) {
-                const e = At(r[t], i[t]);
+                const e = Tt(r[t], i[t]);
                 if (0 !== e) return e;
-                const o = Bt(n[r[t]], s[i[t]]);
+                const o = Qt(n[r[t]], s[i[t]]);
                 if (0 !== o) return o;
             }
-            return At(r.length, i.length);
+            return Tt(r.length, i.length);
         }
         /** Returns a reference value for the provided database and key. */ (t.mapValue, e.mapValue);
 
@@ -1895,35 +1925,35 @@ function Bt(t, e) {
     }
 }
 
-function Qt(t, e) {
-    if ("string" == typeof t && "string" == typeof e && t.length === e.length) return At(t, e);
-    const n = Ft(t), r = Ft(e), s = At(n.seconds, r.seconds);
-    return 0 !== s ? s : At(n.nanos, r.nanos);
+function zt(t, e) {
+    if ("string" == typeof t && "string" == typeof e && t.length === e.length) return Tt(t, e);
+    const n = xt(t), r = xt(e), s = Tt(n.seconds, r.seconds);
+    return 0 !== s ? s : Tt(n.nanos, r.nanos);
 }
 
-function zt(t, e) {
+function Wt(t, e) {
     return {
         referenceValue: `projects/${t.projectId}/databases/${t.database}/documents/${e.path.canonicalString()}`
     };
 }
 
-/** Returns true if `value` is an ArrayValue. */ function Wt(t) {
+/** Returns true if `value` is an ArrayValue. */ function Gt(t) {
     return !!t && "arrayValue" in t;
 }
 
-/** Returns true if `value` is a NullValue. */ function Gt(t) {
+/** Returns true if `value` is a NullValue. */ function Kt(t) {
     return !!t && "nullValue" in t;
 }
 
-/** Returns true if `value` is NaN. */ function Kt(t) {
+/** Returns true if `value` is NaN. */ function Yt(t) {
     return !!t && "doubleValue" in t && isNaN(Number(t.doubleValue));
 }
 
-/** Returns true if `value` is a MapValue. */ function Yt(t) {
+/** Returns true if `value` is a MapValue. */ function Ht(t) {
     return !!t && "mapValue" in t;
 }
 
-/** Creates a deep copy of `source`. */ function Ht(t) {
+/** Creates a deep copy of `source`. */ function Jt(t) {
     if (t.geoPointValue) return {
         geoPointValue: Object.assign({}, t.geoPointValue)
     };
@@ -1936,7 +1966,7 @@ function zt(t, e) {
                 fields: {}
             }
         };
-        return Pt(t.mapValue.fields, ((t, n) => e.mapValue.fields[t] = Ht(n))), e;
+        return Vt(t.mapValue.fields, ((t, n) => e.mapValue.fields[t] = Jt(n))), e;
     }
     if (t.arrayValue) {
         const e = {
@@ -1944,24 +1974,24 @@ function zt(t, e) {
                 values: []
             }
         };
-        for (let n = 0; n < (t.arrayValue.values || []).length; ++n) e.arrayValue.values[n] = Ht(t.arrayValue.values[n]);
+        for (let n = 0; n < (t.arrayValue.values || []).length; ++n) e.arrayValue.values[n] = Jt(t.arrayValue.values[n]);
         return e;
     }
     return Object.assign({}, t);
 }
 
-class Jt {
+class Xt {
     constructor(t, e) {
         this.position = t, this.inclusive = e;
     }
 }
 
-function Xt(t, e) {
+function Zt(t, e) {
     if (null === t) return null === e;
     if (null === e) return !1;
     if (t.inclusive !== e.inclusive || t.position.length !== e.position.length) return !1;
     for (let n = 0; n < t.position.length; n++) {
-        if (!jt(t.position[n], e.position[n])) return !1;
+        if (!Ut(t.position[n], e.position[n])) return !1;
     }
     return !0;
 }
@@ -1981,24 +2011,24 @@ function Xt(t, e) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ class Zt {}
+ */ class te {}
 
-class te extends Zt {
+class ee extends te {
     constructor(t, e, n) {
         super(), this.field = t, this.op = e, this.value = n;
     }
     /**
      * Creates a filter based on the provided arguments.
      */    static create(t, e, n) {
-        return t.isKeyField() ? "in" /* Operator.IN */ === e || "not-in" /* Operator.NOT_IN */ === e ? this.createKeyFieldInFilter(t, e, n) : new re(t, e, n) : "array-contains" /* Operator.ARRAY_CONTAINS */ === e ? new ue(t, n) : "in" /* Operator.IN */ === e ? new ce(t, n) : "not-in" /* Operator.NOT_IN */ === e ? new ae(t, n) : "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */ === e ? new he(t, n) : new te(t, e, n);
+        return t.isKeyField() ? "in" /* Operator.IN */ === e || "not-in" /* Operator.NOT_IN */ === e ? this.createKeyFieldInFilter(t, e, n) : new se(t, e, n) : "array-contains" /* Operator.ARRAY_CONTAINS */ === e ? new ce(t, n) : "in" /* Operator.IN */ === e ? new ae(t, n) : "not-in" /* Operator.NOT_IN */ === e ? new he(t, n) : "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */ === e ? new le(t, n) : new ee(t, e, n);
     }
     static createKeyFieldInFilter(t, e, n) {
-        return "in" /* Operator.IN */ === e ? new se(t, n) : new ie(t, n);
+        return "in" /* Operator.IN */ === e ? new ie(t, n) : new oe(t, n);
     }
     matches(t) {
         const e = t.data.field(this.field);
         // Types do not have to match in NOT_EQUAL filters.
-                return "!=" /* Operator.NOT_EQUAL */ === this.op ? null !== e && this.matchesComparison(Bt(e, this.value)) : null !== e && Lt(this.value) === Lt(e) && this.matchesComparison(Bt(e, this.value));
+                return "!=" /* Operator.NOT_EQUAL */ === this.op ? null !== e && this.matchesComparison(Qt(e, this.value)) : null !== e && jt(this.value) === jt(e) && this.matchesComparison(Qt(e, this.value));
         // Only compare types with matching backend order (such as double and int).
         }
     matchesComparison(t) {
@@ -2039,14 +2069,14 @@ class te extends Zt {
     }
 }
 
-class ee extends Zt {
+class ne extends te {
     constructor(t, e) {
         super(), this.filters = t, this.op = e, this.D = null;
     }
     /**
      * Creates a filter based on the provided arguments.
      */    static create(t, e) {
-        return new ee(t, e);
+        return new ne(t, e);
     }
     matches(t) {
         return "and" /* CompositeOperator.AND */ === this.op ? void 0 === this.filters.find((e => !e.matches(t))) : void 0 !== this.filters.find((e => e.matches(t)));
@@ -2072,19 +2102,19 @@ class ee extends Zt {
     }
 }
 
-function ne(t, e) {
-    return t instanceof te ? function(t, e) {
-        return e instanceof te && t.op === e.op && t.field.isEqual(e.field) && jt(t.value, e.value);
-    }(t, e) : t instanceof ee ? function(t, e) {
-        if (e instanceof ee && t.op === e.op && t.filters.length === e.filters.length) {
-            return t.filters.reduce(((t, n, r) => t && ne(n, e.filters[r])), !0);
+function re(t, e) {
+    return t instanceof ee ? function(t, e) {
+        return e instanceof ee && t.op === e.op && t.field.isEqual(e.field) && Ut(t.value, e.value);
+    }(t, e) : t instanceof ne ? function(t, e) {
+        if (e instanceof ne && t.op === e.op && t.filters.length === e.filters.length) {
+            return t.filters.reduce(((t, n, r) => t && re(n, e.filters[r])), !0);
         }
         return !1;
     }
     /** Filter that matches on key fields (i.e. '__name__'). */ (t, e) : void I();
 }
 
-class re extends te {
+class se extends ee {
     constructor(t, e, n) {
         super(t, e, n), this.key = it.fromName(n.referenceValue);
     }
@@ -2094,69 +2124,69 @@ class re extends te {
     }
 }
 
-/** Filter that matches on key fields within an array. */ class se extends te {
+/** Filter that matches on key fields within an array. */ class ie extends ee {
     constructor(t, e) {
-        super(t, "in" /* Operator.IN */ , e), this.keys = oe("in" /* Operator.IN */ , e);
+        super(t, "in" /* Operator.IN */ , e), this.keys = ue("in" /* Operator.IN */ , e);
     }
     matches(t) {
         return this.keys.some((e => e.isEqual(t.key)));
     }
 }
 
-/** Filter that matches on key fields not present within an array. */ class ie extends te {
+/** Filter that matches on key fields not present within an array. */ class oe extends ee {
     constructor(t, e) {
-        super(t, "not-in" /* Operator.NOT_IN */ , e), this.keys = oe("not-in" /* Operator.NOT_IN */ , e);
+        super(t, "not-in" /* Operator.NOT_IN */ , e), this.keys = ue("not-in" /* Operator.NOT_IN */ , e);
     }
     matches(t) {
         return !this.keys.some((e => e.isEqual(t.key)));
     }
 }
 
-function oe(t, e) {
+function ue(t, e) {
     var n;
     return ((null === (n = e.arrayValue) || void 0 === n ? void 0 : n.values) || []).map((t => it.fromName(t.referenceValue)));
 }
 
-/** A Filter that implements the array-contains operator. */ class ue extends te {
+/** A Filter that implements the array-contains operator. */ class ce extends ee {
     constructor(t, e) {
         super(t, "array-contains" /* Operator.ARRAY_CONTAINS */ , e);
     }
     matches(t) {
         const e = t.data.field(this.field);
-        return Wt(e) && Ut(e.arrayValue, this.value);
+        return Gt(e) && Bt(e.arrayValue, this.value);
     }
 }
 
-/** A Filter that implements the IN operator. */ class ce extends te {
+/** A Filter that implements the IN operator. */ class ae extends ee {
     constructor(t, e) {
         super(t, "in" /* Operator.IN */ , e);
     }
     matches(t) {
         const e = t.data.field(this.field);
-        return null !== e && Ut(this.value.arrayValue, e);
+        return null !== e && Bt(this.value.arrayValue, e);
     }
 }
 
-/** A Filter that implements the not-in operator. */ class ae extends te {
+/** A Filter that implements the not-in operator. */ class he extends ee {
     constructor(t, e) {
         super(t, "not-in" /* Operator.NOT_IN */ , e);
     }
     matches(t) {
-        if (Ut(this.value.arrayValue, {
+        if (Bt(this.value.arrayValue, {
             nullValue: "NULL_VALUE"
         })) return !1;
         const e = t.data.field(this.field);
-        return null !== e && !Ut(this.value.arrayValue, e);
+        return null !== e && !Bt(this.value.arrayValue, e);
     }
 }
 
-/** A Filter that implements the array-contains-any operator. */ class he extends te {
+/** A Filter that implements the array-contains-any operator. */ class le extends ee {
     constructor(t, e) {
         super(t, "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */ , e);
     }
     matches(t) {
         const e = t.data.field(this.field);
-        return !(!Wt(e) || !e.arrayValue.values) && e.arrayValue.values.some((t => Ut(this.value.arrayValue, t)));
+        return !(!Gt(e) || !e.arrayValue.values) && e.arrayValue.values.some((t => Bt(this.value.arrayValue, t)));
     }
 }
 
@@ -2178,13 +2208,13 @@ function oe(t, e) {
  */
 /**
  * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
- */ class le {
+ */ class fe {
     constructor(t, e = "asc" /* Direction.ASCENDING */) {
         this.field = t, this.dir = e;
     }
 }
 
-function fe(t, e) {
+function de(t, e) {
     return t.dir === e.dir && t.field.isEqual(e.field);
 }
 
@@ -2207,18 +2237,18 @@ function fe(t, e) {
 /**
  * A version of a document in Firestore. This corresponds to the version
  * timestamp, such as update_time or read_time.
- */ class de {
+ */ class we {
     constructor(t) {
         this.timestamp = t;
     }
     static fromTimestamp(t) {
-        return new de(t);
+        return new we(t);
     }
     static min() {
-        return new de(new qt(0, 0));
+        return new we(new Ot(0, 0));
     }
     static max() {
-        return new de(new qt(253402300799, 999999999));
+        return new we(new Ot(253402300799, 999999999));
     }
     compareTo(t) {
         return this.timestamp._compareTo(t.timestamp);
@@ -2256,17 +2286,17 @@ function fe(t, e) {
  */
 // An immutable sorted map implementation, based on a Left-leaning Red-Black
 // tree.
-class we {
+class me {
     constructor(t, e) {
-        this.comparator = t, this.root = e || pe.EMPTY;
+        this.comparator = t, this.root = e || ye.EMPTY;
     }
     // Returns a copy of the map, with the specified key/value added or replaced.
     insert(t, e) {
-        return new we(this.comparator, this.root.insert(t, e, this.comparator).copy(null, null, pe.BLACK, null, null));
+        return new me(this.comparator, this.root.insert(t, e, this.comparator).copy(null, null, ye.BLACK, null, null));
     }
     // Returns a copy of the map, with the specified key removed.
     remove(t) {
-        return new we(this.comparator, this.root.remove(t, this.comparator).copy(null, null, pe.BLACK, null, null));
+        return new me(this.comparator, this.root.remove(t, this.comparator).copy(null, null, ye.BLACK, null, null));
     }
     // Returns the value of the node with the given key, or null.
     get(t) {
@@ -2332,22 +2362,22 @@ class we {
     }
     // Returns an iterator over the SortedMap.
     getIterator() {
-        return new me(this.root, null, this.comparator, !1);
+        return new pe(this.root, null, this.comparator, !1);
     }
     getIteratorFrom(t) {
-        return new me(this.root, t, this.comparator, !1);
+        return new pe(this.root, t, this.comparator, !1);
     }
     getReverseIterator() {
-        return new me(this.root, null, this.comparator, !0);
+        return new pe(this.root, null, this.comparator, !0);
     }
     getReverseIteratorFrom(t) {
-        return new me(this.root, t, this.comparator, !0);
+        return new pe(this.root, t, this.comparator, !0);
     }
 }
 
  // end SortedMap
 // An iterator over an LLRBNode.
-class me {
+class pe {
     constructor(t, e, n, r) {
         this.isReverse = r, this.nodeStack = [];
         let s = 1;
@@ -2392,14 +2422,14 @@ class me {
 
  // end SortedMapIterator
 // Represents a node in a Left-leaning Red-Black tree.
-class pe {
+class ye {
     constructor(t, e, n, r, s) {
-        this.key = t, this.value = e, this.color = null != n ? n : pe.RED, this.left = null != r ? r : pe.EMPTY, 
-        this.right = null != s ? s : pe.EMPTY, this.size = this.left.size + 1 + this.right.size;
+        this.key = t, this.value = e, this.color = null != n ? n : ye.RED, this.left = null != r ? r : ye.EMPTY, 
+        this.right = null != s ? s : ye.EMPTY, this.size = this.left.size + 1 + this.right.size;
     }
     // Returns a copy of the current node, optionally replacing pieces of it.
     copy(t, e, n, r, s) {
-        return new pe(null != t ? t : this.key, null != e ? e : this.value, null != n ? n : this.color, null != r ? r : this.left, null != s ? s : this.right);
+        return new ye(null != t ? t : this.key, null != e ? e : this.value, null != n ? n : this.color, null != r ? r : this.left, null != s ? s : this.right);
     }
     isEmpty() {
         return !1;
@@ -2438,7 +2468,7 @@ class pe {
         r.fixUp();
     }
     removeMin() {
-        if (this.left.isEmpty()) return pe.EMPTY;
+        if (this.left.isEmpty()) return ye.EMPTY;
         let t = this;
         return t.left.isRed() || t.left.left.isRed() || (t = t.moveRedLeft()), t = t.copy(null, null, null, t.left.removeMin(), null), 
         t.fixUp();
@@ -2450,7 +2480,7 @@ class pe {
         r = r.copy(null, null, null, r.left.remove(t, e), null); else {
             if (r.left.isRed() && (r = r.rotateRight()), r.right.isEmpty() || r.right.isRed() || r.right.left.isRed() || (r = r.moveRedRight()), 
             0 === e(t, r.key)) {
-                if (r.right.isEmpty()) return pe.EMPTY;
+                if (r.right.isEmpty()) return ye.EMPTY;
                 n = r.right.min(), r = r.copy(n.key, n.value, null, null, r.right.removeMin());
             }
             r = r.copy(null, null, null, null, r.right.remove(t, e));
@@ -2476,11 +2506,11 @@ class pe {
         return t.left.left.isRed() && (t = t.rotateRight(), t = t.colorFlip()), t;
     }
     rotateLeft() {
-        const t = this.copy(null, null, pe.RED, null, this.right.left);
+        const t = this.copy(null, null, ye.RED, null, this.right.left);
         return this.right.copy(null, null, this.color, t, null);
     }
     rotateRight() {
-        const t = this.copy(null, null, pe.RED, this.left.right, null);
+        const t = this.copy(null, null, ye.RED, this.left.right, null);
         return this.left.copy(null, null, this.color, null, t);
     }
     colorFlip() {
@@ -2506,10 +2536,10 @@ class pe {
  // end LLRBNode
 // Empty node is shared between all LLRB trees.
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-pe.EMPTY = null, pe.RED = !0, pe.BLACK = !1;
+ye.EMPTY = null, ye.RED = !0, ye.BLACK = !1;
 
 // end LLRBEmptyNode
-pe.EMPTY = new 
+ye.EMPTY = new 
 // Represents an empty node (a leaf node in the Red-Black Tree).
 class {
     constructor() {
@@ -2536,7 +2566,7 @@ class {
     }
     // Returns a copy of the tree, with the specified key/value added.
     insert(t, e, n) {
-        return new pe(t, e);
+        return new ye(t, e);
     }
     // Returns a copy of the tree, with the specified key removed.
     remove(t, e) {
@@ -2592,9 +2622,9 @@ class {
  * NOTE: if provided comparator returns 0 for two elements, we consider them to
  * be equal!
  */
-class ye {
+class ge {
     constructor(t) {
-        this.comparator = t, this.data = new we(this.comparator);
+        this.comparator = t, this.data = new me(this.comparator);
     }
     has(t) {
         return null !== this.data.get(t);
@@ -2635,10 +2665,10 @@ class ye {
         return e.hasNext() ? e.getNext().key : null;
     }
     getIterator() {
-        return new ge(this.data.getIterator());
+        return new _e(this.data.getIterator());
     }
     getIteratorFrom(t) {
-        return new ge(this.data.getIteratorFrom(t));
+        return new _e(this.data.getIteratorFrom(t));
     }
     /** Inserts or updates an element */    add(t) {
         return this.copy(this.data.remove(t).insert(t, !0));
@@ -2657,7 +2687,7 @@ class ye {
         })), e;
     }
     isEqual(t) {
-        if (!(t instanceof ye)) return !1;
+        if (!(t instanceof ge)) return !1;
         if (this.size !== t.size) return !1;
         const e = this.data.getIterator(), n = t.data.getIterator();
         for (;e.hasNext(); ) {
@@ -2677,12 +2707,12 @@ class ye {
         return this.forEach((e => t.push(e))), "SortedSet(" + t.toString() + ")";
     }
     copy(t) {
-        const e = new ye(this.comparator);
+        const e = new ge(this.comparator);
         return e.data = t, e;
     }
 }
 
-class ge {
+class _e {
     constructor(t) {
         this.iter = t;
     }
@@ -2719,7 +2749,7 @@ class ge {
  *   foo.bar - Overwrites only the field bar of the object foo.
  *             If foo is not an object, foo is replaced with an object
  *             containing foo
- */ class _e {
+ */ class ve {
     constructor(t) {
         this.fields = t, 
         // TODO(dimond): validation of FieldMask
@@ -2727,16 +2757,16 @@ class ge {
         t.sort(st.comparator);
     }
     static empty() {
-        return new _e([]);
+        return new ve([]);
     }
     /**
      * Returns a new FieldMask object that is the result of adding all the given
      * fields paths to this field mask.
      */    unionWith(t) {
-        let e = new ye(st.comparator);
+        let e = new ge(st.comparator);
         for (const t of this.fields) e = e.add(t);
         for (const n of t) e = e.add(n);
-        return new _e(e.toArray());
+        return new ve(e.toArray());
     }
     /**
      * Verifies that `fieldPath` is included by at least one field in this field
@@ -2748,7 +2778,7 @@ class ge {
         return !1;
     }
     isEqual(t) {
-        return Tt(this.fields, t.fields, ((t, e) => t.isEqual(e)));
+        return Rt(this.fields, t.fields, ((t, e) => t.isEqual(e)));
     }
 }
 
@@ -2771,12 +2801,12 @@ class ge {
 /**
  * An ObjectValue represents a MapValue in the Firestore Proto and offers the
  * ability to add and remove fields (via the ObjectValueBuilder).
- */ class ve {
+ */ class be {
     constructor(t) {
         this.value = t;
     }
     static empty() {
-        return new ve({
+        return new be({
             mapValue: {}
         });
     }
@@ -2790,7 +2820,7 @@ class ge {
         {
             let e = this.value;
             for (let n = 0; n < t.length - 1; ++n) if (e = (e.mapValue.fields || {})[t.get(n)], 
-            !Yt(e)) return null;
+            !Ht(e)) return null;
             return e = (e.mapValue.fields || {})[t.lastSegment()], e || null;
         }
     }
@@ -2800,7 +2830,7 @@ class ge {
      * @param path - The field path to set.
      * @param value - The value to set.
      */    set(t, e) {
-        this.getFieldsMap(t.popLast())[t.lastSegment()] = Ht(e);
+        this.getFieldsMap(t.popLast())[t.lastSegment()] = Jt(e);
     }
     /**
      * Sets the provided fields to the provided values.
@@ -2814,7 +2844,7 @@ class ge {
                 const t = this.getFieldsMap(e);
                 this.applyChanges(t, n, r), n = {}, r = [], e = s.popLast();
             }
-            t ? n[s.lastSegment()] = Ht(t) : r.push(s.lastSegment());
+            t ? n[s.lastSegment()] = Jt(t) : r.push(s.lastSegment());
         }));
         const s = this.getFieldsMap(e);
         this.applyChanges(s, n, r);
@@ -2826,10 +2856,10 @@ class ge {
      * @param path - The field path to remove.
      */    delete(t) {
         const e = this.field(t.popLast());
-        Yt(e) && e.mapValue.fields && delete e.mapValue.fields[t.lastSegment()];
+        Ht(e) && e.mapValue.fields && delete e.mapValue.fields[t.lastSegment()];
     }
     isEqual(t) {
-        return jt(this.value, t.value);
+        return Ut(this.value, t.value);
     }
     /**
      * Returns the map that contains the leaf element of `path`. If the parent
@@ -2841,7 +2871,7 @@ class ge {
         });
         for (let n = 0; n < t.length; ++n) {
             let r = e.mapValue.fields[t.get(n)];
-            Yt(r) && r.mapValue.fields || (r = {
+            Ht(r) && r.mapValue.fields || (r = {
                 mapValue: {
                     fields: {}
                 }
@@ -2853,11 +2883,11 @@ class ge {
      * Modifies `fieldsMap` by adding, replacing or deleting the specified
      * entries.
      */    applyChanges(t, e, n) {
-        Pt(e, ((e, n) => t[e] = n));
+        Vt(e, ((e, n) => t[e] = n));
         for (const e of n) delete t[e];
     }
     clone() {
-        return new ve(Ht(this.value));
+        return new be(Jt(this.value));
     }
 }
 
@@ -2886,7 +2916,7 @@ class ge {
  * not transition to one of these states even after all mutations have been
  * applied, `isValidDocument()` returns false and the document should be removed
  * from all views.
- */ class be {
+ */ class Ee {
     constructor(t, e, n, r, s, i, o) {
         this.key = t, this.documentType = e, this.version = n, this.readTime = r, this.createTime = s, 
         this.data = i, this.documentState = o;
@@ -2895,35 +2925,35 @@ class ge {
      * Creates a document with no known version or data, but which can serve as
      * base document for mutations.
      */    static newInvalidDocument(t) {
-        return new be(t, 0 /* DocumentType.INVALID */ , 
-        /* version */ de.min(), 
-        /* readTime */ de.min(), 
-        /* createTime */ de.min(), ve.empty(), 0 /* DocumentState.SYNCED */);
+        return new Ee(t, 0 /* DocumentType.INVALID */ , 
+        /* version */ we.min(), 
+        /* readTime */ we.min(), 
+        /* createTime */ we.min(), be.empty(), 0 /* DocumentState.SYNCED */);
     }
     /**
      * Creates a new document that is known to exist with the given data at the
      * given version.
      */    static newFoundDocument(t, e, n, r) {
-        return new be(t, 1 /* DocumentType.FOUND_DOCUMENT */ , 
+        return new Ee(t, 1 /* DocumentType.FOUND_DOCUMENT */ , 
         /* version */ e, 
-        /* readTime */ de.min(), 
+        /* readTime */ we.min(), 
         /* createTime */ n, r, 0 /* DocumentState.SYNCED */);
     }
     /** Creates a new document that is known to not exist at the given version. */    static newNoDocument(t, e) {
-        return new be(t, 2 /* DocumentType.NO_DOCUMENT */ , 
+        return new Ee(t, 2 /* DocumentType.NO_DOCUMENT */ , 
         /* version */ e, 
-        /* readTime */ de.min(), 
-        /* createTime */ de.min(), ve.empty(), 0 /* DocumentState.SYNCED */);
+        /* readTime */ we.min(), 
+        /* createTime */ we.min(), be.empty(), 0 /* DocumentState.SYNCED */);
     }
     /**
      * Creates a new document that is known to exist at the given version but
      * whose data is not known (e.g. a document that was updated without a known
      * base document).
      */    static newUnknownDocument(t, e) {
-        return new be(t, 3 /* DocumentType.UNKNOWN_DOCUMENT */ , 
+        return new Ee(t, 3 /* DocumentType.UNKNOWN_DOCUMENT */ , 
         /* version */ e, 
-        /* readTime */ de.min(), 
-        /* createTime */ de.min(), ve.empty(), 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */);
+        /* readTime */ we.min(), 
+        /* createTime */ we.min(), be.empty(), 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */);
     }
     /**
      * Changes the document type to indicate that it exists and that its version
@@ -2934,7 +2964,7 @@ class ge {
         // update from Watch or due to applying a local set mutation on top
         // of a deleted document, our best guess about its createTime would be the
         // version at which the document transitioned to a FOUND_DOCUMENT.
-        return !this.createTime.isEqual(de.min()) || 2 /* DocumentType.NO_DOCUMENT */ !== this.documentType && 0 /* DocumentType.INVALID */ !== this.documentType || (this.createTime = t), 
+        return !this.createTime.isEqual(we.min()) || 2 /* DocumentType.NO_DOCUMENT */ !== this.documentType && 0 /* DocumentType.INVALID */ !== this.documentType || (this.createTime = t), 
         this.version = t, this.documentType = 1 /* DocumentType.FOUND_DOCUMENT */ , this.data = e, 
         this.documentState = 0 /* DocumentState.SYNCED */ , this;
     }
@@ -2943,7 +2973,7 @@ class ge {
      * version.
      */    convertToNoDocument(t) {
         return this.version = t, this.documentType = 2 /* DocumentType.NO_DOCUMENT */ , 
-        this.data = ve.empty(), this.documentState = 0 /* DocumentState.SYNCED */ , this;
+        this.data = be.empty(), this.documentState = 0 /* DocumentState.SYNCED */ , this;
     }
     /**
      * Changes the document type to indicate that it exists at a given version but
@@ -2951,14 +2981,14 @@ class ge {
      * base document).
      */    convertToUnknownDocument(t) {
         return this.version = t, this.documentType = 3 /* DocumentType.UNKNOWN_DOCUMENT */ , 
-        this.data = ve.empty(), this.documentState = 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */ , 
+        this.data = be.empty(), this.documentState = 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */ , 
         this;
     }
     setHasCommittedMutations() {
         return this.documentState = 2 /* DocumentState.HAS_COMMITTED_MUTATIONS */ , this;
     }
     setHasLocalMutations() {
-        return this.documentState = 1 /* DocumentState.HAS_LOCAL_MUTATIONS */ , this.version = de.min(), 
+        return this.documentState = 1 /* DocumentState.HAS_LOCAL_MUTATIONS */ , this.version = we.min(), 
         this;
     }
     setReadTime(t) {
@@ -2986,10 +3016,10 @@ class ge {
         return 3 /* DocumentType.UNKNOWN_DOCUMENT */ === this.documentType;
     }
     isEqual(t) {
-        return t instanceof be && this.key.isEqual(t.key) && this.version.isEqual(t.version) && this.documentType === t.documentType && this.documentState === t.documentState && this.data.isEqual(t.data);
+        return t instanceof Ee && this.key.isEqual(t.key) && this.version.isEqual(t.version) && this.documentType === t.documentType && this.documentState === t.documentState && this.data.isEqual(t.data);
     }
     mutableCopy() {
-        return new be(this.key, this.documentType, this.version, this.readTime, this.createTime, this.data.clone(), this.documentState);
+        return new Ee(this.key, this.documentType, this.version, this.readTime, this.createTime, this.data.clone(), this.documentState);
     }
     toString() {
         return `Document(${this.key}, ${this.version}, ${JSON.stringify(this.data.value)}, {createTime: ${this.createTime}}), {documentType: ${this.documentType}}), {documentState: ${this.documentState}})`;
@@ -3013,7 +3043,7 @@ class ge {
  * limitations under the License.
  */
 // Visible for testing
-class Ee {
+class Ie {
     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.S = null;
@@ -3027,8 +3057,8 @@ class Ee {
  * NOTE: you should always construct `Target` from `Query.toTarget` instead of
  * using this factory method, because `Query` provides an implicit `orderBy`
  * property.
- */ function Ie(t, e = null, n = [], r = [], s = null, i = null, o = null) {
-    return new Ee(t, e, n, r, s, i, o);
+ */ function Ae(t, e = null, n = [], r = [], s = null, i = null, o = null) {
+    return new Ie(t, e, n, r, s, i, o);
 }
 
 /**
@@ -3054,7 +3084,7 @@ class Ee {
  *
  * Visible for testing.
  */
-class Ae {
+class Te {
     /**
      * Initializes a Query with a path and optional additional query constraints.
      * Path must currently be empty if this is a collection group query.
@@ -3067,11 +3097,11 @@ class Ae {
     }
 }
 
-/** Creates a new Query for a query that matches all documents at `path` */ function Te(t) {
+/** Creates a new Query for a query that matches all documents at `path` */ function Re(t) {
     return t.explicitOrderBy.length > 0 ? t.explicitOrderBy[0].field : null;
 }
 
-function Re(t) {
+function Pe(t) {
     for (const e of t.filters) {
         const t = e.getFirstInequalityField();
         if (null !== t) return t;
@@ -3087,7 +3117,7 @@ function Re(t) {
  * Returns whether the query matches a collection group rather than a specific
  * collection.
  */
-function Pe(t) {
+function Ve(t) {
     return null !== t.collectionGroup;
 }
 
@@ -3095,23 +3125,23 @@ function Pe(t) {
  * Returns the implicit order by constraint that is used to execute the Query,
  * which can be different from the order by constraints the user provided (e.g.
  * the SDK and backend always orders by `__name__`).
- */ function Ve(t) {
+ */ function $e(t) {
     const e = T(t);
     if (null === e.q) {
         e.q = [];
-        const t = Re(e), n = Te(e);
+        const t = Pe(e), n = Re(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.q.push(new le(t)), e.q.push(new le(st.keyField(), "asc" /* Direction.ASCENDING */)); else {
+        t.isKeyField() || e.q.push(new fe(t)), e.q.push(new fe(st.keyField(), "asc" /* Direction.ASCENDING */)); else {
             let t = !1;
             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" /* Direction.ASCENDING */;
-                e.q.push(new le(st.keyField(), t));
+                e.q.push(new fe(st.keyField(), t));
             }
         }
     }
@@ -3120,38 +3150,38 @@ function Pe(t) {
 
 /**
  * Converts this `Query` instance to it's corresponding `Target` representation.
- */ function $e(t) {
+ */ function Ne(t) {
     const e = T(t);
-    if (!e.O) if ("F" /* LimitType.First */ === e.limitType) e.O = Ie(e.path, e.collectionGroup, Ve(e), e.filters, e.limit, e.startAt, e.endAt); else {
+    if (!e.O) if ("F" /* LimitType.First */ === e.limitType) e.O = Ae(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 Ve(e)) {
+        for (const n of $e(e)) {
             const e = "desc" /* Direction.DESCENDING */ === n.dir ? "asc" /* Direction.ASCENDING */ : "desc" /* Direction.DESCENDING */;
-            t.push(new le(n.field, e));
+            t.push(new fe(n.field, e));
         }
         // We need to swap the cursors to match the now-flipped query ordering.
-                const n = e.endAt ? new Jt(e.endAt.position, e.endAt.inclusive) : null, r = e.startAt ? new Jt(e.startAt.position, e.startAt.inclusive) : null;
+                const n = e.endAt ? new Xt(e.endAt.position, e.endAt.inclusive) : null, r = e.startAt ? new Xt(e.startAt.position, e.startAt.inclusive) : null;
         // Now return as a LimitType.First query.
-        e.O = Ie(e.path, e.collectionGroup, t, e.filters, e.limit, n, r);
+        e.O = Ae(e.path, e.collectionGroup, t, e.filters, e.limit, n, r);
     }
     return e.O;
 }
 
-function Ne(t, e) {
-    e.getFirstInequalityField(), Re(t);
+function De(t, e) {
+    e.getFirstInequalityField(), Pe(t);
     const n = t.filters.concat([ e ]);
-    return new Ae(t.path, t.collectionGroup, t.explicitOrderBy.slice(), n, t.limit, t.limitType, t.startAt, t.endAt);
+    return new Te(t.path, t.collectionGroup, t.explicitOrderBy.slice(), n, t.limit, t.limitType, t.startAt, t.endAt);
 }
 
-function De(t, e) {
+function Fe(t, e) {
     return function(t, e) {
         if (t.limit !== e.limit) return !1;
         if (t.orderBy.length !== e.orderBy.length) return !1;
-        for (let n = 0; n < t.orderBy.length; n++) if (!fe(t.orderBy[n], e.orderBy[n])) return !1;
+        for (let n = 0; n < t.orderBy.length; n++) if (!de(t.orderBy[n], e.orderBy[n])) return !1;
         if (t.filters.length !== e.filters.length) return !1;
-        for (let n = 0; n < t.filters.length; n++) if (!ne(t.filters[n], e.filters[n])) return !1;
-        return t.collectionGroup === e.collectionGroup && !!t.path.isEqual(e.path) && !!Xt(t.startAt, e.startAt) && Xt(t.endAt, e.endAt);
-    }($e(t), $e(e)) && t.limitType === e.limitType;
+        for (let n = 0; n < t.filters.length; n++) if (!re(t.filters[n], e.filters[n])) return !1;
+        return t.collectionGroup === e.collectionGroup && !!t.path.isEqual(e.path) && !!Zt(t.startAt, e.startAt) && Zt(t.endAt, e.endAt);
+    }(Ne(t), Ne(e)) && t.limitType === e.limitType;
 }
 
 /**
@@ -3179,9 +3209,9 @@ function De(t, e) {
  * The return value is an IntegerValue if it can safely represent the value,
  * otherwise a DoubleValue is returned.
  */
-function Fe(t, e) {
+function xe(t, e) {
     return function(t) {
-        return "number" == typeof t && Number.isInteger(t) && !mt(t) && t <= Number.MAX_SAFE_INTEGER && t >= Number.MIN_SAFE_INTEGER;
+        return "number" == typeof t && Number.isInteger(t) && !pt(t) && t <= Number.MAX_SAFE_INTEGER && t >= Number.MIN_SAFE_INTEGER;
     }(e) ? 
     /**
  * Returns an IntegerValue for `value`.
@@ -3203,7 +3233,7 @@ function Fe(t, e) {
             };
         }
         return {
-            doubleValue: mt(e) ? "-0" : e
+            doubleValue: pt(e) ? "-0" : e
         };
     }(t, e);
 }
@@ -3224,7 +3254,7 @@ function Fe(t, e) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** Used to represent a field transform on a mutation. */ class xe {
+/** Used to represent a field transform on a mutation. */ class Se {
     constructor() {
         // Make sure that the structural type of `TransformOperation` is unique.
         // See https://github.com/microsoft/TypeScript/issues/5451
@@ -3232,15 +3262,15 @@ function Fe(t, e) {
     }
 }
 
-/** Transforms a value into a server-generated timestamp. */ class Se extends xe {}
+/** Transforms a value into a server-generated timestamp. */ class qe extends Se {}
 
-/** Transforms an array value via a union operation. */ class qe extends xe {
+/** Transforms an array value via a union operation. */ class Oe extends Se {
     constructor(t) {
         super(), this.elements = t;
     }
 }
 
-/** Transforms an array value via a remove operation. */ class Oe extends xe {
+/** Transforms an array value via a remove operation. */ class ke extends Se {
     constructor(t) {
         super(), this.elements = t;
     }
@@ -3251,7 +3281,7 @@ function Fe(t, e) {
  * transforms. Converts all field values to integers or doubles, but unlike the
  * backend does not cap integer values at 2^63. Instead, JavaScript number
  * arithmetic is used and precision loss can occur for values greater than 2^53.
- */ class ke extends xe {
+ */ class Ce extends Se {
     constructor(t, e) {
         super(), this.serializer = t, this.k = e;
     }
@@ -3273,7 +3303,7 @@ function Fe(t, e) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** A field path and the TransformOperation to perform upon it. */ class Ce {
+/** A field path and the TransformOperation to perform upon it. */ class Me {
     constructor(t, e) {
         this.field = t, this.transform = e;
     }
@@ -3283,18 +3313,18 @@ function Fe(t, e) {
  * Encodes a precondition for a mutation. This follows the model that the
  * backend accepts with the special case of an explicit "empty" precondition
  * (meaning no precondition).
- */ class Me {
+ */ class Le {
     constructor(t, e) {
         this.updateTime = t, this.exists = e;
     }
     /** Creates a new empty Precondition. */    static none() {
-        return new Me;
+        return new Le;
     }
     /** Creates a new Precondition with an exists flag. */    static exists(t) {
-        return new Me(void 0, t);
+        return new Le(void 0, t);
     }
     /** Creates a new Precondition based on a version a document exists at. */    static updateTime(t) {
-        return new Me(t);
+        return new Le(t);
     }
     /** Returns whether this Precondition is empty. */    get isNone() {
         return void 0 === this.updateTime && void 0 === this.exists;
@@ -3347,12 +3377,12 @@ function Fe(t, e) {
  * applyToLocalView() to implement the actual behavior of applying the mutation
  * to some source document (see `setMutationApplyToRemoteDocument()` for an
  * example).
- */ class Le {}
+ */ class je {}
 
 /**
  * A mutation that creates or replaces the document at the given key with the
  * object value contents.
- */ class je extends Le {
+ */ class Ue extends je {
     constructor(t, e, n, r = []) {
         super(), this.key = t, this.value = e, this.precondition = n, this.fieldTransforms = r, 
         this.type = 0 /* MutationType.Set */;
@@ -3374,7 +3404,7 @@ function Fe(t, e) {
  *    is deleted.
  *  * When a field is not in the mask but is in the values, the values map is
  *    ignored.
- */ class Ue extends Le {
+ */ class Be extends je {
     constructor(t, e, n, r, s = []) {
         super(), this.key = t, this.data = e, this.fieldMask = n, this.precondition = r, 
         this.fieldTransforms = s, this.type = 1 /* MutationType.Patch */;
@@ -3384,7 +3414,7 @@ function Fe(t, e) {
     }
 }
 
-/** A mutation that deletes the document at the given key. */ class Be extends Le {
+/** A mutation that deletes the document at the given key. */ class Qe extends je {
     constructor(t, e) {
         super(), this.key = t, this.precondition = e, this.type = 2 /* MutationType.Delete */ , 
         this.fieldTransforms = [];
@@ -3400,7 +3430,7 @@ function Fe(t, e) {
  *
  * The `verify` operation is only used in Transactions, and this class serves
  * primarily to facilitate serialization into protos.
- */ class Qe extends Le {
+ */ class ze extends je {
     constructor(t, e) {
         super(), this.key = t, this.precondition = e, this.type = 3 /* MutationType.Verify */ , 
         this.fieldTransforms = [];
@@ -3425,13 +3455,13 @@ function Fe(t, e) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ const ze = (() => {
+ */ const We = (() => {
     const t = {
         asc: "ASCENDING",
         desc: "DESCENDING"
     };
     return t;
-})(), We = (() => {
+})(), Ge = (() => {
     const t = {
         "<": "LESS_THAN",
         "<=": "LESS_THAN_OR_EQUAL",
@@ -3445,7 +3475,7 @@ function Fe(t, e) {
         "array-contains-any": "ARRAY_CONTAINS_ANY"
     };
     return t;
-})(), Ge = (() => {
+})(), Ke = (() => {
     const t = {
         and: "AND",
         or: "OR"
@@ -3467,7 +3497,7 @@ function Fe(t, e) {
  * TODO(klimt): We can remove the databaseId argument if we keep the full
  * resource name in documents.
  */
-class Ke {
+class Ye {
     constructor(t, e) {
         this.databaseId = t, this.useProto3Json = e;
     }
@@ -3484,7 +3514,7 @@ class Ke {
 /**
  * Returns a value for a Date that's appropriate to put into a proto.
  */
-function Ye(t, e) {
+function He(t, e) {
     if (t.useProto3Json) {
         return `${new Date(1e3 * e.seconds).toISOString().replace(/\.\d*/, "").replace("Z", "")}.${("000000000" + e.nanoseconds).slice(-9)}Z`;
     }
@@ -3499,35 +3529,35 @@ function Ye(t, e) {
  *
  * Visible for testing.
  */
-function He(t, e) {
+function Je(t, e) {
     return t.useProto3Json ? e.toBase64() : e.toUint8Array();
 }
 
-function Je(t, e) {
-    return Ye(t, e.toTimestamp());
+function Xe(t, e) {
+    return He(t, e.toTimestamp());
 }
 
-function Xe(t) {
-    return A(!!t), de.fromTimestamp(function(t) {
-        const e = Ft(t);
-        return new qt(e.seconds, e.nanos);
+function Ze(t) {
+    return A(!!t), we.fromTimestamp(function(t) {
+        const e = xt(t);
+        return new Ot(e.seconds, e.nanos);
     }(t));
 }
 
-function Ze(t, e) {
+function tn(t, e) {
     return function(t) {
         return new nt([ "projects", t.projectId, "databases", t.database ]);
     }(t).child("documents").child(e).canonicalString();
 }
 
-function tn(t, e) {
-    return Ze(t.databaseId, e.path);
+function en(t, e) {
+    return tn(t.databaseId, e.path);
 }
 
-function en(t, e) {
+function nn(t, e) {
     const n = function(t) {
         const e = nt.fromString(t);
-        return A(mn(e)), e;
+        return A(pn(e)), e;
     }(e);
     if (n.get(1) !== t.databaseId.projectId) throw new B($, "Tried to deserialize key from different project: " + n.get(1) + " vs " + t.databaseId.projectId);
     if (n.get(3) !== t.databaseId.database) throw new B($, "Tried to deserialize key from different database: " + n.get(3) + " vs " + t.databaseId.database);
@@ -3535,98 +3565,98 @@ function en(t, e) {
     var r;
     /** Creates a Document proto from key and fields (but no create/update time) */}
 
-function nn(t, e) {
-    return Ze(t.databaseId, e);
+function rn(t, e) {
+    return tn(t.databaseId, e);
 }
 
-function rn(t) {
+function sn(t) {
     return new nt([ "projects", t.databaseId.projectId, "databases", t.databaseId.database ]).canonicalString();
 }
 
-function sn(t, e, n) {
+function on(t, e, n) {
     return {
-        name: tn(t, e),
+        name: en(t, e),
         fields: n.value.mapValue.fields
     };
 }
 
-function on(t, e) {
+function un(t, e) {
     return "found" in e ? function(t, e) {
         A(!!e.found), e.found.name, e.found.updateTime;
-        const n = en(t, e.found.name), r = Xe(e.found.updateTime), s = e.found.createTime ? Xe(e.found.createTime) : de.min(), i = new ve({
+        const n = nn(t, e.found.name), r = Ze(e.found.updateTime), s = e.found.createTime ? Ze(e.found.createTime) : we.min(), i = new be({
             mapValue: {
                 fields: e.found.fields
             }
         });
-        return be.newFoundDocument(n, r, s, i);
+        return Ee.newFoundDocument(n, r, s, i);
     }(t, e) : "missing" in e ? function(t, e) {
         A(!!e.missing), A(!!e.readTime);
-        const n = en(t, e.missing), r = Xe(e.readTime);
-        return be.newNoDocument(n, r);
+        const n = nn(t, e.missing), r = Ze(e.readTime);
+        return Ee.newNoDocument(n, r);
     }(t, e) : I();
 }
 
-function un(t, e) {
+function cn(t, e) {
     let n;
-    if (e instanceof je) n = {
-        update: sn(t, e.key, e.value)
+    if (e instanceof Ue) n = {
+        update: on(t, e.key, e.value)
+    }; else if (e instanceof Qe) n = {
+        delete: en(t, e.key)
     }; else if (e instanceof Be) n = {
-        delete: tn(t, e.key)
-    }; else if (e instanceof Ue) n = {
-        update: sn(t, e.key, e.data),
-        updateMask: wn(e.fieldMask)
+        update: on(t, e.key, e.data),
+        updateMask: mn(e.fieldMask)
     }; else {
-        if (!(e instanceof Qe)) return I();
+        if (!(e instanceof ze)) return I();
         n = {
-            verify: tn(t, e.key)
+            verify: en(t, e.key)
         };
     }
     return e.fieldTransforms.length > 0 && (n.updateTransforms = e.fieldTransforms.map((t => function(t, e) {
         const n = e.transform;
-        if (n instanceof Se) return {
+        if (n instanceof qe) return {
             fieldPath: e.field.canonicalString(),
             setToServerValue: "REQUEST_TIME"
         };
-        if (n instanceof qe) return {
+        if (n instanceof Oe) return {
             fieldPath: e.field.canonicalString(),
             appendMissingElements: {
                 values: n.elements
             }
         };
-        if (n instanceof Oe) return {
+        if (n instanceof ke) return {
             fieldPath: e.field.canonicalString(),
             removeAllFromArray: {
                 values: n.elements
             }
         };
-        if (n instanceof ke) return {
+        if (n instanceof Ce) return {
             fieldPath: e.field.canonicalString(),
             increment: n.k
         };
         throw I();
     }(0, t)))), e.precondition.isNone || (n.currentDocument = function(t, e) {
         return void 0 !== e.updateTime ? {
-            updateTime: Je(t, e.updateTime)
+            updateTime: Xe(t, e.updateTime)
         } : void 0 !== e.exists ? {
             exists: e.exists
         } : I();
     }(t, e.precondition)), n;
 }
 
-function cn(t, e) {
+function an(t, e) {
     // Dissect the path into parent, collectionId, and optional key filter.
     const n = {
         structuredQuery: {}
     }, r = e.path;
-    null !== e.collectionGroup ? (n.parent = nn(t, r), n.structuredQuery.from = [ {
+    null !== e.collectionGroup ? (n.parent = rn(t, r), n.structuredQuery.from = [ {
         collectionId: e.collectionGroup,
         allDescendants: !0
-    } ]) : (n.parent = nn(t, r.popLast()), n.structuredQuery.from = [ {
+    } ]) : (n.parent = rn(t, r.popLast()), n.structuredQuery.from = [ {
         collectionId: r.lastSegment()
     } ]);
     const s = function(t) {
         if (0 === t.length) return;
-        return dn(ee.create(t, "and" /* CompositeOperator.AND */));
+        return wn(ne.create(t, "and" /* CompositeOperator.AND */));
     }(e.filters);
     s && (n.structuredQuery.where = s);
     const i = function(t) {
@@ -3635,8 +3665,8 @@ function cn(t, e) {
         // visible for testing
         function(t) {
             return {
-                field: fn(t.field),
-                direction: an(t.dir)
+                field: dn(t.field),
+                direction: hn(t.dir)
             };
         }
         // visible for testing
@@ -3644,7 +3674,7 @@ function cn(t, e) {
     }(e.orderBy);
     i && (n.structuredQuery.orderBy = i);
     const o = function(t, e) {
-        return t.useProto3Json || wt(e) ? e : {
+        return t.useProto3Json || mt(e) ? e : {
             value: e
         };
     }(t, e.limit);
@@ -3662,81 +3692,81 @@ function cn(t, e) {
     (e.endAt)), n;
 }
 
-function an(t) {
-    return ze[t];
-}
-
-// visible for testing
 function hn(t) {
     return We[t];
 }
 
+// visible for testing
 function ln(t) {
     return Ge[t];
 }
 
 function fn(t) {
+    return Ke[t];
+}
+
+function dn(t) {
     return {
         fieldPath: t.canonicalString()
     };
 }
 
-function dn(t) {
-    return t instanceof te ? function(t) {
+function wn(t) {
+    return t instanceof ee ? function(t) {
         if ("==" /* Operator.EQUAL */ === t.op) {
-            if (Kt(t.value)) return {
+            if (Yt(t.value)) return {
                 unaryFilter: {
-                    field: fn(t.field),
+                    field: dn(t.field),
                     op: "IS_NAN"
                 }
             };
-            if (Gt(t.value)) return {
+            if (Kt(t.value)) return {
                 unaryFilter: {
-                    field: fn(t.field),
+                    field: dn(t.field),
                     op: "IS_NULL"
                 }
             };
         } else if ("!=" /* Operator.NOT_EQUAL */ === t.op) {
-            if (Kt(t.value)) return {
+            if (Yt(t.value)) return {
                 unaryFilter: {
-                    field: fn(t.field),
+                    field: dn(t.field),
                     op: "IS_NOT_NAN"
                 }
             };
-            if (Gt(t.value)) return {
+            if (Kt(t.value)) return {
                 unaryFilter: {
-                    field: fn(t.field),
+                    field: dn(t.field),
                     op: "IS_NOT_NULL"
                 }
             };
         }
         return {
             fieldFilter: {
-                field: fn(t.field),
-                op: hn(t.op),
+                field: dn(t.field),
+                op: ln(t.op),
                 value: t.value
             }
         };
-    }(t) : t instanceof ee ? function(t) {
-        const e = t.getFilters().map((t => dn(t)));
+    }(t) : t instanceof ne ? function(t) {
+        const e = t.getFilters().map((t => wn(t)));
         if (1 === e.length) return e[0];
         return {
             compositeFilter: {
-                op: ln(t.op),
+                op: fn(t.op),
                 filters: e
             }
         };
     }(t) : I();
 }
 
-function wn(t) {
+function mn(t) {
     const e = [];
     return t.fields.forEach((t => e.push(t.canonicalString()))), {
         fieldPaths: e
     };
 }
 
-function mn(t) {
+function pn(t) {
     // Resource names have at least 4 components (project ID, database ID)
     return t.length >= 4 && "projects" === t.get(0) && "databases" === t.get(2);
 }
@@ -3756,8 +3786,8 @@ function mn(t) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ function pn(t) {
-    return new Ke(t, /* useProto3Json= */ !0);
+ */ function yn(t) {
+    return new Ye(t, /* useProto3Json= */ !0);
 }
 
 /**
@@ -3785,7 +3815,7 @@ function mn(t) {
  * base delay. This prevents clients from accidentally synchronizing their
  * delays causing spikes of load to the backend.
  */
-class yn {
+class gn {
     constructor(
     /**
      * The AsyncQueue to run backoff operations on.
@@ -3883,7 +3913,7 @@ class yn {
  * An implementation of Datastore that exposes additional state for internal
  * consumption.
  */
-class gn extends class {} {
+class _n extends class {} {
     constructor(t, e, n, r) {
         super(), this.authCredentials = t, this.appCheckCredentials = e, this.connection = n, 
         this.serializer = r, this.J = !1;
@@ -3910,19 +3940,19 @@ class gn extends class {} {
 
 // TODO(firestorexp): Make sure there is only one Datastore instance per
 // firestore-exp client.
-async function _n(t, e) {
-    const n = T(t), r = rn(n.serializer) + "/documents", s = {
-        writes: e.map((t => un(n.serializer, t)))
+async function vn(t, e) {
+    const n = T(t), r = sn(n.serializer) + "/documents", s = {
+        writes: e.map((t => cn(n.serializer, t)))
     };
     await n.v("Commit", r, s);
 }
 
-async function vn(t, e) {
-    const n = T(t), r = rn(n.serializer) + "/documents", s = {
-        documents: e.map((t => tn(n.serializer, t)))
+async function bn(t, e) {
+    const n = T(t), r = sn(n.serializer) + "/documents", s = {
+        documents: e.map((t => en(n.serializer, t)))
     }, i = await n.R("BatchGetDocuments", r, s, e.length), o = new Map;
     i.forEach((t => {
-        const e = on(n.serializer, t);
+        const e = un(n.serializer, t);
         o.set(e.key.toString(), e);
     }));
     const u = [];
@@ -3932,24 +3962,24 @@ async function vn(t, e) {
     })), u;
 }
 
-async function bn(t, e) {
-    const n = T(t), r = cn(n.serializer, $e(e));
+async function En(t, e) {
+    const n = T(t), r = an(n.serializer, Ne(e));
     return (await n.R("RunQuery", r.parent, {
         structuredQuery: r.structuredQuery
     })).filter((t => !!t.document)).map((t => function(t, e, n) {
-        const r = en(t, e.name), s = Xe(e.updateTime), i = e.createTime ? Xe(e.createTime) : de.min(), o = new ve({
+        const r = nn(t, e.name), s = Ze(e.updateTime), i = e.createTime ? Ze(e.createTime) : we.min(), o = new be({
             mapValue: {
                 fields: e.fields
             }
-        }), u = be.newFoundDocument(r, s, i, o);
+        }), u = Ee.newFoundDocument(r, s, i, o);
         return n && u.setHasCommittedMutations(), n ? u.setHasCommittedMutations() : u;
     }(n.serializer, t.document, void 0)));
 }
 
-async function En(t, e, n) {
+async function In(t, e, n) {
     var r;
     const s = T(t), {request: i, Z: o} = function(t, e, n) {
-        const r = cn(t, e), s = {}, i = [];
+        const r = an(t, e), s = {}, i = [];
         let o = 0;
         return n.forEach((t => {
             // Map all client-side aliases to a unique short-form
@@ -3962,12 +3992,12 @@ async function En(t, e, n) {
             }) : "avg" === t.$ ? i.push({
                 alias: e,
                 avg: {
-                    field: fn(t.fieldPath)
+                    field: dn(t.fieldPath)
                 }
             }) : "sum" === t.$ && i.push({
                 alias: e,
                 sum: {
-                    field: fn(t.fieldPath)
+                    field: dn(t.fieldPath)
                 }
             });
         })), {
@@ -3980,7 +4010,7 @@ async function En(t, e, n) {
             },
             Z: s
         };
-    }(s.serializer, $e(e), n), u = i.parent;
+    }(s.serializer, Ne(e), n), u = i.parent;
     s.connection.g || delete i.parent;
     const c = (await s.R("RunAggregationQuery", u, i, /*expectedResponseCount=*/ 1)).filter((t => !!t.result));
     // Omit RunAggregationQueryResponse that only contain readTimes.
@@ -4007,7 +4037,7 @@ async function En(t, e, n) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ const In = new Map;
+ */ const An = new Map;
 
 /**
  * An instance map that ensures only one Datastore exists per Firestore
@@ -4018,17 +4048,17 @@ async function En(t, e, n) {
  * instance. Callers must invoke removeComponents() when the Firestore
  * instance is terminated.
  */
-function An(t) {
+function Tn(t) {
     if (t._terminated) throw new B(O, "The client has already been terminated.");
-    if (!In.has(t)) {
+    if (!An.has(t)) {
         _("ComponentProvider", "Initializing Datastore");
         const i = function(t) {
-            return new vt(t, fetch.bind(null));
+            return new bt(t, fetch.bind(null));
         }((e = t._databaseId, n = t.app.options.appId || "", r = t._persistenceKey, s = t._freezeSettings(), 
-        new Z(e, n, r, s.host, s.ssl, s.experimentalForceLongPolling, s.experimentalAutoDetectLongPolling, s.useFetchStreams))), o = pn(t._databaseId), u = function(t, e, n, r) {
-            return new gn(t, e, n, r);
+        new Z(e, n, r, s.host, s.ssl, s.experimentalForceLongPolling, s.experimentalAutoDetectLongPolling, ft(s.experimentalLongPollingOptions), s.useFetchStreams))), o = yn(t._databaseId), u = function(t, e, n, r) {
+            return new _n(t, e, n, r);
         }(t._authCredentials, t._appCheckCredentials, i, o);
-        In.set(t, u);
+        An.set(t, u);
     }
     var e, n, r, s;
     /**
@@ -4046,7 +4076,7 @@ function An(t) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */    return In.get(t);
+ */    return An.get(t);
 }
 
 /**
@@ -4058,9 +4088,9 @@ function An(t) {
  * user-supplied `FirestoreSettings` object. This is a separate type so that
  * defaults can be supplied and the value can be checked for equality.
  */
-class Tn {
+class Rn {
     constructor(t) {
-        var e;
+        var e, n;
         if (void 0 === t.host) {
             if (void 0 !== t.ssl) throw new B($, "Can't provide ssl option if host option is not set");
             this.host = "firestore.googleapis.com", this.ssl = true;
@@ -4073,19 +4103,20 @@ class Tn {
         !function(t, e, n, r) {
             if (!0 === e && !0 === r) throw new B($, `${t} and ${n} cannot be used together.`);
         }("experimentalForceLongPolling", t.experimentalForceLongPolling, "experimentalAutoDetectLongPolling", t.experimentalAutoDetectLongPolling), 
-        this.experimentalForceLongPolling = !!t.experimentalForceLongPolling, this.experimentalForceLongPolling ? this.experimentalAutoDetectLongPolling = !1 : void 0 === t.experimentalAutoDetectLongPolling ? this.experimentalAutoDetectLongPolling = false : 
+        this.experimentalForceLongPolling = !!t.experimentalForceLongPolling, this.experimentalForceLongPolling ? this.experimentalAutoDetectLongPolling = !1 : void 0 === t.experimentalAutoDetectLongPolling ? this.experimentalAutoDetectLongPolling = true : 
         // For backwards compatibility, coerce the value to boolean even though
         // the TypeScript compiler has narrowed the type to boolean already.
         // noinspection PointlessBooleanExpressionJS
         this.experimentalAutoDetectLongPolling = !!t.experimentalAutoDetectLongPolling, 
-        this.useFetchStreams = !!t.useFetchStreams;
-    }
-    isEqual(t) {
-        return this.host === t.host && this.ssl === t.ssl && this.credentials === t.credentials && this.cacheSizeBytes === t.cacheSizeBytes && this.experimentalForceLongPolling === t.experimentalForceLongPolling && this.experimentalAutoDetectLongPolling === t.experimentalAutoDetectLongPolling && this.ignoreUndefinedProperties === t.ignoreUndefinedProperties && this.useFetchStreams === t.useFetchStreams;
-    }
-}
-
-/**
+        this.experimentalLongPollingOptions = ft(null !== (n = t.experimentalLongPollingOptions) && void 0 !== n ? n : {}), 
+        function(t) {
+            if (void 0 !== t.timeoutSeconds) {
+                if (isNaN(t.timeoutSeconds)) throw new B($, `invalid long polling timeout: ${t.timeoutSeconds} (must not be NaN)`);
+                if (t.timeoutSeconds < 5) throw new B($, `invalid long polling timeout: ${t.timeoutSeconds} (minimum allowed value is 5)`);
+                if (t.timeoutSeconds > 30) throw new B($, `invalid long polling timeout: ${t.timeoutSeconds} (maximum allowed value is 30)`);
+            }
+        }
+        /**
  * @license
  * Copyright 2020 Google LLC
  *
@@ -4101,11 +4132,20 @@ class Tn {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
+        /**
  * The Cloud Firestore service interface.
  *
  * Do not call this constructor directly. Instead, use {@link (getFirestore:1)}.
- */ class Rn {
+ */ (this.experimentalLongPollingOptions), this.useFetchStreams = !!t.useFetchStreams;
+    }
+    isEqual(t) {
+        return this.host === t.host && this.ssl === t.ssl && this.credentials === t.credentials && this.cacheSizeBytes === t.cacheSizeBytes && this.experimentalForceLongPolling === t.experimentalForceLongPolling && this.experimentalAutoDetectLongPolling === t.experimentalAutoDetectLongPolling && (e = this.experimentalLongPollingOptions, 
+        n = t.experimentalLongPollingOptions, e.timeoutSeconds === n.timeoutSeconds) && this.ignoreUndefinedProperties === t.ignoreUndefinedProperties && this.useFetchStreams === t.useFetchStreams;
+        var e, n;
+    }
+}
+
+class Pn {
     /** @hideconstructor */
     constructor(t, e, n, r) {
         this._authCredentials = t, this._appCheckCredentials = e, this._databaseId = n, 
@@ -4113,7 +4153,7 @@ class Tn {
         /**
          * Whether it's a Firestore or Firestore Lite instance.
          */
-        this.type = "firestore-lite", this._persistenceKey = "(lite)", this._settings = new Tn({}), 
+        this.type = "firestore-lite", this._persistenceKey = "(lite)", this._settings = new Rn({}), 
         this._settingsFrozen = !1;
     }
     /**
@@ -4131,7 +4171,7 @@ class Tn {
     }
     _setSettings(t) {
         if (this._settingsFrozen) throw new B(O, "Firestore has already been started and its settings can no longer be changed. You can only modify settings before calling any other methods on a Firestore object.");
-        this._settings = new Tn(t), void 0 !== t.credentials && (this._authCredentials = function(t) {
+        this._settings = new Rn(t), void 0 !== t.credentials && (this._authCredentials = function(t) {
             if (!t) return new W;
             switch (t.type) {
               case "firstParty":
@@ -4169,13 +4209,13 @@ class Tn {
      * Only ever called once.
      */    _terminate() {
         return function(t) {
-            const e = In.get(t);
-            e && (_("ComponentProvider", "Removing Datastore"), In.delete(t), e.terminate());
+            const e = An.get(t);
+            e && (_("ComponentProvider", "Removing Datastore"), An.delete(t), e.terminate());
         }(this), Promise.resolve();
     }
 }
 
-function Pn(t, e, n) {
+function Vn(t, e, n) {
     n || (n = "(default)");
     const r = _getProvider(t, "firestore/lite");
     if (r.isInitialized(n)) throw new B(O, "Firestore can only be initialized once per app.");
@@ -4185,13 +4225,13 @@ function Pn(t, e, n) {
     });
 }
 
-function Vn(e, n) {
+function $n(e, n) {
     const r = "object" == typeof e ? e : t(), s = "string" == typeof e ? e : n || "(default)", i = _getProvider(r, "firestore/lite").getImmediate({
         identifier: s
     });
     if (!i._initialized) {
         const t = l("firestore");
-        t && $n(i, ...t);
+        t && Nn(i, ...t);
     }
     return i;
 }
@@ -4208,9 +4248,9 @@ function Vn(e, n) {
  * @param port - the emulator port (ex: 9000).
  * @param options.mockUserToken - the mock auth token to use for unit testing
  * Security Rules.
- */ function $n(t, e, n, r = {}) {
+ */ function Nn(t, e, n, r = {}) {
     var s;
-    const i = (t = ht(t, Rn))._getSettings();
+    const i = (t = ht(t, Pn))._getSettings();
     if ("firestore.googleapis.com" !== i.host && i.host !== e && b("Host has been set in both settings() and useEmulator(), emulator host will be used"), 
     t._setSettings(Object.assign(Object.assign({}, i), {
         host: `${e}:${n}`,
@@ -4248,8 +4288,8 @@ function Vn(e, n) {
  * @param firestore - The `Firestore` instance to terminate.
  * @returns A `Promise` that is resolved when the instance has been successfully
  * terminated.
- */ function Nn(t) {
-    return t = ht(t, Rn), e(t.app, "firestore/lite"), t._delete();
+ */ function Dn(t) {
+    return t = ht(t, Pn), e(t.app, "firestore/lite"), t._delete();
 }
 
 /**
@@ -4288,7 +4328,7 @@ function Vn(e, n) {
  * Represents an aggregation that can be performed by Firestore.
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-class Dn {
+class Fn {
     /**
      * Create a new AggregateField<T>
      * @param _aggregateType Specifies the type of aggregation operation to perform.
@@ -4306,7 +4346,7 @@ class Dn {
 
 /**
  * The results of executing an aggregation query.
- */ class Fn {
+ */ class xn {
     /** @hideconstructor */
     constructor(t, e, n) {
         this._userDataWriter = e, this._data = n, 
@@ -4348,7 +4388,7 @@ class Dn {
  * A `DocumentReference` refers to a document location in a Firestore database
  * and can be used to write, read, or listen to the location. The document at
  * the referenced location may or may not exist.
- */ class xn {
+ */ class Sn {
     /** @hideconstructor */
     constructor(t, 
     /**
@@ -4376,17 +4416,17 @@ class Dn {
     /**
      * The collection this `DocumentReference` belongs to.
      */    get parent() {
-        return new qn(this.firestore, this.converter, this._key.path.popLast());
+        return new On(this.firestore, this.converter, this._key.path.popLast());
     }
     withConverter(t) {
-        return new xn(this.firestore, t, this._key);
+        return new Sn(this.firestore, t, this._key);
     }
 }
 
 /**
  * A `Query` refers to a query which you can read or listen to. You can also
  * construct refined `Query` objects by adding filters and ordering.
- */ class Sn {
+ */ class qn {
     // This is the lite version of the Query class in the main SDK.
     /** @hideconstructor protected */
     constructor(t, 
@@ -4399,17 +4439,17 @@ class Dn {
         this.type = "query", this.firestore = t;
     }
     withConverter(t) {
-        return new Sn(this.firestore, t, this._query);
+        return new qn(this.firestore, t, this._query);
     }
 }
 
 /**
  * A `CollectionReference` object can be used for adding documents, getting
  * document references, and querying for documents (using {@link (query:1)}).
- */ class qn extends Sn {
+ */ class On extends qn {
     /** @hideconstructor */
     constructor(t, e, n) {
-        super(t, e, new Ae(n)), this._path = n, 
+        super(t, e, new Te(n)), this._path = n, 
         /** The type of this Firestore reference. */
         this.type = "collection";
     }
@@ -4427,23 +4467,23 @@ class Dn {
      * subcollection. If this isn't a subcollection, the reference is null.
      */    get parent() {
         const t = this._path.popLast();
-        return t.isEmpty() ? null : new xn(this.firestore, 
+        return t.isEmpty() ? null : new Sn(this.firestore, 
         /* converter= */ null, new it(t));
     }
     withConverter(t) {
-        return new qn(this.firestore, t, this._path);
+        return new On(this.firestore, t, this._path);
     }
 }
 
-function On(t, e, ...n) {
-    if (t = d(t), ot("collection", "path", e), t instanceof Rn) {
+function kn(t, e, ...n) {
+    if (t = d(t), ot("collection", "path", e), t instanceof Pn) {
         const r = nt.fromString(e, ...n);
-        return ct(r), new qn(t, /* converter= */ null, r);
+        return ct(r), new On(t, /* converter= */ null, r);
     }
     {
-        if (!(t instanceof xn || t instanceof qn)) throw new B($, "Expected first argument to collection() to be a CollectionReference, a DocumentReference or FirebaseFirestore");
+        if (!(t instanceof Sn || t instanceof On)) throw new B($, "Expected first argument to collection() to be a CollectionReference, a DocumentReference or FirebaseFirestore");
         const r = t._path.child(nt.fromString(e, ...n));
-        return ct(r), new qn(t.firestore, 
+        return ct(r), new On(t.firestore, 
         /* converter= */ null, r);
     }
 }
@@ -4460,27 +4500,27 @@ function On(t, e, ...n) {
  * collection or subcollection with this ID as the last segment of its path
  * will be included. Cannot contain a slash.
  * @returns The created `Query`.
- */ function kn(t, e) {
-    if (t = ht(t, Rn), ot("collectionGroup", "collection id", e), e.indexOf("/") >= 0) throw new B($, `Invalid collection ID '${e}' passed to function collectionGroup(). Collection IDs must not contain '/'.`);
-    return new Sn(t, 
+ */ function Cn(t, e) {
+    if (t = ht(t, Pn), ot("collectionGroup", "collection id", e), e.indexOf("/") >= 0) throw new B($, `Invalid collection ID '${e}' passed to function collectionGroup(). Collection IDs must not contain '/'.`);
+    return new qn(t, 
     /* converter= */ null, function(t) {
-        return new Ae(nt.emptyPath(), t);
+        return new Te(nt.emptyPath(), t);
     }(e));
 }
 
-function Cn(t, e, ...n) {
+function Mn(t, e, ...n) {
     if (t = d(t), 
     // We allow omission of 'pathString' but explicitly prohibit passing in both
     // 'undefined' and 'null'.
-    1 === arguments.length && (e = It.N()), ot("doc", "path", e), t instanceof Rn) {
+    1 === arguments.length && (e = At.N()), ot("doc", "path", e), t instanceof Pn) {
         const r = nt.fromString(e, ...n);
-        return ut(r), new xn(t, 
+        return ut(r), new Sn(t, 
         /* converter= */ null, new it(r));
     }
     {
-        if (!(t instanceof xn || t instanceof qn)) throw new B($, "Expected first argument to collection() to be a CollectionReference, a DocumentReference or FirebaseFirestore");
+        if (!(t instanceof Sn || t instanceof On)) throw new B($, "Expected first argument to collection() to be a CollectionReference, a DocumentReference or FirebaseFirestore");
         const r = t._path.child(nt.fromString(e, ...n));
-        return ut(r), new xn(t.firestore, t instanceof qn ? t.converter : null, new it(r));
+        return ut(r), new Sn(t.firestore, t instanceof On ? t.converter : null, new it(r));
     }
 }
 
@@ -4491,8 +4531,8 @@ function Cn(t, e, ...n) {
  * @param right - A reference to compare.
  * @returns true if the references point to the same location in the same
  * Firestore database.
- */ function Mn(t, e) {
-    return t = d(t), e = d(e), (t instanceof xn || t instanceof qn) && (e instanceof xn || e instanceof qn) && (t.firestore === e.firestore && t.path === e.path && t.converter === e.converter);
+ */ function Ln(t, e) {
+    return t = d(t), e = d(e), (t instanceof Sn || t instanceof On) && (e instanceof Sn || e instanceof On) && (t.firestore === e.firestore && t.path === e.path && t.converter === e.converter);
 }
 
 /**
@@ -4503,8 +4543,8 @@ function Cn(t, e, ...n) {
  * @param right - A `Query` to compare.
  * @returns true if the references point to the same location in the same
  * Firestore database.
- */ function Ln(t, e) {
-    return t = d(t), e = d(e), t instanceof Sn && e instanceof Sn && (t.firestore === e.firestore && De(t._query, e._query) && t.converter === e.converter);
+ */ function jn(t, e) {
+    return t = d(t), e = d(e), t instanceof qn && e instanceof qn && (t.firestore === e.firestore && Fe(t._query, e._query) && t.converter === e.converter);
 }
 
 /**
@@ -4525,7 +4565,7 @@ function Cn(t, e, ...n) {
  */
 /**
  * An immutable object representing an array of bytes.
- */ class jn {
+ */ class Un {
     /** @hideconstructor */
     constructor(t) {
         this._byteString = t;
@@ -4537,7 +4577,7 @@ function Cn(t, e, ...n) {
      * @param base64 - The Base64 string used to create the `Bytes` object.
      */    static fromBase64String(t) {
         try {
-            return new jn(Nt.fromBase64String(t));
+            return new Un(Dt.fromBase64String(t));
         } catch (t) {
             throw new B($, "Failed to construct data from Base64 string: " + t);
         }
@@ -4547,7 +4587,7 @@ function Cn(t, e, ...n) {
      *
      * @param array - The Uint8Array used to create the `Bytes` object.
      */    static fromUint8Array(t) {
-        return new jn(Nt.fromUint8Array(t));
+        return new Un(Dt.fromUint8Array(t));
     }
     /**
      * Returns the underlying bytes as a Base64-encoded string.
@@ -4603,7 +4643,7 @@ function Cn(t, e, ...n) {
  *
  * Create a `FieldPath` by providing field names. If more than one field
  * name is provided, the path will point to a nested field in a document.
- */ class Un {
+ */ class Bn {
     /**
      * Creates a `FieldPath` from the provided field names. If more than one field
      * name is provided, the path will point to a nested field in a document.
@@ -4627,8 +4667,8 @@ function Cn(t, e, ...n) {
 /**
  * Returns a special sentinel `FieldPath` to refer to the ID of a document.
  * It can be used in queries to sort or filter by the document ID.
- */ function Bn() {
-    return new Un("__name__");
+ */ function Qn() {
+    return new Bn("__name__");
 }
 
 /**
@@ -4650,7 +4690,7 @@ function Cn(t, e, ...n) {
 /**
  * Sentinel values that can be used when writing document fields with `set()`
  * or `update()`.
- */ class Qn {
+ */ class zn {
     /**
      * @param _methodName - The public API endpoint that returns this class.
      * @hideconstructor
@@ -4682,7 +4722,7 @@ function Cn(t, e, ...n) {
  *
  * Latitude values are in the range of [-90, 90].
  * Longitude values are in the range of [-180, 180].
- */ class zn {
+ */ class Wn {
     /**
      * Creates a new immutable `GeoPoint` object with the provided latitude and
      * longitude values.
@@ -4722,7 +4762,7 @@ function Cn(t, e, ...n) {
      * Actually private to JS consumers of our API, so this function is prefixed
      * with an underscore.
      */    _compareTo(t) {
-        return At(this._lat, t._lat) || At(this._long, t._long);
+        return Tt(this._lat, t._lat) || Tt(this._long, t._long);
     }
 }
 
@@ -4741,29 +4781,29 @@ function Cn(t, e, ...n) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ const Wn = /^__.*__$/;
+ */ const Gn = /^__.*__$/;
 
-/** The result of parsing document data (e.g. for a setData call). */ class Gn {
+/** The result of parsing document data (e.g. for a setData call). */ class Kn {
     constructor(t, e, n) {
         this.data = t, this.fieldMask = e, this.fieldTransforms = n;
     }
     toMutation(t, e) {
-        return null !== this.fieldMask ? new Ue(t, this.data, this.fieldMask, e, this.fieldTransforms) : new je(t, this.data, e, this.fieldTransforms);
+        return null !== this.fieldMask ? new Be(t, this.data, this.fieldMask, e, this.fieldTransforms) : new Ue(t, this.data, e, this.fieldTransforms);
     }
 }
 
-/** The result of parsing "update" data (i.e. for an updateData call). */ class Kn {
+/** The result of parsing "update" data (i.e. for an updateData call). */ class Yn {
     constructor(t, 
     // The fieldMask does not include document transforms.
     e, n) {
         this.data = t, this.fieldMask = e, this.fieldTransforms = n;
     }
     toMutation(t, e) {
-        return new Ue(t, this.data, this.fieldMask, e, this.fieldTransforms);
+        return new Be(t, this.data, this.fieldMask, e, this.fieldTransforms);
     }
 }
 
-function Yn(t) {
+function Hn(t) {
     switch (t) {
       case 0 /* UserDataSource.Set */ :
  // fall through
@@ -4781,7 +4821,7 @@ function Yn(t) {
     }
 }
 
-/** A "context" object passed around while parsing user data. */ class Hn {
+/** A "context" object passed around while parsing user data. */ class Jn {
     /**
      * Initializes a ParseContext with the given source and path.
      *
@@ -4813,7 +4853,7 @@ function Yn(t) {
         return this.settings.et;
     }
     /** Returns a new context with the specified settings overwritten. */    nt(t) {
-        return new Hn(Object.assign(Object.assign({}, this.settings), t), this.databaseId, this.serializer, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
+        return new Jn(Object.assign(Object.assign({}, this.settings), t), this.databaseId, this.serializer, this.ignoreUndefinedProperties, this.fieldTransforms, this.fieldMask);
     }
     rt(t) {
         var e;
@@ -4840,7 +4880,7 @@ function Yn(t) {
         });
     }
     ct(t) {
-        return pr(t, this.settings.methodName, this.settings.at || !1, this.path, this.settings.ht);
+        return yr(t, this.settings.methodName, this.settings.at || !1, this.path, this.settings.ht);
     }
     /** 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)));
@@ -4852,19 +4892,19 @@ function Yn(t) {
     }
     it(t) {
         if (0 === t.length) throw this.ct("Document fields must not be empty");
-        if (Yn(this.et) && Wn.test(t)) throw this.ct('Document fields cannot begin and end with "__"');
+        if (Hn(this.et) && Gn.test(t)) throw this.ct('Document fields cannot begin and end with "__"');
     }
 }
 
 /**
  * Helper for parsing raw user input (provided via the API) into internal model
  * classes.
- */ class Jn {
+ */ class Xn {
     constructor(t, e, n) {
-        this.databaseId = t, this.ignoreUndefinedProperties = e, this.serializer = n || pn(t);
+        this.databaseId = t, this.ignoreUndefinedProperties = e, this.serializer = n || yn(t);
     }
     /** Creates a new top-level parse context. */    lt(t, e, n, r = !1) {
-        return new Hn({
+        return new Jn({
             et: t,
             methodName: e,
             ht: n,
@@ -4875,29 +4915,29 @@ function Yn(t) {
     }
 }
 
-function Xn(t) {
-    const e = t._freezeSettings(), n = pn(t._databaseId);
-    return new Jn(t._databaseId, !!e.ignoreUndefinedProperties, n);
+function Zn(t) {
+    const e = t._freezeSettings(), n = yn(t._databaseId);
+    return new Xn(t._databaseId, !!e.ignoreUndefinedProperties, n);
 }
 
-/** Parse document data from a set() call. */ function Zn(t, e, n, r, s, i = {}) {
+/** Parse document data from a set() call. */ function tr(t, e, n, r, s, i = {}) {
     const o = t.lt(i.merge || i.mergeFields ? 2 /* UserDataSource.MergeSet */ : 0 /* UserDataSource.Set */ , e, n, s);
-    fr("Data must be an object, but it was:", o, r);
-    const u = hr(r, o);
+    dr("Data must be an object, but it was:", o, r);
+    const u = lr(r, o);
     let c, a;
-    if (i.merge) c = new _e(o.fieldMask), a = o.fieldTransforms; else if (i.mergeFields) {
+    if (i.merge) c = new ve(o.fieldMask), a = o.fieldTransforms; else if (i.mergeFields) {
         const t = [];
         for (const r of i.mergeFields) {
-            const s = dr(e, r, n);
+            const s = wr(e, r, n);
             if (!o.contains(s)) throw new B($, `Field '${s}' is specified in your field mask but missing from your input data.`);
-            yr(t, s) || t.push(s);
+            gr(t, s) || t.push(s);
         }
-        c = new _e(t), a = o.fieldTransforms.filter((t => c.covers(t.field)));
+        c = new ve(t), a = o.fieldTransforms.filter((t => c.covers(t.field)));
     } else c = null, a = o.fieldTransforms;
-    return new Gn(new ve(u), c, a);
+    return new Kn(new be(u), c, a);
 }
 
-class tr extends Qn {
+class er extends zn {
     _toFieldTransform(t) {
         if (2 /* UserDataSource.MergeSet */ !== t.et) throw 1 /* UserDataSource.Update */ === t.et ? t.ct(`${this._methodName}() can only appear at the top level of your update data`) : t.ct(`${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
@@ -4905,7 +4945,7 @@ class tr extends Qn {
         return t.fieldMask.push(t.path), null;
     }
     isEqual(t) {
-        return t instanceof tr;
+        return t instanceof er;
     }
 }
 
@@ -4924,8 +4964,8 @@ class tr extends Qn {
  *     context.
  * @param context - The parent context.
  * @param arrayElement - Whether or not the FieldValue has an array.
- */ function er(t, e, n) {
-    return new Hn({
+ */ function nr(t, e, n) {
+    return new Jn({
         et: 3 /* UserDataSource.Argument */ ,
         ht: e.settings.ht,
         methodName: t._methodName,
@@ -4933,23 +4973,23 @@ class tr extends Qn {
     }, e.databaseId, e.serializer, e.ignoreUndefinedProperties);
 }
 
-class nr extends Qn {
+class rr extends zn {
     _toFieldTransform(t) {
-        return new Ce(t.path, new Se);
+        return new Me(t.path, new qe);
     }
     isEqual(t) {
-        return t instanceof nr;
+        return t instanceof rr;
     }
 }
 
-class rr extends Qn {
+class sr extends zn {
     constructor(t, e) {
         super(t), this.ft = e;
     }
     _toFieldTransform(t) {
-        const e = er(this, t, 
-        /*array=*/ !0), n = this.ft.map((t => ar(t, e))), r = new qe(n);
-        return new Ce(t.path, r);
+        const e = nr(this, t, 
+        /*array=*/ !0), n = this.ft.map((t => hr(t, e))), r = new Oe(n);
+        return new Me(t.path, r);
     }
     isEqual(t) {
         // TODO(mrschmidt): Implement isEquals
@@ -4957,14 +4997,14 @@ class rr extends Qn {
     }
 }
 
-class sr extends Qn {
+class ir extends zn {
     constructor(t, e) {
         super(t), this.ft = e;
     }
     _toFieldTransform(t) {
-        const e = er(this, t, 
-        /*array=*/ !0), n = this.ft.map((t => ar(t, e))), r = new Oe(n);
-        return new Ce(t.path, r);
+        const e = nr(this, t, 
+        /*array=*/ !0), n = this.ft.map((t => hr(t, e))), r = new ke(n);
+        return new Me(t.path, r);
     }
     isEqual(t) {
         // TODO(mrschmidt): Implement isEquals
@@ -4972,13 +5012,13 @@ class sr extends Qn {
     }
 }
 
-class ir extends Qn {
+class or extends zn {
     constructor(t, e) {
         super(t), this.dt = e;
     }
     _toFieldTransform(t) {
-        const e = new ke(t.serializer, Fe(t.serializer, this.dt));
-        return new Ce(t.path, e);
+        const e = new Ce(t.serializer, xe(t.serializer, this.dt));
+        return new Me(t.path, e);
     }
     isEqual(t) {
         // TODO(mrschmidt): Implement isEquals
@@ -4986,50 +5026,50 @@ class ir extends Qn {
     }
 }
 
-/** Parse update data from an update() call. */ function or(t, e, n, r) {
+/** Parse update data from an update() call. */ function ur(t, e, n, r) {
     const s = t.lt(1 /* UserDataSource.Update */ , e, n);
-    fr("Data must be an object, but it was:", s, r);
-    const i = [], o = ve.empty();
-    Pt(r, ((t, r) => {
-        const u = mr(e, t, n);
+    dr("Data must be an object, but it was:", s, r);
+    const i = [], o = be.empty();
+    Vt(r, ((t, r) => {
+        const u = pr(e, t, n);
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 r = d(r);
         const c = s.ot(u);
-        if (r instanceof tr) 
+        if (r instanceof er) 
         // Add it to the field mask, but don't add anything to updateData.
         i.push(u); else {
-            const t = ar(r, c);
+            const t = hr(r, c);
             null != t && (i.push(u), o.set(u, t));
         }
     }));
-    const u = new _e(i);
-    return new Kn(o, u, s.fieldTransforms);
+    const u = new ve(i);
+    return new Yn(o, u, s.fieldTransforms);
 }
 
-/** Parse update data from a list of field/value arguments. */ function ur(t, e, n, r, s, i) {
-    const o = t.lt(1 /* UserDataSource.Update */ , e, n), u = [ dr(e, r, n) ], c = [ s ];
+/** Parse update data from a list of field/value arguments. */ function cr(t, e, n, r, s, i) {
+    const o = t.lt(1 /* UserDataSource.Update */ , e, n), u = [ wr(e, r, n) ], c = [ s ];
     if (i.length % 2 != 0) throw new B($, `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(dr(e, i[t])), c.push(i[t + 1]);
-    const a = [], h = ve.empty();
+    for (let t = 0; t < i.length; t += 2) u.push(wr(e, i[t])), c.push(i[t + 1]);
+    const a = [], h = be.empty();
     // We iterate in reverse order to pick the last value for a field if the
     // user specified the field multiple times.
-    for (let t = u.length - 1; t >= 0; --t) if (!yr(a, u[t])) {
+    for (let t = u.length - 1; t >= 0; --t) if (!gr(a, u[t])) {
         const e = u[t];
         let n = c[t];
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 n = d(n);
         const r = o.ot(e);
-        if (n instanceof tr) 
+        if (n instanceof er) 
         // Add it to the field mask, but don't add anything to updateData.
         a.push(e); else {
-            const t = ar(n, r);
+            const t = hr(n, r);
             null != t && (a.push(e), h.set(e, t));
         }
     }
-    const l = new _e(a);
-    return new Kn(h, l, o.fieldTransforms);
+    const l = new ve(a);
+    return new Yn(h, l, o.fieldTransforms);
 }
 
 /**
@@ -5038,8 +5078,8 @@ class ir extends Qn {
  *
  * @param allowArrays - Whether the query value is an array that may directly
  * contain additional arrays (e.g. the operand of an `in` query).
- */ function cr(t, e, n, r = !1) {
-    return ar(n, t.lt(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , e));
+ */ function ar(t, e, n, r = !1) {
+    return hr(n, t.lt(r ? 4 /* UserDataSource.ArrayArgument */ : 3 /* UserDataSource.Argument */ , e));
 }
 
 /**
@@ -5050,12 +5090,12 @@ class ir extends Qn {
  * the source of the data being parsed, etc.
  * @returns The parsed value, or null if the value was a FieldValue sentinel
  * that should not be included in the resulting parsed data.
- */ function ar(t, e) {
-    if (lr(
+ */ function hr(t, e) {
+    if (fr(
     // Unwrap the API type from the Compat SDK. This will return the API type
     // from firestore-exp.
-    t = d(t))) return fr("Unsupported field value:", e, t), hr(t, e);
-    if (t instanceof Qn) 
+    t = d(t))) return dr("Unsupported field value:", e, t), lr(t, e);
+    if (t instanceof zn) 
     // FieldValues usually parse into transforms (except deleteField())
     // in which case we do not want to include this field in our parsed data
     // (as doing so will overwrite the field directly prior to the transform
@@ -5067,7 +5107,7 @@ class ir extends Qn {
  */
     return function(t, e) {
         // Sentinels are only supported with writes, and not within arrays.
-        if (!Yn(e.et)) throw e.ct(`${t._methodName}() can only be used with update() and set()`);
+        if (!Hn(e.et)) throw e.ct(`${t._methodName}() can only be used with update() and set()`);
         if (!e.path) throw e.ct(`${t._methodName}() is not currently supported inside arrays`);
         const n = t._toFieldTransform(e);
         n && e.fieldTransforms.push(n);
@@ -5097,7 +5137,7 @@ class ir extends Qn {
             const n = [];
             let r = 0;
             for (const s of t) {
-                let t = ar(s, e.ut(r));
+                let t = hr(s, e.ut(r));
                 null == t && (
                 // Just include nulls in the array for fields being replaced with a
                 // sentinel.
@@ -5116,7 +5156,7 @@ class ir extends Qn {
         if (null === (t = d(t))) return {
             nullValue: "NULL_VALUE"
         };
-        if ("number" == typeof t) return Fe(e.serializer, t);
+        if ("number" == typeof t) return xe(e.serializer, t);
         if ("boolean" == typeof t) return {
             booleanValue: t
         };
@@ -5124,34 +5164,34 @@ class ir extends Qn {
             stringValue: t
         };
         if (t instanceof Date) {
-            const n = qt.fromDate(t);
+            const n = Ot.fromDate(t);
             return {
-                timestampValue: Ye(e.serializer, n)
+                timestampValue: He(e.serializer, n)
             };
         }
-        if (t instanceof qt) {
+        if (t instanceof Ot) {
             // Firestore backend truncates precision down to microseconds. To ensure
             // offline mode works the same with regards to truncation, perform the
             // truncation immediately without waiting for the backend to do that.
-            const n = new qt(t.seconds, 1e3 * Math.floor(t.nanoseconds / 1e3));
+            const n = new Ot(t.seconds, 1e3 * Math.floor(t.nanoseconds / 1e3));
             return {
-                timestampValue: Ye(e.serializer, n)
+                timestampValue: He(e.serializer, n)
             };
         }
-        if (t instanceof zn) return {
+        if (t instanceof Wn) return {
             geoPointValue: {
                 latitude: t.latitude,
                 longitude: t.longitude
             }
         };
-        if (t instanceof jn) return {
-            bytesValue: He(e.serializer, t._byteString)
+        if (t instanceof Un) return {
+            bytesValue: Je(e.serializer, t._byteString)
         };
-        if (t instanceof xn) {
+        if (t instanceof Sn) {
             const n = e.databaseId, r = t.firestore._databaseId;
             if (!r.isEqual(n)) throw e.ct(`Document reference is for database ${r.projectId}/${r.database} but should be for database ${n.projectId}/${n.database}`);
             return {
-                referenceValue: Ze(t.firestore._databaseId || e.databaseId, t._key.path)
+                referenceValue: tn(t.firestore._databaseId || e.databaseId, t._key.path)
             };
         }
         throw e.ct(`Unsupported field value: ${at(t)}`);
@@ -5165,13 +5205,13 @@ class ir extends Qn {
  */ (t, e);
 }
 
-function hr(t, e) {
+function lr(t, e) {
     const n = {};
     return !function(t) {
         for (const e in t) if (Object.prototype.hasOwnProperty.call(t, e)) return !1;
         return !0;
-    }(t) ? Pt(t, ((t, r) => {
-        const s = ar(r, e.rt(t));
+    }(t) ? Vt(t, ((t, r) => {
+        const s = hr(r, e.rt(t));
         null != s && (n[t] = s);
     })) : 
     // If we encounter an empty object, we explicitly add it to the update
@@ -5183,12 +5223,12 @@ function hr(t, e) {
     };
 }
 
-function lr(t) {
-    return !("object" != typeof t || null === t || t instanceof Array || t instanceof Date || t instanceof qt || t instanceof zn || t instanceof jn || t instanceof xn || t instanceof Qn);
+function fr(t) {
+    return !("object" != typeof t || null === t || t instanceof Array || t instanceof Date || t instanceof Ot || t instanceof Wn || t instanceof Un || t instanceof Sn || t instanceof zn);
 }
 
-function fr(t, e, n) {
-    if (!lr(n) || !function(t) {
+function dr(t, e, n) {
+    if (!fr(n) || !function(t) {
         return "object" == typeof t && null !== t && (Object.getPrototypeOf(t) === Object.prototype || null === Object.getPrototypeOf(t));
     }(n)) {
         const r = at(n);
@@ -5198,20 +5238,20 @@ function fr(t, e, n) {
 
 /**
  * Helper that calls fromDotSeparatedString() but wraps any error thrown.
- */ function dr(t, e, n) {
+ */ function wr(t, e, n) {
     if ((
     // If required, replace the FieldPath Compat class with with the firestore-exp
     // FieldPath.
-    e = d(e)) instanceof Un) return e._internalPath;
-    if ("string" == typeof e) return mr(t, e);
-    throw pr("Field path arguments must be of type string or ", t, 
+    e = d(e)) instanceof Bn) return e._internalPath;
+    if ("string" == typeof e) return pr(t, e);
+    throw yr("Field path arguments must be of type string or ", t, 
     /* hasConverter= */ !1, 
     /* path= */ void 0, n);
 }
 
 /**
  * Matches any characters in a field path string that are reserved.
- */ const wr = new RegExp("[~\\*/\\[\\]]");
+ */ const mr = new RegExp("[~\\*/\\[\\]]");
 
 /**
  * Wraps fromDotSeparatedString with an error message about the method that
@@ -5221,20 +5261,20 @@ function fr(t, e, n) {
  * split on dots.
  * @param targetDoc - The document against which the field path will be
  * evaluated.
- */ function mr(t, e, n) {
-    if (e.search(wr) >= 0) throw pr(`Invalid field path (${e}). Paths must not contain '~', '*', '/', '[', or ']'`, t, 
+ */ function pr(t, e, n) {
+    if (e.search(mr) >= 0) throw yr(`Invalid field path (${e}). Paths must not contain '~', '*', '/', '[', or ']'`, t, 
     /* hasConverter= */ !1, 
     /* path= */ void 0, n);
     try {
-        return new Un(...e.split("."))._internalPath;
+        return new Bn(...e.split("."))._internalPath;
     } catch (r) {
-        throw pr(`Invalid field path (${e}). Paths must not be empty, begin with '.', end with '.', or contain '..'`, t, 
+        throw yr(`Invalid field path (${e}). Paths must not be empty, begin with '.', end with '.', or contain '..'`, t, 
         /* hasConverter= */ !1, 
         /* path= */ void 0, n);
     }
 }
 
-function pr(t, e, n, r, s) {
+function yr(t, e, n, r, s) {
     const i = r && !r.isEmpty(), o = void 0 !== s;
     let u = `Function ${e}() called with invalid data`;
     n && (u += " (via `toFirestore()`)"), u += ". ";
@@ -5243,7 +5283,7 @@ function pr(t, e, n, r, s) {
     c += ")"), new B($, u + t + c);
 }
 
-/** Checks `haystack` if FieldPath `needle` is present. Runs in O(n). */ function yr(t, e) {
+/** Checks `haystack` if FieldPath `needle` is present. Runs in O(n). */ function gr(t, e) {
     return t.some((t => t.isEqual(e)));
 }
 
@@ -5271,7 +5311,7 @@ function pr(t, e, n, r, s) {
  * For a `DocumentSnapshot` that points to a non-existing document, any data
  * access will return 'undefined'. You can use the `exists()` method to
  * explicitly verify a document's existence.
- */ class gr {
+ */ class _r {
     // Note: This class is stripped down version of the DocumentSnapshot in
     // the legacy SDK. The changes are:
     // - No support for SnapshotMetadata.
@@ -5287,7 +5327,7 @@ function pr(t, e, n, r, s) {
     /**
      * The `DocumentReference` for the document included in the `DocumentSnapshot`.
      */    get ref() {
-        return new xn(this._firestore, this._converter, this._key);
+        return new Sn(this._firestore, this._converter, this._key);
     }
     /**
      * Signals whether or not the document at the snapshot's location exists.
@@ -5307,7 +5347,7 @@ function pr(t, e, n, r, s) {
             if (this._converter) {
                 // We only want to use the converter and create a new DocumentSnapshot
                 // if a converter has been provided.
-                const t = new _r(this._firestore, this._userDataWriter, this._key, this._document, 
+                const t = new vr(this._firestore, this._userDataWriter, this._key, this._document, 
                 /* converter= */ null);
                 return this._converter.fromFirestore(t);
             }
@@ -5327,7 +5367,7 @@ function pr(t, e, n, r, s) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     get(t) {
         if (this._document) {
-            const e = this._document.data.field(Er("DocumentSnapshot.get", t));
+            const e = this._document.data.field(Ir("DocumentSnapshot.get", t));
             if (null !== e) return this._userDataWriter.convertValue(e);
         }
     }
@@ -5343,7 +5383,7 @@ function pr(t, e, n, r, s) {
  * `DocumentSnapshot`. Since query results contain only existing documents, the
  * `exists` property will always be true and `data()` will never return
  * 'undefined'.
- */ class _r extends gr {
+ */ class vr extends _r {
     /**
      * Retrieves all fields in the document as an `Object`.
      *
@@ -5361,7 +5401,7 @@ function pr(t, e, n, r, s) {
  * array via the `docs` property or enumerated using the `forEach` method. The
  * number of documents can be determined via the `empty` and `size`
  * properties.
- */ class vr {
+ */ class br {
     /** @hideconstructor */
     constructor(t, e) {
         this._docs = e, this.query = t;
@@ -5392,14 +5432,14 @@ function pr(t, e, n, r, s) {
  * @param left - A snapshot to compare.
  * @param right - A snapshot to compare.
  * @returns true if the snapshots are equal.
- */ function br(t, e) {
-    return t = d(t), e = d(e), t instanceof gr && e instanceof gr ? t._firestore === e._firestore && t._key.isEqual(e._key) && (null === t._document ? null === e._document : t._document.isEqual(e._document)) && t._converter === e._converter : t instanceof vr && e instanceof vr && (Ln(t.query, e.query) && Tt(t.docs, e.docs, br));
+ */ function Er(t, e) {
+    return t = d(t), e = d(e), t instanceof _r && e instanceof _r ? t._firestore === e._firestore && t._key.isEqual(e._key) && (null === t._document ? null === e._document : t._document.isEqual(e._document)) && t._converter === e._converter : t instanceof br && e instanceof br && (jn(t.query, e.query) && Rt(t.docs, e.docs, Er));
 }
 
 /**
  * Helper that calls `fromDotSeparatedString()` but wraps any error thrown.
- */ function Er(t, e) {
-    return "string" == typeof e ? mr(t, e) : e instanceof Un ? e._internalPath : e._delegate._internalPath;
+ */ function Ir(t, e) {
+    return "string" == typeof e ? pr(t, e) : e instanceof Bn ? e._internalPath : e._delegate._internalPath;
 }
 
 /**
@@ -5422,7 +5462,7 @@ function pr(t, e, n, r, s) {
  * An `AppliableConstraint` is an abstraction of a constraint that can be applied
  * to a Firestore query.
  */
-class Ir {}
+class Ar {}
 
 /**
  * A `QueryConstraint` is used to narrow the set of documents returned by a
@@ -5431,12 +5471,12 @@ class Ir {}
  * (endBefore:1)}, {@link (endAt:1)}, {@link limit}, {@link limitToLast} and
  * can then be passed to {@link (query:1)} to create a new query instance that
  * also contains this `QueryConstraint`.
- */ class Ar extends Ir {}
+ */ class Tr extends Ar {}
 
-function Tr(t, e, ...n) {
+function Rr(t, e, ...n) {
     let r = [];
-    e instanceof Ir && r.push(e), r = r.concat(n), function(t) {
-        const e = t.filter((t => t instanceof Vr)).length, n = t.filter((t => t instanceof Rr)).length;
+    e instanceof Ar && r.push(e), r = r.concat(n), function(t) {
+        const e = t.filter((t => t instanceof $r)).length, n = t.filter((t => t instanceof Pr)).length;
         if (e > 1 || e > 0 && n > 0) throw new B($, "InvalidQuery. When using composite filters, you cannot use more than one filter at the top level. Consider nesting the multiple filters within an `and(...)` statement. For example: change `query(query, where(...), or(...))` to `query(query, and(where(...), or(...)))`.");
     }
     /**
@@ -5471,7 +5511,7 @@ function Tr(t, e, ...n) {
  * `QueryFieldFilterConstraint`s are created by invoking {@link where} and can then
  * be passed to {@link (query:1)} to create a new query instance that also contains
  * this `QueryFieldFilterConstraint`.
- */ class Rr extends Ar {
+ */ class Pr extends Tr {
     /**
      * @internal
      */
@@ -5481,31 +5521,31 @@ function Tr(t, e, ...n) {
         this.type = "where";
     }
     static _create(t, e, n) {
-        return new Rr(t, e, n);
+        return new Pr(t, e, n);
     }
     _apply(t) {
         const e = this._parse(t);
-        return zr(t._query, e), new Sn(t.firestore, t.converter, Ne(t._query, e));
+        return Wr(t._query, e), new qn(t.firestore, t.converter, De(t._query, e));
     }
     _parse(t) {
-        const e = Xn(t.firestore), n = function(t, e, n, r, s, i, o) {
+        const e = Zn(t.firestore), n = function(t, e, n, r, s, i, o) {
             let u;
             if (s.isKeyField()) {
                 if ("array-contains" /* Operator.ARRAY_CONTAINS */ === i || "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */ === i) throw new B($, `Invalid Query. You can't perform '${i}' queries on documentId().`);
                 if ("in" /* Operator.IN */ === i || "not-in" /* Operator.NOT_IN */ === i) {
-                    Qr(o, i);
+                    zr(o, i);
                     const e = [];
-                    for (const n of o) e.push(Br(r, t, n));
+                    for (const n of o) e.push(Qr(r, t, n));
                     u = {
                         arrayValue: {
                             values: e
                         }
                     };
-                } else u = Br(r, t, o);
-            } else "in" /* Operator.IN */ !== i && "not-in" /* Operator.NOT_IN */ !== i && "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */ !== i || Qr(o, i), 
-            u = cr(n, e, o, 
+                } else u = Qr(r, t, o);
+            } else "in" /* Operator.IN */ !== i && "not-in" /* Operator.NOT_IN */ !== i && "array-contains-any" /* Operator.ARRAY_CONTAINS_ANY */ !== i || zr(o, i), 
+            u = ar(n, e, o, 
             /* allowArrays= */ "in" /* Operator.IN */ === i || "not-in" /* Operator.NOT_IN */ === i);
-            return te.create(s, i, u);
+            return ee.create(s, i, u);
         }(t._query, "where", e, t.firestore._databaseId, this._field, this._op, this._value);
         return n;
     }
@@ -5521,9 +5561,9 @@ function Tr(t, e, ...n) {
  *   "&lt;=", "!=").
  * @param value - The value for comparison
  * @returns The created {@link QueryFieldFilterConstraint}.
- */ function Pr(t, e, n) {
-    const r = e, s = Er("where", t);
-    return Rr._create(s, r, n);
+ */ function Vr(t, e, n) {
+    const r = e, s = Ir("where", t);
+    return Pr._create(s, r, n);
 }
 
 /**
@@ -5533,7 +5573,7 @@ function Tr(t, e, ...n) {
  * `QueryCompositeFilterConstraint`s are created by invoking {@link or} or
  * {@link and} and can then be passed to {@link (query:1)} to create a new query
  * instance that also contains the `QueryCompositeFilterConstraint`.
- */ class Vr extends Ir {
+ */ class $r extends Ar {
     /**
      * @internal
      */
@@ -5543,22 +5583,22 @@ function Tr(t, e, ...n) {
         super(), this.type = t, this._queryConstraints = e;
     }
     static _create(t, e) {
-        return new Vr(t, e);
+        return new $r(t, e);
     }
     _parse(t) {
         const e = this._queryConstraints.map((e => e._parse(t))).filter((t => t.getFilters().length > 0));
-        return 1 === e.length ? e[0] : ee.create(e, this._getOperator());
+        return 1 === e.length ? e[0] : ne.create(e, this._getOperator());
     }
     _apply(t) {
         const e = this._parse(t);
         return 0 === e.getFilters().length ? t : (function(t, e) {
             let n = t;
             const r = e.getFlattenedFilters();
-            for (const t of r) zr(n, t), n = Ne(n, t);
+            for (const t of r) Wr(n, t), n = De(n, t);
         }
         // Checks if any of the provided filter operators are included in the given list of filters and
         // returns the first one that is, or null if none are.
-        (t._query, e), new Sn(t.firestore, t.converter, Ne(t._query, e)));
+        (t._query, e), new qn(t.firestore, t.converter, De(t._query, e)));
     }
     _getQueryConstraints() {
         return this._queryConstraints;
@@ -5577,9 +5617,9 @@ function Tr(t, e, ...n) {
  * {@link QueryFilterConstraint}s to perform a disjunction for. These must be
  * created with calls to {@link where}, {@link or}, or {@link and}.
  * @returns The newly created {@link QueryCompositeFilterConstraint}.
- */ function $r(...t) {
+ */ function Nr(...t) {
     // Only support QueryFilterConstraints
-    return t.forEach((t => Gr("or", t))), Vr._create("or" /* CompositeOperator.OR */ , t);
+    return t.forEach((t => Kr("or", t))), $r._create("or" /* CompositeOperator.OR */ , t);
 }
 
 /**
@@ -5591,9 +5631,9 @@ function Tr(t, e, ...n) {
  * {@link QueryFilterConstraint}s to perform a conjunction for. These must be
  * created with calls to {@link where}, {@link or}, or {@link and}.
  * @returns The newly created {@link QueryCompositeFilterConstraint}.
- */ function Nr(...t) {
+ */ function Dr(...t) {
     // Only support QueryFilterConstraints
-    return t.forEach((t => Gr("and", t))), Vr._create("and" /* CompositeOperator.AND */ , t);
+    return t.forEach((t => Kr("and", t))), $r._create("and" /* CompositeOperator.AND */ , t);
 }
 
 /**
@@ -5604,7 +5644,7 @@ function Tr(t, e, ...n) {
  *
  * Note: Documents that do not contain the orderBy field will not be present in
  * the query result.
- */ class Dr extends Ar {
+ */ class Fr extends Tr {
     /**
      * @internal
      */
@@ -5614,18 +5654,18 @@ function Tr(t, e, ...n) {
         this.type = "orderBy";
     }
     static _create(t, e) {
-        return new Dr(t, e);
+        return new Fr(t, e);
     }
     _apply(t) {
         const e = function(t, e, n) {
             if (null !== t.startAt) throw new B($, "Invalid query. You must not call startAt() or startAfter() before calling orderBy().");
             if (null !== t.endAt) throw new B($, "Invalid query. You must not call endAt() or endBefore() before calling orderBy().");
-            const r = new le(e, n);
+            const r = new fe(e, n);
             return function(t, e) {
-                if (null === Te(t)) {
+                if (null === Re(t)) {
                     // This is the first order by. It must match any inequality.
-                    const n = Re(t);
-                    null !== n && Wr(t, n, e.field);
+                    const n = Pe(t);
+                    null !== n && Gr(t, n, e.field);
                 }
             }(t, r), r;
         }
@@ -5640,10 +5680,10 @@ function Tr(t, e, ...n) {
  * of the query or if any of the fields in the order by are an uncommitted
  * server timestamp.
  */ (t._query, this._field, this._direction);
-        return new Sn(t.firestore, t.converter, function(t, e) {
+        return new qn(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 ]);
-            return new Ae(t.path, t.collectionGroup, n, t.filters.slice(), t.limit, t.limitType, t.startAt, t.endAt);
+            return new Te(t.path, t.collectionGroup, n, t.filters.slice(), t.limit, t.limitType, t.startAt, t.endAt);
         }(t._query, e));
     }
 }
@@ -5659,9 +5699,9 @@ function Tr(t, e, ...n) {
  * @param directionStr - Optional direction to sort by ('asc' or 'desc'). If
  * not specified, order will be ascending.
  * @returns The created {@link QueryOrderByConstraint}.
- */ function Fr(t, e = "asc") {
-    const n = e, r = Er("orderBy", t);
-    return Dr._create(r, n);
+ */ function xr(t, e = "asc") {
+    const n = e, r = Ir("orderBy", t);
+    return Fr._create(r, n);
 }
 
 /**
@@ -5670,7 +5710,7 @@ function Tr(t, e, ...n) {
  * `QueryLimitConstraint`s are created by invoking {@link limit} or
  * {@link limitToLast} and can then be passed to {@link (query:1)} to create a new
  * query instance that also contains this `QueryLimitConstraint`.
- */ class xr extends Ar {
+ */ class Sr extends Tr {
     /**
      * @internal
      */
@@ -5680,11 +5720,11 @@ function Tr(t, e, ...n) {
         super(), this.type = t, this._limit = e, this._limitType = n;
     }
     static _create(t, e, n) {
-        return new xr(t, e, n);
+        return new Sr(t, e, n);
     }
     _apply(t) {
-        return new Sn(t.firestore, t.converter, function(t, e, n) {
-            return new Ae(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), e, n, t.startAt, t.endAt);
+        return new qn(t.firestore, t.converter, function(t, e, n) {
+            return new Te(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), e, n, t.startAt, t.endAt);
         }(t._query, this._limit, this._limitType));
     }
 }
@@ -5695,8 +5735,8 @@ function Tr(t, e, ...n) {
  *
  * @param limit - The maximum number of items to return.
  * @returns The created {@link QueryLimitConstraint}.
- */ function Sr(t) {
-    return lt("limit", t), xr._create("limit", t, "F" /* LimitType.First */);
+ */ function qr(t) {
+    return lt("limit", t), Sr._create("limit", t, "F" /* LimitType.First */);
 }
 
 /**
@@ -5708,8 +5748,8 @@ function Tr(t, e, ...n) {
  *
  * @param limit - The maximum number of items to return.
  * @returns The created {@link QueryLimitConstraint}.
- */ function qr(t) {
-    return lt("limitToLast", t), xr._create("limitToLast", t, "L" /* LimitType.Last */);
+ */ function Or(t) {
+    return lt("limitToLast", t), Sr._create("limitToLast", t, "L" /* LimitType.Last */);
 }
 
 /**
@@ -5718,7 +5758,7 @@ function Tr(t, e, ...n) {
  * `QueryStartAtConstraint`s are created by invoking {@link (startAt:1)} or
  * {@link (startAfter:1)} and can then be passed to {@link (query:1)} to create a
  * new query instance that also contains this `QueryStartAtConstraint`.
- */ class Or extends Ar {
+ */ class kr extends Tr {
     /**
      * @internal
      */
@@ -5728,23 +5768,23 @@ function Tr(t, e, ...n) {
         super(), this.type = t, this._docOrFields = e, this._inclusive = n;
     }
     static _create(t, e, n) {
-        return new Or(t, e, n);
+        return new kr(t, e, n);
     }
     _apply(t) {
-        const e = Ur(t, this.type, this._docOrFields, this._inclusive);
-        return new Sn(t.firestore, t.converter, function(t, e) {
-            return new Ae(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, e, t.endAt);
+        const e = Br(t, this.type, this._docOrFields, this._inclusive);
+        return new qn(t.firestore, t.converter, function(t, e) {
+            return new Te(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, e, t.endAt);
         }(t._query, e));
     }
 }
 
-function kr(...t) {
-    return Or._create("startAt", t, 
+function Cr(...t) {
+    return kr._create("startAt", t, 
     /*inclusive=*/ !0);
 }
 
-function Cr(...t) {
-    return Or._create("startAfter", t, 
+function Mr(...t) {
+    return kr._create("startAfter", t, 
     /*inclusive=*/ !1);
 }
 
@@ -5754,7 +5794,7 @@ function Cr(...t) {
  * `QueryEndAtConstraint`s are created by invoking {@link (endAt:1)} or
  * {@link (endBefore:1)} and can then be passed to {@link (query:1)} to create a new
  * query instance that also contains this `QueryEndAtConstraint`.
- */ class Mr extends Ar {
+ */ class Lr extends Tr {
     /**
      * @internal
      */
@@ -5764,28 +5804,28 @@ function Cr(...t) {
         super(), this.type = t, this._docOrFields = e, this._inclusive = n;
     }
     static _create(t, e, n) {
-        return new Mr(t, e, n);
+        return new Lr(t, e, n);
     }
     _apply(t) {
-        const e = Ur(t, this.type, this._docOrFields, this._inclusive);
-        return new Sn(t.firestore, t.converter, function(t, e) {
-            return new Ae(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, t.startAt, e);
+        const e = Br(t, this.type, this._docOrFields, this._inclusive);
+        return new qn(t.firestore, t.converter, function(t, e) {
+            return new Te(t.path, t.collectionGroup, t.explicitOrderBy.slice(), t.filters.slice(), t.limit, t.limitType, t.startAt, e);
         }(t._query, e));
     }
 }
 
-function Lr(...t) {
-    return Mr._create("endBefore", t, 
+function jr(...t) {
+    return Lr._create("endBefore", t, 
     /*inclusive=*/ !1);
 }
 
-function jr(...t) {
-    return Mr._create("endAt", t, 
+function Ur(...t) {
+    return Lr._create("endAt", t, 
     /*inclusive=*/ !0);
 }
 
-/** Helper function to create a bound from a document or fields */ function Ur(t, e, n, r) {
-    if (n[0] = d(n[0]), n[0] instanceof gr) return function(t, e, n, r, s) {
+/** Helper function to create a bound from a document or fields */ function Br(t, e, n, r) {
+    if (n[0] = d(n[0]), n[0] instanceof _r) return function(t, e, n, r, s) {
         if (!r) throw new B(D, `Can't use a DocumentSnapshot that doesn't exist for ${n}().`);
         const i = [];
         // Because people expect to continue/end a query at the exact document
@@ -5795,22 +5835,22 @@ function jr(...t) {
         // the provided document. Without the key (by using the explicit sort
         // orders), multiple documents could match the position, yielding duplicate
         // results.
-                for (const n of Ve(t)) if (n.field.isKeyField()) i.push(zt(e, r.key)); else {
+                for (const n of $e(t)) if (n.field.isKeyField()) i.push(Wt(e, r.key)); else {
             const t = r.data.field(n.field);
-            if (Ot(t)) throw new B($, 'Invalid query. You are trying to start or end a query using a document for which the field "' + n.field + '" is an uncommitted server timestamp. (Since the value of this field is unknown, you cannot start/end a query with it.)');
+            if (kt(t)) throw new B($, 'Invalid query. You are trying to start or end a query using a document for which the field "' + n.field + '" is an uncommitted server timestamp. (Since the value of this field is unknown, you cannot start/end a query with it.)');
             if (null === t) {
                 const t = n.field.canonicalString();
                 throw new B($, `Invalid query. You are trying to start or end a query using a document for which the field '${t}' (used as the orderBy) does not exist.`);
             }
             i.push(t);
         }
-        return new Jt(i, s);
+        return new Xt(i, s);
     }
     /**
  * Converts a list of field values to a `Bound` for the given query.
  */ (t._query, t.firestore._databaseId, e, n[0]._document, r);
     {
-        const s = Xn(t.firestore);
+        const s = Zn(t.firestore);
         return function(t, e, n, r, s, i) {
             // Use explicit order by's because it has to match the query the user made
             const o = t.explicitOrderBy;
@@ -5820,17 +5860,17 @@ function jr(...t) {
                 const c = s[i];
                 if (o[i].field.isKeyField()) {
                     if ("string" != typeof c) throw new B($, `Invalid query. Expected a string for document ID in ${r}(), but got a ${typeof c}`);
-                    if (!Pe(t) && -1 !== c.indexOf("/")) throw new B($, `Invalid query. When querying a collection and ordering by documentId(), the value passed to ${r}() must be a plain document ID, but '${c}' contains a slash.`);
+                    if (!Ve(t) && -1 !== c.indexOf("/")) throw new B($, `Invalid query. When querying a collection and ordering by documentId(), the value passed to ${r}() must be a plain document ID, but '${c}' contains a slash.`);
                     const n = t.path.child(nt.fromString(c));
                     if (!it.isDocumentKey(n)) throw new B($, `Invalid query. When querying a collection group and ordering by documentId(), the value passed to ${r}() must result in a valid document path, but '${n}' is not because it contains an odd number of segments.`);
                     const s = new it(n);
-                    u.push(zt(e, s));
+                    u.push(Wt(e, s));
                 } else {
-                    const t = cr(n, r, c);
+                    const t = ar(n, r, c);
                     u.push(t);
                 }
             }
-            return new Jt(u, i);
+            return new Xt(u, i);
         }
         /**
  * Parses the given `documentIdValue` into a `ReferenceValue`, throwing
@@ -5840,22 +5880,22 @@ function jr(...t) {
     }
 }
 
-function Br(t, e, n) {
+function Qr(t, e, n) {
     if ("string" == typeof (n = d(n))) {
         if ("" === n) throw new B($, "Invalid query. When querying with documentId(), you must provide a valid document ID, but it was an empty string.");
-        if (!Pe(e) && -1 !== n.indexOf("/")) throw new B($, `Invalid query. When querying a collection by documentId(), you must provide a plain document ID, but '${n}' contains a '/' character.`);
+        if (!Ve(e) && -1 !== n.indexOf("/")) throw new B($, `Invalid query. When querying a collection by documentId(), you must provide a plain document ID, but '${n}' contains a '/' character.`);
         const r = e.path.child(nt.fromString(n));
         if (!it.isDocumentKey(r)) throw new B($, `Invalid query. When querying a collection group by documentId(), the value provided must result in a valid document path, but '${r}' is not because it has an odd number of segments (${r.length}).`);
-        return zt(t, new it(r));
+        return Wt(t, new it(r));
     }
-    if (n instanceof xn) return zt(t, n._key);
+    if (n instanceof Sn) return Wt(t, n._key);
     throw new B($, `Invalid query. When querying with documentId(), you must provide a valid string or a DocumentReference, but it was: ${at(n)}.`);
 }
 
 /**
  * Validates that the value passed into a disjunctive filter satisfies all
  * array requirements.
- */ function Qr(t, e) {
+ */ function zr(t, e) {
     if (!Array.isArray(t) || 0 === t.length) throw new B($, `Invalid Query. A non-empty array is required for '${e.toString()}' filters.`);
 }
 
@@ -5868,12 +5908,12 @@ function Br(t, e, n) {
  * Operators in a query must adhere to the following set of rules:
  * 1. Only one inequality per query.
  * 2. `NOT_IN` cannot be used with array, disjunctive, or `NOT_EQUAL` operators.
- */ function zr(t, e) {
+ */ function Wr(t, e) {
     if (e.isInequality()) {
-        const n = Re(t), r = e.field;
+        const n = Pe(t), r = e.field;
         if (null !== n && !n.isEqual(r)) throw new B($, `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 '${r.toString()}'`);
-        const s = Te(t);
-        null !== s && Wr(t, r, s);
+        const s = Re(t);
+        null !== s && Gr(t, r, s);
     }
     const n = function(t, e) {
         for (const n of t) for (const t of n.getFlattenedFilters()) if (e.indexOf(t.op) >= 0) return t.op;
@@ -5899,12 +5939,12 @@ function Br(t, e, n) {
     throw n === e.op ? new B($, `Invalid query. You cannot use more than one '${e.op.toString()}' filter.`) : new B($, `Invalid query. You cannot use '${e.op.toString()}' filters with '${n.toString()}' filters.`);
 }
 
-function Wr(t, e, n) {
+function Gr(t, e, n) {
     if (!n.isEqual(e)) throw new B($, `Invalid query. You have a where filter with an inequality (<, <=, !=, not-in, >, or >=) on field '${e.toString()}' and so you must also use '${e.toString()}' as your first argument to orderBy(), but your first orderBy() is on field '${n.toString()}' instead.`);
 }
 
-function Gr(t, e) {
-    if (!(e instanceof Rr || e instanceof Vr)) throw new B($, `Function ${t}() requires AppliableConstraints created with a call to 'where(...)', 'or(...)', or 'and(...)'.`);
+function Kr(t, e) {
+    if (!(e instanceof Pr || e instanceof $r)) throw new B($, `Function ${t}() requires AppliableConstraints created with a call to 'where(...)', 'or(...)', or 'and(...)'.`);
 }
 
 /**
@@ -5932,7 +5972,7 @@ function Gr(t, e) {
  * their `set()` or fails due to invalid data originating from a `toFirestore()`
  * call.
  */
-function Kr(t, e, n) {
+function Yr(t, e, n) {
     let r;
     // Cast to `any` in order to satisfy the union type constraint on
     // toFirestore().
@@ -5941,9 +5981,9 @@ function Kr(t, e, n) {
     r;
 }
 
-class Yr extends class {
+class Hr extends class {
     convertValue(t, e = "none") {
-        switch (Lt(t)) {
+        switch (jt(t)) {
           case 0 /* TypeOrder.NullValue */ :
             return null;
 
@@ -5951,7 +5991,7 @@ class Yr extends class {
             return t.booleanValue;
 
           case 2 /* TypeOrder.NumberValue */ :
-            return xt(t.integerValue || t.doubleValue);
+            return St(t.integerValue || t.doubleValue);
 
           case 3 /* TypeOrder.TimestampValue */ :
             return this.convertTimestamp(t.timestampValue);
@@ -5963,7 +6003,7 @@ class Yr extends class {
             return t.stringValue;
 
           case 6 /* TypeOrder.BlobValue */ :
-            return this.convertBytes(St(t.bytesValue));
+            return this.convertBytes(qt(t.bytesValue));
 
           case 7 /* TypeOrder.RefValue */ :
             return this.convertReference(t.referenceValue);
@@ -5988,12 +6028,12 @@ class Yr extends class {
      * @internal
      */    convertObjectMap(t, e = "none") {
         const n = {};
-        return Pt(t, ((t, r) => {
+        return Vt(t, ((t, r) => {
             n[t] = this.convertValue(r, e);
         })), n;
     }
     convertGeoPoint(t) {
-        return new zn(xt(t.latitude), xt(t.longitude));
+        return new Wn(St(t.latitude), St(t.longitude));
     }
     convertArray(t, e) {
         return (t.values || []).map((t => this.convertValue(t, e)));
@@ -6001,23 +6041,23 @@ class Yr extends class {
     convertServerTimestamp(t, e) {
         switch (e) {
           case "previous":
-            const n = kt(t);
+            const n = Ct(t);
             return null == n ? null : this.convertValue(n, e);
 
           case "estimate":
-            return this.convertTimestamp(Ct(t));
+            return this.convertTimestamp(Mt(t));
 
           default:
             return null;
         }
     }
     convertTimestamp(t) {
-        const e = Ft(t);
-        return new qt(e.seconds, e.nanos);
+        const e = xt(t);
+        return new Ot(e.seconds, e.nanos);
     }
     convertDocumentKey(t, e) {
         const n = nt.fromString(t);
-        A(mn(n));
+        A(pn(n));
         const r = new tt(n.get(1), n.get(3)), s = new it(n.popFirst(5));
         return r.isEqual(e) || 
         // TODO(b/64130202): Somehow support foreign references.
@@ -6029,11 +6069,11 @@ class Yr extends class {
         super(), this.firestore = t;
     }
     convertBytes(t) {
-        return new jn(t);
+        return new Un(t);
     }
     convertReference(t) {
         const e = this.convertDocumentKey(t, this.firestore._databaseId);
-        return new xn(this.firestore, /* converter= */ null, e);
+        return new Sn(this.firestore, /* converter= */ null, e);
     }
 }
 
@@ -6049,12 +6089,12 @@ class Yr extends class {
  * @param reference - The reference of the document to fetch.
  * @returns A Promise resolved with a `DocumentSnapshot` containing the current
  * document contents.
- */ function Hr(t) {
-    const e = An((t = ht(t, xn)).firestore), n = new Yr(t.firestore);
-    return vn(e, [ t._key ]).then((e => {
+ */ function Jr(t) {
+    const e = Tn((t = ht(t, Sn)).firestore), n = new Hr(t.firestore);
+    return bn(e, [ t._key ]).then((e => {
         A(1 === e.length);
         const r = e[0];
-        return new gr(t.firestore, n, t._key, r.isFoundDocument() ? r : null, t.converter);
+        return new _r(t.firestore, n, t._key, r.isFoundDocument() ? r : null, t.converter);
     }));
 }
 
@@ -6069,33 +6109,33 @@ class Yr extends class {
  *
  * @param query - The `Query` to execute.
  * @returns A Promise that will be resolved with the results of the query.
- */ function Jr(t) {
+ */ function Xr(t) {
     !function(t) {
         if ("L" /* LimitType.Last */ === t.limitType && 0 === t.explicitOrderBy.length) throw new B(M, "limitToLast() queries require specifying at least one orderBy() clause");
-    }((t = ht(t, Sn))._query);
-    const e = An(t.firestore), n = new Yr(t.firestore);
-    return bn(e, t._query).then((e => {
-        const r = e.map((e => new _r(t.firestore, n, e.key, e, t.converter)));
+    }((t = ht(t, qn))._query);
+    const e = Tn(t.firestore), n = new Hr(t.firestore);
+    return En(e, t._query).then((e => {
+        const r = e.map((e => new vr(t.firestore, n, e.key, e, t.converter)));
         return "L" /* LimitType.Last */ === t._query.limitType && 
         // Limit to last queries reverse the orderBy constraint that was
         // specified by the user. As such, we need to reverse the order of the
         // results to return the documents in the expected order.
-        r.reverse(), new vr(t, r);
+        r.reverse(), new br(t, r);
     }));
 }
 
-function Xr(t, e, n) {
-    const r = Kr((t = ht(t, xn)).converter, e, n), s = Zn(Xn(t.firestore), "setDoc", t._key, r, null !== t.converter, n);
-    return _n(An(t.firestore), [ s.toMutation(t._key, Me.none()) ]);
+function Zr(t, e, n) {
+    const r = Yr((t = ht(t, Sn)).converter, e, n), s = tr(Zn(t.firestore), "setDoc", t._key, r, null !== t.converter, n);
+    return vn(Tn(t.firestore), [ s.toMutation(t._key, Le.none()) ]);
 }
 
-function Zr(t, e, n, ...r) {
-    const s = Xn((t = ht(t, xn)).firestore);
+function ts(t, e, n, ...r) {
+    const s = Zn((t = ht(t, Sn)).firestore);
     // For Compat types, we have to "extract" the underlying types before
     // performing validation.
         let i;
-    i = "string" == typeof (e = d(e)) || e instanceof Un ? ur(s, "updateDoc", t._key, e, n, r) : or(s, "updateDoc", t._key, e);
-    return _n(An(t.firestore), [ i.toMutation(t._key, Me.exists(!0)) ]);
+    i = "string" == typeof (e = d(e)) || e instanceof Bn ? cr(s, "updateDoc", t._key, e, n, r) : ur(s, "updateDoc", t._key, e);
+    return vn(Tn(t.firestore), [ i.toMutation(t._key, Le.exists(!0)) ]);
 }
 
 /**
@@ -6109,8 +6149,8 @@ function Zr(t, e, n, ...r) {
  * @param reference - A reference to the document to delete.
  * @returns A `Promise` resolved once the document has been successfully
  * deleted from the backend.
- */ function ts(t) {
-    return _n(An((t = ht(t, xn)).firestore), [ new Be(t._key, Me.none()) ]);
+ */ function es(t) {
+    return vn(Tn((t = ht(t, Sn)).firestore), [ new Qe(t._key, Le.none()) ]);
 }
 
 /**
@@ -6127,9 +6167,9 @@ function Zr(t, e, n, ...r) {
  * @throws Error - If the provided input is not a valid Firestore document.
  * @returns A `Promise` resolved with a `DocumentReference` pointing to the
  * newly created document after it has been written to the backend.
- */ function es(t, e) {
-    const n = Cn(t = ht(t, qn)), r = Kr(t.converter, e), s = Zn(Xn(t.firestore), "addDoc", n._key, r, null !== n.converter, {});
-    return _n(An(t.firestore), [ s.toMutation(n._key, Me.exists(!1)) ]).then((() => n));
+ */ function ns(t, e) {
+    const n = Mn(t = ht(t, On)), r = Yr(t.converter, e), s = tr(Zn(t.firestore), "addDoc", n._key, r, null !== n.converter, {});
+    return vn(Tn(t.firestore), [ s.toMutation(n._key, Le.exists(!1)) ]).then((() => n));
 }
 
 /**
@@ -6161,9 +6201,9 @@ function Zr(t, e, n, ...r) {
  * @returns A Promise that will be resolved with the count; the count can be
  * retrieved from `snapshot.data().count`, where `snapshot` is the
  * `AggregateQuerySnapshot` to which the returned Promise resolves.
- */ function ns(t) {
-    return rs(t, {
-        count: os()
+ */ function rs(t) {
+    return ss(t, {
+        count: us()
     });
 }
 
@@ -6193,16 +6233,16 @@ function Zr(t, e, n, ...r) {
  * const averageScore: number | null = aggregateSnapshot.data().averageScore;
  * ```
  * @internal TODO (sum/avg) remove when public
- */ function rs(t, e) {
-    const n = ht(t.firestore, Rn), r = An(n), s = function(t, e) {
+ */ function ss(t, e) {
+    const n = ht(t.firestore, Pn), r = Tn(n), s = function(t, e) {
         const n = [];
         for (const r in t) Object.prototype.hasOwnProperty.call(t, r) && n.push(e(t[r], r, t));
         return n;
-    }(e, ((t, e) => new bt(e, t._aggregateType, t._internalFieldPath)));
+    }(e, ((t, e) => new Et(e, t._aggregateType, t._internalFieldPath)));
     // Run the aggregation and convert the results
-    return En(r, t._query, s).then((e => function(t, e, n) {
-        const r = new Yr(t);
-        return new Fn(e, r, n);
+    return In(r, t._query, s).then((e => function(t, e, n) {
+        const r = new Hr(t);
+        return new xn(e, r, n);
     }
     /**
  * Create an AggregateField object that can be used to compute the sum of
@@ -6212,8 +6252,8 @@ function Zr(t, e, n, ...r) {
  */ (n, t, e)));
 }
 
-function ss(t) {
-    return new Dn("sum", dr("sum", t));
+function is(t) {
+    return new Fn("sum", wr("sum", t));
 }
 
 /**
@@ -6221,16 +6261,16 @@ function ss(t) {
  * a specified field over a range of documents in the result set of a query.
  * @param field Specifies the field to average across the result set.
  * @internal TODO (sum/avg) remove when public
- */ function is(t) {
-    return new Dn("avg", dr("average", t));
+ */ function os(t) {
+    return new Fn("avg", wr("average", t));
 }
 
 /**
  * Create an AggregateField object that can be used to compute the count of
  * documents in the result set of a query.
  * @internal TODO (sum/avg) remove when public
- */ function os() {
-    return new Dn("count");
+ */ function us() {
+    return new Fn("count");
 }
 
 /**
@@ -6239,9 +6279,9 @@ function ss(t) {
  * @param left Compare this AggregateField to the `right`.
  * @param right Compare this AggregateField to the `left`.
  * @internal TODO (sum/avg) remove when public
- */ function us(t, e) {
+ */ function cs(t, e) {
     var n, r;
-    return t instanceof Dn && e instanceof Dn && t._aggregateType === e._aggregateType && (null === (n = t._internalFieldPath) || void 0 === n ? void 0 : n.canonicalString()) === (null === (r = e._internalFieldPath) || void 0 === r ? void 0 : r.canonicalString());
+    return t instanceof Fn && e instanceof Fn && t._aggregateType === e._aggregateType && (null === (n = t._internalFieldPath) || void 0 === n ? void 0 : n.canonicalString()) === (null === (r = e._internalFieldPath) || void 0 === r ? void 0 : r.canonicalString());
 }
 
 /**
@@ -6255,8 +6295,8 @@ function ss(t) {
  *
  * @returns `true` if the objects are "equal", as defined above, or `false`
  * otherwise.
- */ function cs(t, e) {
-    return Ln(t.query, e.query) && w(t.data(), e.data());
+ */ function as(t, e) {
+    return jn(t.query, e.query) && w(t.data(), e.data());
 }
 
 /**
@@ -6278,15 +6318,15 @@ function ss(t) {
 /**
  * Returns a sentinel for use with {@link @firebase/firestore/lite#(updateDoc:1)} or
  * {@link @firebase/firestore/lite#(setDoc:1)} with `{merge: true}` to mark a field for deletion.
- */ function as() {
-    return new tr("deleteField");
+ */ function hs() {
+    return new er("deleteField");
 }
 
 /**
  * Returns a sentinel used with {@link @firebase/firestore/lite#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
  * include a server-generated timestamp in the written data.
- */ function hs() {
-    return new nr("serverTimestamp");
+ */ function ls() {
+    return new rr("serverTimestamp");
 }
 
 /**
@@ -6300,10 +6340,10 @@ function ss(t) {
  * @param elements - The elements to union into the array.
  * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
  * `updateDoc()`.
- */ function ls(...t) {
+ */ function fs(...t) {
     // NOTE: We don't actually parse the data until it's used in set() or
     // update() since we'd need the Firestore instance to do this.
-    return new rr("arrayUnion", t);
+    return new sr("arrayUnion", t);
 }
 
 /**
@@ -6316,10 +6356,10 @@ function ss(t) {
  * @param elements - The elements to remove from the array.
  * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
  * `updateDoc()`
- */ function fs(...t) {
+ */ function ds(...t) {
     // NOTE: We don't actually parse the data until it's used in set() or
     // update() since we'd need the Firestore instance to do this.
-    return new sr("arrayRemove", t);
+    return new ir("arrayRemove", t);
 }
 
 /**
@@ -6340,8 +6380,8 @@ function ss(t) {
  * @param n - The value to increment by.
  * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
  * `updateDoc()`
- */ function ds(t) {
-    return new ir("increment", t);
+ */ function ws(t) {
+    return new or("increment", t);
 }
 
 /**
@@ -6367,25 +6407,25 @@ function ss(t) {
  * provides methods for adding writes to the write batch. None of the writes
  * will be committed (or visible locally) until {@link WriteBatch.commit} is
  * called.
- */ class ws {
+ */ class ms {
     /** @hideconstructor */
     constructor(t, e) {
         this._firestore = t, this._commitHandler = e, this._mutations = [], this._committed = !1, 
-        this._dataReader = Xn(t);
+        this._dataReader = Zn(t);
     }
     set(t, e, n) {
         this._verifyNotCommitted();
-        const r = ms(t, this._firestore), s = Kr(r.converter, e, n), i = Zn(this._dataReader, "WriteBatch.set", r._key, s, null !== r.converter, n);
-        return this._mutations.push(i.toMutation(r._key, Me.none())), this;
+        const r = ps(t, this._firestore), s = Yr(r.converter, e, n), i = tr(this._dataReader, "WriteBatch.set", r._key, s, null !== r.converter, n);
+        return this._mutations.push(i.toMutation(r._key, Le.none())), this;
     }
     update(t, e, n, ...r) {
         this._verifyNotCommitted();
-        const s = ms(t, this._firestore);
+        const s = ps(t, this._firestore);
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 let i;
-        return i = "string" == typeof (e = d(e)) || e instanceof Un ? ur(this._dataReader, "WriteBatch.update", s._key, e, n, r) : or(this._dataReader, "WriteBatch.update", s._key, e), 
-        this._mutations.push(i.toMutation(s._key, Me.exists(!0))), this;
+        return i = "string" == typeof (e = d(e)) || e instanceof Bn ? cr(this._dataReader, "WriteBatch.update", s._key, e, n, r) : ur(this._dataReader, "WriteBatch.update", s._key, e), 
+        this._mutations.push(i.toMutation(s._key, Le.exists(!0))), this;
     }
     /**
      * Deletes the document referred to by the provided {@link DocumentReference}.
@@ -6394,8 +6434,8 @@ function ss(t) {
      * @returns This `WriteBatch` instance. Used for chaining method calls.
      */    delete(t) {
         this._verifyNotCommitted();
-        const e = ms(t, this._firestore);
-        return this._mutations = this._mutations.concat(new Be(e._key, Me.none())), this;
+        const e = ps(t, this._firestore);
+        return this._mutations = this._mutations.concat(new Qe(e._key, Le.none())), this;
     }
     /**
      * Commits all of the writes in this write batch as a single atomic unit.
@@ -6416,7 +6456,7 @@ function ss(t) {
     }
 }
 
-function ms(t, e) {
+function ps(t, e) {
     if ((t = d(t)).firestore !== e) throw new B($, "Provided document reference is from a different Firestore instance.");
     return t;
 }
@@ -6433,9 +6473,9 @@ function ms(t, e) {
  *
  * @returns A `WriteBatch` that can be used to atomically execute multiple
  * writes.
- */ function ps(t) {
-    const e = An(t = ht(t, Rn));
-    return new ws(t, (t => _n(e, t)));
+ */ function ys(t) {
+    const e = Tn(t = ht(t, Pn));
+    return new ms(t, (t => vn(e, t)));
 }
 
 /**
@@ -6457,7 +6497,7 @@ function ms(t, e) {
 /**
  * Internal transaction object responsible for accumulating the mutations to
  * perform and the base versions for any documents read.
- */ class ys {
+ */ class gs {
     constructor(t) {
         this.datastore = t, 
         // The version of each document that was read during this transaction.
@@ -6477,7 +6517,7 @@ function ms(t, e) {
     }
     async lookup(t) {
         if (this.ensureCommitNotCalled(), this.mutations.length > 0) throw new B($, "Firestore transactions require all reads to be executed before all writes.");
-        const e = await vn(this.datastore, t);
+        const e = await bn(this.datastore, t);
         return e.forEach((t => this.recordVersion(t))), e;
     }
     set(t, e) {
@@ -6492,7 +6532,7 @@ function ms(t, e) {
         this.writtenDocs.add(t.toString());
     }
     delete(t) {
-        this.write(new Be(t, this.precondition(t))), this.writtenDocs.add(t.toString());
+        this.write(new Qe(t, this.precondition(t))), this.writtenDocs.add(t.toString());
     }
     async commit() {
         if (this.ensureCommitNotCalled(), this.lastWriteError) throw this.lastWriteError;
@@ -6505,15 +6545,15 @@ function ms(t, e) {
         // a `verify` operation.
         t.forEach(((t, e) => {
             const n = it.fromPath(e);
-            this.mutations.push(new Qe(n, this.precondition(n)));
-        })), await _n(this.datastore, this.mutations), this.committed = !0;
+            this.mutations.push(new ze(n, this.precondition(n)));
+        })), await vn(this.datastore, this.mutations), this.committed = !0;
     }
     recordVersion(t) {
         let e;
         if (t.isFoundDocument()) e = t.version; else {
             if (!t.isNoDocument()) throw I();
             // Represent a deleted doc using SnapshotVersion.min().
-            e = de.min();
+            e = we.min();
         }
         const n = this.readVersions.get(t.key.toString());
         if (n) {
@@ -6527,7 +6567,7 @@ function ms(t, e) {
      * as a precondition, or no precondition if it was not read.
      */    precondition(t) {
         const e = this.readVersions.get(t.toString());
-        return !this.writtenDocs.has(t.toString()) && e ? e.isEqual(de.min()) ? Me.exists(!1) : Me.updateTime(e) : Me.none();
+        return !this.writtenDocs.has(t.toString()) && e ? e.isEqual(we.min()) ? Le.exists(!1) : Le.updateTime(e) : Le.none();
     }
     /**
      * Returns the precondition for a document if the operation is an update.
@@ -6536,7 +6576,7 @@ function ms(t, e) {
         // The first time a document is written, we want to take into account the
         // read time and existence
                 if (!this.writtenDocs.has(t.toString()) && e) {
-            if (e.isEqual(de.min())) 
+            if (e.isEqual(we.min())) 
             // The document doesn't exist, so fail the transaction.
             // This has to be validated locally because you can't send a
             // precondition that a document does not exist without changing the
@@ -6548,11 +6588,11 @@ function ms(t, e) {
             // transaction.
             throw new B($, "Can't update a document that doesn't exist.");
             // Document exists, base precondition on document update time.
-                        return Me.updateTime(e);
+                        return Le.updateTime(e);
         }
         // Document was not read, so we just use the preconditions for a blind
         // update.
-        return Me.exists(!0);
+        return Le.exists(!0);
     }
     write(t) {
         this.ensureCommitNotCalled(), this.mutations.push(t);
@@ -6575,7 +6615,7 @@ function ms(t, e) {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ const gs = {
+ */ const _s = {
     maxAttempts: 5
 };
 
@@ -6599,17 +6639,17 @@ function ms(t, e) {
  * TransactionRunner encapsulates the logic needed to run and retry transactions
  * with backoff.
  */
-class _s {
+class vs {
     constructor(t, e, n, r, s) {
         this.asyncQueue = t, this.datastore = e, this.options = n, this.updateFunction = r, 
-        this.deferred = s, this.wt = n.maxAttempts, this.yt = new yn(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
+        this.deferred = s, this.wt = n.maxAttempts, this.yt = new gn(this.asyncQueue, "transaction_retry" /* TimerId.TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */    run() {
         this.wt -= 1, this.gt();
     }
     gt() {
         this.yt.K((async () => {
-            const t = new ys(this.datastore), e = this._t(t);
+            const t = new gs(this.datastore), e = this._t(t);
             e && e.then((e => {
                 this.asyncQueue.enqueueAndForget((() => t.commit().then((() => {
                     this.deferred.resolve(e);
@@ -6624,7 +6664,7 @@ class _s {
     _t(t) {
         try {
             const e = this.updateFunction(t);
-            return !wt(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
+            return !mt(e) && e.catch && e.then ? e : (this.deferred.reject(Error("Transaction callback must return a Promise")), 
             null);
         } catch (t) {
             // Do not retry errors thrown by user provided updateFunction.
@@ -6699,7 +6739,7 @@ class _s {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** The Platform's 'document' implementation or null if not available. */ function vs() {
+/** The Platform's 'document' implementation or null if not available. */ function bs() {
     // `document` is not always available, e.g. in ReactNative and WebWorkers.
     // eslint-disable-next-line no-restricted-globals
     return "undefined" != typeof document ? document : null;
@@ -6731,7 +6771,7 @@ class _s {
  * Note: We implement `PromiseLike` instead of `Promise`, as the `Promise` type
  * in newer versions of TypeScript defines `finally`, which is not available in
  * IE.
- */ class bs {
+ */ class Es {
     constructor(t, e, n, r, s) {
         this.asyncQueue = t, this.timerId = e, this.targetTimeMs = n, this.op = r, this.removalCallback = s, 
         this.deferred = new Q, this.then = this.deferred.promise.then.bind(this.deferred.promise), 
@@ -6754,7 +6794,7 @@ class _s {
      *   PORTING NOTE: This exists to prevent making removeDelayedOperation() and
      *   the DelayedOperation class public.
      */    static createAndSchedule(t, e, n, r, s) {
-        const i = Date.now() + n, o = new bs(t, e, i, r, s);
+        const i = Date.now() + n, o = new Es(t, e, i, r, s);
         return o.start(n), o;
     }
     /**
@@ -6803,7 +6843,7 @@ class _s {
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */ class Es {
+ */ class Is {
     constructor() {
         // The last promise in the queue.
         this.Et = Promise.resolve(), 
@@ -6826,15 +6866,15 @@ class _s {
         // List of TimerIds to fast-forward delays for.
         this.$t = [], 
         // Backoff timer used to schedule retries for retryable operations
-        this.yt = new yn(this, "async_queue_retry" /* TimerId.AsyncQueueRetry */), 
+        this.yt = new gn(this, "async_queue_retry" /* TimerId.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.Nt = () => {
-            const t = vs();
+            const t = bs();
             t && _("AsyncQueue", "Visibility state changed to " + t.visibilityState), this.yt.H();
         };
-        const t = vs();
+        const t = bs();
         t && "function" == typeof t.addEventListener && t.addEventListener("visibilitychange", this.Nt);
     }
     get isShuttingDown() {
@@ -6855,7 +6895,7 @@ class _s {
     enterRestrictedMode(t) {
         if (!this.At) {
             this.At = !0, this.Vt = t || !1;
-            const e = vs();
+            const e = bs();
             e && "function" == typeof e.removeEventListener && e.removeEventListener("visibilitychange", this.Nt);
         }
     }
@@ -6987,7 +7027,7 @@ class _s {
         this.Dt(), 
         // Fast-forward delays for timerIds that have been overriden.
         this.$t.indexOf(t) > -1 && (e = 0);
-        const r = bs.createAndSchedule(this, t, e, n, (t => this.St(t)));
+        const r = Es.createAndSchedule(this, t, e, n, (t => this.St(t)));
         return this.Tt.push(r), r;
     }
     Dt() {
@@ -7041,10 +7081,10 @@ class _s {
     }
 }
 
-class Is {
+class As {
     /** @hideconstructor */
     constructor(t, e) {
-        this._firestore = t, this._transaction = e, this._dataReader = Xn(t);
+        this._firestore = t, this._transaction = e, this._dataReader = Zn(t);
     }
     /**
      * Reads the document referenced by the provided {@link DocumentReference}.
@@ -7052,25 +7092,25 @@ class Is {
      * @param documentRef - A reference to the document to be read.
      * @returns A `DocumentSnapshot` with the read data.
      */    get(t) {
-        const e = ms(t, this._firestore), n = new Yr(this._firestore);
+        const e = ps(t, this._firestore), n = new Hr(this._firestore);
         return this._transaction.lookup([ e._key ]).then((t => {
             if (!t || 1 !== t.length) return I();
             const r = t[0];
-            if (r.isFoundDocument()) return new gr(this._firestore, n, r.key, r, e.converter);
-            if (r.isNoDocument()) return new gr(this._firestore, n, e._key, null, e.converter);
+            if (r.isFoundDocument()) return new _r(this._firestore, n, r.key, r, e.converter);
+            if (r.isNoDocument()) return new _r(this._firestore, n, e._key, null, e.converter);
             throw I();
         }));
     }
     set(t, e, n) {
-        const r = ms(t, this._firestore), s = Kr(r.converter, e, n), i = Zn(this._dataReader, "Transaction.set", r._key, s, null !== r.converter, n);
+        const r = ps(t, this._firestore), s = Yr(r.converter, e, n), i = tr(this._dataReader, "Transaction.set", r._key, s, null !== r.converter, n);
         return this._transaction.set(r._key, i), this;
     }
     update(t, e, n, ...r) {
-        const s = ms(t, this._firestore);
+        const s = ps(t, this._firestore);
         // For Compat types, we have to "extract" the underlying types before
         // performing validation.
                 let i;
-        return i = "string" == typeof (e = d(e)) || e instanceof Un ? ur(this._dataReader, "Transaction.update", s._key, e, n, r) : or(this._dataReader, "Transaction.update", s._key, e), 
+        return i = "string" == typeof (e = d(e)) || e instanceof Bn ? cr(this._dataReader, "Transaction.update", s._key, e, n, r) : ur(this._dataReader, "Transaction.update", s._key, e), 
         this._transaction.update(s._key, i), this;
     }
     /**
@@ -7079,7 +7119,7 @@ class Is {
      * @param documentRef - A reference to the document to be deleted.
      * @returns This `Transaction` instance. Used for chaining method calls.
      */    delete(t) {
-        const e = ms(t, this._firestore);
+        const e = ps(t, this._firestore);
         return this._transaction.delete(e._key), this;
     }
 }
@@ -7102,13 +7142,13 @@ class Is {
  * (the `updateFunction` returned a failed promise), the promise returned by the
  * `updateFunction `is returned here. Otherwise, if the transaction failed, a
  * rejected promise with the corresponding failure error is returned.
- */ function As(t, e, n) {
-    const r = An(t = ht(t, Rn)), s = Object.assign(Object.assign({}, gs), n);
+ */ function Ts(t, e, n) {
+    const r = Tn(t = ht(t, Pn)), s = Object.assign(Object.assign({}, _s), n);
     !function(t) {
         if (t.maxAttempts < 1) throw new B($, "Max attempts must be at least 1");
     }(s);
     const i = new Q;
-    return new _s(new Es, r, s, (n => e(new Is(t, n))), i).run(), i.promise;
+    return new vs(new Is, r, s, (n => e(new As(t, n))), i).run(), i.promise;
 }
 
 /**
@@ -7121,7 +7161,7 @@ class Is {
  */ !function(t) {
     p = t;
 }(`${s}_lite`), n(new i("firestore/lite", ((t, {instanceIdentifier: e, options: n}) => {
-    const r = t.getProvider("app").getImmediate(), s = new Rn(new K(t.getProvider("auth-internal")), new X(t.getProvider("app-check-internal")), function(t, e) {
+    const r = t.getProvider("app").getImmediate(), s = new Pn(new K(t.getProvider("auth-internal")), new X(t.getProvider("app-check-internal")), function(t, e) {
         if (!Object.prototype.hasOwnProperty.apply(t.options, [ "projectId" ])) throw new B($, '"projectId" not provided in firebase.initializeApp.');
         return new tt(t.options.projectId, e);
     }
@@ -7144,7 +7184,7 @@ class Is {
     return n && s._setSettings(n), s;
 }), "PUBLIC").setMultipleInstances(!0)), 
 // RUNTIME_ENV and BUILD_TARGET are replaced by real values during the compilation
-r("firestore-lite", "3.11.0", "rn"), r("firestore-lite", "3.11.0", "esm2017");
+r("firestore-lite", "3.12.0-20230511201449", "rn"), r("firestore-lite", "3.12.0-20230511201449", "esm2017");
 
-export { Dn as AggregateField, Fn as AggregateQuerySnapshot, jn as Bytes, qn as CollectionReference, xn as DocumentReference, gr as DocumentSnapshot, Un as FieldPath, Qn as FieldValue, Rn as Firestore, B as FirestoreError, zn as GeoPoint, Sn as Query, Vr as QueryCompositeFilterConstraint, Ar as QueryConstraint, _r as QueryDocumentSnapshot, Mr as QueryEndAtConstraint, Rr as QueryFieldFilterConstraint, xr as QueryLimitConstraint, Dr as QueryOrderByConstraint, vr as QuerySnapshot, Or as QueryStartAtConstraint, qt as Timestamp, Is as Transaction, ws as WriteBatch, es as addDoc, us as aggregateFieldEqual, cs as aggregateQuerySnapshotEqual, Nr as and, fs as arrayRemove, ls as arrayUnion, is as average, On as collection, kn as collectionGroup, $n as connectFirestoreEmulator, os as count, ts as deleteDoc, as as deleteField, Cn as doc, Bn as documentId, jr as endAt, Lr as endBefore, rs as getAggregate, ns as getCount, Hr as getDoc, Jr as getDocs, Vn as getFirestore, ds as increment, Pn as initializeFirestore, Sr as limit, qr as limitToLast, $r as or, Fr as orderBy, Tr as query, Ln as queryEqual, Mn as refEqual, As as runTransaction, hs as serverTimestamp, Xr as setDoc, g as setLogLevel, br as snapshotEqual, Cr as startAfter, kr as startAt, ss as sum, Nn as terminate, Zr as updateDoc, Pr as where, ps as writeBatch };
+export { Fn as AggregateField, xn as AggregateQuerySnapshot, Un as Bytes, On as CollectionReference, Sn as DocumentReference, _r as DocumentSnapshot, Bn as FieldPath, zn as FieldValue, Pn as Firestore, B as FirestoreError, Wn as GeoPoint, qn as Query, $r as QueryCompositeFilterConstraint, Tr as QueryConstraint, vr as QueryDocumentSnapshot, Lr as QueryEndAtConstraint, Pr as QueryFieldFilterConstraint, Sr as QueryLimitConstraint, Fr as QueryOrderByConstraint, br as QuerySnapshot, kr as QueryStartAtConstraint, Ot as Timestamp, As as Transaction, ms as WriteBatch, ns as addDoc, cs as aggregateFieldEqual, as as aggregateQuerySnapshotEqual, Dr as and, ds as arrayRemove, fs as arrayUnion, os as average, kn as collection, Cn as collectionGroup, Nn as connectFirestoreEmulator, us as count, es as deleteDoc, hs as deleteField, Mn as doc, Qn as documentId, Ur as endAt, jr as endBefore, ss as getAggregate, rs as getCount, Jr as getDoc, Xr as getDocs, $n as getFirestore, ws as increment, Vn as initializeFirestore, qr as limit, Or as limitToLast, Nr as or, xr as orderBy, Rr as query, jn as queryEqual, Ln as refEqual, Ts as runTransaction, ls as serverTimestamp, Zr as setDoc, g as setLogLevel, Er as snapshotEqual, Mr as startAfter, Cr as startAt, is as sum, Dn as terminate, ts as updateDoc, Vr as where, ys as writeBatch };
 //# sourceMappingURL=index.rn.esm2017.js.map