@firebase/firestore 3.4.7 → 3.4.8-canary.44948ac91

package/dist/index.node.mjs

@@ -8,7 +8,7 @@ import * as grpc from '@grpc/grpc-js';
 import * as protoLoader from '@grpc/proto-loader';
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.7";
+const version$1 = "3.4.8-canary.44948ac91";
 
 /**
  * @license
@@ -61,7 +61,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.10";
+const version = "9.6.11-canary.44948ac91";
 
 /**
  * @license
@@ -1393,13 +1393,14 @@ const DbIndexEntryKeyPath = [
     'uid',
     'arrayValue',
     'directionalValue',
+    'orderedDocumentKey',
     'documentKey'
 ];
 const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
 const DbIndexEntryDocumentKeyIndexPath = [
     'indexId',
     'uid',
-    'documentKey'
+    'orderedDocumentKey'
 ];
 /** Name of the IndexedDb object store. */
 const DbDocumentOverlayStore = 'documentOverlays';
@@ -2285,9 +2286,7 @@ class SimpleDbStore {
                     cursor.continue(controller.skipToKey);
                 }
             };
-        }).next(() => {
-            return PersistencePromise.waitFor(results);
-        });
+        }).next(() => PersistencePromise.waitFor(results));
     }
     options(indexOrRange, range) {
         let indexName = undefined;
@@ -4196,6 +4195,17 @@ function fieldIndexGetArraySegment(fieldIndex) {
 function fieldIndexGetDirectionalSegments(fieldIndex) {
     return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
 }
+/**
+ * Returns the order of the document key component for the given index.
+ *
+ * PORTING NOTE: This is only used in the Web IndexedDb implementation.
+ */
+function fieldIndexGetKeyOrder(fieldIndex) {
+    const directionalSegments = fieldIndexGetDirectionalSegments(fieldIndex);
+    return directionalSegments.length === 0
+        ? 0 /* ASCENDING */
+        : directionalSegments[directionalSegments.length - 1].kind;
+}
 /** Returns a debug representation of the field index */
 function fieldIndexToString(fieldIndex) {
     return `id=${fieldIndex.indexId}|cg=${fieldIndex.collectionGroup}|f=${fieldIndex.fields.map(f => `${f.fieldPath}:${f.kind}`).join(',')}`;
@@ -4300,7 +4310,7 @@ function indexOffsetComparator(left, right) {
 
 /**
  * @license
- * Copyright 2019 Google LLC
+ * 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.
@@ -4314,1488 +4324,1656 @@ function indexOffsetComparator(left, right) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-// Visible for testing
-class TargetImpl {
-    constructor(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
-        this.path = path;
-        this.collectionGroup = collectionGroup;
-        this.orderBy = orderBy;
-        this.filters = filters;
-        this.limit = limit;
-        this.startAt = startAt;
-        this.endAt = endAt;
-        this.memoizedCanonicalId = null;
+// 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;
     }
-}
-/**
- * Initializes a Target with a path and optional additional query constraints.
- * Path must currently be empty if this is a collection group query.
- *
- * NOTE: you should always construct `Target` from `Query.toTarget` instead of
- * using this factory method, because `Query` provides an implicit `orderBy`
- * property.
- */
-function newTarget(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
-    return new TargetImpl(path, collectionGroup, orderBy, filters, limit, startAt, endAt);
-}
-function canonifyTarget(target) {
-    const targetImpl = debugCast(target);
-    if (targetImpl.memoizedCanonicalId === null) {
-        let str = targetImpl.path.canonicalString();
-        if (targetImpl.collectionGroup !== null) {
-            str += '|cg:' + targetImpl.collectionGroup;
-        }
-        str += '|f:';
-        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
-        str += '|ob:';
-        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
-        if (!isNullOrUndefined(targetImpl.limit)) {
-            str += '|l:';
-            str += targetImpl.limit;
-        }
-        if (targetImpl.startAt) {
-            str += '|lb:';
-            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
-            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
-        }
-        if (targetImpl.endAt) {
-            str += '|ub:';
-            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
-            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
-        }
-        targetImpl.memoizedCanonicalId = str;
+    // 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));
     }
-    return targetImpl.memoizedCanonicalId;
-}
-function stringifyTarget(target) {
-    let str = target.path.canonicalString();
-    if (target.collectionGroup !== null) {
-        str += ' collectionGroup=' + target.collectionGroup;
+    // 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));
     }
-    if (target.filters.length > 0) {
-        str += `, filters: [${target.filters
-            .map(f => stringifyFilter(f))
-            .join(', ')}]`;
+    // 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;
     }
-    if (!isNullOrUndefined(target.limit)) {
-        str += ', limit: ' + target.limit;
+    // 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;
     }
-    if (target.orderBy.length > 0) {
-        str += `, orderBy: [${target.orderBy
-            .map(o => stringifyOrderBy(o))
-            .join(', ')}]`;
+    isEmpty() {
+        return this.root.isEmpty();
     }
-    if (target.startAt) {
-        str += ', startAt: ';
-        str += target.startAt.inclusive ? 'b:' : 'a:';
-        str += target.startAt.position.map(p => canonicalId(p)).join(',');
+    // Returns the total number of nodes in the map.
+    get size() {
+        return this.root.size;
     }
-    if (target.endAt) {
-        str += ', endAt: ';
-        str += target.endAt.inclusive ? 'a:' : 'b:';
-        str += target.endAt.position.map(p => canonicalId(p)).join(',');
+    // Returns the minimum key in the map.
+    minKey() {
+        return this.root.minKey();
     }
-    return `Target(${str})`;
-}
-function targetEquals(left, right) {
-    if (left.limit !== right.limit) {
-        return false;
+    // Returns the maximum key in the map.
+    maxKey() {
+        return this.root.maxKey();
     }
-    if (left.orderBy.length !== right.orderBy.length) {
-        return false;
+    // 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);
     }
-    for (let i = 0; i < left.orderBy.length; i++) {
-        if (!orderByEquals(left.orderBy[i], right.orderBy[i])) {
+    forEach(fn) {
+        this.inorderTraversal((k, v) => {
+            fn(k, v);
             return false;
-        }
-    }
-    if (left.filters.length !== right.filters.length) {
-        return false;
+        });
     }
-    for (let i = 0; i < left.filters.length; i++) {
-        if (!filterEquals(left.filters[i], right.filters[i])) {
+    toString() {
+        const descriptions = [];
+        this.inorderTraversal((k, v) => {
+            descriptions.push(`${k}:${v}`);
             return false;
-        }
-    }
-    if (left.collectionGroup !== right.collectionGroup) {
-        return false;
+        });
+        return `{${descriptions.join(', ')}}`;
     }
-    if (!left.path.isEqual(right.path)) {
-        return false;
+    // 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);
     }
-    if (!boundEquals(left.startAt, right.startAt)) {
-        return false;
+    // Returns an iterator over the SortedMap.
+    getIterator() {
+        return new SortedMapIterator(this.root, null, this.comparator, false);
     }
-    return boundEquals(left.endAt, right.endAt);
-}
-function targetIsDocumentTarget(target) {
-    return (DocumentKey.isDocumentKey(target.path) &&
-        target.collectionGroup === null &&
-        target.filters.length === 0);
-}
-/** Returns the field filters that target the given field path. */
-function targetGetFieldFiltersForPath(target, path) {
-    return target.filters.filter(f => f instanceof FieldFilter && f.field.isEqual(path));
-}
-/**
- * Returns the values that are used in ARRAY_CONTAINS or ARRAY_CONTAINS_ANY
- * filters. Returns `null` if there are no such filters.
- */
-function targetGetArrayValues(target, fieldIndex) {
-    const segment = fieldIndexGetArraySegment(fieldIndex);
-    if (segment === undefined) {
-        return null;
+    getIteratorFrom(key) {
+        return new SortedMapIterator(this.root, key, this.comparator, false);
     }
-    for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-        switch (fieldFilter.op) {
-            case "array-contains-any" /* ARRAY_CONTAINS_ANY */:
-                return fieldFilter.value.arrayValue.values || [];
-            case "array-contains" /* ARRAY_CONTAINS */:
-                return [fieldFilter.value];
-            // Remaining filters are not array filters.
-        }
+    getReverseIterator() {
+        return new SortedMapIterator(this.root, null, this.comparator, true);
     }
-    return null;
-}
-/**
- * Returns the list of values that are used in != or NOT_IN filters. Returns
- * `null` if there are no such filters.
- */
-function targetGetNotInValues(target, fieldIndex) {
-    const values = new Map();
-    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            switch (fieldFilter.op) {
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                    // Encode equality prefix, which is encoded in the index value before
-                    // the inequality (e.g. `a == 'a' && b != 'b'` is encoded to
-                    // `value != 'ab'`).
-                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
-                    break;
-                case "not-in" /* NOT_IN */:
-                case "!=" /* NOT_EQUAL */:
-                    // NotIn/NotEqual is always a suffix. There cannot be any remaining
-                    // segments and hence we can return early here.
-                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
-                    return Array.from(values.values());
-                // Remaining filters cannot be used as notIn bounds.
-            }
-        }
+    getReverseIteratorFrom(key) {
+        return new SortedMapIterator(this.root, key, this.comparator, true);
     }
-    return null;
-}
-/**
- * Returns a lower bound of field values that can be used as a starting point to
- * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
- * exists.
- */
-function targetGetLowerBound(target, fieldIndex) {
-    const values = [];
-    let inclusive = true;
-    // For each segment, retrieve a lower bound if there is a suitable filter or
-    // startAt.
-    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        let segmentValue = undefined;
-        let segmentInclusive = true;
-        // Process all filters to find a value for the current field segment
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            let filterValue = undefined;
-            let filterInclusive = true;
-            switch (fieldFilter.op) {
-                case "<" /* LESS_THAN */:
-                case "<=" /* LESS_THAN_OR_EQUAL */:
-                    filterValue = valuesGetLowerBound(fieldFilter.value);
-                    break;
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                case ">=" /* GREATER_THAN_OR_EQUAL */:
-                    filterValue = fieldFilter.value;
-                    break;
-                case ">" /* GREATER_THAN */:
-                    filterValue = fieldFilter.value;
-                    filterInclusive = false;
-                    break;
-                case "!=" /* NOT_EQUAL */:
-                case "not-in" /* NOT_IN */:
-                    filterValue = MIN_VALUE;
-                    break;
-                // Remaining filters cannot be used as lower bounds.
-            }
-            if (valuesMax(segmentValue, filterValue) === filterValue) {
-                segmentValue = filterValue;
-                segmentInclusive = filterInclusive;
-            }
-        }
-        // If there is a startAt bound, compare the values against the existing
-        // boundary to see if we can narrow the scope.
-        if (target.startAt !== null) {
-            for (let i = 0; i < target.orderBy.length; ++i) {
-                const orderBy = target.orderBy[i];
-                if (orderBy.field.isEqual(segment.fieldPath)) {
-                    const cursorValue = target.startAt.position[i];
-                    if (valuesMax(segmentValue, cursorValue) === cursorValue) {
-                        segmentValue = cursorValue;
-                        segmentInclusive = target.startAt.inclusive;
-                    }
-                    break;
+} // 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;
                 }
             }
         }
-        if (segmentValue === undefined) {
-            // No lower bound exists
-            return null;
-        }
-        values.push(segmentValue);
-        inclusive && (inclusive = segmentInclusive);
     }
-    return new Bound(values, inclusive);
-}
-/**
- * Returns an upper bound of field values that can be used as an ending point
- * when scanning the index defined by `fieldIndex`. Returns `null` if no
- * upper bound exists.
- */
-function targetGetUpperBound(target, fieldIndex) {
-    const values = [];
-    let inclusive = true;
-    // For each segment, retrieve an upper bound if there is a suitable filter or
-    // endAt.
-    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
-        let segmentValue = undefined;
-        let segmentInclusive = true;
-        // Process all filters to find a value for the current field segment
-        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
-            let filterValue = undefined;
-            let filterInclusive = true;
-            switch (fieldFilter.op) {
-                case ">=" /* GREATER_THAN_OR_EQUAL */:
-                case ">" /* GREATER_THAN */:
-                    filterValue = valuesGetUpperBound(fieldFilter.value);
-                    filterInclusive = false;
-                    break;
-                case "==" /* EQUAL */:
-                case "in" /* IN */:
-                case "<=" /* LESS_THAN_OR_EQUAL */:
-                    filterValue = fieldFilter.value;
-                    break;
-                case "<" /* LESS_THAN */:
-                    filterValue = fieldFilter.value;
-                    filterInclusive = false;
-                    break;
-                case "!=" /* NOT_EQUAL */:
-                case "not-in" /* NOT_IN */:
-                    filterValue = MAX_VALUE;
-                    break;
-                // Remaining filters cannot be used as upper bounds.
-            }
-            if (valuesMin(segmentValue, filterValue) === filterValue) {
-                segmentValue = filterValue;
-                segmentInclusive = filterInclusive;
-            }
-        }
-        // If there is a endAt bound, compare the values against the existing
-        // boundary to see if we can narrow the scope.
-        if (target.endAt !== null) {
-            for (let i = 0; i < target.orderBy.length; ++i) {
-                const orderBy = target.orderBy[i];
-                if (orderBy.field.isEqual(segment.fieldPath)) {
-                    const cursorValue = target.endAt.position[i];
-                    if (valuesMin(segmentValue, cursorValue) === cursorValue) {
-                        segmentValue = cursorValue;
-                        segmentInclusive = target.endAt.inclusive;
-                    }
-                    break;
-                }
+    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;
             }
         }
-        if (segmentValue === undefined) {
-            // No upper bound exists
+        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;
         }
-        values.push(segmentValue);
-        inclusive && (inclusive = segmentInclusive);
+        const node = this.nodeStack[this.nodeStack.length - 1];
+        return { key: node.key, value: node.value };
     }
-    return new Bound(values, inclusive);
-}
-class Filter {
-}
-class FieldFilter extends Filter {
-    constructor(field, op, value) {
-        super();
-        this.field = field;
-        this.op = op;
+} // 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;
     }
-    /**
-     * Creates a filter based on the provided arguments.
-     */
-    static create(field, op, value) {
-        if (field.isKeyField()) {
-            if (op === "in" /* IN */ || op === "not-in" /* NOT_IN */) {
-                return this.createKeyFieldInFilter(field, op, value);
-            }
-            else {
-                return new KeyFieldFilter(field, op, value);
-            }
+    // 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 if (op === "array-contains" /* ARRAY_CONTAINS */) {
-            return new ArrayContainsFilter(field, value);
+        else {
+            return this.left.min();
         }
-        else if (op === "in" /* IN */) {
-            return new InFilter(field, value);
+    }
+    // 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 if (op === "not-in" /* NOT_IN */) {
-            return new NotInFilter(field, value);
+        else {
+            return this.right.maxKey();
         }
-        else if (op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
-            return new ArrayContainsAnyFilter(field, value);
+    }
+    // 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 {
-            return new FieldFilter(field, op, value);
+            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
         }
+        return n.fixUp();
     }
-    static createKeyFieldInFilter(field, op, value) {
-        return op === "in" /* IN */
-            ? new KeyFieldInFilter(field, value)
-            : new KeyFieldNotInFilter(field, value);
-    }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        // Types do not have to match in NOT_EQUAL filters.
-        if (this.op === "!=" /* NOT_EQUAL */) {
-            return (other !== null &&
-                this.matchesComparison(valueCompare(other, this.value)));
+    removeMin() {
+        if (this.left.isEmpty()) {
+            return LLRBNode.EMPTY;
         }
-        // Only compare types with matching backend order (such as double and int).
-        return (other !== null &&
-            typeOrder(this.value) === typeOrder(other) &&
-            this.matchesComparison(valueCompare(other, this.value)));
-    }
-    matchesComparison(comparison) {
-        switch (this.op) {
-            case "<" /* LESS_THAN */:
-                return comparison < 0;
-            case "<=" /* LESS_THAN_OR_EQUAL */:
-                return comparison <= 0;
-            case "==" /* EQUAL */:
-                return comparison === 0;
-            case "!=" /* NOT_EQUAL */:
-                return comparison !== 0;
-            case ">" /* GREATER_THAN */:
-                return comparison > 0;
-            case ">=" /* GREATER_THAN_OR_EQUAL */:
-                return comparison >= 0;
-            default:
-                return fail();
+        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();
     }
-    isInequality() {
-        return ([
-            "<" /* LESS_THAN */,
-            "<=" /* LESS_THAN_OR_EQUAL */,
-            ">" /* GREATER_THAN */,
-            ">=" /* GREATER_THAN_OR_EQUAL */,
-            "!=" /* NOT_EQUAL */,
-            "not-in" /* NOT_IN */
-        ].indexOf(this.op) >= 0);
+    // 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();
     }
-}
-function canonifyFilter(filter) {
-    // TODO(b/29183165): Technically, this won't be unique if two values have
-    // the same description, such as the int 3 and the string "3". So we should
-    // add the types in here somehow, too.
-    return (filter.field.canonicalString() +
-        filter.op.toString() +
-        canonicalId(filter.value));
-}
-function filterEquals(f1, f2) {
-    return (f1.op === f2.op &&
-        f1.field.isEqual(f2.field) &&
-        valueEquals(f1.value, f2.value));
-}
-/** Returns a debug description for `filter`. */
-function stringifyFilter(filter) {
-    return `${filter.field.canonicalString()} ${filter.op} ${canonicalId(filter.value)}`;
-}
-/** Filter that matches on key fields (i.e. '__name__'). */
-class KeyFieldFilter extends FieldFilter {
-    constructor(field, op, value) {
-        super(field, op, value);
-        this.key = DocumentKey.fromName(value.referenceValue);
+    isRed() {
+        return this.color;
     }
-    matches(doc) {
-        const comparison = DocumentKey.comparator(doc.key, this.key);
-        return this.matchesComparison(comparison);
+    // 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;
     }
-}
-/** Filter that matches on key fields within an array. */
-class KeyFieldInFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "in" /* IN */, value);
-        this.keys = extractDocumentKeysFromArrayValue("in" /* IN */, value);
+    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;
     }
-    matches(doc) {
-        return this.keys.some(key => key.isEqual(doc.key));
+    moveRedRight() {
+        let n = this.colorFlip();
+        if (n.left.left.isRed()) {
+            n = n.rotateRight();
+            n = n.colorFlip();
+        }
+        return n;
     }
-}
-/** Filter that matches on key fields not present within an array. */
-class KeyFieldNotInFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "not-in" /* NOT_IN */, value);
-        this.keys = extractDocumentKeysFromArrayValue("not-in" /* NOT_IN */, value);
+    rotateLeft() {
+        const nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);
+        return this.right.copy(null, null, this.color, nl, null);
     }
-    matches(doc) {
-        return !this.keys.some(key => key.isEqual(doc.key));
+    rotateRight() {
+        const nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);
+        return this.left.copy(null, null, this.color, null, nr);
     }
-}
-function extractDocumentKeysFromArrayValue(op, value) {
-    var _a;
-    return (((_a = value.arrayValue) === null || _a === void 0 ? void 0 : _a.values) || []).map(v => {
-        return DocumentKey.fromName(v.referenceValue);
-    });
-}
-/** A Filter that implements the array-contains operator. */
-class ArrayContainsFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "array-contains" /* ARRAY_CONTAINS */, value);
+    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);
     }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        return isArray(other) && arrayValueContains(other.arrayValue, this.value);
+    // For testing.
+    checkMaxDepth() {
+        const blackDepth = this.check();
+        if (Math.pow(2.0, blackDepth) <= this.size + 1) {
+            return true;
+        }
+        else {
+            return false;
+        }
     }
-}
-/** A Filter that implements the IN operator. */
-class InFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "in" /* IN */, value);
+    // 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);
+        }
     }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        return other !== null && arrayValueContains(this.value.arrayValue, other);
+} // 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;
     }
-}
-/** A Filter that implements the not-in operator. */
-class NotInFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "not-in" /* NOT_IN */, value);
+    get key() {
+        throw fail();
     }
-    matches(doc) {
-        if (arrayValueContains(this.value.arrayValue, { nullValue: 'NULL_VALUE' })) {
-            return false;
-        }
-        const other = doc.data.field(this.field);
-        return other !== null && !arrayValueContains(this.value.arrayValue, other);
+    get value() {
+        throw fail();
     }
-}
-/** A Filter that implements the array-contains-any operator. */
-class ArrayContainsAnyFilter extends FieldFilter {
-    constructor(field, value) {
-        super(field, "array-contains-any" /* ARRAY_CONTAINS_ANY */, value);
+    get color() {
+        throw fail();
     }
-    matches(doc) {
-        const other = doc.data.field(this.field);
-        if (!isArray(other) || !other.arrayValue.values) {
-            return false;
-        }
-        return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
+    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();
+
 /**
- * Represents a bound of a query.
+ * @license
+ * Copyright 2017 Google LLC
  *
- * The bound is specified with the given components representing a position and
- * whether it's just before or just after the position (relative to whatever the
- * query order is).
+ * 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
  *
- * The position represents a logical index position for a query. It's a prefix
- * of values for the (potentially implicit) order by clauses of a query.
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- * Bound provides a function to determine whether a document comes before or
- * after a bound. This is influenced by whether the position is just before or
- * just after the provided values.
+ * 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.
  */
-class Bound {
-    constructor(position, inclusive) {
-        this.position = position;
-        this.inclusive = inclusive;
-    }
-}
 /**
- * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
+ * 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 OrderBy {
-    constructor(field, dir = "asc" /* ASCENDING */) {
-        this.field = field;
-        this.dir = dir;
+class SortedSet {
+    constructor(comparator) {
+        this.comparator = comparator;
+        this.data = new SortedMap(this.comparator);
     }
-}
-function canonifyOrderBy(orderBy) {
-    // TODO(b/29183165): Make this collision robust.
-    return orderBy.field.canonicalString() + orderBy.dir;
-}
-function stringifyOrderBy(orderBy) {
-    return `${orderBy.field.canonicalString()} (${orderBy.dir})`;
-}
-function orderByEquals(left, right) {
-    return left.dir === right.dir && left.field.isEqual(right.field);
-}
-function boundCompareToDocument(bound, orderBy, doc) {
-    let comparison = 0;
-    for (let i = 0; i < bound.position.length; i++) {
-        const orderByComponent = orderBy[i];
-        const component = bound.position[i];
-        if (orderByComponent.field.isKeyField()) {
-            comparison = DocumentKey.comparator(DocumentKey.fromName(component.referenceValue), doc.key);
+    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);
         }
-        else {
-            const docValue = doc.data.field(orderByComponent.field);
-            comparison = valueCompare(component, docValue);
+    }
+    /**
+     * 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);
         }
-        if (orderByComponent.dir === "desc" /* DESCENDING */) {
-            comparison = comparison * -1;
+        else {
+            iter = this.data.getIterator();
         }
-        if (comparison !== 0) {
-            break;
+        while (iter.hasNext()) {
+            const elem = iter.getNext();
+            const result = cb(elem.key);
+            if (!result) {
+                return;
+            }
         }
     }
-    return comparison;
-}
-/**
- * Returns true if a document sorts after a bound using the provided sort
- * order.
- */
-function boundSortsAfterDocument(bound, orderBy, doc) {
-    const comparison = boundCompareToDocument(bound, orderBy, doc);
-    return bound.inclusive ? comparison >= 0 : comparison > 0;
-}
-/**
- * Returns true if a document sorts before a bound using the provided sort
- * order.
- */
-function boundSortsBeforeDocument(bound, orderBy, doc) {
-    const comparison = boundCompareToDocument(bound, orderBy, doc);
-    return bound.inclusive ? comparison <= 0 : comparison < 0;
-}
-function boundEquals(left, right) {
-    if (left === null) {
-        return right === null;
+    /** 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;
     }
-    else if (right === null) {
-        return false;
+    getIterator() {
+        return new SortedSetIterator(this.data.getIterator());
     }
-    if (left.inclusive !== right.inclusive ||
-        left.position.length !== right.position.length) {
-        return false;
+    getIteratorFrom(key) {
+        return new SortedSetIterator(this.data.getIteratorFrom(key));
     }
-    for (let i = 0; i < left.position.length; i++) {
-        const leftPosition = left.position[i];
-        const rightPosition = right.position[i];
-        if (!valueEquals(leftPosition, rightPosition)) {
+    /** 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;
     }
-    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.
- */
-/**
- * Query encapsulates all the query attributes we support in the SDK. It can
- * be run against the LocalStore, as well as be converted to a `Target` to
- * query the RemoteStore results.
- *
- * Visible for testing.
- */
-class QueryImpl {
-    /**
-     * Initializes a Query with a path and optional additional query constraints.
-     * Path must currently be empty if this is a collection group query.
-     */
-    constructor(path, collectionGroup = null, explicitOrderBy = [], filters = [], limit = null, limitType = "F" /* First */, startAt = null, endAt = null) {
-        this.path = path;
-        this.collectionGroup = collectionGroup;
-        this.explicitOrderBy = explicitOrderBy;
-        this.filters = filters;
-        this.limit = limit;
-        this.limitType = limitType;
-        this.startAt = startAt;
-        this.endAt = endAt;
-        this.memoizedOrderBy = null;
-        // The corresponding `Target` of this `Query` instance.
-        this.memoizedTarget = null;
-        if (this.startAt) ;
-        if (this.endAt) ;
+    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;
     }
 }
-/** Creates a new Query instance with the options provided. */
-function newQuery(path, collectionGroup, explicitOrderBy, filters, limit, limitType, startAt, endAt) {
-    return new QueryImpl(path, collectionGroup, explicitOrderBy, filters, limit, limitType, startAt, endAt);
-}
-/** Creates a new Query for a query that matches all documents at `path` */
-function newQueryForPath(path) {
-    return new QueryImpl(path);
+class SortedSetIterator {
+    constructor(iter) {
+        this.iter = iter;
+    }
+    getNext() {
+        return this.iter.getNext().key;
+    }
+    hasNext() {
+        return this.iter.hasNext();
+    }
 }
 /**
- * Helper to convert a collection group query into a collection query at a
- * specific path. This is used when executing collection group queries, since
- * we have to split the query into a set of collection queries at multiple
- * paths.
- */
-function asCollectionQueryAtPath(query, path) {
-    return new QueryImpl(path, 
-    /*collectionGroup=*/ null, query.explicitOrderBy.slice(), query.filters.slice(), query.limit, query.limitType, query.startAt, query.endAt);
-}
-/**
- * Returns true if this query does not specify any query constraints that
- * could remove results.
+ * Compares two sorted sets for equality using their natural ordering. The
+ * method computes the intersection and invokes `onAdd` for every element that
+ * is in `after` but not `before`. `onRemove` is invoked for every element in
+ * `before` but missing from `after`.
+ *
+ * The method creates a copy of both `before` and `after` and runs in O(n log
+ * n), where n is the size of the two lists.
+ *
+ * @param before - The elements that exist in the original set.
+ * @param after - The elements to diff against the original set.
+ * @param comparator - The comparator for the elements in before and after.
+ * @param onAdd - A function to invoke for every element that is part of `
+ * after` but not `before`.
+ * @param onRemove - A function to invoke for every element that is part of
+ * `before` but not `after`.
  */
-function matchesAllDocuments(query) {
-    return (query.filters.length === 0 &&
-        query.limit === null &&
-        query.startAt == null &&
-        query.endAt == null &&
-        (query.explicitOrderBy.length === 0 ||
-            (query.explicitOrderBy.length === 1 &&
-                query.explicitOrderBy[0].field.isKeyField())));
-}
-function hasLimitToFirst(query) {
-    return !isNullOrUndefined(query.limit) && query.limitType === "F" /* First */;
-}
-function hasLimitToLast(query) {
-    return !isNullOrUndefined(query.limit) && query.limitType === "L" /* Last */;
-}
-function getFirstOrderByField(query) {
-    return query.explicitOrderBy.length > 0
-        ? query.explicitOrderBy[0].field
-        : null;
-}
-function getInequalityFilterField(query) {
-    for (const filter of query.filters) {
-        if (filter.isInequality()) {
-            return filter.field;
+function diffSortedSets(before, after, comparator, onAdd, onRemove) {
+    const beforeIt = before.getIterator();
+    const afterIt = after.getIterator();
+    let beforeValue = advanceIterator(beforeIt);
+    let afterValue = advanceIterator(afterIt);
+    // Walk through the two sets at the same time, using the ordering defined by
+    // `comparator`.
+    while (beforeValue || afterValue) {
+        let added = false;
+        let removed = false;
+        if (beforeValue && afterValue) {
+            const cmp = comparator(beforeValue, afterValue);
+            if (cmp < 0) {
+                // The element was removed if the next element in our ordered
+                // walkthrough is only in `before`.
+                removed = true;
+            }
+            else if (cmp > 0) {
+                // The element was added if the next element in our ordered walkthrough
+                // is only in `after`.
+                added = true;
+            }
         }
-    }
-    return null;
-}
-/**
- * Checks if any of the provided Operators are included in the query and
- * returns the first one that is, or null if none are.
- */
-function findFilterOperator(query, operators) {
-    for (const filter of query.filters) {
-        if (operators.indexOf(filter.op) >= 0) {
-            return filter.op;
+        else if (beforeValue != null) {
+            removed = true;
+        }
+        else {
+            added = true;
+        }
+        if (added) {
+            onAdd(afterValue);
+            afterValue = advanceIterator(afterIt);
+        }
+        else if (removed) {
+            onRemove(beforeValue);
+            beforeValue = advanceIterator(beforeIt);
+        }
+        else {
+            beforeValue = advanceIterator(beforeIt);
+            afterValue = advanceIterator(afterIt);
         }
     }
-    return null;
 }
 /**
- * Creates a new Query for a collection group query that matches all documents
- * within the provided collection group.
+ * Returns the next element from the iterator or `undefined` if none available.
  */
-function newQueryForCollectionGroup(collectionId) {
-    return new QueryImpl(ResourcePath.emptyPath(), collectionId);
-}
+function advanceIterator(it) {
+    return it.hasNext() ? it.getNext() : undefined;
+}
+
 /**
- * Returns whether the query matches a single document by path (rather than a
- * collection).
+ * @license
+ * Copyright 2019 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.
  */
-function isDocumentQuery$1(query) {
-    return (DocumentKey.isDocumentKey(query.path) &&
-        query.collectionGroup === null &&
-        query.filters.length === 0);
+// Visible for testing
+class TargetImpl {
+    constructor(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
+        this.path = path;
+        this.collectionGroup = collectionGroup;
+        this.orderBy = orderBy;
+        this.filters = filters;
+        this.limit = limit;
+        this.startAt = startAt;
+        this.endAt = endAt;
+        this.memoizedCanonicalId = null;
+    }
 }
 /**
- * Returns whether the query matches a collection group rather than a specific
- * collection.
+ * Initializes a Target with a path and optional additional query constraints.
+ * Path must currently be empty if this is a collection group query.
+ *
+ * NOTE: you should always construct `Target` from `Query.toTarget` instead of
+ * using this factory method, because `Query` provides an implicit `orderBy`
+ * property.
  */
-function isCollectionGroupQuery(query) {
-    return query.collectionGroup !== null;
+function newTarget(path, collectionGroup = null, orderBy = [], filters = [], limit = null, startAt = null, endAt = null) {
+    return new TargetImpl(path, collectionGroup, orderBy, filters, limit, startAt, endAt);
 }
-/**
- * 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 queryOrderBy(query) {
-    const queryImpl = debugCast(query);
-    if (queryImpl.memoizedOrderBy === null) {
-        queryImpl.memoizedOrderBy = [];
-        const inequalityField = getInequalityFilterField(queryImpl);
-        const firstOrderByField = getFirstOrderByField(queryImpl);
-        if (inequalityField !== null && firstOrderByField === null) {
-            // 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.
-            if (!inequalityField.isKeyField()) {
-                queryImpl.memoizedOrderBy.push(new OrderBy(inequalityField));
-            }
-            queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), "asc" /* ASCENDING */));
+function canonifyTarget(target) {
+    const targetImpl = debugCast(target);
+    if (targetImpl.memoizedCanonicalId === null) {
+        let str = targetImpl.path.canonicalString();
+        if (targetImpl.collectionGroup !== null) {
+            str += '|cg:' + targetImpl.collectionGroup;
         }
-        else {
-            let foundKeyOrdering = false;
-            for (const orderBy of queryImpl.explicitOrderBy) {
-                queryImpl.memoizedOrderBy.push(orderBy);
-                if (orderBy.field.isKeyField()) {
-                    foundKeyOrdering = true;
-                }
-            }
-            if (!foundKeyOrdering) {
-                // The order of the implicit key ordering always matches the last
-                // explicit order by
-                const lastDirection = queryImpl.explicitOrderBy.length > 0
-                    ? queryImpl.explicitOrderBy[queryImpl.explicitOrderBy.length - 1]
-                        .dir
-                    : "asc" /* ASCENDING */;
-                queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), lastDirection));
-            }
+        str += '|f:';
+        str += targetImpl.filters.map(f => canonifyFilter(f)).join(',');
+        str += '|ob:';
+        str += targetImpl.orderBy.map(o => canonifyOrderBy(o)).join(',');
+        if (!isNullOrUndefined(targetImpl.limit)) {
+            str += '|l:';
+            str += targetImpl.limit;
         }
-    }
-    return queryImpl.memoizedOrderBy;
-}
-/**
- * Converts this `Query` instance to it's corresponding `Target` representation.
- */
-function queryToTarget(query) {
-    const queryImpl = debugCast(query);
-    if (!queryImpl.memoizedTarget) {
-        if (queryImpl.limitType === "F" /* First */) {
-            queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, queryOrderBy(queryImpl), queryImpl.filters, queryImpl.limit, queryImpl.startAt, queryImpl.endAt);
+        if (targetImpl.startAt) {
+            str += '|lb:';
+            str += targetImpl.startAt.inclusive ? 'b:' : 'a:';
+            str += targetImpl.startAt.position.map(p => canonicalId(p)).join(',');
         }
-        else {
-            // Flip the orderBy directions since we want the last results
-            const orderBys = [];
-            for (const orderBy of queryOrderBy(queryImpl)) {
-                const dir = orderBy.dir === "desc" /* DESCENDING */
-                    ? "asc" /* ASCENDING */
-                    : "desc" /* DESCENDING */;
-                orderBys.push(new OrderBy(orderBy.field, dir));
-            }
-            // 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)
-                : null;
-            const endAt = queryImpl.startAt
-                ? 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);
+        if (targetImpl.endAt) {
+            str += '|ub:';
+            str += targetImpl.endAt.inclusive ? 'a:' : 'b:';
+            str += targetImpl.endAt.position.map(p => canonicalId(p)).join(',');
         }
+        targetImpl.memoizedCanonicalId = str;
     }
-    return queryImpl.memoizedTarget;
-}
-function queryWithAddedFilter(query, filter) {
-    const newFilters = query.filters.concat([filter]);
-    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), newFilters, query.limit, query.limitType, query.startAt, query.endAt);
-}
-function queryWithAddedOrderBy(query, orderBy) {
-    // TODO(dimond): validate that orderBy does not list the same key twice.
-    const newOrderBy = query.explicitOrderBy.concat([orderBy]);
-    return new QueryImpl(query.path, query.collectionGroup, newOrderBy, query.filters.slice(), query.limit, query.limitType, query.startAt, query.endAt);
-}
-function queryWithLimit(query, limit, limitType) {
-    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), limit, limitType, query.startAt, query.endAt);
-}
-function queryWithStartAt(query, bound) {
-    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), query.limit, query.limitType, bound, query.endAt);
-}
-function queryWithEndAt(query, bound) {
-    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), query.limit, query.limitType, query.startAt, bound);
+    return targetImpl.memoizedCanonicalId;
 }
-function queryEquals(left, right) {
-    return (targetEquals(queryToTarget(left), queryToTarget(right)) &&
-        left.limitType === right.limitType);
-}
-// TODO(b/29183165): This is used to get a unique string from a query to, for
-// example, use as a dictionary key, but the implementation is subject to
-// collisions. Make it collision-free.
-function canonifyQuery(query) {
-    return `${canonifyTarget(queryToTarget(query))}|lt:${query.limitType}`;
-}
-function stringifyQuery(query) {
-    return `Query(target=${stringifyTarget(queryToTarget(query))}; limitType=${query.limitType})`;
-}
-/** Returns whether `doc` matches the constraints of `query`. */
-function queryMatches(query, doc) {
-    return (doc.isFoundDocument() &&
-        queryMatchesPathAndCollectionGroup(query, doc) &&
-        queryMatchesOrderBy(query, doc) &&
-        queryMatchesFilters(query, doc) &&
-        queryMatchesBounds(query, doc));
-}
-function queryMatchesPathAndCollectionGroup(query, doc) {
-    const docPath = doc.key.path;
-    if (query.collectionGroup !== null) {
-        // NOTE: this.path is currently always empty since we don't expose Collection
-        // Group queries rooted at a document path yet.
-        return (doc.key.hasCollectionId(query.collectionGroup) &&
-            query.path.isPrefixOf(docPath));
+function stringifyTarget(target) {
+    let str = target.path.canonicalString();
+    if (target.collectionGroup !== null) {
+        str += ' collectionGroup=' + target.collectionGroup;
     }
-    else if (DocumentKey.isDocumentKey(query.path)) {
-        // exact match for document queries
-        return query.path.isEqual(docPath);
+    if (target.filters.length > 0) {
+        str += `, filters: [${target.filters
+            .map(f => stringifyFilter(f))
+            .join(', ')}]`;
     }
-    else {
-        // shallow ancestor queries by default
-        return query.path.isImmediateParentOf(docPath);
+    if (!isNullOrUndefined(target.limit)) {
+        str += ', limit: ' + target.limit;
+    }
+    if (target.orderBy.length > 0) {
+        str += `, orderBy: [${target.orderBy
+            .map(o => stringifyOrderBy(o))
+            .join(', ')}]`;
+    }
+    if (target.startAt) {
+        str += ', startAt: ';
+        str += target.startAt.inclusive ? 'b:' : 'a:';
+        str += target.startAt.position.map(p => canonicalId(p)).join(',');
+    }
+    if (target.endAt) {
+        str += ', endAt: ';
+        str += target.endAt.inclusive ? 'a:' : 'b:';
+        str += target.endAt.position.map(p => canonicalId(p)).join(',');
     }
+    return `Target(${str})`;
 }
-/**
- * A document must have a value for every ordering clause in order to show up
- * in the results.
- */
-function queryMatchesOrderBy(query, doc) {
-    for (const orderBy of query.explicitOrderBy) {
-        // order by key always matches
-        if (!orderBy.field.isKeyField() && doc.data.field(orderBy.field) === null) {
+function targetEquals(left, right) {
+    if (left.limit !== right.limit) {
+        return false;
+    }
+    if (left.orderBy.length !== right.orderBy.length) {
+        return false;
+    }
+    for (let i = 0; i < left.orderBy.length; i++) {
+        if (!orderByEquals(left.orderBy[i], right.orderBy[i])) {
             return false;
         }
     }
-    return true;
-}
-function queryMatchesFilters(query, doc) {
-    for (const filter of query.filters) {
-        if (!filter.matches(doc)) {
+    if (left.filters.length !== right.filters.length) {
+        return false;
+    }
+    for (let i = 0; i < left.filters.length; i++) {
+        if (!filterEquals(left.filters[i], right.filters[i])) {
             return false;
         }
     }
-    return true;
-}
-/** Makes sure a document is within the bounds, if provided. */
-function queryMatchesBounds(query, doc) {
-    if (query.startAt &&
-        !boundSortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
+    if (left.collectionGroup !== right.collectionGroup) {
         return false;
     }
-    if (query.endAt &&
-        !boundSortsAfterDocument(query.endAt, queryOrderBy(query), doc)) {
+    if (!left.path.isEqual(right.path)) {
         return false;
     }
-    return true;
+    if (!boundEquals(left.startAt, right.startAt)) {
+        return false;
+    }
+    return boundEquals(left.endAt, right.endAt);
+}
+function targetIsDocumentTarget(target) {
+    return (DocumentKey.isDocumentKey(target.path) &&
+        target.collectionGroup === null &&
+        target.filters.length === 0);
+}
+/** Returns the field filters that target the given field path. */
+function targetGetFieldFiltersForPath(target, path) {
+    return target.filters.filter(f => f instanceof FieldFilter && f.field.isEqual(path));
 }
 /**
- * Returns the collection group that this query targets.
- *
- * PORTING NOTE: This is only used in the Web SDK to facilitate multi-tab
- * synchronization for query results.
+ * Returns the values that are used in ARRAY_CONTAINS or ARRAY_CONTAINS_ANY
+ * filters. Returns `null` if there are no such filters.
  */
-function queryCollectionGroup(query) {
-    return (query.collectionGroup ||
-        (query.path.length % 2 === 1
-            ? query.path.lastSegment()
-            : query.path.get(query.path.length - 2)));
+function targetGetArrayValues(target, fieldIndex) {
+    const segment = fieldIndexGetArraySegment(fieldIndex);
+    if (segment === undefined) {
+        return null;
+    }
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+        switch (fieldFilter.op) {
+            case "array-contains-any" /* ARRAY_CONTAINS_ANY */:
+                return fieldFilter.value.arrayValue.values || [];
+            case "array-contains" /* ARRAY_CONTAINS */:
+                return [fieldFilter.value];
+            // Remaining filters are not array filters.
+        }
+    }
+    return null;
 }
 /**
- * Returns a new comparator function that can be used to compare two documents
- * based on the Query's ordering constraint.
+ * Returns the list of values that are used in != or NOT_IN filters. Returns
+ * `null` if there are no such filters.
  */
-function newQueryComparator(query) {
-    return (d1, d2) => {
-        let comparedOnKeyField = false;
-        for (const orderBy of queryOrderBy(query)) {
-            const comp = compareDocs(orderBy, d1, d2);
-            if (comp !== 0) {
-                return comp;
+function targetGetNotInValues(target, fieldIndex) {
+    const values = new Map();
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        for (const fieldFilter of targetGetFieldFiltersForPath(target, segment.fieldPath)) {
+            switch (fieldFilter.op) {
+                case "==" /* EQUAL */:
+                case "in" /* IN */:
+                    // Encode equality prefix, which is encoded in the index value before
+                    // the inequality (e.g. `a == 'a' && b != 'b'` is encoded to
+                    // `value != 'ab'`).
+                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
+                    break;
+                case "not-in" /* NOT_IN */:
+                case "!=" /* NOT_EQUAL */:
+                    // NotIn/NotEqual is always a suffix. There cannot be any remaining
+                    // segments and hence we can return early here.
+                    values.set(segment.fieldPath.canonicalString(), fieldFilter.value);
+                    return Array.from(values.values());
+                // Remaining filters cannot be used as notIn bounds.
             }
-            comparedOnKeyField = comparedOnKeyField || orderBy.field.isKeyField();
         }
-        return 0;
-    };
-}
-function compareDocs(orderBy, d1, d2) {
-    const comparison = orderBy.field.isKeyField()
-        ? DocumentKey.comparator(d1.key, d2.key)
-        : compareDocumentsByField(orderBy.field, d1, d2);
-    switch (orderBy.dir) {
-        case "asc" /* ASCENDING */:
-            return comparison;
-        case "desc" /* DESCENDING */:
-            return -1 * comparison;
-        default:
-            return fail();
     }
-}
-
+    return null;
+}
 /**
- * @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.
+ * Returns a lower bound of field values that can be used as a starting point to
+ * scan the index defined by `fieldIndex`. Returns `null` if no lower bound
+ * exists.
  */
+function targetGetLowerBound(target, fieldIndex) {
+    const values = [];
+    let inclusive = true;
+    // For each segment, retrieve a lower bound if there is a suitable filter or
+    // startAt.
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        const segmentBound = segment.kind === 0 /* ASCENDING */
+            ? targetGetAscendingBound(target, segment.fieldPath, target.startAt)
+            : targetGetDescendingBound(target, segment.fieldPath, target.startAt);
+        if (!segmentBound.value) {
+            // No lower bound exists
+            return null;
+        }
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
+    }
+    return new Bound(values, inclusive);
+}
 /**
- * A map implementation that uses objects as keys. Objects must have an
- * associated equals function and must be immutable. Entries in the map are
- * stored together with the key being produced from the mapKeyFn. This map
- * automatically handles collisions of keys.
+ * Returns an upper bound of field values that can be used as an ending point
+ * when scanning the index defined by `fieldIndex`. Returns `null` if no
+ * upper bound exists.
  */
-class ObjectMap {
-    constructor(mapKeyFn, equalsFn) {
-        this.mapKeyFn = mapKeyFn;
-        this.equalsFn = equalsFn;
-        /**
-         * The inner map for a key/value pair. Due to the possibility of collisions we
-         * keep a list of entries that we do a linear search through to find an actual
-         * match. Note that collisions should be rare, so we still expect near
-         * constant time lookups in practice.
-         */
-        this.inner = {};
-        /** The number of entries stored in the map */
-        this.innerSize = 0;
-    }
-    /** Get a value for this key, or undefined if it does not exist. */
-    get(key) {
-        const id = this.mapKeyFn(key);
-        const matches = this.inner[id];
-        if (matches === undefined) {
-            return undefined;
-        }
-        for (const [otherKey, value] of matches) {
-            if (this.equalsFn(otherKey, key)) {
-                return value;
-            }
+function targetGetUpperBound(target, fieldIndex) {
+    const values = [];
+    let inclusive = true;
+    // For each segment, retrieve an upper bound if there is a suitable filter or
+    // endAt.
+    for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+        const segmentBound = segment.kind === 0 /* ASCENDING */
+            ? targetGetDescendingBound(target, segment.fieldPath, target.endAt)
+            : targetGetAscendingBound(target, segment.fieldPath, target.endAt);
+        if (!segmentBound.value) {
+            // No upper bound exists
+            return null;
         }
-        return undefined;
+        values.push(segmentBound.value);
+        inclusive && (inclusive = segmentBound.inclusive);
     }
-    has(key) {
-        return this.get(key) !== undefined;
-    }
-    /** Put this key and value in the map. */
-    set(key, value) {
-        const id = this.mapKeyFn(key);
-        const matches = this.inner[id];
-        if (matches === undefined) {
-            this.inner[id] = [[key, value]];
-            this.innerSize++;
-            return;
-        }
-        for (let i = 0; i < matches.length; i++) {
-            if (this.equalsFn(matches[i][0], key)) {
-                // This is updating an existing entry and does not increase `innerSize`.
-                matches[i] = [key, value];
-                return;
-            }
-        }
-        matches.push([key, value]);
-        this.innerSize++;
-    }
-    /**
-     * Remove this key from the map. Returns a boolean if anything was deleted.
-     */
-    delete(key) {
-        const id = this.mapKeyFn(key);
-        const matches = this.inner[id];
-        if (matches === undefined) {
-            return false;
-        }
-        for (let i = 0; i < matches.length; i++) {
-            if (this.equalsFn(matches[i][0], key)) {
-                if (matches.length === 1) {
-                    delete this.inner[id];
-                }
-                else {
-                    matches.splice(i, 1);
+    return new Bound(values, inclusive);
+}
+/**
+ * Returns the value to use as the lower bound for ascending index segment at
+ * the provided `fieldPath` (or the upper bound for an descending segment).
+ */
+function targetGetAscendingBound(target, fieldPath, bound) {
+    let value = undefined;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = undefined;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case "<" /* LESS_THAN */:
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                filterValue = valuesGetLowerBound(fieldFilter.value);
+                break;
+            case "==" /* EQUAL */:
+            case "in" /* IN */:
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case ">" /* GREATER_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* NOT_EQUAL */:
+            case "not-in" /* NOT_IN */:
+                filterValue = MIN_VALUE;
+                break;
+            // Remaining filters cannot be used as lower bounds.
+        }
+        if (valuesMax(value, filterValue) === filterValue) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (valuesMax(value, cursorValue) === cursorValue) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
                 }
-                this.innerSize--;
-                return true;
+                break;
             }
         }
-        return false;
-    }
-    forEach(fn) {
-        forEach(this.inner, (_, entries) => {
-            for (const [k, v] of entries) {
-                fn(k, v);
-            }
-        });
-    }
-    isEmpty() {
-        return isEmpty(this.inner);
     }
-    size() {
-        return this.innerSize;
-    }
-}
-
+    return { value, inclusive };
+}
 /**
- * @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.
+ * Returns the value to use as the upper bound for ascending index segment at
+ * the provided `fieldPath` (or the lower bound for a descending segment).
  */
-// 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));
+function targetGetDescendingBound(target, fieldPath, bound) {
+    let value = undefined;
+    let inclusive = true;
+    // Process all filters to find a value for the current field segment
+    for (const fieldFilter of targetGetFieldFiltersForPath(target, fieldPath)) {
+        let filterValue = undefined;
+        let filterInclusive = true;
+        switch (fieldFilter.op) {
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+            case ">" /* GREATER_THAN */:
+                filterValue = valuesGetUpperBound(fieldFilter.value);
+                filterInclusive = false;
+                break;
+            case "==" /* EQUAL */:
+            case "in" /* IN */:
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                filterValue = fieldFilter.value;
+                break;
+            case "<" /* LESS_THAN */:
+                filterValue = fieldFilter.value;
+                filterInclusive = false;
+                break;
+            case "!=" /* NOT_EQUAL */:
+            case "not-in" /* NOT_IN */:
+                filterValue = MAX_VALUE;
+                break;
+            // Remaining filters cannot be used as upper bounds.
+        }
+        if (valuesMin(value, filterValue) === filterValue) {
+            value = filterValue;
+            inclusive = filterInclusive;
+        }
+    }
+    // If there is an additional bound, compare the values against the existing
+    // range to see if we can narrow the scope.
+    if (bound !== null) {
+        for (let i = 0; i < target.orderBy.length; ++i) {
+            const orderBy = target.orderBy[i];
+            if (orderBy.field.isEqual(fieldPath)) {
+                const cursorValue = bound.position[i];
+                if (valuesMin(value, cursorValue) === cursorValue) {
+                    value = cursorValue;
+                    inclusive = bound.inclusive;
+                }
+                break;
+            }
+        }
     }
-    // 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));
+    return { value, inclusive };
+}
+/** Returns the number of segments of a perfect index for this target. */
+function targetGetSegmentCount(target) {
+    let fields = new SortedSet(FieldPath$1.comparator);
+    let hasArraySegment = false;
+    for (const filter of target.filters) {
+        // TODO(orquery): Use the flattened filters here
+        const fieldFilter = filter;
+        // __name__ is not an explicit segment of any index, so we don't need to
+        // count it.
+        if (fieldFilter.field.isKeyField()) {
+            continue;
+        }
+        // ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filters must be counted separately.
+        // For instance, it is possible to have an index for "a ARRAY a ASC". Even
+        // though these are on the same field, they should be counted as two
+        // separate segments in an index.
+        if (fieldFilter.op === "array-contains" /* ARRAY_CONTAINS */ ||
+            fieldFilter.op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
+            hasArraySegment = true;
+        }
+        else {
+            fields = fields.add(fieldFilter.field);
+        }
     }
-    // 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;
-            }
+    for (const orderBy of target.orderBy) {
+        // __name__ is not an explicit segment of any index, so we don't need to
+        // count it.
+        if (!orderBy.field.isKeyField()) {
+            fields = fields.add(orderBy.field);
         }
-        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;
+    return fields.size + (hasArraySegment ? 1 : 0);
+}
+class Filter {
+}
+class FieldFilter extends Filter {
+    constructor(field, op, value) {
+        super();
+        this.field = field;
+        this.op = op;
+        this.value = value;
+    }
+    /**
+     * Creates a filter based on the provided arguments.
+     */
+    static create(field, op, value) {
+        if (field.isKeyField()) {
+            if (op === "in" /* IN */ || op === "not-in" /* NOT_IN */) {
+                return this.createKeyFieldInFilter(field, op, value);
             }
             else {
-                // Count all nodes left of the node plus the node itself
-                prunedNodes += node.left.size + 1;
-                node = node.right;
+                return new KeyFieldFilter(field, op, value);
             }
         }
-        // Node not found
-        return -1;
-    }
-    isEmpty() {
-        return this.root.isEmpty();
+        else if (op === "array-contains" /* ARRAY_CONTAINS */) {
+            return new ArrayContainsFilter(field, value);
+        }
+        else if (op === "in" /* IN */) {
+            return new InFilter(field, value);
+        }
+        else if (op === "not-in" /* NOT_IN */) {
+            return new NotInFilter(field, value);
+        }
+        else if (op === "array-contains-any" /* ARRAY_CONTAINS_ANY */) {
+            return new ArrayContainsAnyFilter(field, value);
+        }
+        else {
+            return new FieldFilter(field, op, value);
+        }
     }
-    // Returns the total number of nodes in the map.
-    get size() {
-        return this.root.size;
+    static createKeyFieldInFilter(field, op, value) {
+        return op === "in" /* IN */
+            ? new KeyFieldInFilter(field, value)
+            : new KeyFieldNotInFilter(field, value);
     }
-    // Returns the minimum key in the map.
-    minKey() {
-        return this.root.minKey();
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        // Types do not have to match in NOT_EQUAL filters.
+        if (this.op === "!=" /* NOT_EQUAL */) {
+            return (other !== null &&
+                this.matchesComparison(valueCompare(other, this.value)));
+        }
+        // Only compare types with matching backend order (such as double and int).
+        return (other !== null &&
+            typeOrder(this.value) === typeOrder(other) &&
+            this.matchesComparison(valueCompare(other, this.value)));
     }
-    // Returns the maximum key in the map.
-    maxKey() {
-        return this.root.maxKey();
+    matchesComparison(comparison) {
+        switch (this.op) {
+            case "<" /* LESS_THAN */:
+                return comparison < 0;
+            case "<=" /* LESS_THAN_OR_EQUAL */:
+                return comparison <= 0;
+            case "==" /* EQUAL */:
+                return comparison === 0;
+            case "!=" /* NOT_EQUAL */:
+                return comparison !== 0;
+            case ">" /* GREATER_THAN */:
+                return comparison > 0;
+            case ">=" /* GREATER_THAN_OR_EQUAL */:
+                return comparison >= 0;
+            default:
+                return fail();
+        }
     }
-    // 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);
+    isInequality() {
+        return ([
+            "<" /* LESS_THAN */,
+            "<=" /* LESS_THAN_OR_EQUAL */,
+            ">" /* GREATER_THAN */,
+            ">=" /* GREATER_THAN_OR_EQUAL */,
+            "!=" /* NOT_EQUAL */,
+            "not-in" /* NOT_IN */
+        ].indexOf(this.op) >= 0);
     }
-    forEach(fn) {
-        this.inorderTraversal((k, v) => {
-            fn(k, v);
-            return false;
-        });
+}
+function canonifyFilter(filter) {
+    // TODO(b/29183165): Technically, this won't be unique if two values have
+    // the same description, such as the int 3 and the string "3". So we should
+    // add the types in here somehow, too.
+    return (filter.field.canonicalString() +
+        filter.op.toString() +
+        canonicalId(filter.value));
+}
+function filterEquals(f1, f2) {
+    return (f1.op === f2.op &&
+        f1.field.isEqual(f2.field) &&
+        valueEquals(f1.value, f2.value));
+}
+/** Returns a debug description for `filter`. */
+function stringifyFilter(filter) {
+    return `${filter.field.canonicalString()} ${filter.op} ${canonicalId(filter.value)}`;
+}
+/** Filter that matches on key fields (i.e. '__name__'). */
+class KeyFieldFilter extends FieldFilter {
+    constructor(field, op, value) {
+        super(field, op, value);
+        this.key = DocumentKey.fromName(value.referenceValue);
     }
-    toString() {
-        const descriptions = [];
-        this.inorderTraversal((k, v) => {
-            descriptions.push(`${k}:${v}`);
-            return false;
-        });
-        return `{${descriptions.join(', ')}}`;
+    matches(doc) {
+        const comparison = DocumentKey.comparator(doc.key, this.key);
+        return this.matchesComparison(comparison);
     }
-    // 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);
+}
+/** Filter that matches on key fields within an array. */
+class KeyFieldInFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "in" /* IN */, value);
+        this.keys = extractDocumentKeysFromArrayValue("in" /* IN */, value);
     }
-    // Returns an iterator over the SortedMap.
-    getIterator() {
-        return new SortedMapIterator(this.root, null, this.comparator, false);
+    matches(doc) {
+        return this.keys.some(key => key.isEqual(doc.key));
     }
-    getIteratorFrom(key) {
-        return new SortedMapIterator(this.root, key, this.comparator, false);
+}
+/** Filter that matches on key fields not present within an array. */
+class KeyFieldNotInFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "not-in" /* NOT_IN */, value);
+        this.keys = extractDocumentKeysFromArrayValue("not-in" /* NOT_IN */, value);
     }
-    getReverseIterator() {
-        return new SortedMapIterator(this.root, null, this.comparator, true);
+    matches(doc) {
+        return !this.keys.some(key => key.isEqual(doc.key));
     }
-    getReverseIteratorFrom(key) {
-        return new SortedMapIterator(this.root, key, this.comparator, true);
+}
+function extractDocumentKeysFromArrayValue(op, value) {
+    var _a;
+    return (((_a = value.arrayValue) === null || _a === void 0 ? void 0 : _a.values) || []).map(v => {
+        return DocumentKey.fromName(v.referenceValue);
+    });
+}
+/** A Filter that implements the array-contains operator. */
+class ArrayContainsFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "array-contains" /* ARRAY_CONTAINS */, value);
     }
-} // 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;
-                }
-            }
-        }
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        return isArray(other) && arrayValueContains(other.arrayValue, this.value);
     }
-    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;
+}
+/** A Filter that implements the IN operator. */
+class InFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "in" /* IN */, value);
     }
-    hasNext() {
-        return this.nodeStack.length > 0;
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        return other !== null && arrayValueContains(this.value.arrayValue, other);
     }
-    peek() {
-        if (this.nodeStack.length === 0) {
-            return null;
-        }
-        const node = this.nodeStack[this.nodeStack.length - 1];
-        return { key: node.key, value: node.value };
+}
+/** A Filter that implements the not-in operator. */
+class NotInFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "not-in" /* NOT_IN */, 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;
+    matches(doc) {
+        if (arrayValueContains(this.value.arrayValue, { nullValue: 'NULL_VALUE' })) {
+            return false;
+        }
+        const other = doc.data.field(this.field);
+        return other !== null && !arrayValueContains(this.value.arrayValue, other);
     }
-    // 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);
+}
+/** A Filter that implements the array-contains-any operator. */
+class ArrayContainsAnyFilter extends FieldFilter {
+    constructor(field, value) {
+        super(field, "array-contains-any" /* ARRAY_CONTAINS_ANY */, value);
     }
-    isEmpty() {
-        return false;
+    matches(doc) {
+        const other = doc.data.field(this.field);
+        if (!isArray(other) || !other.arrayValue.values) {
+            return false;
+        }
+        return other.arrayValue.values.some(val => arrayValueContains(this.value.arrayValue, val));
     }
-    // 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));
+}
+/**
+ * Represents a bound of a query.
+ *
+ * The bound is specified with the given components representing a position and
+ * whether it's just before or just after the position (relative to whatever the
+ * query order is).
+ *
+ * The position represents a logical index position for a query. It's a prefix
+ * of values for the (potentially implicit) order by clauses of a query.
+ *
+ * Bound provides a function to determine whether a document comes before or
+ * after a bound. This is influenced by whether the position is just before or
+ * just after the provided values.
+ */
+class Bound {
+    constructor(position, inclusive) {
+        this.position = position;
+        this.inclusive = inclusive;
     }
-    // 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));
+}
+/**
+ * An ordering on a field, in some Direction. Direction defaults to ASCENDING.
+ */
+class OrderBy {
+    constructor(field, dir = "asc" /* ASCENDING */) {
+        this.field = field;
+        this.dir = dir;
     }
-    // Returns the minimum node in the tree.
-    min() {
-        if (this.left.isEmpty()) {
-            return this;
+}
+function canonifyOrderBy(orderBy) {
+    // TODO(b/29183165): Make this collision robust.
+    return orderBy.field.canonicalString() + orderBy.dir;
+}
+function stringifyOrderBy(orderBy) {
+    return `${orderBy.field.canonicalString()} (${orderBy.dir})`;
+}
+function orderByEquals(left, right) {
+    return left.dir === right.dir && left.field.isEqual(right.field);
+}
+function boundCompareToDocument(bound, orderBy, doc) {
+    let comparison = 0;
+    for (let i = 0; i < bound.position.length; i++) {
+        const orderByComponent = orderBy[i];
+        const component = bound.position[i];
+        if (orderByComponent.field.isKeyField()) {
+            comparison = DocumentKey.comparator(DocumentKey.fromName(component.referenceValue), doc.key);
         }
         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);
+            const docValue = doc.data.field(orderByComponent.field);
+            comparison = valueCompare(component, docValue);
         }
-        else if (cmp === 0) {
-            n = n.copy(null, value, null, null, null);
+        if (orderByComponent.dir === "desc" /* DESCENDING */) {
+            comparison = comparison * -1;
         }
-        else {
-            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));
+        if (comparison !== 0) {
+            break;
         }
-        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();
+    return comparison;
+}
+/**
+ * Returns true if a document sorts after a bound using the provided sort
+ * order.
+ */
+function boundSortsAfterDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison >= 0 : comparison > 0;
+}
+/**
+ * Returns true if a document sorts before a bound using the provided sort
+ * order.
+ */
+function boundSortsBeforeDocument(bound, orderBy, doc) {
+    const comparison = boundCompareToDocument(bound, orderBy, doc);
+    return bound.inclusive ? comparison <= 0 : comparison < 0;
+}
+function boundEquals(left, right) {
+    if (left === null) {
+        return right === null;
     }
-    // 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();
+    else if (right === null) {
+        return false;
     }
-    isRed() {
-        return this.color;
+    if (left.inclusive !== right.inclusive ||
+        left.position.length !== right.position.length) {
+        return false;
     }
-    // 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();
+    for (let i = 0; i < left.position.length; i++) {
+        const leftPosition = left.position[i];
+        const rightPosition = right.position[i];
+        if (!valueEquals(leftPosition, rightPosition)) {
+            return false;
         }
-        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;
+    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.
+ */
+/**
+ * Query encapsulates all the query attributes we support in the SDK. It can
+ * be run against the LocalStore, as well as be converted to a `Target` to
+ * query the RemoteStore results.
+ *
+ * Visible for testing.
+ */
+class QueryImpl {
+    /**
+     * Initializes a Query with a path and optional additional query constraints.
+     * Path must currently be empty if this is a collection group query.
+     */
+    constructor(path, collectionGroup = null, explicitOrderBy = [], filters = [], limit = null, limitType = "F" /* First */, startAt = null, endAt = null) {
+        this.path = path;
+        this.collectionGroup = collectionGroup;
+        this.explicitOrderBy = explicitOrderBy;
+        this.filters = filters;
+        this.limit = limit;
+        this.limitType = limitType;
+        this.startAt = startAt;
+        this.endAt = endAt;
+        this.memoizedOrderBy = null;
+        // The corresponding `Target` of this `Query` instance.
+        this.memoizedTarget = null;
+        if (this.startAt) ;
+        if (this.endAt) ;
     }
-    moveRedRight() {
-        let n = this.colorFlip();
-        if (n.left.left.isRed()) {
-            n = n.rotateRight();
-            n = n.colorFlip();
+}
+/** Creates a new Query instance with the options provided. */
+function newQuery(path, collectionGroup, explicitOrderBy, filters, limit, limitType, startAt, endAt) {
+    return new QueryImpl(path, collectionGroup, explicitOrderBy, filters, limit, limitType, startAt, endAt);
+}
+/** Creates a new Query for a query that matches all documents at `path` */
+function newQueryForPath(path) {
+    return new QueryImpl(path);
+}
+/**
+ * Helper to convert a collection group query into a collection query at a
+ * specific path. This is used when executing collection group queries, since
+ * we have to split the query into a set of collection queries at multiple
+ * paths.
+ */
+function asCollectionQueryAtPath(query, path) {
+    return new QueryImpl(path, 
+    /*collectionGroup=*/ null, query.explicitOrderBy.slice(), query.filters.slice(), query.limit, query.limitType, query.startAt, query.endAt);
+}
+/**
+ * Returns true if this query does not specify any query constraints that
+ * could remove results.
+ */
+function queryMatchesAllDocuments(query) {
+    return (query.filters.length === 0 &&
+        query.limit === null &&
+        query.startAt == null &&
+        query.endAt == null &&
+        (query.explicitOrderBy.length === 0 ||
+            (query.explicitOrderBy.length === 1 &&
+                query.explicitOrderBy[0].field.isKeyField())));
+}
+function getFirstOrderByField(query) {
+    return query.explicitOrderBy.length > 0
+        ? query.explicitOrderBy[0].field
+        : null;
+}
+function getInequalityFilterField(query) {
+    for (const filter of query.filters) {
+        if (filter.isInequality()) {
+            return filter.field;
         }
-        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);
+    return null;
+}
+/**
+ * Checks if any of the provided Operators are included in the query and
+ * returns the first one that is, or null if none are.
+ */
+function findFilterOperator(query, operators) {
+    for (const filter of query.filters) {
+        if (operators.indexOf(filter.op) >= 0) {
+            return filter.op;
+        }
     }
-    // For testing.
-    checkMaxDepth() {
-        const blackDepth = this.check();
-        if (Math.pow(2.0, blackDepth) <= this.size + 1) {
-            return true;
+    return null;
+}
+/**
+ * Creates a new Query for a collection group query that matches all documents
+ * within the provided collection group.
+ */
+function newQueryForCollectionGroup(collectionId) {
+    return new QueryImpl(ResourcePath.emptyPath(), collectionId);
+}
+/**
+ * Returns whether the query matches a single document by path (rather than a
+ * collection).
+ */
+function isDocumentQuery$1(query) {
+    return (DocumentKey.isDocumentKey(query.path) &&
+        query.collectionGroup === null &&
+        query.filters.length === 0);
+}
+/**
+ * Returns whether the query matches a collection group rather than a specific
+ * collection.
+ */
+function isCollectionGroupQuery(query) {
+    return query.collectionGroup !== null;
+}
+/**
+ * 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 queryOrderBy(query) {
+    const queryImpl = debugCast(query);
+    if (queryImpl.memoizedOrderBy === null) {
+        queryImpl.memoizedOrderBy = [];
+        const inequalityField = getInequalityFilterField(queryImpl);
+        const firstOrderByField = getFirstOrderByField(queryImpl);
+        if (inequalityField !== null && firstOrderByField === null) {
+            // 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.
+            if (!inequalityField.isKeyField()) {
+                queryImpl.memoizedOrderBy.push(new OrderBy(inequalityField));
+            }
+            queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), "asc" /* ASCENDING */));
         }
         else {
-            return false;
+            let foundKeyOrdering = false;
+            for (const orderBy of queryImpl.explicitOrderBy) {
+                queryImpl.memoizedOrderBy.push(orderBy);
+                if (orderBy.field.isKeyField()) {
+                    foundKeyOrdering = true;
+                }
+            }
+            if (!foundKeyOrdering) {
+                // The order of the implicit key ordering always matches the last
+                // explicit order by
+                const lastDirection = queryImpl.explicitOrderBy.length > 0
+                    ? queryImpl.explicitOrderBy[queryImpl.explicitOrderBy.length - 1]
+                        .dir
+                    : "asc" /* ASCENDING */;
+                queryImpl.memoizedOrderBy.push(new OrderBy(FieldPath$1.keyField(), lastDirection));
+            }
         }
     }
-    // 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();
+    return queryImpl.memoizedOrderBy;
+}
+/**
+ * Converts this `Query` instance to it's corresponding `Target` representation.
+ */
+function queryToTarget(query) {
+    const queryImpl = debugCast(query);
+    if (!queryImpl.memoizedTarget) {
+        if (queryImpl.limitType === "F" /* First */) {
+            queryImpl.memoizedTarget = newTarget(queryImpl.path, queryImpl.collectionGroup, queryOrderBy(queryImpl), queryImpl.filters, queryImpl.limit, queryImpl.startAt, queryImpl.endAt);
         }
         else {
-            return blackDepth + (this.isRed() ? 0 : 1);
+            // Flip the orderBy directions since we want the last results
+            const orderBys = [];
+            for (const orderBy of queryOrderBy(queryImpl)) {
+                const dir = orderBy.dir === "desc" /* DESCENDING */
+                    ? "asc" /* ASCENDING */
+                    : "desc" /* DESCENDING */;
+                orderBys.push(new OrderBy(orderBy.field, dir));
+            }
+            // 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)
+                : null;
+            const endAt = queryImpl.startAt
+                ? 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);
         }
     }
-} // 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;
+    return queryImpl.memoizedTarget;
+}
+function queryWithAddedFilter(query, filter) {
+    const newFilters = query.filters.concat([filter]);
+    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), newFilters, query.limit, query.limitType, query.startAt, query.endAt);
+}
+function queryWithAddedOrderBy(query, orderBy) {
+    // TODO(dimond): validate that orderBy does not list the same key twice.
+    const newOrderBy = query.explicitOrderBy.concat([orderBy]);
+    return new QueryImpl(query.path, query.collectionGroup, newOrderBy, query.filters.slice(), query.limit, query.limitType, query.startAt, query.endAt);
+}
+function queryWithLimit(query, limit, limitType) {
+    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), limit, limitType, query.startAt, query.endAt);
+}
+function queryWithStartAt(query, bound) {
+    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), query.limit, query.limitType, bound, query.endAt);
+}
+function queryWithEndAt(query, bound) {
+    return new QueryImpl(query.path, query.collectionGroup, query.explicitOrderBy.slice(), query.filters.slice(), query.limit, query.limitType, query.startAt, bound);
+}
+function queryEquals(left, right) {
+    return (targetEquals(queryToTarget(left), queryToTarget(right)) &&
+        left.limitType === right.limitType);
+}
+// TODO(b/29183165): This is used to get a unique string from a query to, for
+// example, use as a dictionary key, but the implementation is subject to
+// collisions. Make it collision-free.
+function canonifyQuery(query) {
+    return `${canonifyTarget(queryToTarget(query))}|lt:${query.limitType}`;
+}
+function stringifyQuery(query) {
+    return `Query(target=${stringifyTarget(queryToTarget(query))}; limitType=${query.limitType})`;
+}
+/** Returns whether `doc` matches the constraints of `query`. */
+function queryMatches(query, doc) {
+    return (doc.isFoundDocument() &&
+        queryMatchesPathAndCollectionGroup(query, doc) &&
+        queryMatchesOrderBy(query, doc) &&
+        queryMatchesFilters(query, doc) &&
+        queryMatchesBounds(query, doc));
+}
+function queryMatchesPathAndCollectionGroup(query, doc) {
+    const docPath = doc.key.path;
+    if (query.collectionGroup !== null) {
+        // NOTE: this.path is currently always empty since we don't expose Collection
+        // Group queries rooted at a document path yet.
+        return (doc.key.hasCollectionId(query.collectionGroup) &&
+            query.path.isPrefixOf(docPath));
     }
-    // Returns a copy of the tree, with the specified key/value added.
-    insert(key, value, comparator) {
-        return new LLRBNode(key, value);
+    else if (DocumentKey.isDocumentKey(query.path)) {
+        // exact match for document queries
+        return query.path.isEqual(docPath);
     }
-    // Returns a copy of the tree, with the specified key removed.
-    remove(key, comparator) {
-        return this;
+    else {
+        // shallow ancestor queries by default
+        return query.path.isImmediateParentOf(docPath);
     }
-    isEmpty() {
-        return true;
+}
+/**
+ * A document must have a value for every ordering clause in order to show up
+ * in the results.
+ */
+function queryMatchesOrderBy(query, doc) {
+    for (const orderBy of query.explicitOrderBy) {
+        // order by key always matches
+        if (!orderBy.field.isKeyField() && doc.data.field(orderBy.field) === null) {
+            return false;
+        }
     }
-    inorderTraversal(action) {
-        return false;
+    return true;
+}
+function queryMatchesFilters(query, doc) {
+    for (const filter of query.filters) {
+        if (!filter.matches(doc)) {
+            return false;
+        }
     }
-    reverseTraversal(action) {
+    return true;
+}
+/** Makes sure a document is within the bounds, if provided. */
+function queryMatchesBounds(query, doc) {
+    if (query.startAt &&
+        !boundSortsBeforeDocument(query.startAt, queryOrderBy(query), doc)) {
         return false;
     }
-    minKey() {
-        return null;
-    }
-    maxKey() {
-        return null;
-    }
-    isRed() {
+    if (query.endAt &&
+        !boundSortsAfterDocument(query.endAt, queryOrderBy(query), doc)) {
         return false;
     }
-    // For testing.
-    checkMaxDepth() {
-        return true;
-    }
-    check() {
+    return true;
+}
+/**
+ * Returns the collection group that this query targets.
+ *
+ * PORTING NOTE: This is only used in the Web SDK to facilitate multi-tab
+ * synchronization for query results.
+ */
+function queryCollectionGroup(query) {
+    return (query.collectionGroup ||
+        (query.path.length % 2 === 1
+            ? query.path.lastSegment()
+            : query.path.get(query.path.length - 2)));
+}
+/**
+ * Returns a new comparator function that can be used to compare two documents
+ * based on the Query's ordering constraint.
+ */
+function newQueryComparator(query) {
+    return (d1, d2) => {
+        let comparedOnKeyField = false;
+        for (const orderBy of queryOrderBy(query)) {
+            const comp = compareDocs(orderBy, d1, d2);
+            if (comp !== 0) {
+                return comp;
+            }
+            comparedOnKeyField = comparedOnKeyField || orderBy.field.isKeyField();
+        }
         return 0;
+    };
+}
+function compareDocs(orderBy, d1, d2) {
+    const comparison = orderBy.field.isKeyField()
+        ? DocumentKey.comparator(d1.key, d2.key)
+        : compareDocumentsByField(orderBy.field, d1, d2);
+    switch (orderBy.dir) {
+        case "asc" /* ASCENDING */:
+            return comparison;
+        case "desc" /* DESCENDING */:
+            return -1 * comparison;
+        default:
+            return fail();
     }
-} // end LLRBEmptyNode
-LLRBNode.EMPTY = new LLRBEmptyNode();
+}
 
 /**
  * @license
@@ -5814,218 +5992,97 @@ LLRBNode.EMPTY = new LLRBEmptyNode();
  * 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!
+ * A map implementation that uses objects as keys. Objects must have an
+ * associated equals function and must be immutable. Entries in the map are
+ * stored together with the key being produced from the mapKeyFn. This map
+ * automatically handles collisions of keys.
  */
-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);
-        }
+class ObjectMap {
+    constructor(mapKeyFn, equalsFn) {
+        this.mapKeyFn = mapKeyFn;
+        this.equalsFn = equalsFn;
+        /**
+         * The inner map for a key/value pair. Due to the possibility of collisions we
+         * keep a list of entries that we do a linear search through to find an actual
+         * match. Note that collisions should be rare, so we still expect near
+         * constant time lookups in practice.
+         */
+        this.inner = {};
+        /** The number of entries stored in the map */
+        this.innerSize = 0;
     }
-    /**
-     * 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();
+    /** Get a value for this key, or undefined if it does not exist. */
+    get(key) {
+        const id = this.mapKeyFn(key);
+        const matches = this.inner[id];
+        if (matches === undefined) {
+            return undefined;
         }
-        while (iter.hasNext()) {
-            const elem = iter.getNext();
-            const result = cb(elem.key);
-            if (!result) {
-                return;
+        for (const [otherKey, value] of matches) {
+            if (this.equalsFn(otherKey, key)) {
+                return value;
             }
         }
+        return undefined;
     }
-    /** 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));
+    has(key) {
+        return this.get(key) !== undefined;
     }
-    /** Deletes an element */
-    delete(elem) {
-        if (!this.has(elem)) {
-            return this;
+    /** Put this key and value in the map. */
+    set(key, value) {
+        const id = this.mapKeyFn(key);
+        const matches = this.inner[id];
+        if (matches === undefined) {
+            this.inner[id] = [[key, value]];
+            this.innerSize++;
+            return;
         }
-        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;
+        for (let i = 0; i < matches.length; i++) {
+            if (this.equalsFn(matches[i][0], key)) {
+                // This is updating an existing entry and does not increase `innerSize`.
+                matches[i] = [key, value];
+                return;
+            }
         }
-        other.forEach(elem => {
-            result = result.add(elem);
-        });
-        return result;
+        matches.push([key, value]);
+        this.innerSize++;
     }
-    isEqual(other) {
-        if (!(other instanceof SortedSet)) {
-            return false;
-        }
-        if (this.size !== other.size) {
+    /**
+     * Remove this key from the map. Returns a boolean if anything was deleted.
+     */
+    delete(key) {
+        const id = this.mapKeyFn(key);
+        const matches = this.inner[id];
+        if (matches === undefined) {
             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;
+        for (let i = 0; i < matches.length; i++) {
+            if (this.equalsFn(matches[i][0], key)) {
+                if (matches.length === 1) {
+                    delete this.inner[id];
+                }
+                else {
+                    matches.splice(i, 1);
+                }
+                this.innerSize--;
+                return true;
             }
         }
-        return true;
+        return false;
     }
-    toArray() {
-        const res = [];
-        this.forEach(targetId => {
-            res.push(targetId);
+    forEach(fn) {
+        forEach(this.inner, (_, entries) => {
+            for (const [k, v] of entries) {
+                fn(k, v);
+            }
         });
-        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();
+    isEmpty() {
+        return isEmpty(this.inner);
     }
-}
-/**
- * Compares two sorted sets for equality using their natural ordering. The
- * method computes the intersection and invokes `onAdd` for every element that
- * is in `after` but not `before`. `onRemove` is invoked for every element in
- * `before` but missing from `after`.
- *
- * The method creates a copy of both `before` and `after` and runs in O(n log
- * n), where n is the size of the two lists.
- *
- * @param before - The elements that exist in the original set.
- * @param after - The elements to diff against the original set.
- * @param comparator - The comparator for the elements in before and after.
- * @param onAdd - A function to invoke for every element that is part of `
- * after` but not `before`.
- * @param onRemove - A function to invoke for every element that is part of
- * `before` but not `after`.
- */
-function diffSortedSets(before, after, comparator, onAdd, onRemove) {
-    const beforeIt = before.getIterator();
-    const afterIt = after.getIterator();
-    let beforeValue = advanceIterator(beforeIt);
-    let afterValue = advanceIterator(afterIt);
-    // Walk through the two sets at the same time, using the ordering defined by
-    // `comparator`.
-    while (beforeValue || afterValue) {
-        let added = false;
-        let removed = false;
-        if (beforeValue && afterValue) {
-            const cmp = comparator(beforeValue, afterValue);
-            if (cmp < 0) {
-                // The element was removed if the next element in our ordered
-                // walkthrough is only in `before`.
-                removed = true;
-            }
-            else if (cmp > 0) {
-                // The element was added if the next element in our ordered walkthrough
-                // is only in `after`.
-                added = true;
-            }
-        }
-        else if (beforeValue != null) {
-            removed = true;
-        }
-        else {
-            added = true;
-        }
-        if (added) {
-            onAdd(afterValue);
-            afterValue = advanceIterator(afterIt);
-        }
-        else if (removed) {
-            onRemove(beforeValue);
-            beforeValue = advanceIterator(beforeIt);
-        }
-        else {
-            beforeValue = advanceIterator(beforeIt);
-            afterValue = advanceIterator(afterIt);
-        }
+    size() {
+        return this.innerSize;
     }
-}
-/**
- * Returns the next element from the iterator or `undefined` if none available.
- */
-function advanceIterator(it) {
-    return it.hasNext() ? it.getNext() : undefined;
 }
 
 /**
@@ -6049,8 +6106,12 @@ function mutableDocumentMap() {
     return EMPTY_MUTABLE_DOCUMENT_MAP;
 }
 const EMPTY_DOCUMENT_MAP = new SortedMap(DocumentKey.comparator);
-function documentMap() {
-    return EMPTY_DOCUMENT_MAP;
+function documentMap(...docs) {
+    let map = EMPTY_DOCUMENT_MAP;
+    for (const doc of docs) {
+        map = map.insert(doc.key, doc);
+    }
+    return map;
 }
 function newOverlayMap() {
     return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
@@ -9943,9 +10004,9 @@ class MemoryIndexManager {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve(null);
     }
-    getFieldIndex(transaction, target) {
+    getIndexType(transaction, target) {
         // Field indices are not supported with memory persistence.
-        return PersistencePromise.resolve(null);
+        return PersistencePromise.resolve(0 /* NONE */);
     }
     getFieldIndexes(transaction, collectionGroup) {
         // Field indices are not supported with memory persistence.
@@ -9955,6 +10016,9 @@ class MemoryIndexManager {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve(null);
     }
+    getMinOffset(transaction, target) {
+        return PersistencePromise.resolve(IndexOffset.min());
+    }
     updateCollectionGroup(transaction, collectionGroup, offset) {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve();
@@ -10021,8 +10085,9 @@ const EMPTY_VALUE = new Uint8Array(0);
  * data as it supports multi-tab access.
  */
 class IndexedDbIndexManager {
-    constructor(user) {
+    constructor(user, databaseId) {
         this.user = user;
+        this.databaseId = databaseId;
         /**
          * An in-memory copy of the index entries we've already written since the SDK
          * launched. Used to avoid re-writing the same entry repeatedly.
@@ -10118,7 +10183,8 @@ class IndexedDbIndexManager {
                 return PersistencePromise.resolve(null);
             }
             else {
-                let result = documentKeySet();
+                let existingKeys = documentKeySet();
+                const result = [];
                 return PersistencePromise.forEach(indexes, (index, subTarget) => {
                     logDebug(LOG_TAG$f, `Using index ${fieldIndexToString(index)} to execute ${canonifyTarget(target)}`);
                     const arrayValues = targetGetArrayValues(subTarget, index);
@@ -10134,7 +10200,11 @@ class IndexedDbIndexManager {
                             .loadFirst(indexRange, target.limit)
                             .next(entries => {
                             entries.forEach(entry => {
-                                result = result.add(new DocumentKey(decodeResourcePath(entry.documentKey)));
+                                const documentKey = DocumentKey.fromSegments(entry.documentKey);
+                                if (!existingKeys.has(documentKey)) {
+                                    existingKeys = existingKeys.add(documentKey);
+                                    result.push(documentKey);
+                                }
                             });
                         });
                     });
@@ -10175,9 +10245,9 @@ class IndexedDbIndexManager {
             const upperBound = upperBounds
                 ? this.generateUpperBound(indexId, arrayValue, upperBounds[i % scansPerArrayElement], upperBoundInclusive)
                 : this.generateEmptyBound(indexId + 1);
-            indexRanges.push(...this.createRange(lowerBound, upperBound, notInValues.map((notIn // make non-nullable
-            ) => this.generateLowerBound(indexId, arrayValue, notIn, 
-            /* inclusive= */ true))));
+            const notInBound = notInValues.map(notIn => this.generateLowerBound(indexId, arrayValue, notIn, 
+            /* inclusive= */ true));
+            indexRanges.push(...this.createRange(lowerBound, upperBound, notInBound));
         }
         return indexRanges;
     }
@@ -10204,12 +10274,32 @@ class IndexedDbIndexManager {
             ? target.collectionGroup
             : target.path.lastSegment();
         return this.getFieldIndexes(transaction, collectionGroup).next(indexes => {
-            const matchingIndexes = indexes.filter(i => targetIndexMatcher.servedByIndex(i));
-            // Return the index that matches the most number of segments.
-            matchingIndexes.sort((l, r) => r.fields.length - l.fields.length);
-            return matchingIndexes.length > 0 ? matchingIndexes[0] : null;
+            // Return the index with the most number of segments.
+            let index = null;
+            for (const candidate of indexes) {
+                const matches = targetIndexMatcher.servedByIndex(candidate);
+                if (matches &&
+                    (!index || candidate.fields.length > index.fields.length)) {
+                    index = candidate;
+                }
+            }
+            return index;
         });
     }
+    getIndexType(transaction, target) {
+        let indexType = 2 /* FULL */;
+        return PersistencePromise.forEach(this.getSubTargets(target), (target) => {
+            return this.getFieldIndex(transaction, target).next(index => {
+                if (!index) {
+                    indexType = 0 /* NONE */;
+                }
+                else if (indexType !== 0 /* NONE */ &&
+                    index.fields.length < targetGetSegmentCount(target)) {
+                    indexType = 1 /* PARTIAL */;
+                }
+            });
+        }).next(() => indexType);
+    }
     /**
      * Returns the byte encoded form of the directional values in the field index.
      * Returns `null` if the document does not have all fields specified in the
@@ -10233,6 +10323,15 @@ class IndexedDbIndexManager {
         FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* ASCENDING */));
         return encoder.encodedBytes();
     }
+    /**
+     * Returns an encoded form of the document key that sorts based on the key
+     * ordering of the field index.
+     */
+    encodeDirectionalKey(fieldIndex, documentKey) {
+        const encoder = new IndexByteEncoder();
+        FirestoreIndexValueWriter.INSTANCE.writeIndexValue(refValue(this.databaseId, documentKey), encoder.forKind(fieldIndexGetKeyOrder(fieldIndex)));
+        return encoder.encodedBytes();
+    }
     /**
      * Encodes the given field values according to the specification in `target`.
      * For IN queries, a list of possible values is returned.
@@ -10356,7 +10455,7 @@ class IndexedDbIndexManager {
                     return this.getExistingIndexEntries(transaction, key, fieldIndex).next(existingEntries => {
                         const newEntries = this.computeIndexEntries(doc, fieldIndex);
                         if (!existingEntries.isEqual(newEntries)) {
-                            return this.updateEntries(transaction, doc, existingEntries, newEntries);
+                            return this.updateEntries(transaction, doc, fieldIndex, existingEntries, newEntries);
                         }
                         return PersistencePromise.resolve();
                     });
@@ -10364,24 +10463,26 @@ class IndexedDbIndexManager {
             });
         });
     }
-    addIndexEntry(transaction, document, indexEntry) {
+    addIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
         return indexEntries.put({
             indexId: indexEntry.indexId,
             uid: this.uid,
             arrayValue: indexEntry.arrayValue,
             directionalValue: indexEntry.directionalValue,
-            documentKey: encodeResourcePath(document.key.path)
+            orderedDocumentKey: this.encodeDirectionalKey(fieldIndex, document.key),
+            documentKey: document.key.path.toArray()
         });
     }
-    deleteIndexEntry(transaction, document, indexEntry) {
+    deleteIndexEntry(transaction, document, fieldIndex, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
         return indexEntries.delete([
             indexEntry.indexId,
             this.uid,
             indexEntry.arrayValue,
             indexEntry.directionalValue,
-            encodeResourcePath(document.key.path)
+            this.encodeDirectionalKey(fieldIndex, document.key),
+            document.key.path.toArray()
         ]);
     }
     getExistingIndexEntries(transaction, documentKey, fieldIndex) {
@@ -10393,7 +10494,7 @@ class IndexedDbIndexManager {
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
-                encodeResourcePath(documentKey.path)
+                this.encodeDirectionalKey(fieldIndex, documentKey)
             ])
         }, (_, entry) => {
             results = results.add(new IndexEntry(fieldIndex.indexId, documentKey, entry.arrayValue, entry.directionalValue));
@@ -10426,15 +10527,15 @@ class IndexedDbIndexManager {
      * that are no longer referenced in `newEntries` and adding all newly added
      * entries.
      */
-    updateEntries(transaction, document, existingEntries, newEntries) {
+    updateEntries(transaction, document, fieldIndex, existingEntries, newEntries) {
         logDebug(LOG_TAG$f, "Updating index entries for document '%s'", document.key);
         const promises = [];
         diffSortedSets(existingEntries, newEntries, indexEntryComparator, 
         /* onAdd= */ entry => {
-            promises.push(this.addIndexEntry(transaction, document, entry));
+            promises.push(this.addIndexEntry(transaction, document, fieldIndex, entry));
         }, 
         /* onRemove= */ entry => {
-            promises.push(this.deleteIndexEntry(transaction, document, entry));
+            promises.push(this.deleteIndexEntry(transaction, document, fieldIndex, entry));
         });
         return PersistencePromise.waitFor(promises);
     }
@@ -10458,7 +10559,7 @@ class IndexedDbIndexManager {
      * '[foo > 2 && foo != 3]` becomes  `[foo > 2 && < 3, foo > 3]`.
      */
     createRange(lower, upper, notInValues) {
-        // The notIb values need to be sorted and unique so that we can return a
+        // The notIn values need to be sorted and unique so that we can return a
         // sorted set of non-overlapping ranges.
         notInValues = notInValues
             .sort((l, r) => indexEntryComparator(l, r))
@@ -10491,17 +10592,33 @@ class IndexedDbIndexManager {
                 this.uid,
                 bounds[i].arrayValue,
                 bounds[i].directionalValue,
-                ''
+                EMPTY_VALUE,
+                []
             ], [
                 bounds[i + 1].indexId,
                 this.uid,
                 bounds[i + 1].arrayValue,
                 bounds[i + 1].directionalValue,
-                ''
+                EMPTY_VALUE,
+                []
             ]));
         }
         return ranges;
     }
+    getMinOffset(transaction, target) {
+        let offset;
+        return PersistencePromise.forEach(this.getSubTargets(target), (target) => {
+            return this.getFieldIndex(transaction, target).next(index => {
+                if (!index) {
+                    offset = IndexOffset.min();
+                }
+                else if (!offset ||
+                    indexOffsetComparator(index.indexState.offset, offset) < 0) {
+                    offset = index.indexState.offset;
+                }
+            });
+        }).next(() => offset);
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
@@ -12251,12 +12368,31 @@ function dbCollectionGroupKey(collectionGroup, offset) {
 }
 /**
  * Comparator that compares document keys according to the primary key sorting
- * used by the `DbRemoteDocumentDocument` store (by collection path and then
- * document ID).
+ * used by the `DbRemoteDocumentDocument` store (by prefix path, collection id
+ * and then document ID).
+ *
+ * Visible for testing.
  */
 function dbKeyComparator(l, r) {
-    const cmp = l.path.length - r.path.length;
-    return cmp !== 0 ? cmp : DocumentKey.comparator(l, r);
+    const left = l.path.toArray();
+    const right = r.path.toArray();
+    // The ordering is based on https://chromium.googlesource.com/chromium/blink/+/fe5c21fef94dae71c1c3344775b8d8a7f7e6d9ec/Source/modules/indexeddb/IDBKey.cpp#74
+    let cmp = 0;
+    for (let i = 0; i < left.length - 2 && i < right.length - 2; ++i) {
+        cmp = primitiveComparator(left[i], right[i]);
+        if (cmp) {
+            return cmp;
+        }
+    }
+    cmp = primitiveComparator(left.length, right.length);
+    if (cmp) {
+        return cmp;
+    }
+    cmp = primitiveComparator(left[left.length - 2], right[right.length - 2]);
+    if (cmp) {
+        return cmp;
+    }
+    return primitiveComparator(left[left.length - 1], right[right.length - 1]);
 }
 /**
  * Schema Version for the Web client:
@@ -13157,7 +13293,7 @@ class IndexedDbPersistence {
         return this.remoteDocumentCache;
     }
     getIndexManager(user) {
-        return new IndexedDbIndexManager(user);
+        return new IndexedDbIndexManager(user, this.serializer.remoteSerializer.databaseId);
     }
     getDocumentOverlayCache(user) {
         return IndexedDbDocumentOverlayCache.forUser(this.serializer, user);
@@ -13653,7 +13789,7 @@ class LocalStoreImpl {
         this.mutationQueue = this.persistence.getMutationQueue(user, this.indexManager);
         this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue, this.indexManager);
         this.remoteDocuments.setIndexManager(this.indexManager);
-        this.queryEngine.setLocalDocumentsView(this.localDocuments);
+        this.queryEngine.initialize(this.localDocuments, this.indexManager);
     }
     collectGarbage(garbageCollector) {
         return this.persistence.runTransaction('Collect garbage', 'readwrite-primary', txn => garbageCollector.collect(txn, this.targetDataByTarget));
@@ -15395,10 +15531,30 @@ class MemoryEagerDelegate {
  * limitations under the License.
  */
 /**
- * A query engine that takes advantage of the target document mapping in the
- * QueryCache. Query execution is optimized by only reading the documents that
- * previously matched a query plus any documents that were edited after the
- * query was last listened to.
+ * The Firestore query engine.
+ *
+ * Firestore queries can be executed in three modes. The Query Engine determines
+ * what mode to use based on what data is persisted. The mode only determines
+ * the runtime complexity of the query - the result set is equivalent across all
+ * implementations.
+ *
+ * The Query engine will use indexed-based execution if a user has configured
+ * any index that can be used to execute query (via `setIndexConfiguration()`).
+ * Otherwise, the engine will try to optimize the query by re-using a previously
+ * persisted query result. If that is not possible, the query will be executed
+ * via a full collection scan.
+ *
+ * Index-based execution is the default when available. The query engine
+ * supports partial indexed execution and merges the result from the index
+ * lookup with documents that have not yet been indexed. The index evaluation
+ * matches the backend's format and as such, the SDK can use indexing for all
+ * queries that the backend supports.
+ *
+ * If no index exists, the query engine tries to take advantage of the target
+ * document mapping in the TargetCache. These mappings exists for all queries
+ * that have been synced with the backend at least once and allow the query
+ * engine to only read documents that previously matched a query plus any
+ * documents that were edited after the query was last listened to.
  *
  * There are some cases when this optimization is not guaranteed to produce
  * the same results as full collection scans. In these cases, query
@@ -15413,16 +15569,41 @@ class MemoryEagerDelegate {
  * - Queries that have never been CURRENT or free of limbo documents.
  */
 class QueryEngine {
+    constructor() {
+        this.initialized = false;
+    }
     /** Sets the document view to query against. */
-    setLocalDocumentsView(localDocuments) {
+    initialize(localDocuments, indexManager) {
         this.localDocumentsView = localDocuments;
+        this.indexManager = indexManager;
+        this.initialized = true;
     }
     /** Returns all local documents matching the specified query. */
     getDocumentsMatchingQuery(transaction, query, lastLimboFreeSnapshotVersion, remoteKeys) {
-        // Queries that match all documents don't benefit from using
-        // key-based lookups. It is more efficient to scan all documents in a
-        // collection, rather than to perform individual lookups.
-        if (matchesAllDocuments(query)) {
+        return this.performQueryUsingIndex(transaction, query)
+            .next(result => result
+            ? result
+            : this.performQueryUsingRemoteKeys(transaction, query, remoteKeys, lastLimboFreeSnapshotVersion))
+            .next(result => result ? result : this.executeFullCollectionScan(transaction, query));
+    }
+    /**
+     * Performs an indexed query that evaluates the query based on a collection's
+     * persisted index values. Returns `null` if an index is not available.
+     */
+    performQueryUsingIndex(transaction, query) {
+        {
+            return PersistencePromise.resolve(null);
+        }
+    }
+    /**
+     * Performs a query based on the target's persisted query mapping. Returns
+     * `null` if the mapping is not available or cannot be used.
+     */
+    performQueryUsingRemoteKeys(transaction, query, remoteKeys, lastLimboFreeSnapshotVersion) {
+        if (queryMatchesAllDocuments(query)) {
+            // Queries that match all documents don't benefit from using
+            // key-based lookups. It is more efficient to scan all documents in a
+            // collection, rather than to perform individual lookups.
             return this.executeFullCollectionScan(transaction, query);
         }
         // Queries that have never seen a snapshot without limbo free documents
@@ -15432,8 +15613,7 @@ class QueryEngine {
         }
         return this.localDocumentsView.getDocuments(transaction, remoteKeys).next(documents => {
             const previousResults = this.applyQuery(query, documents);
-            if ((hasLimitToFirst(query) || hasLimitToLast(query)) &&
-                this.needsRefill(query.limitType, previousResults, remoteKeys, lastLimboFreeSnapshotVersion)) {
+            if (this.needsRefill(query, previousResults, remoteKeys, lastLimboFreeSnapshotVersion)) {
                 return this.executeFullCollectionScan(transaction, query);
             }
             if (getLogLevel() <= LogLevel.DEBUG) {
@@ -15441,15 +15621,7 @@ class QueryEngine {
             }
             // Retrieve all results for documents that were updated since the last
             // limbo-document free remote snapshot.
-            return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID)).next(updatedResults => {
-                // We merge `previousResults` into `updateResults`, since
-                // `updateResults` is already a DocumentMap. If a document is
-                // contained in both lists, then its contents are the same.
-                previousResults.forEach(doc => {
-                    updatedResults = updatedResults.insert(doc.key, doc);
-                });
-                return updatedResults;
-            });
+            return this.appendRemainingResults(transaction, previousResults, query, newIndexOffsetSuccessorFromReadTime(lastLimboFreeSnapshotVersion, INITIAL_LARGEST_BATCH_ID));
         });
     }
     /** Applies the query filter and sorting to the provided documents.  */
@@ -15468,6 +15640,7 @@ class QueryEngine {
      * Determines if a limit query needs to be refilled from cache, making it
      * ineligible for index-free execution.
      *
+     * @param query The query.
      * @param sortedPreviousResults - The documents that matched the query when it
      * was last synchronized, sorted by the query's comparator.
      * @param remoteKeys - The document keys that matched the query at the last
@@ -15475,10 +15648,14 @@ class QueryEngine {
      * @param limboFreeSnapshotVersion - The version of the snapshot when the
      * query was last synchronized.
      */
-    needsRefill(limitType, sortedPreviousResults, remoteKeys, limboFreeSnapshotVersion) {
-        // The query needs to be refilled if a previously matching document no
-        // longer matches.
+    needsRefill(query, sortedPreviousResults, remoteKeys, limboFreeSnapshotVersion) {
+        if (query.limit === null) {
+            // Queries without limits do not need to be refilled.
+            return false;
+        }
         if (remoteKeys.size !== sortedPreviousResults.size) {
+            // The query needs to be refilled if a previously matching document no
+            // longer matches.
             return true;
         }
         // Limit queries are not eligible for index-free query execution if there is
@@ -15489,7 +15666,7 @@ class QueryEngine {
         // the boundary of the limit itself did not change and documents from cache
         // will continue to be "rejected" by this boundary. Therefore, we can ignore
         // any modifications that don't affect the last document.
-        const docAtLimitEdge = limitType === "F" /* First */
+        const docAtLimitEdge = query.limitType === "F" /* First */
             ? sortedPreviousResults.last()
             : sortedPreviousResults.first();
         if (!docAtLimitEdge) {
@@ -15505,6 +15682,22 @@ class QueryEngine {
         }
         return this.localDocumentsView.getDocumentsMatchingQuery(transaction, query, IndexOffset.min());
     }
+    /**
+     * Combines the results from an indexed execution with the remaining documents
+     * that have not yet been indexed.
+     */
+    appendRemainingResults(transaction, indexedResults, query, offset) {
+        // Retrieve all results for documents that were updated since the offset.
+        return this.localDocumentsView
+            .getDocumentsMatchingQuery(transaction, query, offset)
+            .next(remainingResults => {
+            // Merge with existing results
+            indexedResults.forEach(d => {
+                remainingResults = remainingResults.insert(d.key, d);
+            });
+            return remainingResults;
+        });
+    }
 }
 
 /**
@@ -21764,10 +21957,12 @@ class View {
         //
         // Note that this should never get used in a refill (when previousChanges is
         // set), because there will only be adds -- no deletes or updates.
-        const lastDocInLimit = hasLimitToFirst(this.query) && oldDocumentSet.size === this.query.limit
+        const lastDocInLimit = this.query.limitType === "F" /* First */ &&
+            oldDocumentSet.size === this.query.limit
             ? oldDocumentSet.last()
             : null;
-        const firstDocInLimit = hasLimitToLast(this.query) && oldDocumentSet.size === this.query.limit
+        const firstDocInLimit = this.query.limitType === "L" /* Last */ &&
+            oldDocumentSet.size === this.query.limit
             ? oldDocumentSet.first()
             : null;
         docChanges.inorderTraversal((key, entry) => {
@@ -21840,9 +22035,9 @@ class View {
             }
         });
         // Drop documents out to meet limit/limitToLast requirement.
-        if (hasLimitToFirst(this.query) || hasLimitToLast(this.query)) {
+        if (this.query.limit !== null) {
             while (newDocumentSet.size > this.query.limit) {
-                const oldDoc = hasLimitToFirst(this.query)
+                const oldDoc = this.query.limitType === "F" /* First */
                     ? newDocumentSet.last()
                     : newDocumentSet.first();
                 newDocumentSet = newDocumentSet.delete(oldDoc.key);
@@ -26973,7 +27168,8 @@ function snapshotEqual(left, right) {
  * 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');
     }
 }