@firebase/firestore 3.4.5-canary.2b98b28f2 → 3.4.5-canary.2d672cead

package/dist/index.node.cjs.js

@@ -33,7 +33,7 @@ var grpc__namespace = /*#__PURE__*/_interopNamespace(grpc);
 var protoLoader__namespace = /*#__PURE__*/_interopNamespace(protoLoader);
 
 const name = "@firebase/firestore";
-const version$1 = "3.4.5-canary.2b98b28f2";
+const version$1 = "3.4.5-canary.2d672cead";
 
 /**
  * @license
@@ -86,7 +86,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-canary.2b98b28f2";
+const version = "9.6.7-canary.2d672cead";
 
 /**
  * @license
@@ -1224,55 +1224,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
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
  *
- * 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
+ * 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.
  *
@@ -1280,239 +1248,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.
@@ -1520,310 +1311,55 @@ 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.
@@ -1832,49 +1368,11 @@ DbIndexConfiguration.keyPath = 'indexId';
  * 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;
-    }
-}
+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.
@@ -1883,108 +1381,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;
-    }
-}
+    'documentKey'
+];
+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) {
@@ -5701,6 +5157,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
@@ -6412,6 +5978,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;
@@ -9090,30 +8659,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();
@@ -9129,7 +8704,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);
@@ -9139,7 +8714,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) {
@@ -9195,7 +8776,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.
@@ -9274,7 +8863,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
@@ -9286,7 +8882,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
@@ -9296,7 +8896,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
+    };
 }
 
 /**
@@ -9347,13 +8954,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);
 }
 
 /**
@@ -9400,7 +9007,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));
         });
@@ -9415,19 +9022,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);
@@ -9437,7 +9044,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.
@@ -9445,7 +9052,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
@@ -9453,7 +9060,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;
@@ -9472,7 +9079,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);
 }
 
 /**
@@ -10227,107 +9834,6 @@ class TargetIndexMatcher {
     }
 }
 
-/**
- * @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 2019 Google LLC
@@ -10580,7 +10086,7 @@ class IndexedDbIndexManager {
         return subTargets;
     }
     /**
-     * Constructs a key range query on `DbIndexEntry.store` that unions all
+     * Constructs a key range query on `DbIndexEntryStore` that unions all
      * bounds.
      */
     generateIndexRanges(indexId, arrayValues, lowerBounds, lowerBoundInclusive, upperBounds, upperBoundInclusive, notInValues) {
@@ -10732,7 +10238,7 @@ class IndexedDbIndexManager {
         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) => {
@@ -10762,7 +10268,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) {
@@ -10793,7 +10299,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);
@@ -10810,7 +10322,7 @@ class IndexedDbIndexManager {
         let results = new SortedSet(indexEntryComparator);
         return indexEntries
             .iterate({
-            index: DbIndexEntry.documentKeyIndex,
+            index: DbIndexEntryDocumentKeyIndex,
             range: IDBKeyRange.only([
                 fieldIndex.indexId,
                 this.uid,
@@ -10864,7 +10376,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) => {
@@ -10929,25 +10441,25 @@ class IndexedDbIndexManager {
  * 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);
 }
 
 /**
@@ -10971,8 +10483,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;
@@ -10985,7 +10497,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);
     }
@@ -11074,7 +10586,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();
         })
@@ -11099,10 +10611,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));
@@ -11153,7 +10665,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);
@@ -11169,7 +10681,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();
         })
@@ -11178,13 +10690,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)
@@ -11219,7 +10731,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;
@@ -11255,7 +10767,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
@@ -11327,7 +10839,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) => {
@@ -11355,9 +10867,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: ''
+            });
         });
     }
 }
@@ -11366,7 +10880,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;
@@ -11398,19 +10912,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);
 }
 
 /**
@@ -11574,14 +11088,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));
@@ -11614,7 +11128,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.
@@ -11632,7 +11146,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);
@@ -11678,7 +11192,7 @@ class IndexedDbTargetCache {
         let count = 0;
         return documentTargetStore(txn)
             .iterate({
-            index: DbTargetDocument.documentTargetsIndex,
+            index: DbTargetDocumentDocumentTargetsIndex,
             keysOnly: true,
             range
         }, ([targetId, path], _, control) => {
@@ -11717,19 +11231,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);
 }
 
 /**
@@ -12143,7 +11657,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
@@ -12185,7 +11699,7 @@ 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));
@@ -12459,7 +11973,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) => {
@@ -12489,14 +12003,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
@@ -12531,7 +12045,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);
@@ -12555,7 +12069,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);
         }
@@ -12643,17 +12157,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
@@ -12763,27 +12299,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);
@@ -12799,12 +12335,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
@@ -12825,10 +12365,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) => {
@@ -12843,7 +12383,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());
@@ -12851,7 +12391,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());
@@ -12859,7 +12399,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);
@@ -12871,59 +12411,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')) {
@@ -12936,58 +12476,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 });
 }
 
 /**
@@ -13235,7 +12777,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 => {
@@ -13281,7 +12828,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));
         });
     }
@@ -13299,7 +12846,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);
@@ -13353,7 +12900,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) &&
@@ -13434,7 +12981,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));
         });
@@ -13541,7 +13088,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);
@@ -13559,8 +13106,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();
@@ -13568,10 +13119,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();
@@ -13705,13 +13256,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
@@ -14774,7 +14325,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();
@@ -14788,7 +14339,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);
@@ -14822,19 +14373,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;
             }
         }
@@ -14847,16 +14398,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));
     }
 }