@firebase/firestore 3.4.5 → 3.4.6-2022216223411

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.5";
+const version$1 = "3.4.6-2022216223411";
 
 /**
  * @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.7";
+const version = "9.6.9-2022216223411";
 
 /**
  * @license
@@ -1199,55 +1199,23 @@ function decodeResourcePath(path) {
     }
     return new ResourcePath(segments);
 }
+
 /**
- * Schema Version for the Web client:
- * 1.  Initial version including Mutation Queue, Query Cache, and Remote
- *     Document Cache
- * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
- *     longer required because migration 3 unconditionally clears it.
- * 3.  Dropped and re-created Query Cache to deal with cache corruption related
- *     to limbo resolution. Addresses
- *     https://github.com/firebase/firebase-ios-sdk/issues/1548
- * 4.  Multi-Tab Support.
- * 5.  Removal of held write acks.
- * 6.  Create document global for tracking document cache size.
- * 7.  Ensure every cached document has a sentinel row with a sequence number.
- * 8.  Add collection-parent index for Collection Group queries.
- * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
- *     an auto-incrementing ID. This is required for Index-Free queries.
- * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
- * 11. Add bundles and named_queries for bundle support.
- * 12. Add document overlays.
- * 13. Add indexing support.
- */
-const SCHEMA_VERSION = 12;
-/**
- * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.
- */
-class DbTimestamp {
-    constructor(seconds, nanoseconds) {
-        this.seconds = seconds;
-        this.nanoseconds = nanoseconds;
-    }
-}
-/**
- * A singleton object to be stored in the 'owner' store in IndexedDb.
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * A given database can have a single primary tab assigned at a given time. That
- * tab must validate that it is still holding the primary lease before every
- * operation that requires locked access. The primary tab should regularly
- * write an updated timestamp to this lease to prevent other tabs from
- * "stealing" the primary lease
+ *   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.
  */
-class DbPrimaryClient {
-    constructor(ownerId, 
-    /** Whether to allow shared access from multiple tabs. */
-    allowTabSynchronization, leaseTimestampMs) {
-        this.ownerId = ownerId;
-        this.allowTabSynchronization = allowTabSynchronization;
-        this.leaseTimestampMs = leaseTimestampMs;
-    }
-}
 /**
  * Name of the IndexedDb object store.
  *
@@ -1255,239 +1223,62 @@ class DbPrimaryClient {
  * older clients that only supported single locked access to the persistence
  * layer.
  */
-DbPrimaryClient.store = 'owner';
+const DbPrimaryClientStore = 'owner';
 /**
  * The key string used for the single object that exists in the
  * DbPrimaryClient store.
  */
-DbPrimaryClient.key = 'owner';
-/**
- * An object to be stored in the 'mutationQueues' store in IndexedDb.
- *
- * Each user gets a single queue of MutationBatches to apply to the server.
- * DbMutationQueue tracks the metadata about the queue.
- */
-class DbMutationQueue {
-    constructor(
-    /**
-     * The normalized user ID to which this queue belongs.
-     */
-    userId, 
-    /**
-     * An identifier for the highest numbered batch that has been acknowledged
-     * by the server. All MutationBatches in this queue with batchIds less
-     * than or equal to this value are considered to have been acknowledged by
-     * the server.
-     *
-     * NOTE: this is deprecated and no longer used by the code.
-     */
-    lastAcknowledgedBatchId, 
-    /**
-     * A stream token that was previously sent by the server.
-     *
-     * See StreamingWriteRequest in datastore.proto for more details about
-     * usage.
-     *
-     * After sending this token, earlier tokens may not be used anymore so
-     * only a single stream token is retained.
-     *
-     * NOTE: this is deprecated and no longer used by the code.
-     */
-    lastStreamToken) {
-        this.userId = userId;
-        this.lastAcknowledgedBatchId = lastAcknowledgedBatchId;
-        this.lastStreamToken = lastStreamToken;
-    }
-}
+const DbPrimaryClientKey = 'owner';
 /** Name of the IndexedDb object store.  */
-DbMutationQueue.store = 'mutationQueues';
+const DbMutationQueueStore = 'mutationQueues';
 /** Keys are automatically assigned via the userId property. */
-DbMutationQueue.keyPath = 'userId';
-/**
- * An object to be stored in the 'mutations' store in IndexedDb.
- *
- * Represents a batch of user-level mutations intended to be sent to the server
- * in a single write. Each user-level batch gets a separate DbMutationBatch
- * with a new batchId.
- */
-class DbMutationBatch {
-    constructor(
-    /**
-     * The normalized user ID to which this batch belongs.
-     */
-    userId, 
-    /**
-     * An identifier for this batch, allocated using an auto-generated key.
-     */
-    batchId, 
-    /**
-     * The local write time of the batch, stored as milliseconds since the
-     * epoch.
-     */
-    localWriteTimeMs, 
-    /**
-     * A list of "mutations" that represent a partial base state from when this
-     * write batch was initially created. During local application of the write
-     * batch, these baseMutations are applied prior to the real writes in order
-     * to override certain document fields from the remote document cache. This
-     * is necessary in the case of non-idempotent writes (e.g. `increment()`
-     * transforms) to make sure that the local view of the modified documents
-     * doesn't flicker if the remote document cache receives the result of the
-     * non-idempotent write before the write is removed from the queue.
-     *
-     * These mutations are never sent to the backend.
-     */
-    baseMutations, 
-    /**
-     * A list of mutations to apply. All mutations will be applied atomically.
-     *
-     * Mutations are serialized via toMutation().
-     */
-    mutations) {
-        this.userId = userId;
-        this.batchId = batchId;
-        this.localWriteTimeMs = localWriteTimeMs;
-        this.baseMutations = baseMutations;
-        this.mutations = mutations;
-    }
-}
+const DbMutationQueueKeyPath = 'userId';
 /** Name of the IndexedDb object store.  */
-DbMutationBatch.store = 'mutations';
+const DbMutationBatchStore = 'mutations';
 /** Keys are automatically assigned via the userId, batchId properties. */
-DbMutationBatch.keyPath = 'batchId';
+const DbMutationBatchKeyPath = 'batchId';
 /** The index name for lookup of mutations by user. */
-DbMutationBatch.userMutationsIndex = 'userMutationsIndex';
+const DbMutationBatchUserMutationsIndex = 'userMutationsIndex';
 /** The user mutations index is keyed by [userId, batchId] pairs. */
-DbMutationBatch.userMutationsKeyPath = ['userId', 'batchId'];
+const DbMutationBatchUserMutationsKeyPath = ['userId', 'batchId'];
 /**
- * An object to be stored in the 'documentMutations' store in IndexedDb.
- *
- * A manually maintained index of all the mutation batches that affect a given
- * document key. The rows in this table are references based on the contents of
- * DbMutationBatch.mutations.
+ * Creates a [userId] key for use in the DbDocumentMutations index to iterate
+ * over all of a user's document mutations.
  */
-class DbDocumentMutation {
-    constructor() { }
-    /**
-     * Creates a [userId] key for use in the DbDocumentMutations index to iterate
-     * over all of a user's document mutations.
-     */
-    static prefixForUser(userId) {
-        return [userId];
-    }
-    /**
-     * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
-     * index to iterate over all at document mutations for a given path or lower.
-     */
-    static prefixForPath(userId, path) {
-        return [userId, encodeResourcePath(path)];
-    }
-    /**
-     * Creates a full index key of [userId, encodedPath, batchId] for inserting
-     * and deleting into the DbDocumentMutations index.
-     */
-    static key(userId, path, batchId) {
-        return [userId, encodeResourcePath(path), batchId];
-    }
+function newDbDocumentMutationPrefixForUser(userId) {
+    return [userId];
 }
-DbDocumentMutation.store = 'documentMutations';
 /**
- * Because we store all the useful information for this store in the key,
- * there is no useful information to store as the value. The raw (unencoded)
- * path cannot be stored because IndexedDb doesn't store prototype
- * information.
- */
-DbDocumentMutation.PLACEHOLDER = new DbDocumentMutation();
-/**
- * Represents the known absence of a document at a particular version.
- * Stored in IndexedDb as part of a DbRemoteDocument object.
+ * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
+ * index to iterate over all at document mutations for a given path or lower.
  */
-class DbNoDocument {
-    constructor(path, readTime) {
-        this.path = path;
-        this.readTime = readTime;
-    }
+function newDbDocumentMutationPrefixForPath(userId, path) {
+    return [userId, encodeResourcePath(path)];
 }
 /**
- * Represents a document that is known to exist but whose data is unknown.
- * Stored in IndexedDb as part of a DbRemoteDocument object.
+ * Creates a full index key of [userId, encodedPath, batchId] for inserting
+ * and deleting into the DbDocumentMutations index.
  */
-class DbUnknownDocument {
-    constructor(path, version) {
-        this.path = path;
-        this.version = version;
-    }
+function newDbDocumentMutationKey(userId, path, batchId) {
+    return [userId, encodeResourcePath(path), batchId];
 }
 /**
- * An object to be stored in the 'remoteDocuments' store in IndexedDb.
- * It represents either:
- *
- * - A complete document.
- * - A "no document" representing a document that is known not to exist (at
- * some version).
- * - An "unknown document" representing a document that is known to exist (at
- * some version) but whose contents are unknown.
- *
- * Note: This is the persisted equivalent of a MaybeDocument and could perhaps
- * be made more general if necessary.
+ * Because we store all the useful information for this store in the key,
+ * there is no useful information to store as the value. The raw (unencoded)
+ * path cannot be stored because IndexedDb doesn't store prototype
+ * information.
  */
-class DbRemoteDocument {
-    // TODO: We are currently storing full document keys almost three times
-    // (once as part of the primary key, once - partly - as `parentPath` and once
-    // inside the encoded documents). During our next migration, we should
-    // rewrite the primary key as parentPath + document ID which would allow us
-    // to drop one value.
-    constructor(
-    /**
-     * Set to an instance of DbUnknownDocument if the data for a document is
-     * not known, but it is known that a document exists at the specified
-     * version (e.g. it had a successful update applied to it)
-     */
-    unknownDocument, 
-    /**
-     * Set to an instance of a DbNoDocument if it is known that no document
-     * exists.
-     */
-    noDocument, 
-    /**
-     * Set to an instance of a Document if there's a cached version of the
-     * document.
-     */
-    document, 
-    /**
-     * Documents that were written to the remote document store based on
-     * a write acknowledgment are marked with `hasCommittedMutations`. These
-     * documents are potentially inconsistent with the backend's copy and use
-     * the write's commit version as their document version.
-     */
-    hasCommittedMutations, 
-    /**
-     * When the document was read from the backend. Undefined for data written
-     * prior to schema version 9.
-     */
-    readTime, 
-    /**
-     * The path of the collection this document is part of. Undefined for data
-     * written prior to schema version 9.
-     */
-    parentPath) {
-        this.unknownDocument = unknownDocument;
-        this.noDocument = noDocument;
-        this.document = document;
-        this.hasCommittedMutations = hasCommittedMutations;
-        this.readTime = readTime;
-        this.parentPath = parentPath;
-    }
-}
-DbRemoteDocument.store = 'remoteDocuments';
+const DbDocumentMutationPlaceholder = {};
+const DbDocumentMutationStore = 'documentMutations';
+const DbRemoteDocumentStore = 'remoteDocuments';
 /**
  * An index that provides access to all entries sorted by read time (which
  * corresponds to the last modification time of each row).
  *
  * This index is used to provide a changelog for Multi-Tab.
  */
-DbRemoteDocument.readTimeIndex = 'readTimeIndex';
-DbRemoteDocument.readTimeIndexPath = 'readTime';
+const DbRemoteDocumentReadTimeIndex = 'readTimeIndex';
+const DbRemoteDocumentReadTimeIndexPath = 'readTime';
 /**
  * An index that provides access to documents in a collection sorted by read
  * time.
@@ -1495,361 +1286,68 @@ DbRemoteDocument.readTimeIndexPath = 'readTime';
  * This index is used to allow the RemoteDocumentCache to fetch newly changed
  * documents in a collection.
  */
-DbRemoteDocument.collectionReadTimeIndex = 'collectionReadTimeIndex';
-DbRemoteDocument.collectionReadTimeIndexPath = ['parentPath', 'readTime'];
-/**
- * Contains a single entry that has metadata about the remote document cache.
- */
-class DbRemoteDocumentGlobal {
-    /**
-     * @param byteSize - Approximately the total size in bytes of all the
-     * documents in the document cache.
-     */
-    constructor(byteSize) {
-        this.byteSize = byteSize;
-    }
-}
-DbRemoteDocumentGlobal.store = 'remoteDocumentGlobal';
-DbRemoteDocumentGlobal.key = 'remoteDocumentGlobalKey';
-/**
- * An object to be stored in the 'targets' store in IndexedDb.
- *
- * This is based on and should be kept in sync with the proto used in the iOS
- * client.
- *
- * Each query the client listens to against the server is tracked on disk so
- * that the query can be efficiently resumed on restart.
- */
-class DbTarget {
-    constructor(
-    /**
-     * An auto-generated sequential numeric identifier for the query.
-     *
-     * Queries are stored using their canonicalId as the key, but these
-     * canonicalIds can be quite long so we additionally assign a unique
-     * queryId which can be used by referenced data structures (e.g.
-     * indexes) to minimize the on-disk cost.
-     */
-    targetId, 
-    /**
-     * The canonical string representing this query. This is not unique.
-     */
-    canonicalId, 
-    /**
-     * The last readTime received from the Watch Service for this query.
-     *
-     * This is the same value as TargetChange.read_time in the protos.
-     */
-    readTime, 
-    /**
-     * An opaque, server-assigned token that allows watching a query to be
-     * resumed after disconnecting without retransmitting all the data
-     * that matches the query. The resume token essentially identifies a
-     * point in time from which the server should resume sending results.
-     *
-     * This is related to the snapshotVersion in that the resumeToken
-     * effectively also encodes that value, but the resumeToken is opaque
-     * and sometimes encodes additional information.
-     *
-     * A consequence of this is that the resumeToken should be used when
-     * asking the server to reason about where this client is in the watch
-     * stream, but the client should use the snapshotVersion for its own
-     * purposes.
-     *
-     * This is the same value as TargetChange.resume_token in the protos.
-     */
-    resumeToken, 
-    /**
-     * A sequence number representing the last time this query was
-     * listened to, used for garbage collection purposes.
-     *
-     * Conventionally this would be a timestamp value, but device-local
-     * clocks are unreliable and they must be able to create new listens
-     * even while disconnected. Instead this should be a monotonically
-     * increasing number that's incremented on each listen call.
-     *
-     * This is different from the queryId since the queryId is an
-     * immutable identifier assigned to the Query on first use while
-     * lastListenSequenceNumber is updated every time the query is
-     * listened to.
-     */
-    lastListenSequenceNumber, 
-    /**
-     * Denotes the maximum snapshot version at which the associated query view
-     * contained no limbo documents.  Undefined for data written prior to
-     * schema version 9.
-     */
-    lastLimboFreeSnapshotVersion, 
-    /**
-     * The query for this target.
-     *
-     * Because canonical ids are not unique we must store the actual query. We
-     * use the proto to have an object we can persist without having to
-     * duplicate translation logic to and from a `Query` object.
-     */
-    query) {
-        this.targetId = targetId;
-        this.canonicalId = canonicalId;
-        this.readTime = readTime;
-        this.resumeToken = resumeToken;
-        this.lastListenSequenceNumber = lastListenSequenceNumber;
-        this.lastLimboFreeSnapshotVersion = lastLimboFreeSnapshotVersion;
-        this.query = query;
-    }
-}
-DbTarget.store = 'targets';
+const DbRemoteDocumentCollectionReadTimeIndex = 'collectionReadTimeIndex';
+const DbRemoteDocumentCollectionReadTimeIndexPath = [
+    'parentPath',
+    'readTime'
+];
+const DbRemoteDocumentGlobalStore = 'remoteDocumentGlobal';
+const DbRemoteDocumentGlobalKey = 'remoteDocumentGlobalKey';
+const DbTargetStore = 'targets';
 /** Keys are automatically assigned via the targetId property. */
-DbTarget.keyPath = 'targetId';
+const DbTargetKeyPath = 'targetId';
 /** The name of the queryTargets index. */
-DbTarget.queryTargetsIndexName = 'queryTargetsIndex';
+const DbTargetQueryTargetsIndexName = 'queryTargetsIndex';
 /**
  * The index of all canonicalIds to the targets that they match. This is not
  * a unique mapping because canonicalId does not promise a unique name for all
  * possible queries, so we append the targetId to make the mapping unique.
  */
-DbTarget.queryTargetsKeyPath = ['canonicalId', 'targetId'];
-/**
- * An object representing an association between a target and a document, or a
- * sentinel row marking the last sequence number at which a document was used.
- * Each document cached must have a corresponding sentinel row before lru
- * garbage collection is enabled.
- *
- * The target associations and sentinel rows are co-located so that orphaned
- * documents and their sequence numbers can be identified efficiently via a scan
- * of this store.
- */
-class DbTargetDocument {
-    constructor(
-    /**
-     * The targetId identifying a target or 0 for a sentinel row.
-     */
-    targetId, 
-    /**
-     * The path to the document, as encoded in the key.
-     */
-    path, 
-    /**
-     * If this is a sentinel row, this should be the sequence number of the last
-     * time the document specified by `path` was used. Otherwise, it should be
-     * `undefined`.
-     */
-    sequenceNumber) {
-        this.targetId = targetId;
-        this.path = path;
-        this.sequenceNumber = sequenceNumber;
-    }
-}
+const DbTargetQueryTargetsKeyPath = ['canonicalId', 'targetId'];
 /** Name of the IndexedDb object store.  */
-DbTargetDocument.store = 'targetDocuments';
+const DbTargetDocumentStore = 'targetDocuments';
 /** Keys are automatically assigned via the targetId, path properties. */
-DbTargetDocument.keyPath = ['targetId', 'path'];
+const DbTargetDocumentKeyPath = ['targetId', 'path'];
 /** The index name for the reverse index. */
-DbTargetDocument.documentTargetsIndex = 'documentTargetsIndex';
+const DbTargetDocumentDocumentTargetsIndex = 'documentTargetsIndex';
 /** We also need to create the reverse index for these properties. */
-DbTargetDocument.documentTargetsKeyPath = ['path', 'targetId'];
-/**
- * A record of global state tracked across all Targets, tracked separately
- * to avoid the need for extra indexes.
- *
- * This should be kept in-sync with the proto used in the iOS client.
- */
-class DbTargetGlobal {
-    constructor(
-    /**
-     * The highest numbered target id across all targets.
-     *
-     * See DbTarget.targetId.
-     */
-    highestTargetId, 
-    /**
-     * The highest numbered lastListenSequenceNumber across all targets.
-     *
-     * See DbTarget.lastListenSequenceNumber.
-     */
-    highestListenSequenceNumber, 
-    /**
-     * A global snapshot version representing the last consistent snapshot we
-     * received from the backend. This is monotonically increasing and any
-     * snapshots received from the backend prior to this version (e.g. for
-     * targets resumed with a resumeToken) should be suppressed (buffered)
-     * until the backend has caught up to this snapshot version again. This
-     * prevents our cache from ever going backwards in time.
-     */
-    lastRemoteSnapshotVersion, 
-    /**
-     * The number of targets persisted.
-     */
-    targetCount) {
-        this.highestTargetId = highestTargetId;
-        this.highestListenSequenceNumber = highestListenSequenceNumber;
-        this.lastRemoteSnapshotVersion = lastRemoteSnapshotVersion;
-        this.targetCount = targetCount;
-    }
-}
+const DbTargetDocumentDocumentTargetsKeyPath = ['path', 'targetId'];
 /**
  * The key string used for the single object that exists in the
  * DbTargetGlobal store.
  */
-DbTargetGlobal.key = 'targetGlobalKey';
-DbTargetGlobal.store = 'targetGlobal';
-/**
- * An object representing an association between a Collection id (e.g. 'messages')
- * to a parent path (e.g. '/chats/123') that contains it as a (sub)collection.
- * This is used to efficiently find all collections to query when performing
- * a Collection Group query.
- */
-class DbCollectionParent {
-    constructor(
-    /**
-     * The collectionId (e.g. 'messages')
-     */
-    collectionId, 
-    /**
-     * The path to the parent (either a document location or an empty path for
-     * a root-level collection).
-     */
-    parent) {
-        this.collectionId = collectionId;
-        this.parent = parent;
-    }
-}
+const DbTargetGlobalKey = 'targetGlobalKey';
+const DbTargetGlobalStore = 'targetGlobal';
 /** Name of the IndexedDb object store. */
-DbCollectionParent.store = 'collectionParents';
+const DbCollectionParentStore = 'collectionParents';
 /** Keys are automatically assigned via the collectionId, parent properties. */
-DbCollectionParent.keyPath = ['collectionId', 'parent'];
-/**
- * A record of the metadata state of each client.
- *
- * PORTING NOTE: This is used to synchronize multi-tab state and does not need
- * to be ported to iOS or Android.
- */
-class DbClientMetadata {
-    constructor(
-    // Note: Previous schema versions included a field
-    // "lastProcessedDocumentChangeId". Don't use anymore.
-    /** The auto-generated client id assigned at client startup. */
-    clientId, 
-    /** The last time this state was updated. */
-    updateTimeMs, 
-    /** Whether the client's network connection is enabled. */
-    networkEnabled, 
-    /** Whether this client is running in a foreground tab. */
-    inForeground) {
-        this.clientId = clientId;
-        this.updateTimeMs = updateTimeMs;
-        this.networkEnabled = networkEnabled;
-        this.inForeground = inForeground;
-    }
-}
+const DbCollectionParentKeyPath = ['collectionId', 'parent'];
 /** Name of the IndexedDb object store. */
-DbClientMetadata.store = 'clientMetadata';
+const DbClientMetadataStore = 'clientMetadata';
 /** Keys are automatically assigned via the clientId properties. */
-DbClientMetadata.keyPath = 'clientId';
-/** An object representing a bundle loaded by the SDK. */
-class DbBundle {
-    constructor(
-    /** The ID of the loaded bundle. */
-    bundleId, 
-    /** The create time of the loaded bundle. */
-    createTime, 
-    /** The schema version of the loaded bundle. */
-    version) {
-        this.bundleId = bundleId;
-        this.createTime = createTime;
-        this.version = version;
-    }
-}
+const DbClientMetadataKeyPath = 'clientId';
 /** Name of the IndexedDb object store. */
-DbBundle.store = 'bundles';
-DbBundle.keyPath = 'bundleId';
-/** An object representing a named query loaded by the SDK via a bundle. */
-class DbNamedQuery {
-    constructor(
-    /** The name of the query. */
-    name, 
-    /** The read time of the results saved in the bundle from the named query. */
-    readTime, 
-    /** The query saved in the bundle. */
-    bundledQuery) {
-        this.name = name;
-        this.readTime = readTime;
-        this.bundledQuery = bundledQuery;
-    }
-}
+const DbBundleStore = 'bundles';
+const DbBundleKeyPath = 'bundleId';
 /** Name of the IndexedDb object store. */
-DbNamedQuery.store = 'namedQueries';
-DbNamedQuery.keyPath = 'name';
-/** An object representing the global configuration for a field index. */
-class DbIndexConfiguration {
-    constructor(
-    /**
-     * The index id for this entry. Undefined for indexes that are not yet
-     * persisted.
-     */
-    indexId, 
-    /** The collection group this index belongs to. */
-    collectionGroup, 
-    /** The fields to index for this index. */
-    fields) {
-        this.indexId = indexId;
-        this.collectionGroup = collectionGroup;
-        this.fields = fields;
-    }
-}
+const DbNamedQueryStore = 'namedQueries';
+const DbNamedQueryKeyPath = 'name';
 /** Name of the IndexedDb object store. */
-DbIndexConfiguration.store = 'indexConfiguration';
-DbIndexConfiguration.keyPath = 'indexId';
+const DbIndexConfigurationStore = 'indexConfiguration';
+const DbIndexConfigurationKeyPath = 'indexId';
 /**
- * An index that provides access to the index configurations by collection
- * group.
- *
- * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
- * not possible here as the Web client supports concurrent access to
- * persistence via multi-tab.
- */
-DbIndexConfiguration.collectionGroupIndex = 'collectionGroupIndex';
-DbIndexConfiguration.collectionGroupIndexPath = 'collectionGroup';
-/**
- * An object describing how up-to-date the index backfill is for each user and
- * index.
- */
-class DbIndexState {
-    constructor(
-    /** The index id for this entry. */
-    indexId, 
-    /** The user id for this entry. */
-    uid, 
-    /**
-     * A number that indicates when the index was last updated (relative to
-     * other indexes).
-     */
-    sequenceNumber, 
-    /**
-     * The latest read time that has been indexed by Firestore for this field
-     * index. Set to `{seconds: 0, nanos: 0}` if no documents have been indexed.
-     */
-    readTime, 
-    /**
-     * The last document that has been indexed for this field index. Empty if
-     * no documents have been indexed.
-     */
-    documentKey, 
-    /**
-     * The largest mutation batch id that has been processed for this index. -1
-     * if no mutations have been indexed.
-     */
-    largestBatchId) {
-        this.indexId = indexId;
-        this.uid = uid;
-        this.sequenceNumber = sequenceNumber;
-        this.readTime = readTime;
-        this.documentKey = documentKey;
-        this.largestBatchId = largestBatchId;
-    }
-}
+ * An index that provides access to the index configurations by collection
+ * group.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+const DbIndexConfigurationCollectionGroupIndex = 'collectionGroupIndex';
+const DbIndexConfigurationCollectionGroupIndexPath = 'collectionGroup';
 /** Name of the IndexedDb object store. */
-DbIndexState.store = 'indexState';
-DbIndexState.keyPath = ['indexId', 'uid'];
+const DbIndexStateStore = 'indexState';
+const DbIndexStateKeyPath = ['indexId', 'uid'];
 /**
  * An index that provides access to documents in a collection sorted by last
  * update time. Used by the backfiller.
@@ -1858,108 +1356,66 @@ DbIndexState.keyPath = ['indexId', 'uid'];
  * not possible here as the Web client supports concurrent access to
  * persistence via multi-tab.
  */
-DbIndexState.sequenceNumberIndex = 'sequenceNumberIndex';
-DbIndexState.sequenceNumberIndexPath = ['uid', 'sequenceNumber'];
-/** An object that stores the encoded entries for all documents and fields. */
-class DbIndexEntry {
-    constructor(
-    /** The index id for this entry. */
-    indexId, 
-    /** The user id for this entry. */
-    uid, 
-    /** The encoded array index value for this entry. */
-    arrayValue, 
-    /** The encoded directional value for equality and inequality filters. */
-    directionalValue, 
-    /** The document key this entry points to. */
-    documentKey) {
-        this.indexId = indexId;
-        this.uid = uid;
-        this.arrayValue = arrayValue;
-        this.directionalValue = directionalValue;
-        this.documentKey = documentKey;
-    }
-}
+const DbIndexStateSequenceNumberIndex = 'sequenceNumberIndex';
+const DbIndexStateSequenceNumberIndexPath = ['uid', 'sequenceNumber'];
 /** Name of the IndexedDb object store. */
-DbIndexEntry.store = 'indexEntries';
-DbIndexEntry.keyPath = [
+const DbIndexEntryStore = 'indexEntries';
+const DbIndexEntryKeyPath = [
     'indexId',
     'uid',
     'arrayValue',
     'directionalValue',
     'documentKey'
 ];
-DbIndexEntry.documentKeyIndex = 'documentKeyIndex';
-DbIndexEntry.documentKeyIndexPath = ['indexId', 'uid', 'documentKey'];
-/**
- * An object representing a document overlay.
- */
-class DbDocumentOverlay {
-    constructor(
-    /** The user ID to whom this overlay belongs. */
-    userId, 
-    /** The path to the collection that contains the document. */
-    collectionPath, 
-    /** The ID (key) of the document within the collection. */
-    documentId, 
-    /** The collection group to which the document belongs. */
-    collectionGroup, 
-    /** The largest batch ID that's been applied for this overlay. */
-    largestBatchId, 
-    /** The overlay mutation. */
-    overlayMutation) {
-        this.userId = userId;
-        this.collectionPath = collectionPath;
-        this.documentId = documentId;
-        this.collectionGroup = collectionGroup;
-        this.largestBatchId = largestBatchId;
-        this.overlayMutation = overlayMutation;
-    }
-}
+const DbIndexEntryDocumentKeyIndex = 'documentKeyIndex';
+const DbIndexEntryDocumentKeyIndexPath = [
+    'indexId',
+    'uid',
+    'documentKey'
+];
 /** Name of the IndexedDb object store. */
-DbDocumentOverlay.store = 'documentOverlays';
-DbDocumentOverlay.keyPath = ['userId', 'collectionPath', 'documentId'];
-DbDocumentOverlay.collectionPathOverlayIndex = 'collectionPathOverlayIndex';
-DbDocumentOverlay.collectionPathOverlayIndexPath = [
+const DbDocumentOverlayStore = 'documentOverlays';
+const DbDocumentOverlayKeyPath = [
+    'userId',
+    'collectionPath',
+    'documentId'
+];
+const DbDocumentOverlayCollectionPathOverlayIndex = 'collectionPathOverlayIndex';
+const DbDocumentOverlayCollectionPathOverlayIndexPath = [
     'userId',
     'collectionPath',
     'largestBatchId'
 ];
-DbDocumentOverlay.collectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
-DbDocumentOverlay.collectionGroupOverlayIndexPath = [
+const DbDocumentOverlayCollectionGroupOverlayIndex = 'collectionGroupOverlayIndex';
+const DbDocumentOverlayCollectionGroupOverlayIndexPath = [
     'userId',
     'collectionGroup',
     'largestBatchId'
 ];
 // Visible for testing
 const V1_STORES = [
-    DbMutationQueue.store,
-    DbMutationBatch.store,
-    DbDocumentMutation.store,
-    DbRemoteDocument.store,
-    DbTarget.store,
-    DbPrimaryClient.store,
-    DbTargetGlobal.store,
-    DbTargetDocument.store
+    DbMutationQueueStore,
+    DbMutationBatchStore,
+    DbDocumentMutationStore,
+    DbRemoteDocumentStore,
+    DbTargetStore,
+    DbPrimaryClientStore,
+    DbTargetGlobalStore,
+    DbTargetDocumentStore
 ];
-// V2 is no longer usable (see comment at top of file)
 // Visible for testing
 const V3_STORES = V1_STORES;
 // Note: DbRemoteDocumentChanges is no longer used and dropped with v9.
-const V4_STORES = [...V3_STORES, DbClientMetadata.store];
-// V5 does not change the set of stores.
-const V6_STORES = [...V4_STORES, DbRemoteDocumentGlobal.store];
-// V7 does not change the set of stores.
-const V8_STORES = [...V6_STORES, DbCollectionParent.store];
-// V9 does not change the set of stores.
-// V10 does not change the set of stores.
-const V11_STORES = [...V8_STORES, DbBundle.store, DbNamedQuery.store];
-const V12_STORES = [...V11_STORES, DbDocumentOverlay.store];
+const V4_STORES = [...V3_STORES, DbClientMetadataStore];
+const V6_STORES = [...V4_STORES, DbRemoteDocumentGlobalStore];
+const V8_STORES = [...V6_STORES, DbCollectionParentStore];
+const V11_STORES = [...V8_STORES, DbBundleStore, DbNamedQueryStore];
+const V12_STORES = [...V11_STORES, DbDocumentOverlayStore];
 const V13_STORES = [
     ...V12_STORES,
-    DbIndexConfiguration.store,
-    DbIndexState.store,
-    DbIndexEntry.store
+    DbIndexConfigurationStore,
+    DbIndexStateStore,
+    DbIndexEntryStore
 ];
 /** Returns the object stores for the provided schema. */
 function getObjectStores(schemaVersion) {
@@ -2677,6 +2133,21 @@ class SimpleDbStore {
             });
         }
     }
+    /**
+     * Loads the first `count` elements from the provided index range. Loads all
+     * elements if no limit is provided.
+     */
+    loadFirst(range, count) {
+        const request = this.store.getAll(range, count === null ? undefined : count);
+        return new PersistencePromise((resolve, reject) => {
+            request.onerror = (event) => {
+                reject(event.target.error);
+            };
+            request.onsuccess = (event) => {
+                resolve(event.target.result);
+            };
+        });
+    }
     deleteAll(indexOrRange, range) {
         logDebug(LOG_TAG$h, 'DELETE ALL', this.store.name);
         const options = this.options(indexOrRange, range);
@@ -3287,17 +2758,15 @@ class FieldMask {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Converts a Base64 encoded string to a binary string. */
 function decodeBase64(encoded) {
-    // Node actually doesn't validate base64 strings.
-    // A quick sanity check that is not a fool-proof validation
-    if (/[^-A-Za-z0-9+/=]/.test(encoded)) {
-        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Not a valid Base64 string: ' + encoded);
-    }
-    return new Buffer(encoded, 'base64').toString('binary');
+    // Note: We used to validate the base64 string here via a regular expression.
+    // This was removed to improve the performance of indexing.
+    return Buffer.from(encoded, 'base64').toString('binary');
 }
 /** Converts a binary string to a Base64 encoded string. */
 function encodeBase64(raw) {
-    return new Buffer(raw, 'binary').toString('base64');
+    return Buffer.from(raw, 'binary').toString('base64');
 }
 /** True if and only if the Base64 conversion functions are available. */
 function isBase64Available() {
@@ -3338,6 +2807,8 @@ class ByteString {
         return new ByteString(binaryString);
     }
     static fromUint8Array(array) {
+        // TODO(indexing); Remove the copy of the byte string here as this method
+        // is frequently called during indexing.
         const binaryString = binaryStringFromUint8Array(array);
         return new ByteString(binaryString);
     }
@@ -3756,13 +3227,17 @@ class DocumentKey {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const MAX_VALUE_TYPE = '__max__';
 const MAX_VALUE = {
     mapValue: {
         fields: {
-            '__type__': { stringValue: '__max___' }
+            '__type__': { stringValue: MAX_VALUE_TYPE }
         }
     }
 };
+const MIN_VALUE = {
+    nullValue: 'NULL_VALUE'
+};
 /** Extracts the backend's type order for the provided value. */
 function typeOrder(value) {
     if ('nullValue' in value) {
@@ -3796,6 +3271,9 @@ function typeOrder(value) {
         if (isServerTimestamp(value)) {
             return 4 /* ServerTimestampValue */;
         }
+        else if (isMaxValue(value)) {
+            return 9 /* ArrayValue */;
+        }
         return 10 /* ObjectValue */;
     }
     else {
@@ -3835,6 +3313,8 @@ function valueEquals(left, right) {
             return arrayEquals(left.arrayValue.values || [], right.arrayValue.values || [], valueEquals);
         case 10 /* ObjectValue */:
             return objectEquals(left, right);
+        case 9007199254740991 /* MaxValue */:
+            return true;
         default:
             return fail();
     }
@@ -3907,6 +3387,7 @@ function valueCompare(left, right) {
     }
     switch (leftType) {
         case 0 /* NullValue */:
+        case 9007199254740991 /* MaxValue */:
             return 0;
         case 1 /* BooleanValue */:
             return primitiveComparator(left.booleanValue, right.booleanValue);
@@ -4175,7 +3656,102 @@ function deepClone(source) {
 }
 /** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
 function isMaxValue(value) {
-    return valueEquals(value, MAX_VALUE);
+    return ((((value.mapValue || {}).fields || {})['__type__'] || {}).stringValue ===
+        MAX_VALUE_TYPE);
+}
+/** Returns the lowest value for the given value type (inclusive). */
+function valuesGetLowerBound(value) {
+    if ('nullValue' in value) {
+        return MIN_VALUE;
+    }
+    else if ('booleanValue' in value) {
+        return { booleanValue: false };
+    }
+    else if ('integerValue' in value || 'doubleValue' in value) {
+        return { doubleValue: NaN };
+    }
+    else if ('timestampValue' in value) {
+        return { timestampValue: { seconds: Number.MIN_SAFE_INTEGER } };
+    }
+    else if ('stringValue' in value) {
+        return { stringValue: '' };
+    }
+    else if ('bytesValue' in value) {
+        return { bytesValue: '' };
+    }
+    else if ('referenceValue' in value) {
+        return refValue(DatabaseId.empty(), DocumentKey.empty());
+    }
+    else if ('geoPointValue' in value) {
+        return { geoPointValue: { latitude: -90, longitude: -180 } };
+    }
+    else if ('arrayValue' in value) {
+        return { arrayValue: {} };
+    }
+    else if ('mapValue' in value) {
+        return { mapValue: {} };
+    }
+    else {
+        return fail();
+    }
+}
+/** Returns the largest value for the given value type (exclusive). */
+function valuesGetUpperBound(value) {
+    if ('nullValue' in value) {
+        return { booleanValue: false };
+    }
+    else if ('booleanValue' in value) {
+        return { doubleValue: NaN };
+    }
+    else if ('integerValue' in value || 'doubleValue' in value) {
+        return { timestampValue: { seconds: Number.MIN_SAFE_INTEGER } };
+    }
+    else if ('timestampValue' in value) {
+        return { stringValue: '' };
+    }
+    else if ('stringValue' in value) {
+        return { bytesValue: '' };
+    }
+    else if ('bytesValue' in value) {
+        return refValue(DatabaseId.empty(), DocumentKey.empty());
+    }
+    else if ('referenceValue' in value) {
+        return { geoPointValue: { latitude: -90, longitude: -180 } };
+    }
+    else if ('geoPointValue' in value) {
+        return { arrayValue: {} };
+    }
+    else if ('arrayValue' in value) {
+        return { mapValue: {} };
+    }
+    else if ('mapValue' in value) {
+        return MAX_VALUE;
+    }
+    else {
+        return fail();
+    }
+}
+function valuesMax(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    else if (right === undefined) {
+        return left;
+    }
+    else {
+        return valueCompare(left, right) > 0 ? left : right;
+    }
+}
+function valuesMin(left, right) {
+    if (left === undefined) {
+        return right;
+    }
+    else if (right === undefined) {
+        return left;
+    }
+    else {
+        return valueCompare(left, right) < 0 ? left : right;
+    }
 }
 
 /**
@@ -4570,6 +4146,10 @@ function fieldIndexGetArraySegment(fieldIndex) {
 function fieldIndexGetDirectionalSegments(fieldIndex) {
     return fieldIndex.fields.filter(s => s.kind !== 2 /* CONTAINS */);
 }
+/** 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(',')}`;
+}
 /** An index component consisting of field path and index type.  */
 class IndexSegment {
     constructor(
@@ -4766,6 +4346,191 @@ function targetIsDocumentTarget(target) {
         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;
+    }
+    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 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.
+            }
+        }
+    }
+    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;
+                }
+            }
+        }
+        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;
+                }
+            }
+        }
+        if (segmentValue === undefined) {
+            // No upper bound exists
+            return null;
+        }
+        values.push(segmentValue);
+        inclusive && (inclusive = segmentInclusive);
+    }
+    return new Bound(values, inclusive);
+}
 class Filter {
 }
 class FieldFilter extends Filter {
@@ -5367,6 +5132,116 @@ function compareDocs(orderBy, d1, d2) {
     }
 }
 
+/**
+ * @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.
+ */
+/**
+ * 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 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;
+            }
+        }
+        return undefined;
+    }
+    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);
+                }
+                this.innerSize--;
+                return true;
+            }
+        }
+        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;
+    }
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -5509,7 +5384,7 @@ class SortedMapIterator {
         while (!node.isEmpty()) {
             cmp = startKey ? comparator(node.key, startKey) : 1;
             // flip the comparison if we're going in reverse
-            if (isReverse) {
+            if (startKey && isReverse) {
                 cmp *= -1;
             }
             if (cmp < 0) {
@@ -6078,6 +5953,9 @@ const EMPTY_DOCUMENT_MAP = new SortedMap(DocumentKey.comparator);
 function documentMap() {
     return EMPTY_DOCUMENT_MAP;
 }
+function newOverlayMap() {
+    return new ObjectMap(key => key.toString(), (l, r) => l.isEqual(r));
+}
 const EMPTY_DOCUMENT_VERSION_MAP = new SortedMap(DocumentKey.comparator);
 function documentVersionMap() {
     return EMPTY_DOCUMENT_VERSION_MAP;
@@ -8756,30 +8634,36 @@ function fromDbRemoteDocument(localSerializer, remoteDoc) {
 }
 /** Encodes a document for storage locally. */
 function toDbRemoteDocument(localSerializer, document) {
-    const dbReadTime = toDbTimestampKey(document.readTime);
     const parentPath = document.key.path.popLast().toArray();
+    const readTime = toDbTimestampKey(document.readTime);
     if (document.isFoundDocument()) {
         const doc = toDocument(localSerializer.remoteSerializer, document);
         const hasCommittedMutations = document.hasCommittedMutations;
-        return new DbRemoteDocument(
-        /* unknownDocument= */ null, 
-        /* noDocument= */ null, doc, hasCommittedMutations, dbReadTime, parentPath);
+        return {
+            document: doc,
+            hasCommittedMutations,
+            readTime,
+            parentPath
+        };
     }
     else if (document.isNoDocument()) {
         const path = document.key.path.toArray();
-        const version = toDbTimestamp(document.version);
         const hasCommittedMutations = document.hasCommittedMutations;
-        return new DbRemoteDocument(
-        /* unknownDocument= */ null, new DbNoDocument(path, version), 
-        /* document= */ null, hasCommittedMutations, dbReadTime, parentPath);
+        return {
+            noDocument: { path, readTime: toDbTimestamp(document.version) },
+            hasCommittedMutations,
+            readTime,
+            parentPath
+        };
     }
     else if (document.isUnknownDocument()) {
         const path = document.key.path.toArray();
-        const readTime = toDbTimestamp(document.version);
-        return new DbRemoteDocument(new DbUnknownDocument(path, readTime), 
-        /* noDocument= */ null, 
-        /* document= */ null, 
-        /* hasCommittedMutations= */ true, dbReadTime, parentPath);
+        return {
+            unknownDocument: { path, version: toDbTimestamp(document.version) },
+            hasCommittedMutations: true,
+            readTime,
+            parentPath
+        };
     }
     else {
         return fail();
@@ -8795,7 +8679,7 @@ function fromDbTimestampKey(dbTimestampKey) {
 }
 function toDbTimestamp(snapshotVersion) {
     const timestamp = snapshotVersion.toTimestamp();
-    return new DbTimestamp(timestamp.seconds, timestamp.nanoseconds);
+    return { seconds: timestamp.seconds, nanoseconds: timestamp.nanoseconds };
 }
 function fromDbTimestamp(dbTimestamp) {
     const timestamp = new Timestamp(dbTimestamp.seconds, dbTimestamp.nanoseconds);
@@ -8805,7 +8689,13 @@ function fromDbTimestamp(dbTimestamp) {
 function toDbMutationBatch(localSerializer, userId, batch) {
     const serializedBaseMutations = batch.baseMutations.map(m => toMutation(localSerializer.remoteSerializer, m));
     const serializedMutations = batch.mutations.map(m => toMutation(localSerializer.remoteSerializer, m));
-    return new DbMutationBatch(userId, batch.batchId, batch.localWriteTime.toMillis(), serializedBaseMutations, serializedMutations);
+    return {
+        userId,
+        batchId: batch.batchId,
+        localWriteTimeMs: batch.localWriteTime.toMillis(),
+        baseMutations: serializedBaseMutations,
+        mutations: serializedMutations
+    };
 }
 /** Decodes a DbMutationBatch into a MutationBatch */
 function fromDbMutationBatch(localSerializer, dbBatch) {
@@ -8861,7 +8751,15 @@ function toDbTarget(localSerializer, targetData) {
     // convert it to a base64 string for storage.
     const resumeToken = targetData.resumeToken.toBase64();
     // lastListenSequenceNumber is always 0 until we do real GC.
-    return new DbTarget(targetData.targetId, canonifyTarget(targetData.target), dbTimestamp, resumeToken, targetData.sequenceNumber, dbLastLimboFreeTimestamp, queryProto);
+    return {
+        targetId: targetData.targetId,
+        canonicalId: canonifyTarget(targetData.target),
+        readTime: dbTimestamp,
+        resumeToken,
+        lastListenSequenceNumber: targetData.sequenceNumber,
+        lastLimboFreeSnapshotVersion: dbLastLimboFreeTimestamp,
+        query: queryProto
+    };
 }
 /**
  * A helper function for figuring out what kind of query has been stored.
@@ -8940,7 +8838,14 @@ function fromDbDocumentOverlay(localSerializer, dbDocumentOverlay) {
 /** Decodes an Overlay model object into a DbDocumentOverlay object. */
 function toDbDocumentOverlay(localSerializer, userId, overlay) {
     const [_, collectionPath, documentId] = toDbDocumentOverlayKey(userId, overlay.mutation.key);
-    return new DbDocumentOverlay(userId, collectionPath, documentId, overlay.mutation.key.getCollectionGroup(), overlay.largestBatchId, toMutation(localSerializer.remoteSerializer, overlay.mutation));
+    return {
+        userId,
+        collectionPath,
+        documentId,
+        collectionGroup: overlay.mutation.key.getCollectionGroup(),
+        largestBatchId: overlay.largestBatchId,
+        overlayMutation: toMutation(localSerializer.remoteSerializer, overlay.mutation)
+    };
 }
 /**
  * Returns the DbDocumentOverlayKey corresponding to the given user and
@@ -8952,7 +8857,11 @@ function toDbDocumentOverlayKey(userId, docKey) {
     return [userId, collectionPath, docId];
 }
 function toDbIndexConfiguration(index) {
-    return new DbIndexConfiguration(index.indexId, index.collectionGroup, index.fields.map(s => [s.fieldPath.canonicalString(), s.kind]));
+    return {
+        indexId: index.indexId,
+        collectionGroup: index.collectionGroup,
+        fields: index.fields.map(s => [s.fieldPath.canonicalString(), s.kind])
+    };
 }
 function fromDbIndexConfiguration(index, state) {
     const decodedState = state
@@ -8962,7 +8871,14 @@ function fromDbIndexConfiguration(index, state) {
     return new FieldIndex(index.indexId, index.collectionGroup, decodedSegments, decodedState);
 }
 function toDbIndexState(indexId, user, sequenceNumber, offset) {
-    return new DbIndexState(indexId, user.uid || '', sequenceNumber, toDbTimestamp(offset.readTime), encodeResourcePath(offset.documentKey.path), offset.largestBatchId);
+    return {
+        indexId,
+        uid: user.uid || '',
+        sequenceNumber,
+        readTime: toDbTimestamp(offset.readTime),
+        documentKey: encodeResourcePath(offset.documentKey.path),
+        largestBatchId: offset.largestBatchId
+    };
 }
 
 /**
@@ -9013,13 +8929,13 @@ class IndexedDbBundleCache {
  * Helper to get a typed SimpleDbStore for the bundles object store.
  */
 function bundlesStore(txn) {
-    return getStore(txn, DbBundle.store);
+    return getStore(txn, DbBundleStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the namedQueries object store.
  */
 function namedQueriesStore(txn) {
-    return getStore(txn, DbNamedQuery.store);
+    return getStore(txn, DbNamedQueryStore);
 }
 
 /**
@@ -9066,7 +8982,7 @@ class IndexedDbDocumentOverlayCache {
     }
     saveOverlays(transaction, largestBatchId, overlays) {
         const promises = [];
-        overlays.forEach(mutation => {
+        overlays.forEach((_, mutation) => {
             const overlay = new Overlay(largestBatchId, mutation);
             promises.push(this.saveOverlay(transaction, overlay));
         });
@@ -9081,19 +8997,19 @@ class IndexedDbDocumentOverlayCache {
             const range = IDBKeyRange.bound([this.userId, collectionPath, batchId], [this.userId, collectionPath, batchId + 1], 
             /*lowerOpen=*/ false, 
             /*upperOpen=*/ true);
-            promises.push(documentOverlayStore(transaction).deleteAll(DbDocumentOverlay.collectionPathOverlayIndex, range));
+            promises.push(documentOverlayStore(transaction).deleteAll(DbDocumentOverlayCollectionPathOverlayIndex, range));
         });
         return PersistencePromise.waitFor(promises);
     }
     getOverlaysForCollection(transaction, collection, sinceBatchId) {
-        const result = new Map();
+        const result = newOverlayMap();
         const collectionPath = encodeResourcePath(collection);
         // We want batch IDs larger than `sinceBatchId`, and so the lower bound
         // is not inclusive.
         const range = IDBKeyRange.bound([this.userId, collectionPath, sinceBatchId], [this.userId, collectionPath, Number.POSITIVE_INFINITY], 
         /*lowerOpen=*/ true);
         return documentOverlayStore(transaction)
-            .loadAll(DbDocumentOverlay.collectionPathOverlayIndex, range)
+            .loadAll(DbDocumentOverlayCollectionPathOverlayIndex, range)
             .next(dbOverlays => {
             for (const dbOverlay of dbOverlays) {
                 const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
@@ -9103,7 +9019,7 @@ class IndexedDbDocumentOverlayCache {
         });
     }
     getOverlaysForCollectionGroup(transaction, collectionGroup, sinceBatchId, count) {
-        const result = new Map();
+        const result = newOverlayMap();
         let currentBatchId = undefined;
         // We want batch IDs larger than `sinceBatchId`, and so the lower bound
         // is not inclusive.
@@ -9111,7 +9027,7 @@ class IndexedDbDocumentOverlayCache {
         /*lowerOpen=*/ true);
         return documentOverlayStore(transaction)
             .iterate({
-            index: DbDocumentOverlay.collectionGroupOverlayIndex,
+            index: DbDocumentOverlayCollectionGroupOverlayIndex,
             range
         }, (_, dbOverlay, control) => {
             // We do not want to return partial batch overlays, even if the size
@@ -9119,7 +9035,7 @@ class IndexedDbDocumentOverlayCache {
             // continue to aggregate results even after the result size exceeds
             // `count` if there are more overlays from the `currentBatchId`.
             const overlay = fromDbDocumentOverlay(this.serializer, dbOverlay);
-            if (result.size < count ||
+            if (result.size() < count ||
                 overlay.largestBatchId === currentBatchId) {
                 result.set(overlay.getKey(), overlay);
                 currentBatchId = overlay.largestBatchId;
@@ -9138,7 +9054,7 @@ class IndexedDbDocumentOverlayCache {
  * Helper to get a typed SimpleDbStore for the document overlay object store.
  */
 function documentOverlayStore(txn) {
-    return getStore(txn, DbDocumentOverlay.store);
+    return getStore(txn, DbDocumentOverlayStore);
 }
 
 /**
@@ -9694,21 +9610,40 @@ class IndexEntry {
         this.arrayValue = arrayValue;
         this.directionalValue = directionalValue;
     }
+    /**
+     * Returns an IndexEntry entry that sorts immediately after the current
+     * directional value.
+     */
+    successor() {
+        const currentLength = this.directionalValue.length;
+        const newLength = currentLength === 0 || this.directionalValue[currentLength - 1] === 255
+            ? currentLength + 1
+            : currentLength;
+        const successor = new Uint8Array(newLength);
+        successor.set(this.directionalValue, 0);
+        if (newLength !== currentLength) {
+            successor.set([0], this.directionalValue.length);
+        }
+        else {
+            ++successor[successor.length - 1];
+        }
+        return new IndexEntry(this.indexId, this.documentKey, this.arrayValue, successor);
+    }
 }
 function indexEntryComparator(left, right) {
     let cmp = left.indexId - right.indexId;
     if (cmp !== 0) {
         return cmp;
     }
-    cmp = DocumentKey.comparator(left.documentKey, right.documentKey);
+    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
     if (cmp !== 0) {
         return cmp;
     }
-    cmp = compareByteArrays(left.arrayValue, right.arrayValue);
+    cmp = compareByteArrays(left.directionalValue, right.directionalValue);
     if (cmp !== 0) {
         return cmp;
     }
-    return compareByteArrays(left.directionalValue, right.directionalValue);
+    return DocumentKey.comparator(left.documentKey, right.documentKey);
 }
 function compareByteArrays(left, right) {
     for (let i = 0; i < left.length && i < right.length; ++i) {
@@ -9720,6 +9655,160 @@ function compareByteArrays(left, right) {
     return left.length - right.length;
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A light query planner for Firestore.
+ *
+ * This class matches a `FieldIndex` against a Firestore Query `Target`. It
+ * determines whether a given index can be used to serve the specified target.
+ *
+ * The following table showcases some possible index configurations:
+ *
+ * Query                                               | Index
+ * -----------------------------------------------------------------------------
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC, b DESC
+ * where('a', '==', 'a').where('b', '==', 'b')         | a ASC
+ * where('a', '==', 'a').where('b', '==', 'b')         | b DESC
+ * where('a', '>=', 'a').orderBy('a')                  | a ASC
+ * where('a', '>=', 'a').orderBy('a', 'desc')          | a DESC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC, b ASC
+ * where('a', '>=', 'a').orderBy('a').orderBy('b')     | a ASC
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS, b ASCENDING
+ * where('a', 'array-contains', 'a').orderBy('b')      | a CONTAINS
+ */
+class TargetIndexMatcher {
+    constructor(target) {
+        this.collectionId =
+            target.collectionGroup != null
+                ? target.collectionGroup
+                : target.path.lastSegment();
+        this.orderBys = target.orderBy;
+        this.equalityFilters = [];
+        for (const filter of target.filters) {
+            const fieldFilter = filter;
+            if (fieldFilter.isInequality()) {
+                this.inequalityFilter = fieldFilter;
+            }
+            else {
+                this.equalityFilters.push(fieldFilter);
+            }
+        }
+    }
+    /**
+     * Returns whether the index can be used to serve the TargetIndexMatcher's
+     * target.
+     *
+     * An index is considered capable of serving the target when:
+     * - The target uses all index segments for its filters and orderBy clauses.
+     *   The target can have additional filter and orderBy clauses, but not
+     *   fewer.
+     * - If an ArrayContains/ArrayContainsAnyfilter is used, the index must also
+     *   have a corresponding `CONTAINS` segment.
+     * - All directional index segments can be mapped to the target as a series of
+     *   equality filters, a single inequality filter and a series of orderBy
+     *   clauses.
+     * - The segments that represent the equality filters may appear out of order.
+     * - The optional segment for the inequality filter must appear after all
+     *   equality segments.
+     * - The segments that represent that orderBy clause of the target must appear
+     *   in order after all equality and inequality segments. Single orderBy
+     *   clauses cannot be skipped, but a continuous orderBy suffix may be
+     *   omitted.
+     */
+    servedByIndex(index) {
+        // If there is an array element, find a matching filter.
+        const arraySegment = fieldIndexGetArraySegment(index);
+        if (arraySegment !== undefined &&
+            !this.hasMatchingEqualityFilter(arraySegment)) {
+            return false;
+        }
+        const segments = fieldIndexGetDirectionalSegments(index);
+        let segmentIndex = 0;
+        let orderBysIndex = 0;
+        // Process all equalities first. Equalities can appear out of order.
+        for (; segmentIndex < segments.length; ++segmentIndex) {
+            // We attempt to greedily match all segments to equality filters. If a
+            // filter matches an index segment, we can mark the segment as used.
+            // Since it is not possible to use the same field path in both an equality
+            // and inequality/oderBy clause, we do not have to consider the possibility
+            // that a matching equality segment should instead be used to map to an
+            // inequality filter or orderBy clause.
+            if (!this.hasMatchingEqualityFilter(segments[segmentIndex])) {
+                // If we cannot find a matching filter, we need to verify whether the
+                // remaining segments map to the target's inequality and its orderBy
+                // clauses.
+                break;
+            }
+        }
+        // If we already have processed all segments, all segments are used to serve
+        // the equality filters and we do not need to map any segments to the
+        // target's inequality and orderBy clauses.
+        if (segmentIndex === segments.length) {
+            return true;
+        }
+        // If there is an inequality filter, the next segment must match both the
+        // filter and the first orderBy clause.
+        if (this.inequalityFilter !== undefined) {
+            const segment = segments[segmentIndex];
+            if (!this.matchesFilter(this.inequalityFilter, segment) ||
+                !this.matchesOrderBy(this.orderBys[orderBysIndex++], segment)) {
+                return false;
+            }
+            ++segmentIndex;
+        }
+        // All remaining segments need to represent the prefix of the target's
+        // orderBy.
+        for (; segmentIndex < segments.length; ++segmentIndex) {
+            const segment = segments[segmentIndex];
+            if (orderBysIndex >= this.orderBys.length ||
+                !this.matchesOrderBy(this.orderBys[orderBysIndex++], segment)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    hasMatchingEqualityFilter(segment) {
+        for (const filter of this.equalityFilters) {
+            if (this.matchesFilter(filter, segment)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    matchesFilter(filter, segment) {
+        if (filter === undefined || !filter.field.isEqual(segment.fieldPath)) {
+            return false;
+        }
+        const isArrayOperator = filter.op === "array-contains" /* ARRAY_CONTAINS */ ||
+            filter.op === "array-contains-any" /* ARRAY_CONTAINS_ANY */;
+        return (segment.kind === 2 /* CONTAINS */) === isArrayOperator;
+    }
+    matchesOrderBy(orderBy, segment) {
+        if (!orderBy.field.isEqual(segment.fieldPath)) {
+            return false;
+        }
+        return ((segment.kind === 0 /* ASCENDING */ &&
+            orderBy.dir === "asc" /* ASCENDING */) ||
+            (segment.kind === 1 /* DESCENDING */ &&
+                orderBy.dir === "desc" /* DESCENDING */));
+    }
+}
+
 /**
  * @license
  * Copyright 2019 Google LLC
@@ -9758,9 +9847,9 @@ class MemoryIndexManager {
         // Field indices are not supported with memory persistence.
         return PersistencePromise.resolve();
     }
-    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
+    getDocumentsMatchingTarget(transaction, target) {
         // Field indices are not supported with memory persistence.
-        return PersistencePromise.resolve(documentKeySet());
+        return PersistencePromise.resolve(null);
     }
     getFieldIndex(transaction, target) {
         // Field indices are not supported with memory persistence.
@@ -9832,6 +9921,7 @@ class MemoryCollectionParentIndex {
  * limitations under the License.
  */
 const LOG_TAG$f = 'IndexedDbIndexManager';
+const EMPTY_VALUE = new Uint8Array(0);
 /**
  * A persisted implementation of IndexManager.
  *
@@ -9849,6 +9939,11 @@ class IndexedDbIndexManager {
          * used to satisfy reads.
          */
         this.collectionParentsCache = new MemoryCollectionParentIndex();
+        /**
+         * Maps from a target to its equivalent list of sub-targets. Each sub-target
+         * contains only one term from the target's disjunctive normal form (DNF).
+         */
+        this.targetToDnfSubTargets = new ObjectMap(t => canonifyTarget(t), (l, r) => targetEquals(l, r));
         this.uid = user.uid || '';
     }
     /**
@@ -9917,13 +10012,111 @@ class IndexedDbIndexManager {
         /*lowerOpen=*/ false, 
         /*upperOpen=*/ true)));
     }
-    getDocumentsMatchingTarget(transaction, fieldIndex, target) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve(documentKeySet());
+    getDocumentsMatchingTarget(transaction, target) {
+        const indexEntries = indexEntriesStore(transaction);
+        let canServeTarget = true;
+        const indexes = new Map();
+        return PersistencePromise.forEach(this.getSubTargets(target), (subTarget) => {
+            return this.getFieldIndex(transaction, subTarget).next(index => {
+                canServeTarget && (canServeTarget = !!index);
+                indexes.set(subTarget, index);
+            });
+        }).next(() => {
+            if (!canServeTarget) {
+                return PersistencePromise.resolve(null);
+            }
+            else {
+                let result = documentKeySet();
+                return PersistencePromise.forEach(indexes, (index, subTarget) => {
+                    logDebug(LOG_TAG$f, `Using index ${fieldIndexToString(index)} to execute ${canonifyTarget(target)}`);
+                    const arrayValues = targetGetArrayValues(subTarget, index);
+                    const notInValues = targetGetNotInValues(subTarget, index);
+                    const lowerBound = targetGetLowerBound(subTarget, index);
+                    const upperBound = targetGetUpperBound(subTarget, index);
+                    const lowerBoundEncoded = this.encodeBound(index, subTarget, lowerBound);
+                    const upperBoundEncoded = this.encodeBound(index, subTarget, upperBound);
+                    const notInEncoded = this.encodeValues(index, subTarget, notInValues);
+                    const indexRanges = this.generateIndexRanges(index.indexId, arrayValues, lowerBoundEncoded, !!lowerBound && lowerBound.inclusive, upperBoundEncoded, !!upperBound && upperBound.inclusive, notInEncoded);
+                    return PersistencePromise.forEach(indexRanges, (indexRange) => {
+                        return indexEntries
+                            .loadFirst(indexRange, target.limit)
+                            .next(entries => {
+                            entries.forEach(entry => {
+                                result = result.add(new DocumentKey(decodeResourcePath(entry.documentKey)));
+                            });
+                        });
+                    });
+                }).next(() => result);
+            }
+        });
+    }
+    getSubTargets(target) {
+        let subTargets = this.targetToDnfSubTargets.get(target);
+        if (subTargets) {
+            return subTargets;
+        }
+        // TODO(orquery): Implement DNF transform
+        subTargets = [target];
+        this.targetToDnfSubTargets.set(target, subTargets);
+        return subTargets;
+    }
+    /**
+     * Constructs a key range query on `DbIndexEntryStore` that unions all
+     * bounds.
+     */
+    generateIndexRanges(indexId, arrayValues, lowerBounds, lowerBoundInclusive, upperBounds, upperBoundInclusive, notInValues) {
+        // The number of total index scans we union together. This is similar to a
+        // distributed normal form, but adapted for array values. We create a single
+        // index range per value in an ARRAY_CONTAINS or ARRAY_CONTAINS_ANY filter
+        // combined with the values from the query bounds.
+        const totalScans = (arrayValues != null ? arrayValues.length : 1) *
+            Math.max(lowerBounds != null ? lowerBounds.length : 1, upperBounds != null ? upperBounds.length : 1);
+        const scansPerArrayElement = totalScans / (arrayValues != null ? arrayValues.length : 1);
+        const indexRanges = [];
+        for (let i = 0; i < totalScans; ++i) {
+            const arrayValue = arrayValues
+                ? this.encodeSingleElement(arrayValues[i / scansPerArrayElement])
+                : EMPTY_VALUE;
+            const lowerBound = lowerBounds
+                ? this.generateLowerBound(indexId, arrayValue, lowerBounds[i % scansPerArrayElement], lowerBoundInclusive)
+                : this.generateEmptyBound(indexId);
+            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))));
+        }
+        return indexRanges;
+    }
+    /** Generates the lower bound for `arrayValue` and `directionalValue`. */
+    generateLowerBound(indexId, arrayValue, directionalValue, inclusive) {
+        const entry = new IndexEntry(indexId, DocumentKey.empty(), arrayValue, directionalValue);
+        return inclusive ? entry : entry.successor();
+    }
+    /** Generates the upper bound for `arrayValue` and `directionalValue`. */
+    generateUpperBound(indexId, arrayValue, directionalValue, inclusive) {
+        const entry = new IndexEntry(indexId, DocumentKey.empty(), arrayValue, directionalValue);
+        return inclusive ? entry.successor() : entry;
+    }
+    /**
+     * Generates an empty bound that scopes the index scan to the current index
+     * and user.
+     */
+    generateEmptyBound(indexId) {
+        return new IndexEntry(indexId, DocumentKey.empty(), EMPTY_VALUE, EMPTY_VALUE);
     }
     getFieldIndex(transaction, target) {
-        // TODO(indexing): Implement
-        return PersistencePromise.resolve(null);
+        const targetIndexMatcher = new TargetIndexMatcher(target);
+        const collectionGroup = target.collectionGroup != null
+            ? 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;
+        });
     }
     /**
      * Returns the byte encoded form of the directional values in the field index.
@@ -9948,11 +10141,79 @@ class IndexedDbIndexManager {
         FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, encoder.forKind(0 /* ASCENDING */));
         return encoder.encodedBytes();
     }
+    /**
+     * Encodes the given field values according to the specification in `target`.
+     * For IN queries, a list of possible values is returned.
+     */
+    encodeValues(fieldIndex, target, bound) {
+        if (bound === null) {
+            return [];
+        }
+        let encoders = [];
+        encoders.push(new IndexByteEncoder());
+        let boundIdx = 0;
+        for (const segment of fieldIndexGetDirectionalSegments(fieldIndex)) {
+            const value = bound[boundIdx++];
+            for (const encoder of encoders) {
+                if (this.isInFilter(target, segment.fieldPath) && isArray(value)) {
+                    encoders = this.expandIndexValues(encoders, segment, value);
+                }
+                else {
+                    const directionalEncoder = encoder.forKind(segment.kind);
+                    FirestoreIndexValueWriter.INSTANCE.writeIndexValue(value, directionalEncoder);
+                }
+            }
+        }
+        return this.getEncodedBytes(encoders);
+    }
+    /**
+     * Encodes the given bounds according to the specification in `target`. For IN
+     * queries, a list of possible values is returned.
+     */
+    encodeBound(fieldIndex, target, bound) {
+        if (bound == null) {
+            return null;
+        }
+        return this.encodeValues(fieldIndex, target, bound.position);
+    }
+    /** Returns the byte representation for the provided encoders. */
+    getEncodedBytes(encoders) {
+        const result = [];
+        for (let i = 0; i < encoders.length; ++i) {
+            result[i] = encoders[i].encodedBytes();
+        }
+        return result;
+    }
+    /**
+     * Creates a separate encoder for each element of an array.
+     *
+     * The method appends each value to all existing encoders (e.g. filter("a",
+     * "==", "a1").filter("b", "in", ["b1", "b2"]) becomes ["a1,b1", "a1,b2"]). A
+     * list of new encoders is returned.
+     */
+    expandIndexValues(encoders, segment, value) {
+        const prefixes = [...encoders];
+        const results = [];
+        for (const arrayElement of value.arrayValue.values || []) {
+            for (const prefix of prefixes) {
+                const clonedEncoder = new IndexByteEncoder();
+                clonedEncoder.seed(prefix.encodedBytes());
+                FirestoreIndexValueWriter.INSTANCE.writeIndexValue(arrayElement, clonedEncoder.forKind(segment.kind));
+                results.push(clonedEncoder);
+            }
+        }
+        return results;
+    }
+    isInFilter(target, fieldPath) {
+        return !!target.filters.find(f => f instanceof FieldFilter &&
+            f.field.isEqual(fieldPath) &&
+            (f.op === "in" /* IN */ || f.op === "not-in" /* NOT_IN */));
+    }
     getFieldIndexes(transaction, collectionGroup) {
         const indexes = indexConfigurationStore(transaction);
         const states = indexStateStore(transaction);
         return (collectionGroup
-            ? indexes.loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            ? indexes.loadAll(DbIndexConfigurationCollectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
             : indexes.loadAll()).next(indexConfigs => {
             const result = [];
             return PersistencePromise.forEach(indexConfigs, (indexConfig) => {
@@ -9969,7 +10230,12 @@ class IndexedDbIndexManager {
             if (indexes.length === 0) {
                 return null;
             }
-            indexes.sort((l, r) => l.indexState.sequenceNumber - r.indexState.sequenceNumber);
+            indexes.sort((l, r) => {
+                const cmp = l.indexState.sequenceNumber - r.indexState.sequenceNumber;
+                return cmp !== 0
+                    ? cmp
+                    : primitiveComparator(l.collectionGroup, r.collectionGroup);
+            });
             return indexes[0].collectionGroup;
         });
     }
@@ -9977,7 +10243,7 @@ class IndexedDbIndexManager {
         const indexes = indexConfigurationStore(transaction);
         const states = indexStateStore(transaction);
         return this.getNextSequenceNumber(transaction).next(nextSequenceNumber => indexes
-            .loadAll(DbIndexConfiguration.collectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
+            .loadAll(DbIndexConfigurationCollectionGroupIndex, IDBKeyRange.bound(collectionGroup, collectionGroup))
             .next(configs => PersistencePromise.forEach(configs, (config) => states.put(toDbIndexState(config.indexId, this.user, nextSequenceNumber, offset)))));
     }
     updateIndexEntries(transaction, documents) {
@@ -10008,7 +10274,13 @@ class IndexedDbIndexManager {
     }
     addIndexEntry(transaction, document, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
-        return indexEntries.put(new DbIndexEntry(indexEntry.indexId, this.uid, indexEntry.arrayValue, indexEntry.directionalValue, encodeResourcePath(document.key.path)));
+        return indexEntries.put({
+            indexId: indexEntry.indexId,
+            uid: this.uid,
+            arrayValue: indexEntry.arrayValue,
+            directionalValue: indexEntry.directionalValue,
+            documentKey: encodeResourcePath(document.key.path)
+        });
     }
     deleteIndexEntry(transaction, document, indexEntry) {
         const indexEntries = indexEntriesStore(transaction);
@@ -10025,7 +10297,7 @@ class IndexedDbIndexManager {
         let results = new SortedSet(indexEntryComparator);
         return indexEntries
             .iterate({
-            index: DbIndexEntry.documentKeyIndex,
+            index: DbIndexEntryDocumentKeyIndex,
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
@@ -10053,7 +10325,7 @@ class IndexedDbIndexManager {
             }
         }
         else {
-            results = results.add(new IndexEntry(fieldIndex.indexId, document.key, new Uint8Array(), directionalValue));
+            results = results.add(new IndexEntry(fieldIndex.indexId, document.key, EMPTY_VALUE, directionalValue));
         }
         return results;
     }
@@ -10079,7 +10351,7 @@ class IndexedDbIndexManager {
         const states = indexStateStore(transaction);
         return states
             .iterate({
-            index: DbIndexState.sequenceNumberIndex,
+            index: DbIndexStateSequenceNumberIndex,
             reverse: true,
             range: IDBKeyRange.upperBound([this.uid, Number.MAX_SAFE_INTEGER])
         }, (_, state, controller) => {
@@ -10088,31 +10360,81 @@ class IndexedDbIndexManager {
         })
             .next(() => nextSequenceNumber);
     }
+    /**
+     * Returns a new set of IDB ranges that splits the existing range and excludes
+     * any values that match the `notInValue` from these ranges. As an example,
+     * '[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
+        // sorted set of non-overlapping ranges.
+        notInValues = notInValues
+            .sort((l, r) => indexEntryComparator(l, r))
+            .filter((el, i, values) => !i || indexEntryComparator(el, values[i - 1]) !== 0);
+        const bounds = [];
+        bounds.push(lower);
+        for (const notInValue of notInValues) {
+            const cmpToLower = indexEntryComparator(notInValue, lower);
+            const cmpToUpper = indexEntryComparator(notInValue, upper);
+            if (cmpToLower === 0) {
+                // `notInValue` is the lower bound. We therefore need to raise the bound
+                // to the next value.
+                bounds[0] = lower.successor();
+            }
+            else if (cmpToLower > 0 && cmpToUpper < 0) {
+                // `notInValue` is in the middle of the range
+                bounds.push(notInValue);
+                bounds.push(notInValue.successor());
+            }
+            else if (cmpToUpper > 0) {
+                // `notInValue` (and all following values) are out of the range
+                break;
+            }
+        }
+        bounds.push(upper);
+        const ranges = [];
+        for (let i = 0; i < bounds.length; i += 2) {
+            ranges.push(IDBKeyRange.bound([
+                bounds[i].indexId,
+                this.uid,
+                bounds[i].arrayValue,
+                bounds[i].directionalValue,
+                ''
+            ], [
+                bounds[i + 1].indexId,
+                this.uid,
+                bounds[i + 1].arrayValue,
+                bounds[i + 1].directionalValue,
+                ''
+            ]));
+        }
+        return ranges;
+    }
 }
 /**
  * Helper to get a typed SimpleDbStore for the collectionParents
  * document store.
  */
 function collectionParentsStore(txn) {
-    return getStore(txn, DbCollectionParent.store);
+    return getStore(txn, DbCollectionParentStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the index entry object store.
  */
 function indexEntriesStore(txn) {
-    return getStore(txn, DbIndexEntry.store);
+    return getStore(txn, DbIndexEntryStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the index configuration object store.
  */
 function indexConfigurationStore(txn) {
-    return getStore(txn, DbIndexConfiguration.store);
+    return getStore(txn, DbIndexConfigurationStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the index state object store.
  */
 function indexStateStore(txn) {
-    return getStore(txn, DbIndexState.store);
+    return getStore(txn, DbIndexStateStore);
 }
 
 /**
@@ -10136,8 +10458,8 @@ function indexStateStore(txn) {
  * @returns A PersistencePromise of the document mutations that were removed.
  */
 function removeMutationBatch(txn, userId, batch) {
-    const mutationStore = txn.store(DbMutationBatch.store);
-    const indexTxn = txn.store(DbDocumentMutation.store);
+    const mutationStore = txn.store(DbMutationBatchStore);
+    const indexTxn = txn.store(DbDocumentMutationStore);
     const promises = [];
     const range = IDBKeyRange.only(batch.batchId);
     let numDeleted = 0;
@@ -10150,7 +10472,7 @@ function removeMutationBatch(txn, userId, batch) {
     }));
     const removedDocuments = [];
     for (const mutation of batch.mutations) {
-        const indexKey = DbDocumentMutation.key(userId, mutation.key.path, batch.batchId);
+        const indexKey = newDbDocumentMutationKey(userId, mutation.key.path, batch.batchId);
         promises.push(indexTxn.delete(indexKey));
         removedDocuments.push(mutation.key);
     }
@@ -10239,7 +10561,7 @@ class IndexedDbMutationQueue {
         let empty = true;
         const range = IDBKeyRange.bound([this.userId, Number.NEGATIVE_INFINITY], [this.userId, Number.POSITIVE_INFINITY]);
         return mutationsStore(transaction)
-            .iterate({ index: DbMutationBatch.userMutationsIndex, range }, (key, value, control) => {
+            .iterate({ index: DbMutationBatchUserMutationsIndex, range }, (key, value, control) => {
             empty = false;
             control.done();
         })
@@ -10264,10 +10586,10 @@ class IndexedDbMutationQueue {
             const promises = [];
             let collectionParents = new SortedSet((l, r) => primitiveComparator(l.canonicalString(), r.canonicalString()));
             for (const mutation of mutations) {
-                const indexKey = DbDocumentMutation.key(this.userId, mutation.key.path, batchId);
+                const indexKey = newDbDocumentMutationKey(this.userId, mutation.key.path, batchId);
                 collectionParents = collectionParents.add(mutation.key.path.popLast());
                 promises.push(mutationStore.put(dbBatch));
-                promises.push(documentStore.put(indexKey, DbDocumentMutation.PLACEHOLDER));
+                promises.push(documentStore.put(indexKey, DbDocumentMutationPlaceholder));
             }
             collectionParents.forEach(parent => {
                 promises.push(this.indexManager.addToCollectionParentIndex(transaction, parent));
@@ -10318,7 +10640,7 @@ class IndexedDbMutationQueue {
         const range = IDBKeyRange.lowerBound([this.userId, nextBatchId]);
         let foundBatch = null;
         return mutationsStore(transaction)
-            .iterate({ index: DbMutationBatch.userMutationsIndex, range }, (key, dbBatch, control) => {
+            .iterate({ index: DbMutationBatchUserMutationsIndex, range }, (key, dbBatch, control) => {
             if (dbBatch.userId === this.userId) {
                 hardAssert(dbBatch.batchId >= nextBatchId);
                 foundBatch = fromDbMutationBatch(this.serializer, dbBatch);
@@ -10334,7 +10656,7 @@ class IndexedDbMutationQueue {
         ]);
         let batchId = BATCHID_UNKNOWN;
         return mutationsStore(transaction)
-            .iterate({ index: DbMutationBatch.userMutationsIndex, range, reverse: true }, (key, dbBatch, control) => {
+            .iterate({ index: DbMutationBatchUserMutationsIndex, range, reverse: true }, (key, dbBatch, control) => {
             batchId = dbBatch.batchId;
             control.done();
         })
@@ -10343,13 +10665,13 @@ class IndexedDbMutationQueue {
     getAllMutationBatches(transaction) {
         const range = IDBKeyRange.bound([this.userId, BATCHID_UNKNOWN], [this.userId, Number.POSITIVE_INFINITY]);
         return mutationsStore(transaction)
-            .loadAll(DbMutationBatch.userMutationsIndex, range)
+            .loadAll(DbMutationBatchUserMutationsIndex, range)
             .next(dbBatches => dbBatches.map(dbBatch => fromDbMutationBatch(this.serializer, dbBatch)));
     }
     getAllMutationBatchesAffectingDocumentKey(transaction, documentKey) {
         // Scan the document-mutation index starting with a prefix starting with
         // the given documentKey.
-        const indexPrefix = DbDocumentMutation.prefixForPath(this.userId, documentKey.path);
+        const indexPrefix = newDbDocumentMutationPrefixForPath(this.userId, documentKey.path);
         const indexStart = IDBKeyRange.lowerBound(indexPrefix);
         const results = [];
         return documentMutationsStore(transaction)
@@ -10384,7 +10706,7 @@ class IndexedDbMutationQueue {
         let uniqueBatchIDs = new SortedSet(primitiveComparator);
         const promises = [];
         documentKeys.forEach(documentKey => {
-            const indexStart = DbDocumentMutation.prefixForPath(this.userId, documentKey.path);
+            const indexStart = newDbDocumentMutationPrefixForPath(this.userId, documentKey.path);
             const range = IDBKeyRange.lowerBound(indexStart);
             const promise = documentMutationsStore(transaction).iterate({ range }, (indexKey, _, control) => {
                 const [userID, encodedPath, batchID] = indexKey;
@@ -10420,7 +10742,7 @@ class IndexedDbMutationQueue {
         // Since we don't yet index the actual properties in the mutations, our
         // current approach is to just return all mutation batches that affect
         // documents in the collection being queried.
-        const indexPrefix = DbDocumentMutation.prefixForPath(this.userId, queryPath);
+        const indexPrefix = newDbDocumentMutationPrefixForPath(this.userId, queryPath);
         const indexStart = IDBKeyRange.lowerBound(indexPrefix);
         // Collect up unique batchIDs encountered during a scan of the index. Use a
         // SortedSet to accumulate batch IDs so they can be traversed in order in a
@@ -10492,7 +10814,7 @@ class IndexedDbMutationQueue {
             }
             // Verify that there are no entries in the documentMutations index if
             // the queue is empty.
-            const startRange = IDBKeyRange.lowerBound(DbDocumentMutation.prefixForUser(this.userId));
+            const startRange = IDBKeyRange.lowerBound(newDbDocumentMutationPrefixForUser(this.userId));
             const danglingMutationReferences = [];
             return documentMutationsStore(txn)
                 .iterate({ range: startRange }, (key, _, control) => {
@@ -10520,9 +10842,11 @@ class IndexedDbMutationQueue {
         return mutationQueuesStore(transaction)
             .get(this.userId)
             .next((metadata) => {
-            return (metadata ||
-                new DbMutationQueue(this.userId, BATCHID_UNKNOWN, 
-                /*lastStreamToken=*/ ''));
+            return (metadata || {
+                userId: this.userId,
+                lastAcknowledgedBatchId: BATCHID_UNKNOWN,
+                lastStreamToken: ''
+            });
         });
     }
 }
@@ -10531,7 +10855,7 @@ class IndexedDbMutationQueue {
  *         mutation for the given key.
  */
 function mutationQueueContainsKey(txn, userId, key) {
-    const indexKey = DbDocumentMutation.prefixForPath(userId, key.path);
+    const indexKey = newDbDocumentMutationPrefixForPath(userId, key.path);
     const encodedPath = indexKey[1];
     const startRange = IDBKeyRange.lowerBound(indexKey);
     let containsKey = false;
@@ -10563,19 +10887,19 @@ function mutationQueuesContainKey(txn, docKey) {
  * Helper to get a typed SimpleDbStore for the mutations object store.
  */
 function mutationsStore(txn) {
-    return getStore(txn, DbMutationBatch.store);
+    return getStore(txn, DbMutationBatchStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the mutationQueues object store.
  */
 function documentMutationsStore(txn) {
-    return getStore(txn, DbDocumentMutation.store);
+    return getStore(txn, DbDocumentMutationStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the mutationQueues object store.
  */
 function mutationQueuesStore(txn) {
-    return getStore(txn, DbMutationQueue.store);
+    return getStore(txn, DbMutationQueueStore);
 }
 
 /**
@@ -10739,14 +11063,14 @@ class IndexedDbTargetCache {
     }
     retrieveMetadata(transaction) {
         return globalTargetStore(transaction)
-            .get(DbTargetGlobal.key)
+            .get(DbTargetGlobalKey)
             .next(metadata => {
             hardAssert(metadata !== null);
             return metadata;
         });
     }
     saveMetadata(transaction, metadata) {
-        return globalTargetStore(transaction).put(DbTargetGlobal.key, metadata);
+        return globalTargetStore(transaction).put(DbTargetGlobalKey, metadata);
     }
     saveTargetData(transaction, targetData) {
         return targetsStore(transaction).put(toDbTarget(this.serializer, targetData));
@@ -10779,7 +11103,7 @@ class IndexedDbTargetCache {
         const range = IDBKeyRange.bound([canonicalId, Number.NEGATIVE_INFINITY], [canonicalId, Number.POSITIVE_INFINITY]);
         let result = null;
         return targetsStore(transaction)
-            .iterate({ range, index: DbTarget.queryTargetsIndexName }, (key, value, control) => {
+            .iterate({ range, index: DbTargetQueryTargetsIndexName }, (key, value, control) => {
             const found = fromDbTarget(value);
             // After finding a potential match, check that the target is
             // actually equal to the requested target.
@@ -10797,7 +11121,7 @@ class IndexedDbTargetCache {
         const store = documentTargetStore(txn);
         keys.forEach(key => {
             const path = encodeResourcePath(key.path);
-            promises.push(store.put(new DbTargetDocument(targetId, path)));
+            promises.push(store.put({ targetId, path }));
             promises.push(this.referenceDelegate.addReference(txn, targetId, key));
         });
         return PersistencePromise.waitFor(promises);
@@ -10843,7 +11167,7 @@ class IndexedDbTargetCache {
         let count = 0;
         return documentTargetStore(txn)
             .iterate({
-            index: DbTargetDocument.documentTargetsIndex,
+            index: DbTargetDocumentDocumentTargetsIndex,
             keysOnly: true,
             range
         }, ([targetId, path], _, control) => {
@@ -10882,19 +11206,19 @@ class IndexedDbTargetCache {
  * Helper to get a typed SimpleDbStore for the queries object store.
  */
 function targetsStore(txn) {
-    return getStore(txn, DbTarget.store);
+    return getStore(txn, DbTargetStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the target globals object store.
  */
 function globalTargetStore(txn) {
-    return getStore(txn, DbTargetGlobal.store);
+    return getStore(txn, DbTargetGlobalStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the document target object store.
  */
 function documentTargetStore(txn) {
-    return getStore(txn, DbTargetDocument.store);
+    return getStore(txn, DbTargetDocumentStore);
 }
 
 /**
@@ -11308,7 +11632,7 @@ class IndexedDbLruDelegateImpl {
         let nextPath;
         return store
             .iterate({
-            index: DbTargetDocument.documentTargetsIndex
+            index: DbTargetDocumentDocumentTargetsIndex
         }, ([targetId, docKey], { path, sequenceNumber }) => {
             if (targetId === 0) {
                 // if nextToReport is valid, report it, this is a new key so the
@@ -11350,113 +11674,12 @@ function sentinelKey$1(key) {
  * store.
  */
 function sentinelRow(key, sequenceNumber) {
-    return new DbTargetDocument(0, encodeResourcePath(key.path), sequenceNumber);
+    return { targetId: 0, path: encodeResourcePath(key.path), sequenceNumber };
 }
 function writeSentinelKey(txn, key) {
     return documentTargetStore(txn).put(sentinelRow(key, txn.currentSequenceNumber));
 }
 
-/**
- * @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.
- */
-/**
- * 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 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 = {};
-    }
-    /** 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;
-            }
-        }
-        return undefined;
-    }
-    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]];
-            return;
-        }
-        for (let i = 0; i < matches.length; i++) {
-            if (this.equalsFn(matches[i][0], key)) {
-                matches[i] = [key, value];
-                return;
-            }
-        }
-        matches.push([key, value]);
-    }
-    /**
-     * 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 true;
-            }
-        }
-        return false;
-    }
-    forEach(fn) {
-        forEach(this.inner, (_, entries) => {
-            for (const [k, v] of entries) {
-                fn(k, v);
-            }
-        });
-    }
-    isEmpty() {
-        return isEmpty(this.inner);
-    }
-}
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -11725,7 +11948,7 @@ class IndexedDbRemoteDocumentCacheImpl {
             const readTimeKey = toDbTimestampKey(sinceReadTime);
             iterationOptions.range = IDBKeyRange.lowerBound([collectionKey, readTimeKey], 
             /* open= */ true);
-            iterationOptions.index = DbRemoteDocument.collectionReadTimeIndex;
+            iterationOptions.index = DbRemoteDocumentCollectionReadTimeIndex;
         }
         return remoteDocumentsStore(transaction)
             .iterate(iterationOptions, (key, dbRemoteDoc, control) => {
@@ -11755,14 +11978,14 @@ class IndexedDbRemoteDocumentCacheImpl {
     }
     getMetadata(txn) {
         return documentGlobalStore(txn)
-            .get(DbRemoteDocumentGlobal.key)
+            .get(DbRemoteDocumentGlobalKey)
             .next(metadata => {
             hardAssert(!!metadata);
             return metadata;
         });
     }
     setMetadata(txn, metadata) {
-        return documentGlobalStore(txn).put(DbRemoteDocumentGlobal.key, metadata);
+        return documentGlobalStore(txn).put(DbRemoteDocumentGlobalKey, metadata);
     }
     /**
      * Decodes `dbRemoteDoc` and returns the document (or an invalid document if
@@ -11797,7 +12020,7 @@ function remoteDocumentCacheGetNewDocumentChanges(remoteDocumentCache, transacti
     const documentsStore = remoteDocumentsStore(transaction);
     const range = IDBKeyRange.lowerBound(lastReadTime, true);
     return documentsStore
-        .iterate({ index: DbRemoteDocument.readTimeIndex, range }, (_, dbRemoteDoc) => {
+        .iterate({ index: DbRemoteDocumentReadTimeIndex, range }, (_, dbRemoteDoc) => {
         // Unlike `getEntry()` and others, `getNewDocumentChanges()` parses
         // the documents directly since we want to keep sentinel deletes.
         const doc = fromDbRemoteDocument(remoteDocumentCacheImpl.serializer, dbRemoteDoc);
@@ -11821,7 +12044,7 @@ function remoteDocumentCacheGetLastReadTime(transaction) {
     // If there are no existing entries, we return SnapshotVersion.min().
     let readTime = SnapshotVersion.min();
     return documentsStore
-        .iterate({ index: DbRemoteDocument.readTimeIndex, reverse: true }, (key, dbRemoteDoc, control) => {
+        .iterate({ index: DbRemoteDocumentReadTimeIndex, reverse: true }, (key, dbRemoteDoc, control) => {
         if (dbRemoteDoc.readTime) {
             readTime = fromDbTimestampKey(dbRemoteDoc.readTime);
         }
@@ -11909,17 +12132,39 @@ class IndexedDbRemoteDocumentChangeBuffer extends RemoteDocumentChangeBuffer {
     }
 }
 function documentGlobalStore(txn) {
-    return getStore(txn, DbRemoteDocumentGlobal.store);
+    return getStore(txn, DbRemoteDocumentGlobalStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the remoteDocuments object store.
  */
 function remoteDocumentsStore(txn) {
-    return getStore(txn, DbRemoteDocument.store);
+    return getStore(txn, DbRemoteDocumentStore);
 }
 function dbKey(docKey) {
     return docKey.path.toArray();
 }
+/**
+ * Schema Version for the Web client:
+ * 1.  Initial version including Mutation Queue, Query Cache, and Remote
+ *     Document Cache
+ * 2.  Used to ensure a targetGlobal object exists and add targetCount to it. No
+ *     longer required because migration 3 unconditionally clears it.
+ * 3.  Dropped and re-created Query Cache to deal with cache corruption related
+ *     to limbo resolution. Addresses
+ *     https://github.com/firebase/firebase-ios-sdk/issues/1548
+ * 4.  Multi-Tab Support.
+ * 5.  Removal of held write acks.
+ * 6.  Create document global for tracking document cache size.
+ * 7.  Ensure every cached document has a sentinel row with a sequence number.
+ * 8.  Add collection-parent index for Collection Group queries.
+ * 9.  Change RemoteDocumentChanges store to be keyed by readTime rather than
+ *     an auto-incrementing ID. This is required for Index-Free queries.
+ * 10. Rewrite the canonical IDs to the explicit Protobuf-based format.
+ * 11. Add bundles and named_queries for bundle support.
+ * 12. Add document overlays.
+ * 13. Add indexing support.
+ */
+const SCHEMA_VERSION = 12;
 
 /**
  * @license
@@ -12029,27 +12274,27 @@ class SchemaConverter {
         return p;
     }
     addDocumentGlobal(txn) {
-        let byteCount = 0;
+        let byteSize = 0;
         return txn
-            .store(DbRemoteDocument.store)
+            .store(DbRemoteDocumentStore)
             .iterate((_, doc) => {
-            byteCount += dbDocumentSize(doc);
+            byteSize += dbDocumentSize(doc);
         })
             .next(() => {
-            const metadata = new DbRemoteDocumentGlobal(byteCount);
+            const metadata = { byteSize };
             return txn
-                .store(DbRemoteDocumentGlobal.store)
-                .put(DbRemoteDocumentGlobal.key, metadata);
+                .store(DbRemoteDocumentGlobalStore)
+                .put(DbRemoteDocumentGlobalKey, metadata);
         });
     }
     removeAcknowledgedMutations(txn) {
-        const queuesStore = txn.store(DbMutationQueue.store);
-        const mutationsStore = txn.store(DbMutationBatch.store);
+        const queuesStore = txn.store(DbMutationQueueStore);
+        const mutationsStore = txn.store(DbMutationBatchStore);
         return queuesStore.loadAll().next(queues => {
             return PersistencePromise.forEach(queues, (queue) => {
                 const range = IDBKeyRange.bound([queue.userId, BATCHID_UNKNOWN], [queue.userId, queue.lastAcknowledgedBatchId]);
                 return mutationsStore
-                    .loadAll(DbMutationBatch.userMutationsIndex, range)
+                    .loadAll(DbMutationBatchUserMutationsIndex, range)
                     .next(dbBatches => {
                     return PersistencePromise.forEach(dbBatches, (dbBatch) => {
                         hardAssert(dbBatch.userId === queue.userId);
@@ -12065,12 +12310,16 @@ class SchemaConverter {
      * with a sequence number. Missing rows are given the most recently used sequence number.
      */
     ensureSequenceNumbers(txn) {
-        const documentTargetStore = txn.store(DbTargetDocument.store);
-        const documentsStore = txn.store(DbRemoteDocument.store);
-        const globalTargetStore = txn.store(DbTargetGlobal.store);
-        return globalTargetStore.get(DbTargetGlobal.key).next(metadata => {
+        const documentTargetStore = txn.store(DbTargetDocumentStore);
+        const documentsStore = txn.store(DbRemoteDocumentStore);
+        const globalTargetStore = txn.store(DbTargetGlobalStore);
+        return globalTargetStore.get(DbTargetGlobalKey).next(metadata => {
             const writeSentinelKey = (path) => {
-                return documentTargetStore.put(new DbTargetDocument(0, encodeResourcePath(path), metadata.highestListenSequenceNumber));
+                return documentTargetStore.put({
+                    targetId: 0,
+                    path: encodeResourcePath(path),
+                    sequenceNumber: metadata.highestListenSequenceNumber
+                });
             };
             const promises = [];
             return documentsStore
@@ -12091,10 +12340,10 @@ class SchemaConverter {
     }
     createCollectionParentIndex(db, txn) {
         // Create the index.
-        db.createObjectStore(DbCollectionParent.store, {
-            keyPath: DbCollectionParent.keyPath
+        db.createObjectStore(DbCollectionParentStore, {
+            keyPath: DbCollectionParentKeyPath
         });
-        const collectionParentsStore = txn.store(DbCollectionParent.store);
+        const collectionParentsStore = txn.store(DbCollectionParentStore);
         // Helper to add an index entry iff we haven't already written it.
         const cache = new MemoryCollectionParentIndex();
         const addEntry = (collectionPath) => {
@@ -12109,7 +12358,7 @@ class SchemaConverter {
         };
         // Index existing remote documents.
         return txn
-            .store(DbRemoteDocument.store)
+            .store(DbRemoteDocumentStore)
             .iterate({ keysOnly: true }, (pathSegments, _) => {
             const path = new ResourcePath(pathSegments);
             return addEntry(path.popLast());
@@ -12117,7 +12366,7 @@ class SchemaConverter {
             .next(() => {
             // Index existing mutations.
             return txn
-                .store(DbDocumentMutation.store)
+                .store(DbDocumentMutationStore)
                 .iterate({ keysOnly: true }, ([userID, encodedPath, batchId], _) => {
                 const path = decodeResourcePath(encodedPath);
                 return addEntry(path.popLast());
@@ -12125,7 +12374,7 @@ class SchemaConverter {
         });
     }
     rewriteCanonicalIds(txn) {
-        const targetStore = txn.store(DbTarget.store);
+        const targetStore = txn.store(DbTargetStore);
         return targetStore.iterate((key, originalDbTarget) => {
             const originalTargetData = fromDbTarget(originalDbTarget);
             const updatedDbTarget = toDbTarget(this.serializer, originalTargetData);
@@ -12137,59 +12386,59 @@ function sentinelKey(path) {
     return [0, encodeResourcePath(path)];
 }
 function createPrimaryClientStore(db) {
-    db.createObjectStore(DbPrimaryClient.store);
+    db.createObjectStore(DbPrimaryClientStore);
 }
 function createMutationQueue(db) {
-    db.createObjectStore(DbMutationQueue.store, {
-        keyPath: DbMutationQueue.keyPath
+    db.createObjectStore(DbMutationQueueStore, {
+        keyPath: DbMutationQueueKeyPath
     });
-    const mutationBatchesStore = db.createObjectStore(DbMutationBatch.store, {
-        keyPath: DbMutationBatch.keyPath,
+    const mutationBatchesStore = db.createObjectStore(DbMutationBatchStore, {
+        keyPath: DbMutationBatchKeyPath,
         autoIncrement: true
     });
-    mutationBatchesStore.createIndex(DbMutationBatch.userMutationsIndex, DbMutationBatch.userMutationsKeyPath, { unique: true });
-    db.createObjectStore(DbDocumentMutation.store);
+    mutationBatchesStore.createIndex(DbMutationBatchUserMutationsIndex, DbMutationBatchUserMutationsKeyPath, { unique: true });
+    db.createObjectStore(DbDocumentMutationStore);
 }
 /**
  * Upgrade function to migrate the 'mutations' store from V1 to V3. Loads
  * and rewrites all data.
  */
 function upgradeMutationBatchSchemaAndMigrateData(db, txn) {
-    const v1MutationsStore = txn.store(DbMutationBatch.store);
+    const v1MutationsStore = txn.store(DbMutationBatchStore);
     return v1MutationsStore.loadAll().next(existingMutations => {
-        db.deleteObjectStore(DbMutationBatch.store);
-        const mutationsStore = db.createObjectStore(DbMutationBatch.store, {
-            keyPath: DbMutationBatch.keyPath,
+        db.deleteObjectStore(DbMutationBatchStore);
+        const mutationsStore = db.createObjectStore(DbMutationBatchStore, {
+            keyPath: DbMutationBatchKeyPath,
             autoIncrement: true
         });
-        mutationsStore.createIndex(DbMutationBatch.userMutationsIndex, DbMutationBatch.userMutationsKeyPath, { unique: true });
-        const v3MutationsStore = txn.store(DbMutationBatch.store);
+        mutationsStore.createIndex(DbMutationBatchUserMutationsIndex, DbMutationBatchUserMutationsKeyPath, { unique: true });
+        const v3MutationsStore = txn.store(DbMutationBatchStore);
         const writeAll = existingMutations.map(mutation => v3MutationsStore.put(mutation));
         return PersistencePromise.waitFor(writeAll);
     });
 }
 function createRemoteDocumentCache(db) {
-    db.createObjectStore(DbRemoteDocument.store);
+    db.createObjectStore(DbRemoteDocumentStore);
 }
 function createDocumentGlobalStore(db) {
-    db.createObjectStore(DbRemoteDocumentGlobal.store);
+    db.createObjectStore(DbRemoteDocumentGlobalStore);
 }
 function createQueryCache(db) {
-    const targetDocumentsStore = db.createObjectStore(DbTargetDocument.store, {
-        keyPath: DbTargetDocument.keyPath
+    const targetDocumentsStore = db.createObjectStore(DbTargetDocumentStore, {
+        keyPath: DbTargetDocumentKeyPath
     });
-    targetDocumentsStore.createIndex(DbTargetDocument.documentTargetsIndex, DbTargetDocument.documentTargetsKeyPath, { unique: true });
-    const targetStore = db.createObjectStore(DbTarget.store, {
-        keyPath: DbTarget.keyPath
+    targetDocumentsStore.createIndex(DbTargetDocumentDocumentTargetsIndex, DbTargetDocumentDocumentTargetsKeyPath, { unique: true });
+    const targetStore = db.createObjectStore(DbTargetStore, {
+        keyPath: DbTargetKeyPath
     });
     // NOTE: This is unique only because the TargetId is the suffix.
-    targetStore.createIndex(DbTarget.queryTargetsIndexName, DbTarget.queryTargetsKeyPath, { unique: true });
-    db.createObjectStore(DbTargetGlobal.store);
+    targetStore.createIndex(DbTargetQueryTargetsIndexName, DbTargetQueryTargetsKeyPath, { unique: true });
+    db.createObjectStore(DbTargetGlobalStore);
 }
 function dropQueryCache(db) {
-    db.deleteObjectStore(DbTargetDocument.store);
-    db.deleteObjectStore(DbTarget.store);
-    db.deleteObjectStore(DbTargetGlobal.store);
+    db.deleteObjectStore(DbTargetDocumentStore);
+    db.deleteObjectStore(DbTargetStore);
+    db.deleteObjectStore(DbTargetGlobalStore);
 }
 function dropRemoteDocumentChangesStore(db) {
     if (db.objectStoreNames.contains('remoteDocumentChanges')) {
@@ -12202,58 +12451,60 @@ function dropRemoteDocumentChangesStore(db) {
  * @param txn - The version upgrade transaction for indexeddb
  */
 function writeEmptyTargetGlobalEntry(txn) {
-    const globalStore = txn.store(DbTargetGlobal.store);
-    const metadata = new DbTargetGlobal(
-    /*highestTargetId=*/ 0, 
-    /*lastListenSequenceNumber=*/ 0, SnapshotVersion.min().toTimestamp(), 
-    /*targetCount=*/ 0);
-    return globalStore.put(DbTargetGlobal.key, metadata);
+    const globalStore = txn.store(DbTargetGlobalStore);
+    const metadata = {
+        highestTargetId: 0,
+        highestListenSequenceNumber: 0,
+        lastRemoteSnapshotVersion: SnapshotVersion.min().toTimestamp(),
+        targetCount: 0
+    };
+    return globalStore.put(DbTargetGlobalKey, metadata);
 }
 /**
  * Creates indices on the RemoteDocuments store used for both multi-tab
  * and Index-Free queries.
  */
 function createRemoteDocumentReadTimeIndex(txn) {
-    const remoteDocumentStore = txn.objectStore(DbRemoteDocument.store);
-    remoteDocumentStore.createIndex(DbRemoteDocument.readTimeIndex, DbRemoteDocument.readTimeIndexPath, { unique: false });
-    remoteDocumentStore.createIndex(DbRemoteDocument.collectionReadTimeIndex, DbRemoteDocument.collectionReadTimeIndexPath, { unique: false });
+    const remoteDocumentStore = txn.objectStore(DbRemoteDocumentStore);
+    remoteDocumentStore.createIndex(DbRemoteDocumentReadTimeIndex, DbRemoteDocumentReadTimeIndexPath, { unique: false });
+    remoteDocumentStore.createIndex(DbRemoteDocumentCollectionReadTimeIndex, DbRemoteDocumentCollectionReadTimeIndexPath, { unique: false });
 }
 function createClientMetadataStore(db) {
-    db.createObjectStore(DbClientMetadata.store, {
-        keyPath: DbClientMetadata.keyPath
+    db.createObjectStore(DbClientMetadataStore, {
+        keyPath: DbClientMetadataKeyPath
     });
 }
 function createBundlesStore(db) {
-    db.createObjectStore(DbBundle.store, {
-        keyPath: DbBundle.keyPath
+    db.createObjectStore(DbBundleStore, {
+        keyPath: DbBundleKeyPath
     });
 }
 function createNamedQueriesStore(db) {
-    db.createObjectStore(DbNamedQuery.store, {
-        keyPath: DbNamedQuery.keyPath
+    db.createObjectStore(DbNamedQueryStore, {
+        keyPath: DbNamedQueryKeyPath
     });
 }
 function createFieldIndex(db) {
-    const indexConfiguratioStore = db.createObjectStore(DbIndexConfiguration.store, {
-        keyPath: DbIndexConfiguration.keyPath,
+    const indexConfiguratioStore = db.createObjectStore(DbIndexConfigurationStore, {
+        keyPath: DbIndexConfigurationKeyPath,
         autoIncrement: true
     });
-    indexConfiguratioStore.createIndex(DbIndexConfiguration.collectionGroupIndex, DbIndexConfiguration.collectionGroupIndexPath, { unique: false });
-    const indexStateStore = db.createObjectStore(DbIndexState.store, {
-        keyPath: DbIndexState.keyPath
+    indexConfiguratioStore.createIndex(DbIndexConfigurationCollectionGroupIndex, DbIndexConfigurationCollectionGroupIndexPath, { unique: false });
+    const indexStateStore = db.createObjectStore(DbIndexStateStore, {
+        keyPath: DbIndexStateKeyPath
     });
-    indexStateStore.createIndex(DbIndexState.sequenceNumberIndex, DbIndexState.sequenceNumberIndexPath, { unique: false });
-    const indexEntryStore = db.createObjectStore(DbIndexEntry.store, {
-        keyPath: DbIndexEntry.keyPath
+    indexStateStore.createIndex(DbIndexStateSequenceNumberIndex, DbIndexStateSequenceNumberIndexPath, { unique: false });
+    const indexEntryStore = db.createObjectStore(DbIndexEntryStore, {
+        keyPath: DbIndexEntryKeyPath
     });
-    indexEntryStore.createIndex(DbIndexEntry.documentKeyIndex, DbIndexEntry.documentKeyIndexPath, { unique: false });
+    indexEntryStore.createIndex(DbIndexEntryDocumentKeyIndex, DbIndexEntryDocumentKeyIndexPath, { unique: false });
 }
 function createDocumentOverlayStore(db) {
-    const documentOverlayStore = db.createObjectStore(DbDocumentOverlay.store, {
-        keyPath: DbDocumentOverlay.keyPath
+    const documentOverlayStore = db.createObjectStore(DbDocumentOverlayStore, {
+        keyPath: DbDocumentOverlayKeyPath
     });
-    documentOverlayStore.createIndex(DbDocumentOverlay.collectionPathOverlayIndex, DbDocumentOverlay.collectionPathOverlayIndexPath, { unique: false });
-    documentOverlayStore.createIndex(DbDocumentOverlay.collectionGroupOverlayIndex, DbDocumentOverlay.collectionGroupOverlayIndexPath, { unique: false });
+    documentOverlayStore.createIndex(DbDocumentOverlayCollectionPathOverlayIndex, DbDocumentOverlayCollectionPathOverlayIndexPath, { unique: false });
+    documentOverlayStore.createIndex(DbDocumentOverlayCollectionGroupOverlayIndex, DbDocumentOverlayCollectionGroupOverlayIndexPath, { unique: false });
 }
 
 /**
@@ -12501,7 +12752,12 @@ class IndexedDbPersistence {
         return this.runTransaction('updateClientMetadataAndTryBecomePrimary', 'readwrite', txn => {
             const metadataStore = clientMetadataStore(txn);
             return metadataStore
-                .put(new DbClientMetadata(this.clientId, Date.now(), this.networkEnabled, this.inForeground))
+                .put({
+                clientId: this.clientId,
+                updateTimeMs: Date.now(),
+                networkEnabled: this.networkEnabled,
+                inForeground: this.inForeground
+            })
                 .next(() => {
                 if (this.isPrimary) {
                     return this.verifyPrimaryLease(txn).next(success => {
@@ -12547,7 +12803,7 @@ class IndexedDbPersistence {
     }
     verifyPrimaryLease(txn) {
         const store = primaryClientStore(txn);
-        return store.get(DbPrimaryClient.key).next(primaryClient => {
+        return store.get(DbPrimaryClientKey).next(primaryClient => {
             return PersistencePromise.resolve(this.isLocalClient(primaryClient));
         });
     }
@@ -12565,7 +12821,7 @@ class IndexedDbPersistence {
             !this.isWithinAge(this.lastGarbageCollectionTime, MAX_CLIENT_AGE_MS)) {
             this.lastGarbageCollectionTime = Date.now();
             const inactiveClients = await this.runTransaction('maybeGarbageCollectMultiClientState', 'readwrite-primary', txn => {
-                const metadataStore = getStore(txn, DbClientMetadata.store);
+                const metadataStore = getStore(txn, DbClientMetadataStore);
                 return metadataStore.loadAll().next(existingClients => {
                     const active = this.filterActiveClients(existingClients, MAX_CLIENT_AGE_MS);
                     const inactive = existingClients.filter(client => active.indexOf(client) === -1);
@@ -12619,7 +12875,7 @@ class IndexedDbPersistence {
         }
         const store = primaryClientStore(txn);
         return store
-            .get(DbPrimaryClient.key)
+            .get(DbPrimaryClientKey)
             .next(currentPrimary => {
             const currentLeaseIsValid = currentPrimary !== null &&
                 this.isWithinAge(currentPrimary.leaseTimestampMs, MAX_PRIMARY_ELIGIBLE_AGE_MS) &&
@@ -12700,7 +12956,7 @@ class IndexedDbPersistence {
         this.detachWindowUnloadHook();
         // Use `SimpleDb.runTransaction` directly to avoid failing if another tab
         // has obtained the primary lease.
-        await this.simpleDb.runTransaction('shutdown', 'readwrite', [DbPrimaryClient.store, DbClientMetadata.store], simpleDbTxn => {
+        await this.simpleDb.runTransaction('shutdown', 'readwrite', [DbPrimaryClientStore, DbClientMetadataStore], simpleDbTxn => {
             const persistenceTransaction = new IndexedDbTransaction(simpleDbTxn, ListenSequence.INVALID);
             return this.releasePrimaryLeaseIfHeld(persistenceTransaction).next(() => this.removeClientMetadata(persistenceTransaction));
         });
@@ -12807,7 +13063,7 @@ class IndexedDbPersistence {
     // be turned off.
     verifyAllowTabSynchronization(txn) {
         const store = primaryClientStore(txn);
-        return store.get(DbPrimaryClient.key).next(currentPrimary => {
+        return store.get(DbPrimaryClientKey).next(currentPrimary => {
             const currentLeaseIsValid = currentPrimary !== null &&
                 this.isWithinAge(currentPrimary.leaseTimestampMs, MAX_PRIMARY_ELIGIBLE_AGE_MS) &&
                 !this.isClientZombied(currentPrimary.ownerId);
@@ -12825,8 +13081,12 @@ class IndexedDbPersistence {
      * method does not verify that the client is eligible for this lease.
      */
     acquireOrExtendPrimaryLease(txn) {
-        const newPrimary = new DbPrimaryClient(this.clientId, this.allowTabSynchronization, Date.now());
-        return primaryClientStore(txn).put(DbPrimaryClient.key, newPrimary);
+        const newPrimary = {
+            ownerId: this.clientId,
+            allowTabSynchronization: this.allowTabSynchronization,
+            leaseTimestampMs: Date.now()
+        };
+        return primaryClientStore(txn).put(DbPrimaryClientKey, newPrimary);
     }
     static isAvailable() {
         return SimpleDb.isAvailable();
@@ -12834,10 +13094,10 @@ class IndexedDbPersistence {
     /** Checks the primary lease and removes it if we are the current primary. */
     releasePrimaryLeaseIfHeld(txn) {
         const store = primaryClientStore(txn);
-        return store.get(DbPrimaryClient.key).next(primaryClient => {
+        return store.get(DbPrimaryClientKey).next(primaryClient => {
             if (this.isLocalClient(primaryClient)) {
                 logDebug(LOG_TAG$d, 'Releasing primary lease.');
-                return store.delete(DbPrimaryClient.key);
+                return store.delete(DbPrimaryClientKey);
             }
             else {
                 return PersistencePromise.resolve();
@@ -12971,13 +13231,13 @@ class IndexedDbPersistence {
  * Helper to get a typed SimpleDbStore for the primary client object store.
  */
 function primaryClientStore(txn) {
-    return getStore(txn, DbPrimaryClient.store);
+    return getStore(txn, DbPrimaryClientStore);
 }
 /**
  * Helper to get a typed SimpleDbStore for the client metadata object store.
  */
 function clientMetadataStore(txn) {
-    return getStore(txn, DbClientMetadata.store);
+    return getStore(txn, DbClientMetadataStore);
 }
 /**
  * Generates a string used as a prefix when storing data in IndexedDB and
@@ -14040,7 +14300,7 @@ class MemoryDocumentOverlayCache {
         return PersistencePromise.resolve(this.overlays.get(key));
     }
     saveOverlays(transaction, largestBatchId, overlays) {
-        overlays.forEach(mutation => {
+        overlays.forEach((_, mutation) => {
             this.saveOverlay(transaction, largestBatchId, mutation);
         });
         return PersistencePromise.resolve();
@@ -14054,7 +14314,7 @@ class MemoryDocumentOverlayCache {
         return PersistencePromise.resolve();
     }
     getOverlaysForCollection(transaction, collection, sinceBatchId) {
-        const result = new Map();
+        const result = newOverlayMap();
         const immediateChildrenPathLength = collection.length + 1;
         const prefix = new DocumentKey(collection.child(''));
         const iter = this.overlays.getIteratorFrom(prefix);
@@ -14088,19 +14348,19 @@ class MemoryDocumentOverlayCache {
             if (overlay.largestBatchId > sinceBatchId) {
                 let overlaysForBatchId = batchIdToOverlays.get(overlay.largestBatchId);
                 if (overlaysForBatchId === null) {
-                    overlaysForBatchId = new Map();
+                    overlaysForBatchId = newOverlayMap();
                     batchIdToOverlays = batchIdToOverlays.insert(overlay.largestBatchId, overlaysForBatchId);
                 }
                 overlaysForBatchId.set(overlay.getKey(), overlay);
             }
         }
-        const result = new Map();
+        const result = newOverlayMap();
         const batchIter = batchIdToOverlays.getIterator();
         while (batchIter.hasNext()) {
             const entry = batchIter.getNext();
             const overlays = entry.value;
-            overlays.forEach((overlay, key) => result.set(key, overlay));
-            if (result.size >= count) {
+            overlays.forEach((key, overlay) => result.set(key, overlay));
+            if (result.size() >= count) {
                 break;
             }
         }
@@ -14113,16 +14373,19 @@ class MemoryDocumentOverlayCache {
         // Remove the association of the overlay to its batch id.
         const existing = this.overlays.get(mutation.key);
         if (existing !== null) {
-            this.overlayByBatchId.get(existing.largestBatchId).delete(mutation.key);
+            const newSet = this.overlayByBatchId
+                .get(existing.largestBatchId)
+                .delete(mutation.key);
+            this.overlayByBatchId.set(existing.largestBatchId, newSet);
         }
         this.overlays = this.overlays.insert(mutation.key, new Overlay(largestBatchId, mutation));
         // Create the association of this overlay to the given largestBatchId.
         let batch = this.overlayByBatchId.get(largestBatchId);
         if (batch === undefined) {
-            batch = new Set();
+            batch = documentKeySet();
             this.overlayByBatchId.set(largestBatchId, batch);
         }
-        batch.add(mutation.key);
+        this.overlayByBatchId.set(largestBatchId, batch.add(mutation.key));
     }
 }
 
@@ -15973,9 +16236,13 @@ function createMetadata(databasePath, authToken, appCheckToken, appId) {
         metadata.set('X-Firebase-GMPID', appId);
     }
     metadata.set('X-Goog-Api-Client', X_GOOG_API_CLIENT_VALUE);
-    // This header is used to improve routing and project isolation by the
+    // These headers are used to improve routing and project isolation by the
     // backend.
+    // TODO(b/199767712): We are keeping 'Google-Cloud-Resource-Prefix' until Emulators can be
+    // released with cl/428820046. Currently blocked because Emulators are now built with Java
+    // 11 from Google3.
     metadata.set('Google-Cloud-Resource-Prefix', databasePath);
+    metadata.set('x-goog-request-params', databasePath);
     return metadata;
 }
 /**