@firebase/firestore 3.4.8 → 3.4.9-canary.0197076b8

package/dist/lite/index.node.cjs.js

@@ -14,7 +14,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 
 var nodeFetch__default = /*#__PURE__*/_interopDefaultLegacy(nodeFetch);
 
-const version$1 = "3.4.8";
+const version$1 = "3.4.9-canary.0197076b8";
 
 /**
  * @license
@@ -67,7 +67,7 @@ User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');
 User.FIRST_PARTY = new User('first-party-uid');
 User.MOCK_USER = new User('mock-user');
 
-const version = "9.6.11";
+const version = "9.8.2-canary.0197076b8";
 
 /**
  * @license
@@ -1824,6 +1824,627 @@ function isEmpty(obj) {
     return true;
 }
 
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+// An immutable sorted map implementation, based on a Left-leaning Red-Black
+// tree.
+class SortedMap {
+    constructor(comparator, root) {
+        this.comparator = comparator;
+        this.root = root ? root : LLRBNode.EMPTY;
+    }
+    // Returns a copy of the map, with the specified key/value added or replaced.
+    insert(key, value) {
+        return new SortedMap(this.comparator, this.root
+            .insert(key, value, this.comparator)
+            .copy(null, null, LLRBNode.BLACK, null, null));
+    }
+    // Returns a copy of the map, with the specified key removed.
+    remove(key) {
+        return new SortedMap(this.comparator, this.root
+            .remove(key, this.comparator)
+            .copy(null, null, LLRBNode.BLACK, null, null));
+    }
+    // Returns the value of the node with the given key, or null.
+    get(key) {
+        let node = this.root;
+        while (!node.isEmpty()) {
+            const cmp = this.comparator(key, node.key);
+            if (cmp === 0) {
+                return node.value;
+            }
+            else if (cmp < 0) {
+                node = node.left;
+            }
+            else if (cmp > 0) {
+                node = node.right;
+            }
+        }
+        return null;
+    }
+    // Returns the index of the element in this sorted map, or -1 if it doesn't
+    // exist.
+    indexOf(key) {
+        // Number of nodes that were pruned when descending right
+        let prunedNodes = 0;
+        let node = this.root;
+        while (!node.isEmpty()) {
+            const cmp = this.comparator(key, node.key);
+            if (cmp === 0) {
+                return prunedNodes + node.left.size;
+            }
+            else if (cmp < 0) {
+                node = node.left;
+            }
+            else {
+                // Count all nodes left of the node plus the node itself
+                prunedNodes += node.left.size + 1;
+                node = node.right;
+            }
+        }
+        // Node not found
+        return -1;
+    }
+    isEmpty() {
+        return this.root.isEmpty();
+    }
+    // Returns the total number of nodes in the map.
+    get size() {
+        return this.root.size;
+    }
+    // Returns the minimum key in the map.
+    minKey() {
+        return this.root.minKey();
+    }
+    // Returns the maximum key in the map.
+    maxKey() {
+        return this.root.maxKey();
+    }
+    // Traverses the map in key order and calls the specified action function
+    // for each key/value pair. If action returns true, traversal is aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    inorderTraversal(action) {
+        return this.root.inorderTraversal(action);
+    }
+    forEach(fn) {
+        this.inorderTraversal((k, v) => {
+            fn(k, v);
+            return false;
+        });
+    }
+    toString() {
+        const descriptions = [];
+        this.inorderTraversal((k, v) => {
+            descriptions.push(`${k}:${v}`);
+            return false;
+        });
+        return `{${descriptions.join(', ')}}`;
+    }
+    // Traverses the map in reverse key order and calls the specified action
+    // function for each key/value pair. If action returns true, traversal is
+    // aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    reverseTraversal(action) {
+        return this.root.reverseTraversal(action);
+    }
+    // Returns an iterator over the SortedMap.
+    getIterator() {
+        return new SortedMapIterator(this.root, null, this.comparator, false);
+    }
+    getIteratorFrom(key) {
+        return new SortedMapIterator(this.root, key, this.comparator, false);
+    }
+    getReverseIterator() {
+        return new SortedMapIterator(this.root, null, this.comparator, true);
+    }
+    getReverseIteratorFrom(key) {
+        return new SortedMapIterator(this.root, key, this.comparator, true);
+    }
+} // end SortedMap
+// An iterator over an LLRBNode.
+class SortedMapIterator {
+    constructor(node, startKey, comparator, isReverse) {
+        this.isReverse = isReverse;
+        this.nodeStack = [];
+        let cmp = 1;
+        while (!node.isEmpty()) {
+            cmp = startKey ? comparator(node.key, startKey) : 1;
+            // flip the comparison if we're going in reverse
+            if (startKey && isReverse) {
+                cmp *= -1;
+            }
+            if (cmp < 0) {
+                // This node is less than our start key. ignore it
+                if (this.isReverse) {
+                    node = node.left;
+                }
+                else {
+                    node = node.right;
+                }
+            }
+            else if (cmp === 0) {
+                // This node is exactly equal to our start key. Push it on the stack,
+                // but stop iterating;
+                this.nodeStack.push(node);
+                break;
+            }
+            else {
+                // This node is greater than our start key, add it to the stack and move
+                // to the next one
+                this.nodeStack.push(node);
+                if (this.isReverse) {
+                    node = node.right;
+                }
+                else {
+                    node = node.left;
+                }
+            }
+        }
+    }
+    getNext() {
+        let node = this.nodeStack.pop();
+        const result = { key: node.key, value: node.value };
+        if (this.isReverse) {
+            node = node.left;
+            while (!node.isEmpty()) {
+                this.nodeStack.push(node);
+                node = node.right;
+            }
+        }
+        else {
+            node = node.right;
+            while (!node.isEmpty()) {
+                this.nodeStack.push(node);
+                node = node.left;
+            }
+        }
+        return result;
+    }
+    hasNext() {
+        return this.nodeStack.length > 0;
+    }
+    peek() {
+        if (this.nodeStack.length === 0) {
+            return null;
+        }
+        const node = this.nodeStack[this.nodeStack.length - 1];
+        return { key: node.key, value: node.value };
+    }
+} // end SortedMapIterator
+// Represents a node in a Left-leaning Red-Black tree.
+class LLRBNode {
+    constructor(key, value, color, left, right) {
+        this.key = key;
+        this.value = value;
+        this.color = color != null ? color : LLRBNode.RED;
+        this.left = left != null ? left : LLRBNode.EMPTY;
+        this.right = right != null ? right : LLRBNode.EMPTY;
+        this.size = this.left.size + 1 + this.right.size;
+    }
+    // Returns a copy of the current node, optionally replacing pieces of it.
+    copy(key, value, color, left, right) {
+        return new LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);
+    }
+    isEmpty() {
+        return false;
+    }
+    // Traverses the tree in key order and calls the specified action function
+    // for each node. If action returns true, traversal is aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    inorderTraversal(action) {
+        return (this.left.inorderTraversal(action) ||
+            action(this.key, this.value) ||
+            this.right.inorderTraversal(action));
+    }
+    // Traverses the tree in reverse key order and calls the specified action
+    // function for each node. If action returns true, traversal is aborted.
+    // Returns the first truthy value returned by action, or the last falsey
+    // value returned by action.
+    reverseTraversal(action) {
+        return (this.right.reverseTraversal(action) ||
+            action(this.key, this.value) ||
+            this.left.reverseTraversal(action));
+    }
+    // Returns the minimum node in the tree.
+    min() {
+        if (this.left.isEmpty()) {
+            return this;
+        }
+        else {
+            return this.left.min();
+        }
+    }
+    // Returns the maximum key in the tree.
+    minKey() {
+        return this.min().key;
+    }
+    // Returns the maximum key in the tree.
+    maxKey() {
+        if (this.right.isEmpty()) {
+            return this.key;
+        }
+        else {
+            return this.right.maxKey();
+        }
+    }
+    // Returns new tree, with the key/value added.
+    insert(key, value, comparator) {
+        let n = this;
+        const cmp = comparator(key, n.key);
+        if (cmp < 0) {
+            n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);
+        }
+        else if (cmp === 0) {
+            n = n.copy(null, value, null, null, null);
+        }
+        else {
+            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
+        }
+        return n.fixUp();
+    }
+    removeMin() {
+        if (this.left.isEmpty()) {
+            return LLRBNode.EMPTY;
+        }
+        let n = this;
+        if (!n.left.isRed() && !n.left.left.isRed()) {
+            n = n.moveRedLeft();
+        }
+        n = n.copy(null, null, null, n.left.removeMin(), null);
+        return n.fixUp();
+    }
+    // Returns new tree, with the specified item removed.
+    remove(key, comparator) {
+        let smallest;
+        let n = this;
+        if (comparator(key, n.key) < 0) {
+            if (!n.left.isEmpty() && !n.left.isRed() && !n.left.left.isRed()) {
+                n = n.moveRedLeft();
+            }
+            n = n.copy(null, null, null, n.left.remove(key, comparator), null);
+        }
+        else {
+            if (n.left.isRed()) {
+                n = n.rotateRight();
+            }
+            if (!n.right.isEmpty() && !n.right.isRed() && !n.right.left.isRed()) {
+                n = n.moveRedRight();
+            }
+            if (comparator(key, n.key) === 0) {
+                if (n.right.isEmpty()) {
+                    return LLRBNode.EMPTY;
+                }
+                else {
+                    smallest = n.right.min();
+                    n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin());
+                }
+            }
+            n = n.copy(null, null, null, null, n.right.remove(key, comparator));
+        }
+        return n.fixUp();
+    }
+    isRed() {
+        return this.color;
+    }
+    // Returns new tree after performing any needed rotations.
+    fixUp() {
+        let n = this;
+        if (n.right.isRed() && !n.left.isRed()) {
+            n = n.rotateLeft();
+        }
+        if (n.left.isRed() && n.left.left.isRed()) {
+            n = n.rotateRight();
+        }
+        if (n.left.isRed() && n.right.isRed()) {
+            n = n.colorFlip();
+        }
+        return n;
+    }
+    moveRedLeft() {
+        let n = this.colorFlip();
+        if (n.right.left.isRed()) {
+            n = n.copy(null, null, null, null, n.right.rotateRight());
+            n = n.rotateLeft();
+            n = n.colorFlip();
+        }
+        return n;
+    }
+    moveRedRight() {
+        let n = this.colorFlip();
+        if (n.left.left.isRed()) {
+            n = n.rotateRight();
+            n = n.colorFlip();
+        }
+        return n;
+    }
+    rotateLeft() {
+        const nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);
+        return this.right.copy(null, null, this.color, nl, null);
+    }
+    rotateRight() {
+        const nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);
+        return this.left.copy(null, null, this.color, null, nr);
+    }
+    colorFlip() {
+        const left = this.left.copy(null, null, !this.left.color, null, null);
+        const right = this.right.copy(null, null, !this.right.color, null, null);
+        return this.copy(null, null, !this.color, left, right);
+    }
+    // For testing.
+    checkMaxDepth() {
+        const blackDepth = this.check();
+        if (Math.pow(2.0, blackDepth) <= this.size + 1) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    // In a balanced RB tree, the black-depth (number of black nodes) from root to
+    // leaves is equal on both sides.  This function verifies that or asserts.
+    check() {
+        if (this.isRed() && this.left.isRed()) {
+            throw fail();
+        }
+        if (this.right.isRed()) {
+            throw fail();
+        }
+        const blackDepth = this.left.check();
+        if (blackDepth !== this.right.check()) {
+            throw fail();
+        }
+        else {
+            return blackDepth + (this.isRed() ? 0 : 1);
+        }
+    }
+} // end LLRBNode
+// Empty node is shared between all LLRB trees.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+LLRBNode.EMPTY = null;
+LLRBNode.RED = true;
+LLRBNode.BLACK = false;
+// Represents an empty node (a leaf node in the Red-Black Tree).
+class LLRBEmptyNode {
+    constructor() {
+        this.size = 0;
+    }
+    get key() {
+        throw fail();
+    }
+    get value() {
+        throw fail();
+    }
+    get color() {
+        throw fail();
+    }
+    get left() {
+        throw fail();
+    }
+    get right() {
+        throw fail();
+    }
+    // Returns a copy of the current node.
+    copy(key, value, color, left, right) {
+        return this;
+    }
+    // Returns a copy of the tree, with the specified key/value added.
+    insert(key, value, comparator) {
+        return new LLRBNode(key, value);
+    }
+    // Returns a copy of the tree, with the specified key removed.
+    remove(key, comparator) {
+        return this;
+    }
+    isEmpty() {
+        return true;
+    }
+    inorderTraversal(action) {
+        return false;
+    }
+    reverseTraversal(action) {
+        return false;
+    }
+    minKey() {
+        return null;
+    }
+    maxKey() {
+        return null;
+    }
+    isRed() {
+        return false;
+    }
+    // For testing.
+    checkMaxDepth() {
+        return true;
+    }
+    check() {
+        return 0;
+    }
+} // end LLRBEmptyNode
+LLRBNode.EMPTY = new LLRBEmptyNode();
+
+/**
+ * @license
+ * Copyright 2017 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.
+ */
+/**
+ * SortedSet is an immutable (copy-on-write) collection that holds elements
+ * in order specified by the provided comparator.
+ *
+ * NOTE: if provided comparator returns 0 for two elements, we consider them to
+ * be equal!
+ */
+class SortedSet {
+    constructor(comparator) {
+        this.comparator = comparator;
+        this.data = new SortedMap(this.comparator);
+    }
+    has(elem) {
+        return this.data.get(elem) !== null;
+    }
+    first() {
+        return this.data.minKey();
+    }
+    last() {
+        return this.data.maxKey();
+    }
+    get size() {
+        return this.data.size;
+    }
+    indexOf(elem) {
+        return this.data.indexOf(elem);
+    }
+    /** Iterates elements in order defined by "comparator" */
+    forEach(cb) {
+        this.data.inorderTraversal((k, v) => {
+            cb(k);
+            return false;
+        });
+    }
+    /** Iterates over `elem`s such that: range[0] &lt;= elem &lt; range[1]. */
+    forEachInRange(range, cb) {
+        const iter = this.data.getIteratorFrom(range[0]);
+        while (iter.hasNext()) {
+            const elem = iter.getNext();
+            if (this.comparator(elem.key, range[1]) >= 0) {
+                return;
+            }
+            cb(elem.key);
+        }
+    }
+    /**
+     * Iterates over `elem`s such that: start &lt;= elem until false is returned.
+     */
+    forEachWhile(cb, start) {
+        let iter;
+        if (start !== undefined) {
+            iter = this.data.getIteratorFrom(start);
+        }
+        else {
+            iter = this.data.getIterator();
+        }
+        while (iter.hasNext()) {
+            const elem = iter.getNext();
+            const result = cb(elem.key);
+            if (!result) {
+                return;
+            }
+        }
+    }
+    /** Finds the least element greater than or equal to `elem`. */
+    firstAfterOrEqual(elem) {
+        const iter = this.data.getIteratorFrom(elem);
+        return iter.hasNext() ? iter.getNext().key : null;
+    }
+    getIterator() {
+        return new SortedSetIterator(this.data.getIterator());
+    }
+    getIteratorFrom(key) {
+        return new SortedSetIterator(this.data.getIteratorFrom(key));
+    }
+    /** Inserts or updates an element */
+    add(elem) {
+        return this.copy(this.data.remove(elem).insert(elem, true));
+    }
+    /** Deletes an element */
+    delete(elem) {
+        if (!this.has(elem)) {
+            return this;
+        }
+        return this.copy(this.data.remove(elem));
+    }
+    isEmpty() {
+        return this.data.isEmpty();
+    }
+    unionWith(other) {
+        let result = this;
+        // Make sure `result` always refers to the larger one of the two sets.
+        if (result.size < other.size) {
+            result = other;
+            other = this;
+        }
+        other.forEach(elem => {
+            result = result.add(elem);
+        });
+        return result;
+    }
+    isEqual(other) {
+        if (!(other instanceof SortedSet)) {
+            return false;
+        }
+        if (this.size !== other.size) {
+            return false;
+        }
+        const thisIt = this.data.getIterator();
+        const otherIt = other.data.getIterator();
+        while (thisIt.hasNext()) {
+            const thisElem = thisIt.getNext().key;
+            const otherElem = otherIt.getNext().key;
+            if (this.comparator(thisElem, otherElem) !== 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toArray() {
+        const res = [];
+        this.forEach(targetId => {
+            res.push(targetId);
+        });
+        return res;
+    }
+    toString() {
+        const result = [];
+        this.forEach(elem => result.push(elem));
+        return 'SortedSet(' + result.toString() + ')';
+    }
+    copy(data) {
+        const result = new SortedSet(this.comparator);
+        result.data = data;
+        return result;
+    }
+}
+class SortedSetIterator {
+    constructor(iter) {
+        this.iter = iter;
+    }
+    getNext() {
+        return this.iter.getNext().key;
+    }
+    hasNext() {
+        return this.iter.hasNext();
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -1857,6 +2478,23 @@ class FieldMask {
         // Sort the field mask to support `FieldMask.isEqual()` and assert below.
         fields.sort(FieldPath$1.comparator);
     }
+    static empty() {
+        return new FieldMask([]);
+    }
+    /**
+     * Returns a new FieldMask object that is the result of adding all the given
+     * fields paths to this field mask.
+     */
+    unionWith(extraFields) {
+        let mergedMaskSet = new SortedSet(FieldPath$1.comparator);
+        for (const fieldPath of this.fields) {
+            mergedMaskSet = mergedMaskSet.add(fieldPath);
+        }
+        for (const fieldPath of extraFields) {
+            mergedMaskSet = mergedMaskSet.add(fieldPath);
+        }
+        return new FieldMask(mergedMaskSet.toArray());
+    }
     /**
      * Verifies that `fieldPath` is included by at least one field in this field
      * mask.
@@ -2194,6 +2832,13 @@ function isSafeInteger(value) {
  * limitations under the License.
  */
 const MAX_VALUE_TYPE = '__max__';
+const MAX_VALUE = {
+    mapValue: {
+        fields: {
+            '__type__': { stringValue: MAX_VALUE_TYPE }
+        }
+    }
+};
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
@@ -2228,7 +2873,7 @@ function typeOrder(value) {
             return 4 /* ServerTimestampValue */;
         }
         else if (isMaxValue(value)) {
-            return 9 /* ArrayValue */;
+            return 9007199254740991 /* MaxValue */;
         }
         return 10 /* ObjectValue */;
     }
@@ -2440,6 +3085,15 @@ function compareArrays(left, right) {
     return primitiveComparator(leftArray.length, rightArray.length);
 }
 function compareMaps(left, right) {
+    if (left === MAX_VALUE.mapValue && right === MAX_VALUE.mapValue) {
+        return 0;
+    }
+    else if (left === MAX_VALUE.mapValue) {
+        return 1;
+    }
+    else if (right === MAX_VALUE.mapValue) {
+        return -1;
+    }
     const leftMap = left.fields || {};
     const leftKeys = Object.keys(leftMap);
     const rightMap = right.fields || {};
@@ -2752,6 +3406,7 @@ class MutableDocument {
     }
     setHasLocalMutations() {
         this.documentState = 1 /* HAS_LOCAL_MUTATIONS */;
+        this.version = SnapshotVersion.min();
         return this;
     }
     setReadTime(readTime) {
@@ -3140,9 +3795,6 @@ class QueryImpl {
 function newQueryForPath(path) {
     return new QueryImpl(path);
 }
-function hasLimitToLast(query) {
-    return !isNullOrUndefined(query.limit) && query.limitType === "L" /* Last */;
-}
 function getFirstOrderByField(query) {
     return query.explicitOrderBy.length > 0
         ? query.explicitOrderBy[0].field
@@ -3243,10 +3895,10 @@ function queryToTarget(query) {
             }
             // We need to swap the cursors to match the now-flipped query ordering.
             const startAt = queryImpl.endAt
-                ? new Bound(queryImpl.endAt.position, !queryImpl.endAt.inclusive)
+                ? new Bound(queryImpl.endAt.position, queryImpl.endAt.inclusive)
                 : null;
             const endAt = queryImpl.startAt
-                ? new Bound(queryImpl.startAt.position, !queryImpl.startAt.inclusive)
+                ? new Bound(queryImpl.startAt.position, queryImpl.startAt.inclusive)
                 : null;
             // Now return as a LimitType.First query.
             queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, orderBys, queryImpl.filters, queryImpl.limit, startAt, endAt);
@@ -3496,6 +4148,9 @@ class SetMutation extends Mutation {
         this.fieldTransforms = fieldTransforms;
         this.type = 0 /* Set */;
     }
+    getFieldMask() {
+        return null;
+    }
 }
 /**
  * A mutation that modifies fields of the document at the given key with the
@@ -3520,6 +4175,9 @@ class PatchMutation extends Mutation {
         this.fieldTransforms = fieldTransforms;
         this.type = 1 /* Patch */;
     }
+    getFieldMask() {
+        return this.fieldMask;
+    }
 }
 /** A mutation that deletes the document at the given key. */
 class DeleteMutation extends Mutation {
@@ -3530,6 +4188,9 @@ class DeleteMutation extends Mutation {
         this.type = 2 /* Delete */;
         this.fieldTransforms = [];
     }
+    getFieldMask() {
+        return null;
+    }
 }
 /**
  * A mutation that verifies the existence of the document at the given key with
@@ -3546,6 +4207,9 @@ class VerifyMutation extends Mutation {
         this.type = 3 /* Verify */;
         this.fieldTransforms = [];
     }
+    getFieldMask() {
+        return null;
+    }
 }
 
 /**
@@ -6064,7 +6728,8 @@ function fieldPathFromArgument(methodName, arg) {
  * limitations under the License.
  */
 function validateHasExplicitOrderByForLimitToLast(query) {
-    if (hasLimitToLast(query) && query.explicitOrderBy.length === 0) {
+    if (query.limitType === "L" /* Last */ &&
+        query.explicitOrderBy.length === 0) {
         throw new FirestoreError(Code.UNIMPLEMENTED, 'limitToLast() queries require specifying at least one orderBy() clause');
     }
 }
@@ -6704,7 +7369,7 @@ function getDocs(query) {
     const userDataWriter = new LiteUserDataWriter(query.firestore);
     return invokeRunQueryRpc(datastore, query._query).then(result => {
         const docs = result.map(doc => new QueryDocumentSnapshot(query.firestore, userDataWriter, doc.key, doc, query.converter));
-        if (hasLimitToLast(query._query)) {
+        if (query._query.limitType === "L" /* Last */) {
             // 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.
@@ -6999,6 +7664,31 @@ function writeBatch(firestore) {
     return new WriteBatch(firestore, writes => invokeCommitRpc(datastore, writes));
 }
 
+/**
+ * @license
+ * Copyright 2022 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.
+ */
+const DEFAULT_TRANSACTION_OPTIONS = {
+    maxAttempts: 5
+};
+function validateTransactionOptions(options) {
+    if (options.maxAttempts < 1) {
+        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Max attempts must be at least 1');
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -7173,18 +7863,18 @@ class Transaction$1 {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-const DEFAULT_MAX_ATTEMPTS_COUNT = 5;
 /**
  * TransactionRunner encapsulates the logic needed to run and retry transactions
  * with backoff.
  */
 class TransactionRunner {
-    constructor(asyncQueue, datastore, updateFunction, deferred) {
+    constructor(asyncQueue, datastore, options, updateFunction, deferred) {
         this.asyncQueue = asyncQueue;
         this.datastore = datastore;
+        this.options = options;
         this.updateFunction = updateFunction;
         this.deferred = deferred;
-        this.attemptsRemaining = DEFAULT_MAX_ATTEMPTS_COUNT;
+        this.attemptsRemaining = options.maxAttempts;
         this.backoff = new ExponentialBackoff(this.asyncQueue, "transaction_retry" /* TransactionRetry */);
     }
     /** Runs the transaction and sets the result on deferred. */
@@ -7723,16 +8413,20 @@ class Transaction {
  * transaction against.
  * @param updateFunction - The function to execute within the transaction
  * context.
+ * @param options - An options object to configure maximum number of attempts to
+ * commit.
  * @returns If the transaction completed successfully or was explicitly aborted
  * (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 runTransaction(firestore, updateFunction) {
+function runTransaction(firestore, updateFunction, options) {
     firestore = cast(firestore, Firestore);
     const datastore = getDatastore(firestore);
+    const optionsWithDefaults = Object.assign(Object.assign({}, DEFAULT_TRANSACTION_OPTIONS), options);
+    validateTransactionOptions(optionsWithDefaults);
     const deferred = new Deferred();
-    new TransactionRunner(newAsyncQueue(), datastore, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)), deferred).run();
+    new TransactionRunner(newAsyncQueue(), datastore, optionsWithDefaults, internalTransaction => updateFunction(new Transaction(firestore, internalTransaction)), deferred).run();
     return deferred.promise;
 }