@firebase/firestore 3.4.5 → 3.4.6-2022216223411

package/dist/lite/firestore/src/local/indexeddb_sentinels.d.ts

@@ -0,0 +1,238 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BatchId, TargetId } from '../core/types';
+import { ResourcePath } from '../model/path';
+import { EncodedResourcePath } from './encoded_resource_path';
+import { DbDocumentMutation } from './indexeddb_schema';
+/** A timestamp type that can be used in IndexedDb keys. */
+export declare type DbTimestampKey = [/* seconds */ number, /* nanos */ number];
+export declare type DbPrimaryClientKey = typeof DbPrimaryClientKey;
+/**
+ * Name of the IndexedDb object store.
+ *
+ * Note that the name 'owner' is chosen to ensure backwards compatibility with
+ * older clients that only supported single locked access to the persistence
+ * layer.
+ */
+export declare const DbPrimaryClientStore = "owner";
+/**
+ * The key string used for the single object that exists in the
+ * DbPrimaryClient store.
+ */
+export declare const DbPrimaryClientKey = "owner";
+/** Object keys in the 'mutationQueues' store are userId strings. */
+export declare type DbMutationQueueKey = string;
+/** Name of the IndexedDb object store.  */
+export declare const DbMutationQueueStore = "mutationQueues";
+/** Keys are automatically assigned via the userId property. */
+export declare const DbMutationQueueKeyPath = "userId";
+/** The 'mutations' store  is keyed by batch ID. */
+export declare type DbMutationBatchKey = BatchId;
+/** Name of the IndexedDb object store.  */
+export declare const DbMutationBatchStore = "mutations";
+/** Keys are automatically assigned via the userId, batchId properties. */
+export declare const DbMutationBatchKeyPath = "batchId";
+/** The index name for lookup of mutations by user. */
+export declare const DbMutationBatchUserMutationsIndex = "userMutationsIndex";
+/** The user mutations index is keyed by [userId, batchId] pairs. */
+export declare const DbMutationBatchUserMutationsKeyPath: string[];
+/**
+ * The key for a db document mutation, which is made up of a userID, path, and
+ * batchId. Note that the path must be serialized into a form that indexedDB can
+ * sort.
+ */
+export declare type DbDocumentMutationKey = [string, EncodedResourcePath, BatchId];
+/**
+ * Creates a [userId] key for use in the DbDocumentMutations index to iterate
+ * over all of a user's document mutations.
+ */
+export declare function newDbDocumentMutationPrefixForUser(userId: string): [string];
+/**
+ * Creates a [userId, encodedPath] key for use in the DbDocumentMutations
+ * index to iterate over all at document mutations for a given path or lower.
+ */
+export declare function newDbDocumentMutationPrefixForPath(userId: string, path: ResourcePath): [string, EncodedResourcePath];
+/**
+ * Creates a full index key of [userId, encodedPath, batchId] for inserting
+ * and deleting into the DbDocumentMutations index.
+ */
+export declare function newDbDocumentMutationKey(userId: string, path: ResourcePath, batchId: BatchId): DbDocumentMutationKey;
+/**
+ * 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.
+ */
+export declare const DbDocumentMutationPlaceholder: DbDocumentMutation;
+export declare const DbDocumentMutationStore = "documentMutations";
+export declare 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.
+ */
+export declare const DbRemoteDocumentReadTimeIndex = "readTimeIndex";
+export declare const DbRemoteDocumentReadTimeIndexPath = "readTime";
+/**
+ * An index that provides access to documents in a collection sorted by read
+ * time.
+ *
+ * This index is used to allow the RemoteDocumentCache to fetch newly changed
+ * documents in a collection.
+ */
+export declare const DbRemoteDocumentCollectionReadTimeIndex = "collectionReadTimeIndex";
+export declare const DbRemoteDocumentCollectionReadTimeIndexPath: string[];
+export declare const DbRemoteDocumentGlobalStore = "remoteDocumentGlobal";
+export declare const DbRemoteDocumentGlobalKey = "remoteDocumentGlobalKey";
+export declare type DbRemoteDocumentGlobalKey = typeof DbRemoteDocumentGlobalKey;
+/**
+ * A key in the 'targets' object store is a targetId of the query.
+ */
+export declare type DbTargetKey = TargetId;
+export declare const DbTargetStore = "targets";
+/** Keys are automatically assigned via the targetId property. */
+export declare const DbTargetKeyPath = "targetId";
+/** The name of the queryTargets index. */
+export declare 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.
+ */
+export declare const DbTargetQueryTargetsKeyPath: string[];
+/**
+ * The key for a DbTargetDocument, containing a targetId and an encoded resource
+ * path.
+ */
+export declare type DbTargetDocumentKey = [TargetId, EncodedResourcePath];
+/** Name of the IndexedDb object store.  */
+export declare const DbTargetDocumentStore = "targetDocuments";
+/** Keys are automatically assigned via the targetId, path properties. */
+export declare const DbTargetDocumentKeyPath: string[];
+/** The index name for the reverse index. */
+export declare const DbTargetDocumentDocumentTargetsIndex = "documentTargetsIndex";
+/** We also need to create the reverse index for these properties. */
+export declare const DbTargetDocumentDocumentTargetsKeyPath: string[];
+/**
+ * The type to represent the single allowed key for the DbTargetGlobal store.
+ */
+export declare type DbTargetGlobalKey = typeof DbTargetGlobalKey;
+/**
+ * The key string used for the single object that exists in the
+ * DbTargetGlobal store.
+ */
+export declare const DbTargetGlobalKey = "targetGlobalKey";
+export declare const DbTargetGlobalStore = "targetGlobal";
+/**
+ * The key for a DbCollectionParent entry, containing the collection ID
+ * and the parent path that contains it. Note that the parent path will be an
+ * empty path in the case of root-level collections.
+ */
+export declare type DbCollectionParentKey = [string, EncodedResourcePath];
+/** Name of the IndexedDb object store. */
+export declare const DbCollectionParentStore = "collectionParents";
+/** Keys are automatically assigned via the collectionId, parent properties. */
+export declare const DbCollectionParentKeyPath: string[];
+/** Name of the IndexedDb object store. */
+export declare const DbClientMetadataStore = "clientMetadata";
+/** Keys are automatically assigned via the clientId properties. */
+export declare const DbClientMetadataKeyPath = "clientId";
+/** Object keys in the 'clientMetadata' store are clientId strings. */
+export declare type DbClientMetadataKey = string;
+export declare type DbBundlesKey = string;
+/** Name of the IndexedDb object store. */
+export declare const DbBundleStore = "bundles";
+export declare const DbBundleKeyPath = "bundleId";
+export declare type DbNamedQueriesKey = string;
+/** Name of the IndexedDb object store. */
+export declare const DbNamedQueryStore = "namedQueries";
+export declare const DbNamedQueryKeyPath = "name";
+/** The key for each index consisting of just the index id. */
+export declare type DbIndexConfigurationKey = number;
+/** Name of the IndexedDb object store. */
+export declare const DbIndexConfigurationStore = "indexConfiguration";
+export declare const DbIndexConfigurationKeyPath = "indexId";
+/**
+ * An index that provides access to the index configurations by collection
+ * group.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+export declare const DbIndexConfigurationCollectionGroupIndex = "collectionGroupIndex";
+export declare const DbIndexConfigurationCollectionGroupIndexPath = "collectionGroup";
+/** The key for each index state consisting of the index id and its user id. */
+export declare type DbIndexStateKey = [number, string];
+/** Name of the IndexedDb object store. */
+export declare const DbIndexStateStore = "indexState";
+export declare const DbIndexStateKeyPath: string[];
+/**
+ * An index that provides access to documents in a collection sorted by last
+ * update time. Used by the backfiller.
+ *
+ * PORTING NOTE: iOS and Android maintain this index in-memory, but this is
+ * not possible here as the Web client supports concurrent access to
+ * persistence via multi-tab.
+ */
+export declare const DbIndexStateSequenceNumberIndex = "sequenceNumberIndex";
+export declare const DbIndexStateSequenceNumberIndexPath: string[];
+/**
+ * The key for each index entry consists of the index id and its user id,
+ * the encoded array and directional value for the indexed fields as well as
+ * the encoded document path for the indexed document.
+ */
+export declare type DbIndexEntryKey = [number, string, Uint8Array, Uint8Array, string];
+/** Name of the IndexedDb object store. */
+export declare const DbIndexEntryStore = "indexEntries";
+export declare const DbIndexEntryKeyPath: string[];
+export declare const DbIndexEntryDocumentKeyIndex = "documentKeyIndex";
+export declare const DbIndexEntryDocumentKeyIndexPath: string[];
+export declare type DbDocumentOverlayKey = [
+    string,
+    string,
+    string
+];
+/** Name of the IndexedDb object store. */
+export declare const DbDocumentOverlayStore = "documentOverlays";
+export declare const DbDocumentOverlayKeyPath: string[];
+export declare const DbDocumentOverlayCollectionPathOverlayIndex = "collectionPathOverlayIndex";
+export declare const DbDocumentOverlayCollectionPathOverlayIndexPath: string[];
+export declare const DbDocumentOverlayCollectionGroupOverlayIndex = "collectionGroupOverlayIndex";
+export declare const DbDocumentOverlayCollectionGroupOverlayIndexPath: string[];
+export declare const V1_STORES: string[];
+export declare const V3_STORES: string[];
+export declare const V4_STORES: string[];
+export declare const V6_STORES: string[];
+export declare const V8_STORES: string[];
+export declare const V11_STORES: string[];
+export declare const V12_STORES: string[];
+export declare const V13_STORES: string[];
+/**
+ * The list of all default IndexedDB stores used throughout the SDK. This is
+ * used when creating transactions so that access across all stores is done
+ * atomically.
+ */
+export declare const ALL_STORES: string[];
+/** Returns the object stores for the provided schema. */
+export declare function getObjectStores(schemaVersion: number): string[];
+/**
+ * A key in the 'remoteDocuments' object store is a string array containing the
+ * segments that make up the path.
+ */
+export declare type DbRemoteDocumentKey = string[];

package/dist/lite/firestore/src/local/indexeddb_target_cache.d.ts

@@ -20,7 +20,8 @@ import { ListenSequenceNumber, TargetId } from '../core/types';
 import { DocumentKeySet } from '../model/collections';
 import { DocumentKey } from '../model/document_key';
 import { IndexedDbLruDelegate } from './indexeddb_lru_delegate';
-import { DbTargetDocument, DbTargetDocumentKey } from './indexeddb_schema';
+import { DbTargetDocument } from './indexeddb_schema';
+import { DbTargetDocumentKey } from './indexeddb_sentinels';
 import { LocalSerializer } from './local_serializer';
 import { ActiveTargets } from './lru_garbage_collector';
 import { PersistencePromise } from './persistence_promise';

package/dist/lite/firestore/src/local/local_serializer.d.ts

@@ -25,7 +25,8 @@ import { MutationBatch } from '../model/mutation_batch';
 import { Overlay } from '../model/overlay';
 import { BundledQuery as ProtoBundledQuery, BundleMetadata as ProtoBundleMetadata, NamedQuery as ProtoNamedQuery } from '../protos/firestore_bundle_proto';
 import { JsonProtoSerializer } from '../remote/serializer';
-import { DbBundle, DbDocumentOverlay, DbDocumentOverlayKey, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget, DbTimestampKey } from './indexeddb_schema';
+import { DbBundle, DbDocumentOverlay, DbIndexConfiguration, DbIndexState, DbMutationBatch, DbNamedQuery, DbRemoteDocument, DbTarget } from './indexeddb_schema';
+import { DbDocumentOverlayKey, DbTimestampKey } from './indexeddb_sentinels';
 import { TargetData } from './target_data';
 /** Serializer for values stored in the LocalStore. */
 export declare class LocalSerializer {

package/dist/lite/firestore/src/local/memory_document_overlay_cache.d.ts

@@ -14,9 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { DocumentKeySet } from '../model/collections';
+import { DocumentKeySet, MutationMap, OverlayMap } from '../model/collections';
 import { DocumentKey } from '../model/document_key';
-import { Mutation } from '../model/mutation';
 import { Overlay } from '../model/overlay';
 import { ResourcePath } from '../model/path';
 import { DocumentOverlayCache } from './document_overlay_cache';
@@ -29,9 +28,9 @@ export declare class MemoryDocumentOverlayCache implements DocumentOverlayCache
     private overlays;
     private overlayByBatchId;
     getOverlay(transaction: PersistenceTransaction, key: DocumentKey): PersistencePromise<Overlay | null>;
-    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: Map<DocumentKey, Mutation>): PersistencePromise<void>;
+    saveOverlays(transaction: PersistenceTransaction, largestBatchId: number, overlays: MutationMap): PersistencePromise<void>;
     removeOverlaysForBatchId(transaction: PersistenceTransaction, documentKeys: DocumentKeySet, batchId: number): PersistencePromise<void>;
-    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<Map<DocumentKey, Overlay>>;
-    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollection(transaction: PersistenceTransaction, collection: ResourcePath, sinceBatchId: number): PersistencePromise<OverlayMap>;
+    getOverlaysForCollectionGroup(transaction: PersistenceTransaction, collectionGroup: string, sinceBatchId: number, count: number): PersistencePromise<OverlayMap>;
     private saveOverlay;
 }

package/dist/lite/firestore/src/local/memory_index_manager.d.ts

@@ -30,7 +30,7 @@ export declare class MemoryIndexManager implements IndexManager {
     getCollectionParents(transaction: PersistenceTransaction, collectionId: string): PersistencePromise<ResourcePath[]>;
     addFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
     deleteFieldIndex(transaction: PersistenceTransaction, index: FieldIndex): PersistencePromise<void>;
-    getDocumentsMatchingTarget(transaction: PersistenceTransaction, fieldIndex: FieldIndex, target: Target): PersistencePromise<DocumentKeySet>;
+    getDocumentsMatchingTarget(transaction: PersistenceTransaction, target: Target): PersistencePromise<DocumentKeySet | null>;
     getFieldIndex(transaction: PersistenceTransaction, target: Target): PersistencePromise<FieldIndex | null>;
     getFieldIndexes(transaction: PersistenceTransaction, collectionGroup?: string): PersistencePromise<FieldIndex[]>;
     getNextCollectionGroupToUpdate(transaction: PersistenceTransaction): PersistencePromise<string | null>;

package/dist/lite/firestore/src/local/simple_db.d.ts

@@ -182,9 +182,20 @@ export declare class SimpleDbStore<KeyType extends IDBValidKey, ValueType extend
      * Returns the number of rows in the store.
      */
     count(): PersistencePromise<number>;
+    /** Loads all elements from the object store. */
     loadAll(): PersistencePromise<ValueType[]>;
+    /** Loads all elements for the index range from the object store. */
     loadAll(range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /**
+     * Loads all elements from the object store that fall into the provided in the
+     * index range for the given index.
+     */
     loadAll(index: string, range: IDBKeyRange): PersistencePromise<ValueType[]>;
+    /**
+     * Loads the first `count` elements from the provided index range. Loads all
+     * elements if no limit is provided.
+     */
+    loadFirst(range: IDBKeyRange, count: number | null): PersistencePromise<ValueType[]>;
     deleteAll(): PersistencePromise<void>;
     deleteAll(range: IDBKeyRange): PersistencePromise<void>;
     deleteAll(index: string, range: IDBKeyRange): PersistencePromise<void>;

package/dist/lite/firestore/src/model/collections.d.ts

@@ -16,10 +16,13 @@
  */
 import { SnapshotVersion } from '../core/snapshot_version';
 import { TargetId } from '../core/types';
+import { ObjectMap } from '../util/obj_map';
 import { SortedMap } from '../util/sorted_map';
 import { SortedSet } from '../util/sorted_set';
 import { Document, MutableDocument } from './document';
 import { DocumentKey } from './document_key';
+import { Mutation } from './mutation';
+import { Overlay } from './overlay';
 /** Miscellaneous collection types / constants. */
 export declare type MutableDocumentMap = SortedMap<DocumentKey, MutableDocument>;
 export declare function mutableDocumentMap(): MutableDocumentMap;
@@ -29,6 +32,10 @@ export interface DocumentSizeEntries {
 }
 export declare type DocumentMap = SortedMap<DocumentKey, Document>;
 export declare function documentMap(): DocumentMap;
+export declare type OverlayMap = ObjectMap<DocumentKey, Overlay>;
+export declare function newOverlayMap(): OverlayMap;
+export declare type MutationMap = ObjectMap<DocumentKey, Mutation>;
+export declare function newMutationMap(): MutationMap;
 export declare type DocumentVersionMap = SortedMap<DocumentKey, SnapshotVersion>;
 export declare function documentVersionMap(): DocumentVersionMap;
 export declare type DocumentKeySet = SortedSet<DocumentKey>;

package/dist/lite/firestore/src/model/field_index.d.ts

@@ -70,6 +70,8 @@ export declare function fieldIndexGetDirectionalSegments(fieldIndex: FieldIndex)
  * index ID.
  */
 export declare function fieldIndexSemanticComparator(left: FieldIndex, right: FieldIndex): number;
+/** Returns a debug representation of the field index */
+export declare function fieldIndexToString(fieldIndex: FieldIndex): string;
 /** The type of the index, e.g. for which type of query it can be used. */
 export declare const enum IndexKind {
     /**

package/dist/lite/firestore/src/model/type_order.d.ts

@@ -32,5 +32,6 @@ export declare const enum TypeOrder {
     RefValue = 7,
     GeoPointValue = 8,
     ArrayValue = 9,
-    ObjectValue = 10
+    ObjectValue = 10,
+    MaxValue = 9007199254740991
 }

package/dist/lite/firestore/src/platform/node/base64.d.ts

@@ -14,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/** Converts a Base64 encoded string to a binary string. */
 export declare function decodeBase64(encoded: string): string;
 /** Converts a binary string to a Base64 encoded string. */
 export declare function encodeBase64(raw: string): string;

package/dist/lite/firestore/src/util/obj_map.d.ts

@@ -30,6 +30,8 @@ export declare class ObjectMap<KeyType, ValueType> {
      * constant time lookups in practice.
      */
     private inner;
+    /** The number of entries stored in the map */
+    private innerSize;
     constructor(mapKeyFn: (key: KeyType) => string, equalsFn: (l: KeyType, r: KeyType) => boolean);
     /** Get a value for this key, or undefined if it does not exist. */
     get(key: KeyType): ValueType | undefined;
@@ -42,4 +44,5 @@ export declare class ObjectMap<KeyType, ValueType> {
     delete(key: KeyType): boolean;
     forEach(fn: (key: KeyType, val: ValueType) => void): void;
     isEmpty(): boolean;
+    size(): number;
 }

package/dist/lite/firestore/test/unit/local/test_document_overlay_cache.d.ts

@@ -16,7 +16,7 @@
  */
 import { DocumentOverlayCache } from '../../../src/local/document_overlay_cache';
 import { Persistence } from '../../../src/local/persistence';
-import { DocumentKeySet } from '../../../src/model/collections';
+import { DocumentKeySet, MutationMap, OverlayMap } from '../../../src/model/collections';
 import { DocumentKey } from '../../../src/model/document_key';
 import { Mutation } from '../../../src/model/mutation';
 import { Overlay } from '../../../src/model/overlay';
@@ -29,10 +29,10 @@ export declare class TestDocumentOverlayCache {
     private persistence;
     private cache;
     constructor(persistence: Persistence, cache: DocumentOverlayCache);
-    saveOverlays(largestBatch: number, data: Map<DocumentKey, Mutation>): Promise<void>;
+    saveOverlays(largestBatch: number, data: MutationMap): Promise<void>;
     getOverlay(key: DocumentKey): Promise<Overlay | null>;
     getOverlayMutation(docKey: string): Promise<Mutation | null>;
-    getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<Map<DocumentKey, Overlay>>;
-    getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<Map<DocumentKey, Overlay>>;
+    getOverlaysForCollection(path: ResourcePath, sinceBatchId: number): Promise<OverlayMap>;
+    getOverlaysForCollectionGroup(collectionGroup: string, sinceBatchId: number, count: number): Promise<OverlayMap>;
     removeOverlaysForBatchId(documentKeys: DocumentKeySet, batchId: number): Promise<void>;
 }

package/dist/lite/firestore/test/unit/local/test_index_manager.d.ts

@@ -34,7 +34,7 @@ export declare class TestIndexManager {
     deleteFieldIndex(index: FieldIndex): Promise<void>;
     getFieldIndexes(collectionGroup?: string): Promise<FieldIndex[]>;
     getFieldIndex(target: Target): Promise<FieldIndex | null>;
-    getDocumentsMatchingTarget(fieldIndex: FieldIndex, target: Target): Promise<DocumentKeySet>;
+    getDocumentsMatchingTarget(target: Target): Promise<DocumentKeySet | null>;
     getNextCollectionGroupToUpdate(): Promise<string | null>;
     updateCollectionGroup(collectionGroup: string, offset: IndexOffset): Promise<void>;
     updateIndexEntries(documents: DocumentMap): Promise<void>;

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

@@ -63,7 +63,7 @@ l.MOCK_USER = new l("mock-user");
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-let f = "9.6.7";
+let f = "9.6.9-2022216223411";
 
 /**
  * @license
@@ -1471,6 +1471,8 @@ class It {
         return new It(e);
     }
     static fromUint8Array(t) {
+        // TODO(indexing); Remove the copy of the byte string here as this method
+        // is frequently called during indexing.
         const e = 
         /**
  * Helper function to convert an Uint8array to a binary string.
@@ -1656,8 +1658,33 @@ const At = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/** Extracts the backend's type order for the provided value. */ function St(t) {
-    return "nullValue" in t ? 0 /* NullValue */ : "booleanValue" in t ? 1 /* BooleanValue */ : "integerValue" in t || "doubleValue" in t ? 2 /* NumberValue */ : "timestampValue" in t ? 3 /* TimestampValue */ : "stringValue" in t ? 5 /* StringValue */ : "bytesValue" in t ? 6 /* BlobValue */ : "referenceValue" in t ? 7 /* RefValue */ : "geoPointValue" in t ? 8 /* GeoPointValue */ : "arrayValue" in t ? 9 /* ArrayValue */ : "mapValue" in t ? Dt(t) ? 4 /* ServerTimestampValue */ : 10 /* ObjectValue */ : g();
+/** Extracts the backend's type order for the provided value. */
+function St(t) {
+    return "nullValue" in t ? 0 /* NullValue */ : "booleanValue" in t ? 1 /* BooleanValue */ : "integerValue" in t || "doubleValue" in t ? 2 /* NumberValue */ : "timestampValue" in t ? 3 /* TimestampValue */ : "stringValue" in t ? 5 /* StringValue */ : "bytesValue" in t ? 6 /* BlobValue */ : "referenceValue" in t ? 7 /* RefValue */ : "geoPointValue" in t ? 8 /* GeoPointValue */ : "arrayValue" in t ? 9 /* ArrayValue */ : "mapValue" in t ? Dt(t) ? 4 /* ServerTimestampValue */ : 
+    /** Returns true if the Value represents the canonical {@link #MAX_VALUE} . */
+    function(t) {
+        return "__max__" === (((t.mapValue || {}).fields || {}).__type__ || {}).stringValue;
+    }
+    /**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+    /**
+ * An ObjectValue represents a MapValue in the Firestore Proto and offers the
+ * ability to add and remove fields (via the ObjectValueBuilder).
+ */ (t) ? 9 /* ArrayValue */ : 10 /* ObjectValue */ : g();
 }
 
 /** Tests `left` and `right` for equality based on the backend semantics. */ function Ft(t, e) {
@@ -1666,6 +1693,7 @@ const At = new RegExp(/^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d(?:\.(\d+))?Z$/);
     if (n !== St(e)) return !1;
     switch (n) {
       case 0 /* NullValue */ :
+      case 9007199254740991 /* MaxValue */ :
         return !0;
 
       case 1 /* BooleanValue */ :
@@ -1736,6 +1764,7 @@ function qt(t, e) {
     if (n !== r) return yt(n, r);
     switch (n) {
       case 0 /* NullValue */ :
+      case 9007199254740991 /* MaxValue */ :
         return 0;
 
       case 1 /* BooleanValue */ :
@@ -1869,26 +1898,7 @@ function Ct(t, e) {
     return Object.assign({}, t);
 }
 
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * An ObjectValue represents a MapValue in the Firestore Proto and offers the
- * ability to add and remove fields (via the ObjectValueBuilder).
- */ class Bt {
+class Bt {
     constructor(t) {
         this.value = t;
     }
@@ -5961,7 +5971,7 @@ class Ur {
     return e && r._setSettings(e), r;
 }), "PUBLIC")), 
 // RUNTIME_ENV and BUILD_TARGET are replaced by real values during the compilation
-registerVersion("firestore-lite", "3.4.5", ""), registerVersion("firestore-lite", "3.4.5", "esm2017");
+registerVersion("firestore-lite", "3.4.6-2022216223411", ""), registerVersion("firestore-lite", "3.4.6-2022216223411", "esm2017");
 
 export { gn as Bytes, ln as CollectionReference, an as DocumentReference, Yn as DocumentSnapshot, yn as FieldPath, vn as FieldValue, rn as Firestore, U as FirestoreError, bn as GeoPoint, hn as Query, Zn as QueryConstraint, Hn as QueryDocumentSnapshot, Kn as QuerySnapshot, gt as Timestamp, Ur as Transaction, $r as WriteBatch, Ar as addDoc, Dr as arrayRemove, Vr as arrayUnion, fn as collection, dn as collectionGroup, un as connectFirestoreEmulator, Ir as deleteDoc, Rr as deleteField, wn as doc, _n as documentId, dr as endAt, fr as endBefore, vr as getDoc, br as getDocs, on as getFirestore, Nr as increment, sn as initializeFirestore, or as limit, ur as limitToLast, sr as orderBy, tr as query, pn as queryEqual, mn as refEqual, kr as runTransaction, Pr as serverTimestamp, Er as setDoc, w as setLogLevel, Jn as snapshotEqual, hr as startAfter, ar as startAt, cn as terminate, Tr as updateDoc, nr as where, Fr as writeBatch };
 //# sourceMappingURL=index.browser.esm2017.js.map