{"version":3,"sources":["webpack:///firebase-firestore.js","webpack:///./firestore/index.js","webpack:///../firestore/dist/esm/src/util/log.js","webpack:///../firestore/dist/esm/src/util/assert.js","webpack:///../firestore/dist/esm/src/platform/platform.js","webpack:///../firestore/dist/esm/src/util/api.js","webpack:///../firestore/dist/esm/src/util/obj.js","webpack:///../firestore/dist/esm/src/util/input_validation.js","webpack:///../firestore/dist/esm/src/util/misc.js","webpack:///../firestore/dist/esm/src/api/blob.js","webpack:///../firestore/dist/esm/src/model/field_value.js","webpack:///../firestore/dist/esm/src/util/types.js","webpack:///../firestore/dist/esm/src/core/query.js","webpack:///../firestore/dist/esm/src/remote/rpc_error.js","webpack:///../firestore/dist/esm/src/model/collections.js","webpack:///../firestore/dist/esm/src/remote/watch_change.js","webpack:///../firestore/dist/esm/src/remote/serializer.js","webpack:///../firestore/dist/esm/src/api/field_path.js","webpack:///../firestore/dist/esm/src/core/view.js","webpack:///../firestore/dist/esm/src/local/encoded_resource_path.js","webpack:///../firestore/dist/esm/src/local/indexeddb_schema.js","webpack:///../firestore/dist/esm/src/local/simple_db.js","webpack:///../firestore/dist/esm/src/local/indexeddb_mutation_queue.js","webpack:///../firestore/dist/esm/src/local/indexeddb_query_cache.js","webpack:///../firestore/dist/esm/src/local/indexeddb_remote_document_cache.js","webpack:///../firestore/dist/esm/src/local/local_serializer.js","webpack:///../firestore/dist/esm/src/api/credentials.js","webpack:///../firestore/dist/esm/src/api/observer.js","webpack:///../firestore/dist/esm/src/api/user_data_converter.js","webpack:///../firestore/dist/esm/src/api/database.js","webpack:///../firestore/dist/esm/src/platform/config.js","webpack:///../firestore/dist/esm/index.js","webpack:///../firestore/dist/esm/src/core/version.js","webpack:///../firestore/dist/esm/src/util/error.js","webpack:///../firestore/dist/esm/src/api/geo_point.js","webpack:///../firestore/dist/esm/src/core/database_info.js","webpack:///../firestore/dist/esm/src/model/path.js","webpack:///../firestore/dist/esm/src/model/document_key.js","webpack:///../firestore/dist/esm/src/model/document.js","webpack:///../firestore/dist/esm/src/util/sorted_map.js","webpack:///../firestore/dist/esm/src/local/query_data.js","webpack:///../firestore/dist/esm/src/core/timestamp.js","webpack:///../firestore/dist/esm/src/core/snapshot_version.js","webpack:///../firestore/dist/esm/src/model/mutation.js","webpack:///../firestore/dist/esm/src/remote/existence_filter.js","webpack:///../firestore/dist/esm/src/util/sorted_set.js","webpack:///../firestore/dist/esm/src/remote/remote_event.js","webpack:///../firestore/dist/esm/src/remote/stream_bridge.js","webpack:///../firestore/dist/esm/src/platform_browser/webchannel_connection.js","webpack:///../firestore/dist/esm/src/platform_browser/browser_platform.js","webpack:///../firestore/dist/esm/src/platform_browser/browser_init.js","webpack:///../firestore/dist/esm/src/core/types.js","webpack:///../firestore/dist/esm/src/core/view_snapshot.js","webpack:///../firestore/dist/esm/src/core/target_id_generator.js","webpack:///../firestore/dist/esm/src/model/document_set.js","webpack:///../firestore/dist/esm/src/util/obj_map.js","webpack:///../firestore/dist/esm/src/core/event_manager.js","webpack:///../firestore/dist/esm/src/local/persistence_promise.js","webpack:///../firestore/dist/esm/src/local/eager_garbage_collector.js","webpack:///../firestore/dist/esm/src/local/local_view_changes.js","webpack:///../firestore/dist/esm/src/local/reference_set.js","webpack:///../firestore/dist/esm/src/util/async_queue.js","webpack:///../firestore/dist/esm/src/core/sync_engine.js","webpack:///../firestore/dist/esm/src/model/mutation_batch.js","webpack:///../firestore/dist/esm/src/local/indexeddb_persistence.js","webpack:///../firestore/dist/esm/src/local/local_documents_view.js","webpack:///../firestore/dist/esm/src/local/remote_document_change_buffer.js","webpack:///../firestore/dist/esm/src/local/local_store.js","webpack:///../firestore/dist/esm/src/local/memory_mutation_queue.js","webpack:///../firestore/dist/esm/src/local/memory_query_cache.js","webpack:///../firestore/dist/esm/src/local/memory_remote_document_cache.js","webpack:///../firestore/dist/esm/src/local/memory_persistence.js","webpack:///../firestore/dist/esm/src/local/no_op_garbage_collector.js","webpack:///../firestore/dist/esm/src/util/promise.js","webpack:///../firestore/dist/esm/src/remote/persistent_stream.js","webpack:///../firestore/dist/esm/src/remote/backoff.js","webpack:///../firestore/dist/esm/src/remote/datastore.js","webpack:///../firestore/dist/esm/src/core/transaction.js","webpack:///../firestore/dist/esm/src/remote/remote_store.js","webpack:///../firestore/dist/esm/src/core/firestore_client.js","webpack:///../firestore/dist/esm/src/util/async_observer.js","webpack:///../firestore/dist/esm/src/auth/user.js","webpack:///../firestore/dist/esm/src/api/field_value.js","webpack:///../webchannel-wrapper/dist/index.js"],"names":["webpackJsonpFirebase","113","module","exports","__webpack_require__","114","__webpack_exports__","getLogLevel","logLevel","setLogLevel","newLevel","debug","tag","msg","obj","_i","arguments","length","LogLevel","DEBUG","time","Date","toISOString","args","map","argToString","console","log","apply","SDK_VERSION","concat","log_error","ERROR","error","platform","platform_PlatformSupport","getPlatform","formatJSON","e","fail","failure","message","Error","assert","assertion","emptyByteString","makeConstructorPrivate","cls","optionalMessage","PublicConstructor","FirestoreError","Code","INVALID_ARGUMENT","prototype","staticProperty","hasOwnProperty","contains","key","Object","call","defaulted","value","defaultValue","undefined","forEachNumber","fn","num","isNaN","forEach","isEmpty","shallowCopy","result","validateExactNumberOfArgs","functionName","numberOfArgs","formatPlural","validateAtLeastNumberOfArgs","minNumberOfArgs","validateBetweenNumberOfArgs","maxNumberOfArgs","validateNamedArrayAtLeastNumberOfElements","name","minNumberOfElements","Array","validateArgType","type","position","argument","validateType","ordinal","validateOptionalArgType","validateNamedType","optionName","validateNamedOptionalType","validateNamedPropertyEquals","inputName","input","expected","expectedDescription","expected_1","val","push","valueDescription","actualDescription","join","validateNamedOptionalPropertyEquals","isPlainObject","description","getPrototypeOf","substring","JSON","stringify","customObjectName","tryGetCustomObjectType","constructor","funcNameRegex","results","exec","validateDefined","validateOptionNames","options","optionNames","_","indexOf","invalidClassError","str","primitiveComparator","left","right","equals","isEqual","arrayEquals","i","immediatePredecessor","s","lastIndex","charAt","String","fromCharCode","charCodeAt","immediateSuccessor","assertUint8ArrayAvailable","Uint8Array","UNIMPLEMENTED","assertBase64Available","base64Available","numericComparator","numericEquals","isNullOrUndefined","isSafeInteger","isInteger","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","fieldFilter","field","op","NullValue","INSTANCE","query_RelationOp","EQUAL","NullFilter","DoubleValue","NAN","NanFilter","query_RelationFilter","isPermanentError","code","OK","CANCELLED","UNKNOWN","DEADLINE_EXCEEDED","RESOURCE_EXHAUSTED","INTERNAL","UNAVAILABLE","UNAUTHENTICATED","NOT_FOUND","ALREADY_EXISTS","PERMISSION_DENIED","FAILED_PRECONDITION","ABORTED","OUT_OF_RANGE","DATA_LOSS","mapCodeFromRpcStatus","status","RpcCode","mapCodeFromRpcCode","mapRpcCodeFromCode","mapCodeFromHttpStatus","maybeDocumentMap","EMPTY_MAYBE_DOCUMENT_MAP","documentMap","EMPTY_DOCUMENT_MAP","documentVersionMap","EMPTY_DOCUMENT_VERSION_MAP","documentKeySet","EMPTY_DOCUMENT_KEY_SET","applyResumeToken","change","resumeToken","assertPresent","parseInt64","hasTag","fromDotSeparatedString","path","search","RESERVED","field_path_FieldPath","bind","split","compareChangeType","c1","c2","order","ChangeType","Added","Modified","Metadata","Removed","encode","encodeSeparator","encodeSegment","get","segment","resultBuf","c","escapeChar","encodedNul","encodedEscape","encodedSeparatorChar","decode","path_ResourcePath","EMPTY_PATH","lastReasonableEscapeIndex","segments","segmentBuilder","start","end","currentPiece","createOrUpgradeDb","db","oldVersion","createObjectStore","DbMutationQueue","store","keyPath","DbMutationBatch","DbTargetDocument","createIndex","documentTargetsIndex","documentTargetsKeyPath","unique","DbTarget","queryTargetsIndexName","queryTargetsKeyPath","indexeddb_schema_DbDocumentMutation","DbRemoteDocument","DbOwner","DbTargetGlobal","wrapRequest","request","persistence_promise_PersistencePromise","resolve","reject","onsuccess","event","target","onerror","validateStreamToken","token","mutationsStore","txn","getStore","documentMutationsStore","mutationQueuesStore","simple_db_SimpleDbTransaction","targetsStore","indexeddb_query_cache_getStore","globalTargetStore","documentTargetStore","remoteDocumentsStore","dbKey","docKey","toArray","isDocumentQuery","dbQuery","documents","makeCredentialsProvider","credentials","credentials_EmptyCredentialsProvider","credentials_FirstPartyCredentialsProvider","client","sessionIndex","isPartialObserver","implementsAnyMethods","methods","object","methods_1","method","isWrite","dataSource","UserDataSource","Set","MergeSet","Update","QueryValue","looksLikeJsonObject","geo_point_GeoPoint","blob_Blob","DocumentKeyReference","FieldValueImpl","validatePlainObject","context","createError","fieldPathFromArgument","methodName","_internalPath","fieldPathFromDotSeparatedString","errorMessage","validateSetOptions","merge","validateSnapshotOptions","serverTimestamps","validateReference","documentRef","firestore","database_DocumentReference","changesFromSnapshot","snapshot","oldDocs","lastDoc_1","index_1","docChanges","doc","database_QueryDocumentSnapshot","fromCache","query","docComparator","oldIndex","newIndex","indexTracker_1","delete","add","resultChangeType","configureForFirebase","firebase","registerService","app","database_Firestore","firestoreNamespace","registerFirestore","instance","defineProperty","esm","PlatformSupport","setPlatform","__extends","this","extendStatics","setPrototypeOf","__proto__","d","b","p","__","create","_super","_this","toString","misc_AutoId","AutoId","newId","chars","autoId","Math","floor","random","Blob","binaryString","_binaryString","fromBase64String","base64","atob","fromUint8Array","array","char","toBase64","btoa","toUint8Array","buffer","other","_compareTo","PublicBlob","GeoPoint","latitude","longitude","isFinite","_lat","_long","enumerable","configurable","DatabaseInfo","databaseId","persistenceKey","host","ssl","DEFAULT_DATABASE_NAME","database_info_DatabaseId","DatabaseId","projectId","database","compareTo","path___extends","path_Path","Path","offset","init","len","construct","comparator","child","nameOrPath","slice","limit","popFirst","size","popLast","firstSegment","lastSegment","index","isPrefixOf","p1","p2","min","ResourcePath","canonicalString","fromString","filter","identifierRegExp","path_FieldPath","FieldPath","isValidIdentifier","test","replace","isKeyField","keyField","fromServerFormat","current","addCurrentSegment","inBackticks","next","document_key_DocumentKey","DocumentKey","isDocumentKey","k1","k2","fromSegments","fromPathString","EMPTY","document_Document","Document","version","data","hasLocalMutations","fieldValue","compareByKey","d1","d2","compareByField","v1","v2","document_NoDocument","NoDocument","SortedMap","root","sorted_map_LLRBNode","insert","copy","BLACK","remove","node","cmp","prunedNodes","minKey","maxKey","inorderTraversal","action","k","v","reverseTraversal","getIterator","sorted_map_SortedMapIterator","getIteratorFrom","getReverseIterator","getReverseIteratorFrom","SortedMapIterator","startKey","isReverse","nodeStack","getNext","pop","hasNext","peek","LLRBNode","color","RED","n","fixUp","removeMin","isRed","moveRedLeft","smallest","rotateRight","moveRedRight","rotateLeft","colorFlip","nl","nr","checkMaxDepth","blackDepth","check","pow","LLRBEmptyNode","TypeOrder","field_value___extends","ServerTimestampBehavior","QueryPurpose","field_value_FieldValueOptions","FieldValueOptions","serverTimestampBehavior","fromSnapshotOptions","Estimate","Previous","defaultOptions","Default","field_value_FieldValue","FieldValue","defaultCompareTo","typeOrder","internalValue","field_value_BooleanValue","BooleanValue","of","TRUE","FALSE","NumberValue","IntegerValue","NaN","POSITIVE_INFINITY","Infinity","NEGATIVE_INFINITY","field_value_StringValue","StringValue","TimestampValue","toDate","ServerTimestampValue","localWriteTime","previousValue","BlobValue","field_value_RefValue","RefValue","GeoPointValue","field_value_ObjectValue","ObjectValue","it1","it2","next1","next2","set","to","setChild","newChild","pathSegment","childName","field_value_ArrayValue","ArrayValue","minLength","NumberAsAny","Number","query_Query","Query","explicitOrderBy","filters","startAt","endAt","memoizedCanonicalId","memoizedOrderBy","assertValidBound","atPath","inequalityField","getInequalityFilterField","firstOrderByField","getFirstOrderByField","KEY_ORDERING_ASC","query_OrderBy","foundKeyOrdering","_a","orderBy","lastDirection","dir","Direction","ASCENDING","KEY_ORDERING_DESC","addFilter","isInequality","newFilters","addOrderBy","newOrderBy","withLimit","withStartAt","bound","withEndAt","canonicalId","_b","_c","comparedOnKeyField","comp","compare","matches","matchesAncestor","matchesOrderBy","matchesFilters","matchesBounds","hasLimit","docPath","sortsBeforeDocument","RelationOp","LESS_THAN","LESS_THAN_OR_EQUAL","GREATER_THAN_OR_EQUAL","GREATER_THAN","RelationFilter","refValue","comparison","matchesComparison","matchesValue","DESCENDING","query_Bound","Bound","before","component","orderByComponent","docValue","thisPosition","otherPosition","OrderBy","isKeyOrderBy","isoRegExp","RegExp","timestamp_Timestamp","Timestamp","seconds","nanos","now","fromEpochMilliseconds","fromDate","date","getTime","milliseconds","fromISOString","utc","fraction","nanoStr","substr","toEpochMilliseconds","snapshot_version_SnapshotVersion","SnapshotVersion","timestamp","fromMicroseconds","fromTimestamp","forDeletedDoc","MIN","toMicroseconds","toTimestamp","MutationType","query_data_QueryData","QueryData","targetId","purpose","snapshotVersion","update","updated","mutation___extends","mutation_FieldMask","FieldMask","fields","ServerTimestampTransform","FieldTransform","transform","MutationResult","transformResults","mutation_Precondition","Precondition","updateTime","exists","isValidFor","maybeDoc","isNone","NONE","mutation_Mutation","Mutation","verifyKeyMatches","getPostMutationVersion","mutation_SetMutation","SetMutation","precondition","applyToRemoteDocument","mutationResult","applyToLocalView","baseDoc","mutation_PatchMutation","PatchMutation","fieldMask","Patch","newData","patchDocument","patchObject","fieldPath","newValue","mutation_TransformMutation","TransformMutation","fieldTransforms","Transform","requireDocument","transformObject","localTransformResults","fieldTransform","mutation_DeleteMutation","DeleteMutation","Delete","ExistenceFilter","count","CurrentStatusUpdate","sorted_set_SortedSet","SortedSet","fromMapKeys","keys","has","elem","first","last","cb","forEachInRange","range","iter","forEachWhile","firstAfterOrEqual","unionWith","thisIt","otherIt","thisElem","otherElem","remote_event_RemoteEvent","RemoteEvent","targetChanges","documentUpdates","addDocumentUpdate","handleExistenceFilterMismatch","mapping","ResetMapping","currentStatusUpdate","MarkNotCurrent","WatchTargetChangeState","EMPTY_KEY_SET","docs","UpdateMapping","addedDocuments","removedDocuments","applyToKeySet","DocumentWatchChange","updatedTargetIds","removedTargetIds","newDoc","ExistenceFilterChange","existenceFilter","watch_change_WatchTargetChange","WatchTargetChange","state","targetIds","cause","watch_change_WatchChangeAggregator","WatchChangeAggregator","listenTargets","pendingTargetResponses","existenceFilters","frozen","watchChange","addDocumentChange","addTargetChange","addExistenceFilterChange","addChanges","watchChanges","createRemoteEvent","isActiveTarget","ensureTargetChange","None","docChange","relevant","targetChange","NoChange","recordTargetResponse","Current","MarkCurrent","Reset","newCount","DIRECTIONS","dirs","OPERATORS","ops","serializer_JsonProtoSerializer","JsonProtoSerializer","useProto3Json","unsafeCastProtoByteString","byteString","fromRpcStatus","toInt32Value","fromInt32Value","toBytes","bytes","fromBlob","blob","toVersion","fromVersion","toResourceName","fullyQualifiedPrefixPath","fromResourceName","resource","isValidResourceName","toName","fromName","extractLocalPathFromResourceName","toQueryPath","encodedDatabaseId","fromQueryPath","resourceName","toValue","nullValue","booleanValue","integerValue","doubleValue","stringValue","mapValue","toMapValue","arrayValue","toArrayValue","timestampValue","geoPointValue","bytesValue","referenceValue","fromValue","fromFields","values","dbId","toMutationDocument","toFields","toDocument","document","fromDocument","fromFound","found","fromMissing","missing","readTime","fromMaybeDocument","toWatchTargetChangeState","toTestWatchChange","documentChange","documentDelete","documentRemove","targetChangeType","fromWatchChange","fromWatchTargetChangeState","causeProto","entityChange","docDelete","docRemove","versionFromListenResponse","toMutation","mutation","updateMask","toDocumentMask","toFieldTransform","currentDocument","toPrecondition","fromMutation","proto","fromPrecondition","fromDocumentMask","fromFieldTransform","fromWriteResult","fromWriteResults","protos","setToServerValue","toDocumentsTarget","fromDocumentsTarget","documentsTarget","toQueryTarget","structuredQuery","parent","from","collectionId","where","toFilter","toOrder","toCursor","fromQueryTarget","fromCount","filterBy","fromFilter","fromOrder","fromCursor","toListenRequestLabels","queryData","toLabel","goog-listen-tags","Listen","ExistenceFilterMismatch","LimboResolution","toTarget","toRelationFilter","toUnaryFilter","compositeFilter","unaryFilter","fromUnaryFilter","fromRelationFilter","f","reduce","accum","orderBys","toPropertyOrder","fromPropertyOrder","cursor","toDirection","fromDirection","toOperatorName","fromOperatorName","toFieldPathReference","fromFieldPathReference","fieldReference","direction","nanField","nullField","fieldPaths","paths","dist","stream_bridge_StreamBridge","StreamBridge","sendFn","closeFn","onOpen","callback","wrappedOnOpen","onClose","wrappedOnClose","onMessage","wrappedOnMessage","close","send","callOnOpen","callOnClose","err","callOnMessage","LOG_TAG","RPC_NAME_REST_MAPPING","BatchGetDocuments","Commit","X_GOOG_API_CLIENT_VALUE","webchannel_connection_WebChannelConnection","WebChannelConnection","info","pool","baseUrl","modifyHeadersForRequest","headers","header","authHeaders","invokeRPC","rpcName","url","makeUrl","Promise","getObject","xhr","listenOnce","COMPLETE","getLastErrorCode","NO_ERROR","json","getResponseJson","TIMEOUT","HTTP_ERROR","status_1","getStatus","getResponseText","getStatusText","getLastError","releaseObject","requestString","Content-Type","invokeStreamingRPC","openStream","urlParts","webchannelTransport","backgroundChannelTest","httpSessionIdParam","initMessageHeaders","httpHeadersOverwriteParam","sendRawJson","supportsCrossDomainXhr","channel","createWebChannel","opened","closed","streamBridge","open","unguardedEventListen","listen","param","setTimeout","EventType","OPEN","CLOSE","MESSAGE","msgData","status_2","urlRpcName","browser_platform_BrowserPlatform","BrowserPlatform","loadConnection","databaseInfo","newSerializer","encoded","raw","OnlineState","fieldNames","documentId","_DOCUMENT_ID","SyncState","GeneratorIds","view_snapshot_DocumentChangeSet","DocumentChangeSet","changeMap","track","oldChange","getChanges","changes","ViewSnapshot","hasPendingWrites","syncStateChanged","otherChanges","document_set_DocumentSet","DocumentSet","keyedMap","sortedSet","emptySet","oldSet","thisDoc","otherDoc","docStrings","newSet","obj_map_ObjectMap","ObjectMap","mapKeyFn","inner","id","matches_1","otherKey","splice","entries","entries_1","QueryListenersInfo","listeners","event_manager_EventManager","EventManager","syncEngine","queries","q","onlineState","Unknown","subscribe","onChange","onError","listener","firstListen","queryInfo","applyOnlineStateChange","viewSnap","onViewSnapshot","then","unlisten","lastListen","viewSnaps","viewSnaps_1","event_manager_QueryListener","QueryListener","queryObserver","raisedInitialEvent","snap","includeDocumentMetadataChanges","shouldRaiseEvent","shouldRaiseInitialEvent","raiseInitialEvent","maybeOnline","Failed","waitForSyncWhenOnline","hasPendingWritesChanged","includeQueryMetadataChanges","getInitialViewChanges","PersistencePromise","nextCallback","catchCallback","isDone","callbackAttached","catch","nextFn","catchFn","wrapFailure","wrapSuccess","toPromise","wrapUserFunction","waitFor","all","promise","nextPromise","idx","initial","eager_garbage_collector_EagerGarbageCollector","EagerGarbageCollector","isEager","sources","potentialGarbage","addGarbageSource","garbageSource","setGarbageCollector","removeGarbageSource","addPotentialGarbageKey","collectGarbage","promises","garbageKeys","hasRefsPromise","documentHasAnyReferences","hasRefs","source","containsKey","local_view_changes_LocalViewChanges","LocalViewChanges","addedKeys","removedKeys","fromSnapshot","viewSnapshot","reference_set_ReferenceSet","ReferenceSet","refsByKey","reference_set_DocReference","refsByTarget","compareByTargetId","garbageCollector","addReference","ref","addReferences","removeReference","removeRef","removeReferences","removeReferencesForId","emptyKey","startRef","endRef","removeAllReferences","referencesForId","firstRef","DocReference","targetOrBatchId","RESERVED_BITS","TimerId","TargetIdGenerator","generatorId","initAfter","afterWithoutGenerator","afterGenerator","previousId","forLocalStore","LocalStore","forSyncEngine","SyncEngine","AddedLimboDocument","RemovedLimboDocument","view_View","View","syncedDocuments","syncState","limboDocuments","mutatedKeys","documentSet","computeDocChanges","previousChanges","changeSet","oldDocumentSet","newMutatedKeys","newDocumentSet","needsRefill","lastDocInLimit","newMaybeDoc","oldDoc","docsEqual","applyChanges","sort","applyTargetChange","limboChanges","updateLimboDocuments","synced","newSyncState","Synced","Local","shouldBeInLimbo","targetMapping","oldLimboDocuments","QueryView","view","sync_engine_SyncEngine","localStore","remoteStore","currentUser","viewHandler","errorHandler","queryViewsByQuery","queryViewsByTarget","limboTargetsByKey","limboKeysByTarget","limboDocumentRefs","limboCollector","mutationUserCallbacks","targetIdGenerator","assertSubscribed","allocateQuery","executeQuery","remoteDocumentKeys","remoteKeys","viewDocChanges","viewChange","queryView","releaseQuery","removeAndCleanupQuery","write","batch","userCallback","localWrite","addMutationCallback","batchId","emitNewSnapsAndNotifyLocalStore","fillWritePipeline","wrapUpdateFunctionError","runTransaction","updateFunction","retries","transaction","createTransaction","userPromise","commit","applyRemoteEvent","remoteEvent","limboKey","newViewSnapshots","rejectListen","docMap","event_1","queryView_1","applySuccessfulWrite","mutationBatchResult","processUserCallback","acknowledgeBatch","rejectFailedWrite","rejectBatch","newCallbacks","toKey","gcLimboDocuments","updateTrackedLimbos","limboChanges_1","limboChange","trackLimboChange","limboTargetId","currentLimboDocs","newSnaps","docChangesInAllViews","queriesProcessed","notifyLocalViewChanges","fnName","handleUserChange","user","BATCHID_UNKNOWN","mutation_batch_MutationBatch","MutationBatch","mutations","batchResult","mutationResults","keySet","isTombstone","toTombstone","mutation_batch_MutationBatchResult","MutationBatchResult","commitVersion","streamToken","docVersions","versionMap","DbTimestamp","ownerId","leaseTimestampMs","userId","lastAcknowledgedBatchId","lastStreamToken","localWriteTimeMs","DbDocumentMutation","prefixForUser","prefixForPath","PLACEHOLDER","DbNoDocument","noDocument","lastListenSequenceNumber","highestTargetId","highestListenSequenceNumber","lastRemoteSnapshotVersion","ALL_STORES","simple_db_SimpleDb","SimpleDb","openOrCreate","runUpgrade","isAvailable","window","indexedDB","onupgradeneeded","deleteDatabase","ua","navigator","userAgent","mode","objectStores","transactionFn","transactionFnResult","abort","completionPromise","IterationController","dbCursor","shouldStop","nextKey","done","skip","SimpleDbTransaction","objectStoresNames","aborted","onabort","oncomplete","storeName","objectStore","simple_db_SimpleDbStore","SimpleDbStore","put","keyOrValue","loadAll","indexOrRange","iterateCursor","deleteAll","keysOnly","control","iterate","optionsOrCallback","cursorRequest","controller","userResult","primaryKey","skipToKey","continue","indexName","reverse","openKeyCursor","openCursor","indexeddb_mutation_queue_IndexedDbMutationQueue","IndexedDbMutationQueue","serializer","forUser","uid","isAuthenticated","loadNextBatchIdFromDb","nextBatchId","metadata","checkEmpty","empty","maxBatchId","nextUser","IDBKeyRange","keyForBatchId","getNextBatchId","getHighestAcknowledgedBatchId","getLastStreamToken","setLastStreamToken","addMutationBatch","dbBatch","toDbMutationBatch","mutations_1","indexKey","lookupMutationBatch","fromDbMutationBatch","getNextMutationBatchAfterBatchId","lowerBound","foundBatch","getAllMutationBatches","dbBatches","getAllMutationBatchesThroughBatchId","getAllMutationBatchesAffectingDocumentKey","documentKey","indexPrefix","indexStart","userID","encodedPath","batchID","mutationKey","getAllMutationBatchesAffectingQuery","queryPath","immediateChildrenLength","uniqueBatchIDs","removeMutationBatches","batches","indexTxn","this_1","batches_1","only","numDeleted","removePromise","performConsistencyCheck","startRange","danglingMutationReferences","gc","indexeddb_query_cache_IndexedDbQueryCache","IndexedDbQueryCache","lastSavedVersion","getHighestTargetId","getLastRemoteSnapshotVersion","setLastRemoteSnapshotVersion","addQueryData","addedQueryPromise","toDbTarget","removeQueryData","removeMatchingKeysForTargetId","getQueryData","fromDbTarget","addMatchingKeys","removeMatchingKeys","notifyGCForRemovedKeys","getMatchingKeysForTargetId","indexeddb_remote_document_cache_IndexedDbRemoteDocumentCache","IndexedDbRemoteDocumentCache","addEntry","maybeDocument","toDbRemoteDocument","removeEntry","getEntry","dbRemoteDoc","fromDbRemoteDocument","getDocumentsMatchingQuery","local_serializer_LocalSerializer","LocalSerializer","remoteSerializer","remoteDoc","serializedMutations","m","dbTarget","queryProto","dbTimestamp","EXISTING_OWNER_ERROR_MSG","indexeddb_persistence_IndexedDbPersistence","IndexedDbPersistence","prefix","generateOwnerId","dbName","MAIN_DATABASE","localStoragePrefix","started","simpleDb","tryAcquireOwnerLease","scheduleOwnerLeaseRefreshes","attachWindowUnloadHook","persistenceError","shutdown","detachWindowUnloadHook","stopOwnerLeaseRefreshes","releaseOwnerLease","getMutationQueue","getQueryCache","getRemoteDocumentCache","operation","ensureOwnerLease","buildStoragePrefix","isDefaultDatabase","dbOwner","validOwner","newDbOwner","minAcceptable","maxAcceptable","getZombiedOwnerId","ownerLeaseRefreshHandle","setInterval","reason","clearInterval","windowUnloadHandler","setZombiedOwnerId","addEventListener","removeEventListener","zombiedOwnerId","localStorage","getItem","zombiedOwnerLocalStorageKey","zombieOwnerId","removeItem","setItem","local_documents_view_LocalDocumentsView","LocalDocumentsView","remoteDocumentCache","mutationQueue","getDocument","computeLocalDocument","getDocuments","getDocumentsMatchingDocumentQuery","getDocumentsMatchingCollectionQuery","queryResults","computeLocalDocuments","promisedResults","matchingMutationBatches","matchingKeys","matchingMutationBatches_1","mutatedDoc","remote_document_change_buffer_RemoteDocumentChangeBuffer","RemoteDocumentChangeBuffer","assertChanges","bufferedEntry","local_store_LocalStore","persistence","initialUser","localViewReferences","heldBatchResults","remoteDocuments","queryCache","localDocuments","startMutationQueue","startQueryCache","oldBatches","promisedOldBatches","newBatches","changedKeys","_d","highestAck","ackedBatches","promisedBatch","changedDocuments","affected","shouldHoldBatchResult","documentBuffer_1","releaseBatchResults","promisedAffectedKeys","toReject","affectedKeys","promisedToReject","lastAcked","removeMutationBatch","documentBuffer","changedDocKeys","existingDoc","lastRemoteVersion","remoteVersion","releasedWriteKeys","releaseHeldBatchResults","promisedReleasedWriteKeys","viewChanges","viewChanges_1","nextMutationBatch","afterBatchId","readDocument","cached","documentBuffer_2","garbage","toRelease","isRemoteUpToVersion","batchResults","promiseChain","batchResults_1","applyWriteToRemoteDocuments","affectedDocs","batches_2","docKeys","ackVersion","memory_mutation_queue_MemoryMutationQueue","MemoryMutationQueue","highestAcknowledgedBatchId","batchesByDocumentKey","batchIndex","indexOfExistingBatchId","findMutationBatch","max","rawIndex","indexOfBatchId","getAllLiveMutationBatchesBeforeIndex","endIndex","immediateChildrenPathLength","startPath","rowKeyPath","batchCount","firstBatchId","queueCount","startIndex","queueIndex","length_1","references","memory_query_cache_MemoryQueryCache","MemoryQueryCache","memory_remote_document_cache_MemoryRemoteDocumentCache","MemoryRemoteDocumentCache","iterator","memory_persistence_MemoryPersistence","MemoryPersistence","mutationQueues","queue","MemoryPersistenceTransaction","no_op_garbage_collector_NoOpGarbageCollector","NoOpGarbageCollector","Deferred","PersistentStreamState","async_queue_DelayedOperation","DelayedOperation","asyncQueue","timerId","targetTimeMs","removalCallback","deferred","createAndSchedule","delayMs","targetTime","delayedOp","timerHandle","handleDelayElapsed","skipDelay","cancel","clearTimeout","enqueue","async_queue_AsyncQueue","AsyncQueue","tail","delayedOperations","operationInProgress","verifyNotFailed","newTail","stack","enqueueAfterDelay","containsDelayedOperation","removeDelayedOperation","verifyOperationInProgress","drain","findIndex","runDelayedOperationsEarly","lastTimerId","a","backoff_ExponentialBackoff","ExponentialBackoff","initialDelayMs","backoffFactor","maxDelayMs","timerPromise","reset","currentBaseMs","resetToMax","backoffAndRun","delayWithJitterMs","jitterDelayMs","persistent_stream___extends","BACKOFF_INITIAL_DELAY_MS","BACKOFF_MAX_DELAY_MS","BACKOFF_FACTOR","persistent_stream_PersistentStream","PersistentStream","connectionTimerId","idleTimerId","connection","credentialsProvider","inactivityTimerPromise","stream","backoff","Initial","isStarted","Backoff","Auth","Open","isOpen","performBackoff","auth","stop","Stopped","inhibitBackoff","markIdle","handleIdleCloseTimer","sendRequest","cancelIdleCheck","finalState","tearDown","getToken","startStream","rpcError","handleStreamClose","dispatchIfStillActive","currentStream_1","startRpc","persistent_stream_PersistentListenStream","PersistentListenStream","ListenStreamConnection","ListenStreamIdle","watchChangeProto","onWatchChange","watch","addTarget","labels","unwatch","removeTarget","persistent_stream_PersistentWriteStream","PersistentWriteStream","WriteStreamConnection","WriteStreamIdle","handshakeComplete_","writeMutations","responseProto","writeResults","commitTime","onMutationResult","onHandshakeComplete","writeHandshake","writes","datastore_Datastore","Datastore","newPersistentWriteStream","newPersistentWatchStream","params","response","lookup","transaction_Transaction","Transaction","datastore","readVersions","committed","recordVersion","docVersion","existingVersion","preconditionForUpdate","toMutations","unwritten","remote_store_RemoteStore","RemoteStore","onlineStateHandler","pendingWrites","lastBatchSeen","accumulatedWatchChanges","watchStream","writeStream","watchStreamOnlineState","watchStreamFailures","shouldWarnOffline","enableNetwork","updateOnlineState","newState","Healthy","updateOnlineStateAfterFailure","isNetworkEnabled","shouldStartWatchStream","startWatchStream","disableNetwork","disableNetworkInternal","cleanUpWatchStreamState","cleanUpWriteStreamState","sendWatchRequest","sendUnwatchRequest","recordPendingTargetRequest","onWatchStreamOpen","onWatchStreamClose","onWatchStreamChange","handleTargetError","handleWatchChangeBatch","aggregator","deletedDoc","trackedRemote","newQueryData","requestQueryData","canWriteMutations","outstandingWrites","shouldStartWriteStream","startWriteStream","handshakeComplete","onWriteStreamOpen","onWriteStreamClose","onWriteHandshakeComplete","shift","success","errorHandling","handleWriteError","handleHandshakeError","firestore_client_FirestoreClient","FirestoreClient","usePersistence","initializationDone","persistenceResult","initialized","setUserChangeListener","initializePersistence","initializeRest","startIndexedDbPersistence","canFallback","warn","startMemoryPersistence","storagePrefix","onlineStateChangedHandler","eventMgr","removeUserChangeListener","observer","AsyncObserver","muted","scheduleEvent","mute","eventHandler","User","otherUser","GOOGLE_CREDENTIALS","FIRST_PARTY","OAuthToken","Authorization","EmptyCredentialsProvider","userListener","forceRefresh","credentials_FirebaseCredentialsProvider","FirebaseCredentialsProvider","tokenListener","userCounter","newUser","getUser","addAuthTokenListener","initialUserCounter","tokenData","accessToken","removeAuthTokenListener","getUid","currentUid","credentials_FirstPartyToken","FirstPartyToken","gapi","X-Goog-AuthUser","FirstPartyCredentialsProvider","api_field_value___extends","DeleteFieldValueImpl","serverTimestamp","ServerTimestampFieldValueImpl","PublicFieldValue","RESERVED_FIELD_REGEX","user_data_converter_ParsedSetData","ParsedSetData","user_data_converter_ParsedUpdateData","ParsedUpdateData","user_data_converter_ParseContext","ParseContext","arrayElement","validatePath","childContextForField","childPath","validatePathSegment","childContextForFieldPath","childContextForArray","fieldDescription","user_data_converter_UserDataConverter","UserDataConverter","preConverter","parseSetData","updateData","parseData","parseMergeData","parseUpdateData","fieldMaskPaths","childContext","runPreConverter","parsedValue","mask","parseUpdateVarargs","moreFieldsAndValues","value_1","parseQueryValue","parsed","parseArray","parseObject","parseScalarValue","entryIndex","array_1","entry","parsedEntry","database___extends","DEFAULT_HOST","DEFAULT_SSL","database_FirestoreSettings","FirestoreSettings","settings","FirestoreConfig","Firestore","databaseIdOrApp","_queue","_firestoreClient","config","firebaseApp","databaseIdFromApp","external_1","_config","_databaseId","settingsLiteral","newSettings","ensureClientConfigured","enablePersistence","configureClient","thisDb","otherDb","_key","_dataConverter","collection","pathString","database_CollectionReference","forPath","database_Transaction","database_WriteBatch","SILENT","level","_firestore","_transaction","database_DocumentSnapshot","fieldOrUpdateData","WriteBatch","_mutations","_committed","verifyNotCommitted","DocumentReference","onSnapshot","includeMetadataChanges","currArg","internalOptions","complete","onSnapshotInternal","errHandler","asyncObserver","internalListener","SnapshotMetadata","DocumentSnapshot","_document","_fromCache","convertObject","convertValue","convertArray","QueryDocumentSnapshot","database_Query","_query","opStr","validateNewFilter","directionStr","validateNewOrderBy","docOrField","boundFromDocOrFields","startAfter","endBefore","boundFromDocument","allFields","boundFromFields","components","rawValue","wrapped","database_QuerySnapshot","firestoreClient","existingField","validateOrderByAndInequalityMatch","inequality","QuerySnapshot","_originalQuery","_snapshot","_cachedChanges","thisArg","convertToDocumentImpl","CollectionReference","parentPath","docRef","PublicFirestore","PublicTransaction","PublicWriteBatch","PublicDocumentReference","PublicDocumentSnapshot","PublicQueryDocumentSnapshot","PublicQuery","PublicQuerySnapshot","PublicCollectionReference","115","global","l","aa","ba","propertyIsEnumerable","ca","da","ea","ha","ia","unshift","Function","ja","t","H","Db","ka","captureStackTrace","la","ma","u","na","pa","fa","sa","ta","va","wa","xa","za","x","w","Ca","Da","Ea","Fa","Ha","Ga","Ia","Ja","Ka","Qa","documentMode","Va","ya","Ra","h","parseInt","z","bb","relatedTarget","button","screenY","screenX","clientY","clientX","metaKey","shiftKey","altKey","ctrlKey","pointerId","pointerType","changedTouches","srcElement","Oa","nodeName","fromElement","toElement","pageX","pageY","defaultPrevented","fb","proxy","src","capture","ga","eb","Z","gb","hb","jb","qa","ib","nb","once","ob","pb","qb","rb","kb","sb","ab","attachEvent","tb","addListener","removeListener","mb","ub","Za","vb","wb","detachEvent","lb","xb","yb","keyCode","returnValue","parentNode","zb","handleEvent","A","N","J","Ab","Bb","Cb","eval","Eb","Fb","Boolean","Gb","valueOf","Ib","Hb","Jb","Kb","Ob","Pb","Mb","Qb","Sb","MessageChannel","postMessage","createElement","style","display","documentElement","appendChild","contentWindow","location","protocol","origin","port1","onmessage","port2","onreadystatechange","removeChild","Ub","Tb","Vb","setImmediate","Window","Rb","Nb","Wb","Xb","g","r","Yb","O","Zb","$b","ac","Y","bc","dc","cc","ec","fc","hc","B","nc","qc","pc","oc","lc","lastIndexOf","C","jc","rc","kc","D","mc","sc","tc","E","I","W","Lb","uc","F","vc","wc","G","xc","ic","parse","yc","zc","dispatchEvent","Ac","K","Bc","Cc","Dc","Gc","Ic","Jc","Kc","Lc","Mc","Oc","Pc","ActiveXObject","XMLHttpRequest","L","T","R","Qc","Na","S","j","U","o","X","Rc","Uc","Vc","M","Wc","Xc","Yc","Zc","$c","V","ad","bd","cd","dd","ed","fd","gd","hd","Tc","Sc","jd","$","kd","ld","ra","nd","od","P","md","qd","decodeURIComponent","Q","rd","sd","td","ud","vd","match","pd","wd","xd","Dd","yd","Ed","Fd","abs","Gd","Hd","decodeURI","encodeURI","Id","Kd","Jd","Ld","toLowerCase","Md","Od","Nd","Pd","Qd","Rd","Sd","Td","Vd","Wd","Xd","Yd","Zd","$d","oa","La","ae","be","ce","de","ee","fe","ge","he","ie","je","encodeURIComponent","ke","Image","onload","le","ontimeout","me","re","y","timeout","pe","se","te","ue","goog","Ma","self","ne","qe","readyState","getResponseHeader","ve","we","xe","Ua","concurrentRequestLimit","fastHandshake","ye","ze","Ae","sendBeacon","Be","Ce","De","Ee","Pa","Fe","Ge","Ie","He","round","Wa","Je","Ke","Le","Ud","Aa","Me","hostname","port","Ne","Oe","Pe","testUrl","messageUrlParams","messageHeaders","clientProtocolHeaderRequired","X-Client-Protocol","messageContentType","X-WebChannel-Content-Type","X-WebChannel-Client-Profile","Qe","Re","__sm__","Se","Ue","Ve","We","Xe","Ye","$e","Ze","af","bf","cf","df","trim","Ba","Sa","Ta","parseFloat","Xa","compatMode","Ya","freeze","$a","2","3","4","preventDefault","\"","\\","/","\b","\f","\n","\r","\t","\u000b","Ec","Fc","Hc","Nc","zd","Ad","Bd","Cd","oe","toUpperCase","FormData","setRequestHeader","responseType","withCredentials","statusText","responseText","__data__","Te","createWebChannelTransport","ErrorCode","WebChannel","XhrIoPool"],"mappings":";;;;;AAKA,IACQA,sBAAsB,IAExBC,IACA,SAAUC,EAAQC,EAASC,GCOjCA,EAAA,MDgBMC,IACA,SAAUH,EAAQI,EAAqBF,GAE7C,YETA,SAAAG,KACA,MAAAC,IAEA,QAAAC,GAAAC,GACAF,GAAAE,EAEA,QAAAC,GAAAC,EAAAC,GAEA,OADAC,MACAC,EAAA,EAAoBA,EAAAC,UAAAC,OAAuBF,IAC3CD,EAAAC,EAAA,GAAAC,UAAAD,EAEA,IAAAP,IAAAU,GAAAC,MAAA,CACA,GAAAC,IAAA,GAAAC,OAAAC,cACAC,EAAAT,EAAAU,IAAAC,EACAC,SAAAC,IAAAC,MAAAF,SAAA,cAAAG,GAAA,KAAAT,EAAA,KAAAR,EAAA,MAAAC,GAAAiB,OAAAP,KAGA,QAAAQ,GAAAlB,GAEA,OADAC,MACAC,EAAA,EAAoBA,EAAAC,UAAAC,OAAuBF,IAC3CD,EAAAC,EAAA,GAAAC,UAAAD,EAEA,IAAAP,IAAAU,GAAAc,MAAA,CACA,GAAAZ,IAAA,GAAAC,OAAAC,cACAC,EAAAT,EAAAU,IAAAC,EACAC,SAAAO,MAAAL,MAAAF,SAAA,cAAAG,GAAA,KAAAT,EAAA,KAAAP,GAAAiB,OAAAP,KAMA,QAAAE,GAAAX,GACA,mBAAAA,GACA,MAAAA,EAGA,IAAAoB,GAAAC,GAAAC,aACA,KACA,MAAAF,GAAAG,WAAAvB,GAEA,MAAAwB,GAEA,MAAAxB,IC5CA,QAAAyB,GAAAC,GAGA,GAAAC,GAAA,cAAAZ,GAAA,gCAAAW,CAKA,MAJAT,GAAAU,GAIAC,MAAAD,GAMA,QAAAE,GAAAC,EAAAH,GACAG,GACAL,EAAAE,GCGA,QAAAI,KACA,MAAAV,IAAAC,cAAAS,gBCfA,QAAAC,GAAAC,EAAAC,GACA,QAAAC,KACA,GAAAhB,GAAA,8BAKA,MAJAe,KACAf,GAAA,IACAA,GAAAe,GAEA,GAAAE,IAAAC,GAAAC,iBAAAnB,GAIAgB,EAAAI,UAAAN,EAAAM,SAEA,QAAAC,KAAAP,GACAA,EAAAQ,eAAAD,KACAL,EAAAK,GAAAP,EAAAO,GAGA,OAAAL,GC/BA,QAAAO,GAAA1C,EAAA2C,GACA,MAAAC,QAAAL,UAAAE,eAAAI,KAAA7C,EAAA2C,GAeA,QAAAG,GAAAC,EAAAC,GACA,WAAAC,KAAAF,IAAAC,EAEA,QAAAE,GAAAlD,EAAAmD,GACA,OAAAR,KAAA3C,GACA,GAAA4C,OAAAL,UAAAE,eAAAI,KAAA7C,EAAA2C,GAAA,CACA,GAAAS,IAAAT,CACAU,OAAAD,IACAD,EAAAC,EAAApD,EAAA2C,KAKA,QAAAW,GAAAtD,EAAAmD,GACA,OAAAR,KAAA3C,GACA4C,OAAAL,UAAAE,eAAAI,KAAA7C,EAAA2C,IACAQ,EAAAR,EAAA3C,EAAA2C,IAUA,QAAAY,GAAAvD,GACA6B,EAAA,MAAA7B,GAAA,gBAAAA,GAAA,sCACA,QAAA2C,KAAA3C,GACA,GAAA4C,OAAAL,UAAAE,eAAAI,KAAA7C,EAAA2C,GACA,QAGA,UAEA,QAAAa,GAAAxD,GACA6B,EAAA7B,GAAA,gBAAAA,GAAA,0CACA,IAAAyD,KACA,QAAAd,KAAA3C,GACA4C,OAAAL,UAAAE,eAAAI,KAAA7C,EAAA2C,KACAc,EAAAd,GAAA3C,EAAA2C,GAGA,OAAAc,GClDA,QAAAC,GAAAC,EAAAlD,EAAAmD,GACA,GAAAnD,EAAAN,SAAAyD,EACA,SAAAxB,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,eACAE,EAAAD,EAAA,YACA,yBACAC,EAAApD,EAAAN,OAAA,YACA,KAWA,QAAA2D,GAAAH,EAAAlD,EAAAsD,GACA,GAAAtD,EAAAN,OAAA4D,EACA,SAAA3B,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,wBACAE,EAAAE,EAAA,YACA,yBACAF,EAAApD,EAAAN,OAAA,YACA,KAWA,QAAA6D,GAAAL,EAAAlD,EAAAsD,EAAAE,GACA,GAAAxD,EAAAN,OAAA4D,GAAAtD,EAAAN,OAAA8D,EACA,SAAA7B,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,uBAAAI,EAAA,QACAE,EAAA,mCACAJ,EAAApD,EAAAN,OAAA,YACA,KAOA,QAAA+D,GAAAP,EAAAZ,EAAAoB,EAAAC,GACA,KAAArB,YAAAsB,SAAAtB,EAAA5C,OAAAiE,EACA,SAAAhC,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,mBAAAQ,EAAA,0CAEAN,EAAAO,EAAA,gBAOA,QAAAE,GAAAX,EAAAY,EAAAC,EAAAC,GACAC,EAAAf,EAAAY,EAAAI,EAAAH,GAAA,YAAAC,GAMA,QAAAG,GAAAjB,EAAAY,EAAAC,EAAAC,OACAxB,KAAAwB,GACAH,EAAAX,EAAAY,EAAAC,EAAAC,GAOA,QAAAI,GAAAlB,EAAAY,EAAAO,EAAAL,GACAC,EAAAf,EAAAY,EAAAO,EAAA,UAAAL,GAMA,QAAAM,GAAApB,EAAAY,EAAAO,EAAAL,OACAxB,KAAAwB,GACAI,EAAAlB,EAAAY,EAAAO,EAAAL,GAMA,QAAAO,GAAArB,EAAAsB,EAAAH,EAAAI,EAAAC,GAEA,OADAC,MACAnF,EAAA,EAAAoF,EAAAF,EAA2ClF,EAAAoF,EAAAlF,OAAwBF,IAAA,CACnE,GAAAqF,GAAAD,EAAApF,EACA,IAAAqF,IAAAJ,EACA,MAEAE,GAAAG,KAAAC,EAAAF,IAEA,GAAAG,GAAAD,EAAAN,EACA,UAAA9C,IAAAC,GAAAC,iBAAA,iBAAAmD,EAAA,yBAAA9B,EAAA,kBAAAmB,EAAA,yBAAAM,EAAAM,KAAA,OAMA,QAAAC,GAAAhC,EAAAsB,EAAAH,EAAAI,EAAAC,OACAlC,KAAAiC,GACAF,EAAArB,EAAAsB,EAAAH,EAAAI,EAAAC,GAIA,QAAAT,GAAAf,EAAAY,EAAAU,EAAAC,GACA,SAAAA,KAAAX,GAAA,WAAAA,IAAAqB,EAAAV,GAAA,CACA,GAAAW,GAAAL,EAAAN,EACA,UAAA9C,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,mBAAAsB,EAAA,kBACAV,EAAA,iBAAAsB,IAOA,QAAAD,GAAAV,GACA,sBAAAA,IACA,OAAAA,GACAtC,OAAAkD,eAAAZ,KAAAtC,OAAAL,UAGA,QAAAiD,GAAAN,GACA,OAAAjC,KAAAiC,EACA,iBAEA,WAAAA,EACA,YAEA,oBAAAA,GAIA,MAHAA,GAAA/E,OAAA,KACA+E,IAAAa,UAAA,aAEAC,KAAAC,UAAAf,EAEA,oBAAAA,IAAA,iBAAAA,GACA,SAAAA,CAEA,oBAAAA,GAAA,CACA,GAAAA,YAAAb,OACA,gBAGA,IAAA6B,GAAAC,EAAAjB,EACA,OAAAgB,GACA,YAAAA,EAAA,UAGA,YAIA,wBAAAhB,GACA,aAGAzD,EAAA,6BAAAyD,IAIA,QAAAiB,GAAAjB,GACA,GAAAA,EAAAkB,YAAA,CACA,GAAAC,GAAA,4BACAC,EAAAD,EAAAE,KAAArB,KAAAkB,YACA,IAAAE,KAAAnG,OAAA,EACA,MAAAmG,GAAA,GAGA,YAGA,QAAAE,GAAA7C,EAAAa,EAAAC,GACA,OAAAxB,KAAAwB,EACA,SAAArC,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,uBAAAgB,EAAAH,GAAA,oCAQA,QAAAiC,GAAA9C,EAAA+C,EAAAC,GACArD,EAAAoD,EAAA,SAAA/D,EAAAiE,GACA,GAAAD,EAAAE,QAAAlE,GAAA,EACA,SAAAP,IAAAC,GAAAC,iBAAA,mBAAAK,EAAA,wBAAAgB,EAAA,0BAEAgD,EAAAjB,KAAA,SAQA,QAAAoB,GAAAnD,EAAAY,EAAAC,EAAAC,GACA,GAAAoB,GAAAL,EAAAf,EACA,WAAArC,IAAAC,GAAAC,iBAAA,YAAAqB,EAAA,mBAAAgB,EAAAH,GAAA,qBACAD,EAAA,iBAAAsB,GAGA,QAAAlB,GAAAvB,GACA,OAAAA,GACA,OACA,aACA,QACA,cACA,QACA,aACA,SACA,MAAAA,GAAA,MAMA,QAAAS,GAAAT,EAAA2D,GACA,MAAA3D,GAAA,IAAA2D,GAAA,IAAA3D,EAAA,QCrNA,QAAA4D,GAAAC,EAAAC,GACA,MAAAD,GAAAC,GACA,EACAD,EAAAC,EACA,EACA,EAGA,QAAAC,GAAAF,EAAAC,GACA,cAAAD,OAAAhE,KAAAgE,KACAC,IAAAD,EAAAG,QAAAF,IAKAD,IAAAC,EAIA,QAAAG,GAAAJ,EAAAC,GACA,GAAAD,EAAA9G,SAAA+G,EAAA/G,OACA,QAEA,QAAAmH,GAAA,EAAmBA,EAAAL,EAAA9G,OAAiBmH,IACpC,IAAAL,EAAAK,GAAAF,QAAAF,EAAAI,IACA,QAGA,UAWA,QAAAC,GAAAC,GAIA,GAAAC,GAAAD,EAAArH,OAAA,CACA,YAAAqH,EAAArH,OAEA,GAEA,OAAAqH,EAAAE,OAAAD,GACAD,EAAAzB,UAAA,EAAA0B,GAGAD,EAAAzB,UAAA,EAAA0B,GACAE,OAAAC,aAAAJ,EAAAK,WAAAJ,GAAA,GAOA,QAAAK,GAAAN,GAEA,MAAAA,GAAA,KC1EA,QAAAO,KACA,sBAAAC,YACA,SAAA5F,IAAAC,GAAA4F,cAAA,sDAIA,QAAAC,KACA,IAAA7G,GAAAC,cAAA6G,gBACA,SAAA/F,IAAAC,GAAA4F,cAAA,2DC0IA,QAAAG,GAAAnB,EAAAC,GACA,MAAAD,GAAAC,GACA,EAEAD,EAAAC,EACA,EAEAD,IAAAC,EACA,EAIA7D,MAAA4D,GACA5D,MAAA6D,GAAA,KAGA,EAQA,QAAAmB,GAAApB,EAAAC,GAGA,MAAAD,KAAAC,EAEA,IAAAD,GAAA,EAAAA,GAAA,EAAAC,EAIAD,OAAAC,MC7JA,QAAAoB,GAAAvF,GACA,cAAAA,OAAAE,KAAAF,EAMA,QAAAwF,GAAAxF,GACA,MAAAyF,IAAAzF,IACAA,GAAA0F,IACA1F,GAAA2F,GCqZA,QAAAC,GAAAC,EAAAC,EAAA9F,GACA,GAAAA,EAAAqE,QAAA0B,GAAAC,UAAA,CACA,GAAAF,IAAAG,GAAAC,MACA,SAAA7G,IAAAC,GAAAC,iBAAA,kEAEA,WAAA4G,IAAAN,GAEA,GAAA7F,EAAAqE,QAAA+B,GAAAC,KAAA,CACA,GAAAP,IAAAG,GAAAC,MACA,SAAA7G,IAAAC,GAAAC,iBAAA,iEAEA,WAAA+G,IAAAT,GAGA,UAAAU,IAAAV,EAAAC,EAAA9F,GCxaA,QAAAwG,GAAAC,GACA,OAAAA,GACA,IAAAnH,IAAAoH,GACA,MAAAhI,GAAA,6BACA,KAAAY,IAAAqH,UACA,IAAArH,IAAAsH,QACA,IAAAtH,IAAAuH,kBACA,IAAAvH,IAAAwH,mBACA,IAAAxH,IAAAyH,SACA,IAAAzH,IAAA0H,YAIA,IAAA1H,IAAA2H,gBACA,QACA,KAAA3H,IAAAC,iBACA,IAAAD,IAAA4H,UACA,IAAA5H,IAAA6H,eACA,IAAA7H,IAAA8H,kBACA,IAAA9H,IAAA+H,oBAIA,IAAA/H,IAAAgI,QACA,IAAAhI,IAAAiI,aACA,IAAAjI,IAAA4F,cACA,IAAA5F,IAAAkI,UACA,QACA,SACA,MAAA9I,GAAA,wBAAA+H,IASA,QAAAgB,GAAAC,GAEA,GAAAjB,GAAAkB,GAAAD,EACA,QAAAxH,KAAAuG,EAGA,MAAAmB,GAAAnB,GASA,QAAAmB,GAAAnB,GACA,OAAAvG,KAAAuG,EAIA,MADAvI,GAAA,2BACAoB,GAAAsH,OAEA,QAAAH,GACA,IAAAkB,IAAAjB,GACA,MAAApH,IAAAoH,EACA,KAAAiB,IAAAhB,UACA,MAAArH,IAAAqH,SACA,KAAAgB,IAAAf,QACA,MAAAtH,IAAAsH,OACA,KAAAe,IAAAd,kBACA,MAAAvH,IAAAuH,iBACA,KAAAc,IAAAb,mBACA,MAAAxH,IAAAwH,kBACA,KAAAa,IAAAZ,SACA,MAAAzH,IAAAyH,QACA,KAAAY,IAAAX,YACA,MAAA1H,IAAA0H,WACA,KAAAW,IAAAV,gBACA,MAAA3H,IAAA2H,eACA,KAAAU,IAAApI,iBACA,MAAAD,IAAAC,gBACA,KAAAoI,IAAAT,UACA,MAAA5H,IAAA4H,SACA,KAAAS,IAAAR,eACA,MAAA7H,IAAA6H,cACA,KAAAQ,IAAAP,kBACA,MAAA9H,IAAA8H,iBACA,KAAAO,IAAAN,oBACA,MAAA/H,IAAA+H,mBACA,KAAAM,IAAAL,QACA,MAAAhI,IAAAgI,OACA,KAAAK,IAAAJ,aACA,MAAAjI,IAAAiI,YACA,KAAAI,IAAAzC,cACA,MAAA5F,IAAA4F,aACA,KAAAyC,IAAAH,UACA,MAAAlI,IAAAkI,SACA,SACA,MAAA9I,GAAA,wBAAA+H,IAOA,QAAAoB,GAAApB,GACA,OAAAvG,KAAAuG,EACA,MAAAkB,IAAAjB,EAEA,QAAAD,GACA,IAAAnH,IAAAoH,GACA,MAAAiB,IAAAjB,EACA,KAAApH,IAAAqH,UACA,MAAAgB,IAAAhB,SACA,KAAArH,IAAAsH,QACA,MAAAe,IAAAf,OACA,KAAAtH,IAAAuH,kBACA,MAAAc,IAAAd,iBACA,KAAAvH,IAAAwH,mBACA,MAAAa,IAAAb,kBACA,KAAAxH,IAAAyH,SACA,MAAAY,IAAAZ,QACA,KAAAzH,IAAA0H,YACA,MAAAW,IAAAX,WACA,KAAA1H,IAAA2H,gBACA,MAAAU,IAAAV,eACA,KAAA3H,IAAAC,iBACA,MAAAoI,IAAApI,gBACA,KAAAD,IAAA4H,UACA,MAAAS,IAAAT,SACA,KAAA5H,IAAA6H,eACA,MAAAQ,IAAAR,cACA,KAAA7H,IAAA8H,kBACA,MAAAO,IAAAP,iBACA,KAAA9H,IAAA+H,oBACA,MAAAM,IAAAN,mBACA,KAAA/H,IAAAgI,QACA,MAAAK,IAAAL,OACA,KAAAhI,IAAAiI,aACA,MAAAI,IAAAJ,YACA,KAAAjI,IAAA4F,cACA,MAAAyC,IAAAzC,aACA,KAAA5F,IAAAkI,UACA,MAAAG,IAAAH,SACA,SACA,MAAA9I,GAAA,wBAAA+H,IAUA,QAAAqB,GAAAJ,GAOA,OAAAA,GACA,SACA,MAAApI,IAAAoH,EACA,UACA,MAAApH,IAAAC,gBAIA,UACA,MAAAD,IAAA2H,eACA,UACA,MAAA3H,IAAA8H,iBACA,UACA,MAAA9H,IAAA4H,SACA,UACA,MAAA5H,IAAAgI,OAGA,UACA,MAAAhI,IAAAiI,YACA,UACA,MAAAjI,IAAAwH,kBACA,UACA,MAAAxH,IAAAqH,SACA,UACA,MAAArH,IAAAsH,OAIA,UACA,MAAAtH,IAAA4F,aACA,UACA,MAAA5F,IAAA0H,WACA,UACA,MAAA1H,IAAAuH,iBACA,SACA,MAAAa,IAAA,KAAAA,EAAA,IACApI,GAAAoH,GACAgB,GAAA,KAAAA,EAAA,IACApI,GAAA+H,oBACAK,GAAA,KAAAA,EAAA,IACApI,GAAAyH,SACAzH,GAAAsH,SCvOA,QAAAmB,MACA,MAAAC,IAGA,QAAAC,MACA,MAAAC,IAGA,QAAAC,MACA,MAAAC,IAGA,QAAAC,MACA,MAAAC,ICkPA,QAAAC,IAAAC,EAAAC,GACAA,EAAArL,OAAA,IACAoL,EAAAC,eCnOA,QAAAC,IAAA1I,EAAA8C,GACAhE,GAAAyG,EAAAvF,GAAA8C,EAAA,eAEA,QAAA6F,IAAA3I,GAEA,sBAAAA,GACAA,EAEA,gBAAAA,IACAA,EAGAtB,EAAA,eAAAsB,GAihCA,QAAA4I,IAAA3L,EAAAuE,EAAAzE,GACA,MAAAyE,KAAAzE,IAAAyE,GAAAzE,IAAAE,GCpgCA,QAAA4L,IAAAC,GAEA,GADAA,EAAAC,OAAAC,KACA,EACA,SAAA3J,IAAAC,GAAAC,iBAAA,uBAAAuJ,EAAA,uDAGA,KACA,WAAAG,GAAAC,KAAAnL,MAAAkL,QAAA,IAAAhL,OAAA6K,EAAAK,MAAA,QAEA,MAAA1K,GACA,SAAAY,IAAAC,GAAAC,iBAAA,uBAAAuJ,EAAA,8ECkOA,QAAAM,IAAAC,EAAAC,GACA,GAAAC,GAAA,SAAAf,GACA,OAAAA,GACA,IAAAgB,IAAAC,MACA,QACA,KAAAD,IAAAE,SAEA,IAAAF,IAAAG,SAIA,QACA,KAAAH,IAAAI,QACA,QACA,SACA,MAAAlL,GAAA,uBAAA8J,IAGA,OAAAe,GAAAF,GAAAE,EAAAD,GCjTA,QAAAO,IAAAf,GAEA,OADApI,GAAA,GACA6D,EAAA,EAAmBA,EAAAuE,EAAA1L,OAAiBmH,IACpC7D,EAAAtD,OAAA,IACAsD,EAAAoJ,GAAApJ,IAEAA,EAAAqJ,GAAAjB,EAAAkB,IAAAzF,GAAA7D,EAEA,OAAAoJ,IAAApJ,GAGA,QAAAqJ,IAAAE,EAAAC,GAGA,OAFAxJ,GAAAwJ,EACA9M,EAAA6M,EAAA7M,OACAmH,EAAA,EAAmBA,EAAAnH,EAAYmH,IAAA,CAC/B,GAAA4F,GAAAF,EAAAtF,OAAAJ,EACA,QAAA4F,GACA,SACAzJ,GAAA0J,GAAAC,EACA,MACA,KAAAD,IACA1J,GAAA0J,GAAAE,EACA,MACA,SACA5J,GAAAyJ,GAGA,MAAAzJ,GAGA,QAAAoJ,IAAApJ,GACA,MAAAA,GAAA0J,GAAAG,GAQA,QAAAC,IAAA1B,GAGA,GAAA1L,GAAA0L,EAAA1L,MAEA,IADA0B,EAAA1B,GAAA,kBAAA0L,GACA,IAAA1L,EAEA,MADA0B,GAAAgK,EAAAnE,OAAA,KAAAyF,IAAAtB,EAAAnE,OAAA,KAAA4F,GAAA,kBAAAzB,EAAA,iBACA2B,GAAAC,UAOA,QAHAC,GAAAvN,EAAA,EACAwN,KACAC,EAAA,GACAC,EAAA,EAAuBA,EAAA1N,GAAgB,CAGvC,GAAA2N,GAAAjC,EAAAhF,QAAAsG,GAAAU,EAKA,SAJAC,EAAA,GAAAA,EAAAJ,IACAjM,EAAA,mCAAAoK,EAAA,KAEAA,EAAAnE,OAAAoG,EAAA,IAEA,IAAAR,IACA,GAAAS,GAAAlC,EAAA9F,UAAA8H,EAAAC,GACAd,MAAA,EACA,KAAAY,EAAAzN,OAGA6M,EAAAe,GAGAH,GAAAG,EACAf,EAAAY,EACAA,EAAA,IAEAD,EAAApI,KAAAyH,EACA,MACA,KAAAI,IACAQ,GAAA/B,EAAA9F,UAAA8H,EAAAC,GACAF,GAAA,IACA,MACA,KAAAP,IAEAO,GAAA/B,EAAA9F,UAAA8H,EAAAC,EAAA,EACA,MACA,SACArM,EAAA,mCAAAoK,EAAA,KAEAgC,EAAAC,EAAA,EAEA,UAAAN,IAAAG,GC/FA,QAAAK,IAAAC,EAAAC,GACArM,EAAA,IAAAqM,EAAA,mCAAAA,GACAD,EAAAE,kBAAAC,GAAAC,OACAC,QAAAF,GAAAE,UAIAL,EAAAE,kBAAAI,GAAAF,OAEKC,QAAAC,GAAAD,UACLL,EAAAE,kBAAAK,GAAAH,OAEKC,QAAAE,GAAAF,UACLG,YAAAD,GAAAE,qBAAAF,GAAAG,wBAAsHC,QAAA,IACtHX,EAAAE,kBAAAU,GAAAR,OACAC,QAAAO,GAAAP,UAGAG,YAAAI,GAAAC,sBAAAD,GAAAE,qBAA2FH,QAAA,IAG3FX,EAAAE,kBAAAa,GAAAX,OACAJ,EAAAE,kBAAAc,GAAAZ,OACAJ,EAAAE,kBAAAe,GAAAb,OACAJ,EAAAE,kBAAAgB,GAAAd,OCwUA,QAAAe,IAAAC,GACA,UAAAC,IAAA,SAAAC,EAAAC,GACAH,EAAAI,UAAA,SAAAC,GACA,GAAAjM,GAAAiM,EAAAC,OAAAlM,MACA8L,GAAA9L,IAEA4L,EAAAO,QAAA,SAAAF,GACAF,EAAAE,EAAAC,OAAAxO,UCMA,QAAA0O,IAAAC,GAEA,MADAjO,GAAA,gBAAAiO,GAAA,qDACAA,EAKA,QAAAC,IAAAC,GACA,MAAAC,IAAAD,EAAAzB,GAAAF,OAKA,QAAA6B,IAAAF,GACA,MAAAC,IAAAD,EAAAhB,GAAAX,OAKA,QAAA8B,IAAAH,GACA,MAAAC,IAAAD,EAAA5B,GAAAC,OAKA,QAAA4B,IAAAD,EAAA3B,GACA,MAAA2B,aAAAI,IACAJ,EAAA3B,SAGA5M,EAAA,wCCtNA,QAAA4O,IAAAL,GACA,MAAAM,IAAAN,EAAAnB,GAAAR,OAKA,QAAAkC,IAAAP,GACA,MAAAM,IAAAN,EAAAb,GAAAd,OAKA,QAAAmC,IAAAR,GACA,MAAAM,IAAAN,EAAAxB,GAAAH,OAKA,QAAAiC,IAAAN,EAAA3B,GACA,MAAA2B,aAAAI,IACAJ,EAAA3B,SAGA5M,EAAA,wCC9JA,QAAAgP,IAAAT,GACA,MAAAA,aAAAI,IACAJ,EAAA3B,MAAAY,GAAAZ,OAGA5M,EAAA,wCAGA,QAAAiP,IAAAC,GACA,MAAAA,GAAA9E,KAAA+E,UCsCA,QAAAC,IAAAC,GACA,WAAA7N,KAAA6N,EAAAC,UCqFA,QAAAC,IAAAC,GACA,IAAAA,EACA,UAAAC,GAEA,QAAAD,EAAA1M,MACA,WACA,UAAA4M,IAAAF,EAAAG,OAAAH,EAAAI,cAAA,IACA,gBACA,MAAAJ,GAAAG,MACA,SACA,SAAAhP,IAAAC,GAAAC,iBAAA,kECjMA,QAAAgP,IAAAtR,GACA,MAAAuR,IAAAvR,GAAA,4BAMA,QAAAuR,IAAAvR,EAAAwR,GACA,mBAAAxR,IAAA,OAAAA,EACA,QAGA,QADAyR,GAAAzR,EACAC,EAAA,EAAAyR,EAAAF,EAAyCvR,EAAAyR,EAAAvR,OAAuBF,IAAA,CAChE,GAAA0R,GAAAD,EAAAzR,EACA,IAAA0R,IAAAF,IAAA,kBAAAA,GAAAE,GACA,SAGA,SCqDA,QAAAC,IAAAC,GACA,OAAAA,GACA,IAAAC,IAAAC,IACA,IAAAD,IAAAE,SACA,IAAAF,IAAAG,OACA,QACA,KAAAH,IAAAI,WACA,QACA,SACA,KAAAzQ,GAAA,uCAAAoQ,IAgWA,QAAAM,IAAAjN,GACA,wBAAAA,IACA,OAAAA,GACAA,YAAAb,QACAa,YAAA3E,OACA2E,YAAAkN,KACAlN,YAAAmN,KACAnN,YAAAoN,KACApN,YAAAqN,KAEA,QAAAC,IAAA7Q,EAAA8Q,EAAAvN,GACA,IAAAiN,GAAAjN,KAAAU,EAAAV,GAAA,CACA,GAAAW,GAAAL,EAAAN,EACA,oBAAAW,EAEA4M,EAAAC,YAAA/Q,EAAA,oBAGA8Q,EAAAC,YAAA/Q,EAAA,IAAAkE,IAOA,QAAA8M,IAAAC,EAAA/G,GACA,GAAAA,YAAAG,IACA,MAAAH,GAAAgH,CAEA,oBAAAhH,GACA,MAAAiH,IAAAF,EAAA/G,EAIA,UAAAzJ,IAAAC,GAAAC,iBAAA,YAAAsQ,EAAA,0FAUA,QAAAE,IAAAF,EAAA/G,GACA,IACA,MAAAD,IAAAC,GAAAgH,EAEA,MAAArR,GACA,GAAAG,GAAAoR,GAAAvR,EACA,UAAAY,IAAAC,GAAAC,iBAAA,YAAAsQ,EAAA,gCAAAjR,IAOA,QAAAoR,IAAA5R,GACA,MAAAA,aAAAS,OAAAT,EAAAQ,QAAAR,KC2rBA,QAAA6R,IAAAJ,EAAAlM,GACA,WAAAzD,KAAAyD,GAEAuM,OAAA,IAGAxM,EAAAmM,EAAAlM,GAAA,UACA3B,EAAA6N,EAAA,kBAAAlM,EAAAuM,OACAvM,GAEA,QAAAwM,IAAAN,EAAAlM,GACA,WAAAzD,KAAAyD,MAGAD,EAAAmM,EAAAlM,GAAA,qBACAf,EAAAiN,EAAA,6BAAAlM,EAAAyM,kBAAA,+BACAzM,GAEA,QAAA0M,IAAAR,EAAAS,EAAAC,GACA,GAAAD,YAAAE,IAGA,IAAAF,EAAAC,cACA,SAAAlR,IAAAC,GAAAC,iBAAA,sEAGA,OAAA+Q,GANA,KAAAvM,GAAA8L,EAAA,sBAAAS,GAcA,QAAAG,IAAAF,EAAAG,GACA,GAAAA,EAAAC,QAAAnQ,UAAA,CAGA,GAAAoQ,GACAC,EAAA,CACA,OAAAH,GAAAI,WAAAnT,IAAA,SAAA6K,GACA,GAAAuI,GAAA,GAAAC,IAAAT,EAAA/H,EAAAuI,IAAAnR,IAAA4I,EAAAuI,IAAAL,EAAAO,UAIA,OAHAnS,GAAA0J,EAAAhH,OAAAgI,GAAAC,MAAA,yCACA3K,GAAA8R,GAAAF,EAAAQ,MAAAC,cAAAP,EAAApI,EAAAuI,KAAA,qCACAH,EAAApI,EAAAuI,KAEAvP,KAAA,QACAuP,MACAK,UAAA,EACAC,SAAAR,OAOA,GAAAS,GAAAZ,EAAAC,OACA,OAAAD,GAAAI,WAAAnT,IAAA,SAAA6K,GACA,GAAAuI,GAAA,GAAAC,IAAAT,EAAA/H,EAAAuI,IAAAnR,IAAA4I,EAAAuI,IAAAL,EAAAO,WACAG,GAAA,EACAC,GAAA,CAUA,OATA7I,GAAAhH,OAAAgI,GAAAC,QACA2H,EAAAE,EAAAxN,QAAA0E,EAAAuI,IAAAnR,KACAd,EAAAsS,GAAA,kCACAE,IAAAC,OAAA/I,EAAAuI,IAAAnR,MAEA4I,EAAAhH,OAAAgI,GAAAI,UACA0H,IAAAE,IAAAhJ,EAAAuI,KACAM,EAAAC,EAAAxN,QAAA0E,EAAAuI,IAAAnR,OAEoB4B,KAAAiQ,GAAAjJ,EAAAhH,MAAAuP,MAAAK,WAAAC,cAIpB,QAAAI,IAAAjQ,GACA,OAAAA,GACA,IAAAgI,IAAAC,MACA,aACA,KAAAD,IAAAE,SACA,IAAAF,IAAAG,SACA,gBACA,KAAAH,IAAAI,QACA,eACA,SACA,MAAAlL,GAAA,wBAAA8C,IChuCA,QAAAkQ,IAAAC,GACAA,EAAA5K,SAAA6K,gBAAA,qBAAAC,GAAmE,UAAAC,IAAAD,IAA6BpR,EAAAsR,KCvBhG,QAAAC,IAAAC,GACAP,GAAAO,G/BiBApS,OAAOqS,eAAezV,EAAqB,cAAgBuD,OAAO,GAGlE,IErBA3C,IFqBI8U,GAAM5V,EAAoB,GgCtB9ByB,GAAAmU,GAAA,QAAAnU,a9BEA,SAAAX,GACAA,IAAA,iBACAA,IAAA,iBACAA,IAAA,oBACCA,YACD,IAAAV,IAAAU,GAAAc,MEHAG,GAAA,WACA,QAAA8T,MAcA,MAZAA,GAAAC,YAAA,SAAAhU,GACA+T,EAAA/T,UACAK,EAAA,4BAEA0T,EAAA/T,YAEA+T,EAAA7T,YAAA,WAIA,MAHA6T,GAAA/T,UACAK,EAAA,oBAEA0T,EAAA/T,UAEA+T,K6BrBAE,GAAAC,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,QAKAxT,IAIAoH,GAAA,KAEAC,UAAA,YAEAC,QAAA,UAOArH,iBAAA,mBAQAsH,kBAAA,oBAEAK,UAAA,YAKAC,eAAA,iBAQAC,kBAAA,oBAKAH,gBAAA,kBAKAH,mBAAA,qBAqBAO,oBAAA,sBAQAC,QAAA,UAgBAC,aAAA,eAEArC,cAAA,gBAKA6B,SAAA,WAQAC,YAAA,cAEAQ,UAAA,aAQAnI,GAAA,SAAA2T,GAEA,QAAA3T,GAAAoH,EAAA7H,GACA,GAAAqU,GAAAD,EAAAlT,KAAAyS,KAAA3T,IAAA2T,IAQA,OAPAU,GAAAxM,OACAwM,EAAArU,UACAqU,EAAA7R,KAAA,gBAIA6R,EAAAC,SAAA,WAAsC,MAAAD,GAAA7R,KAAA,WAAA6R,EAAAxM,KAAA,MAAAwM,EAAArU,SACtCqU,EAEA,MAZAX,IAAAjT,EAAA2T,GAYA3T,GACCR,OzB9IDsU,GAAA,WACA,QAAAC,MAYA,MAVAA,GAAAC,MAAA,WAIA,OAFAC,GAAA,iEACAC,EAAA,GACAhP,EAAA,EAAuBA,EAAA,GAAQA,IAC/BgP,GAAAD,EAAA3O,OAAA6O,KAAAC,MAAAD,KAAAE,SAAAJ,EAAAlW,QAGA,OADA0B,GAAA,KAAAyU,EAAAnW,OAAA,oBAAAmW,GACAA,GAEAH,KCSA9D,GAAA,WACA,QAAAqE,GAAAC,GACAzO,IACAoN,KAAAsB,EAAAD,EAyDA,MAvDAD,GAAAG,iBAAA,SAAAC,GACApT,EAAA,wBAAAxD,UAAA,GACAoE,EAAA,mCAAAwS,GACA5O,GACA,KAEA,UAAAwO,GADArV,GAAAC,cAAAyV,KAAAD,IAGA,MAAAtV,GACA,SAAAY,IAAAC,GAAAC,iBAAA,gDAAAd,KAGAkV,EAAAM,eAAA,SAAAC,GAGA,GAFAvT,EAAA,sBAAAxD,UAAA,GACA6H,MACAkP,YAAAjP,aACA,KAAAlB,GAAA,qCAAAmQ,EAUA,WAAAP,GALArS,MAAA9B,UAAA7B,IACAmC,KAAAoU,EAAA,SAAAC,GACA,MAAAvP,QAAAC,aAAAsP,KAEAxR,KAAA,MAGAgR,EAAAnU,UAAA4U,SAAA,WAGA,MAFAzT,GAAA,gBAAAxD,UAAA,GACAgI,IACA7G,GAAAC,cAAA8V,KAAA9B,KAAAsB,IAEAF,EAAAnU,UAAA8U,aAAA,WACA3T,EAAA,oBAAAxD,UAAA,GACA6H,GAEA,QADAuP,GAAA,GAAAtP,YAAAsN,KAAAsB,EAAAzW,QACAmH,EAAA,EAAuBA,EAAAgO,KAAAsB,EAAAzW,OAA+BmH,IACtDgQ,EAAAhQ,GAAAgO,KAAAsB,EAAA/O,WAAAP,EAEA,OAAAgQ,IAEAZ,EAAAnU,UAAA0T,SAAA,WACA,sBAAAX,KAAA6B,WAAA,KAEAT,EAAAnU,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAsB,IAAAW,EAAAX,GAMAF,EAAAnU,UAAAiV,EAAA,SAAAD,GACA,MAAAvQ,GAAAsO,KAAAsB,EAAAW,EAAAX,IAEAF,KAWAe,GAAAzV,EAAAqQ,GAAA,iEyBxFAD,GAAA,WACA,QAAAsF,GAAAC,EAAAC,GAIA,GAHAlU,EAAA,WAAAxD,UAAA,GACAoE,EAAA,sBAAAqT,GACArT,EAAA,sBAAAsT,IACAC,SAAAF,OAAA,IAAAA,EAAA,GACA,SAAAvV,IAAAC,GAAAC,iBAAA,0DAAAqV,EAEA,KAAAE,SAAAD,OAAA,KAAAA,EAAA,IACA,SAAAxV,IAAAC,GAAAC,iBAAA,6DAAAsV,EAEAtC,MAAAwC,KAAAH,EACArC,KAAAyC,EAAAH,EAiCA,MA/BAhV,QAAAqS,eAAAyC,EAAAnV,UAAA,YAIAwK,IAAA,WACA,MAAAuI,MAAAwC,MAEAE,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAyC,EAAAnV,UAAA,aAIAwK,IAAA,WACA,MAAAuI,MAAAyC,GAEAC,YAAA,EACAC,cAAA,IAEAP,EAAAnV,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAwC,OAAAP,EAAAO,MAAAxC,KAAAyC,IAAAR,EAAAQ,GAMAL,EAAAnV,UAAAiV,EAAA,SAAAD,GACA,MAAAvQ,GAAAsO,KAAAwC,KAAAP,EAAAO,OACA9Q,EAAAsO,KAAAyC,EAAAR,EAAAQ,IAEAL,KCnDAQ,GAAA,WAWA,QAAAA,GAAAC,EAAAC,EAAAC,EAAAC,GACAhD,KAAA6C,aACA7C,KAAA8C,iBACA9C,KAAA+C,OACA/C,KAAAgD,MAEA,MAAAJ,MAIAK,GAAA,YAEAC,GAAA,WACA,QAAAC,GAAAC,EAAAC,GACArD,KAAAoD,YACApD,KAAAqD,YAAAJ,GAkBA,MAhBA3V,QAAAqS,eAAAwD,EAAAlW,UAAA,qBACAwK,IAAA,WACA,MAAAuI,MAAAqD,WAAAJ,IAEAP,YAAA,EACAC,cAAA,IAEAQ,EAAAlW,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAkB,IACAlB,EAAAmB,YAAApD,KAAAoD,WACAnB,EAAAoB,WAAArD,KAAAqD,UAEAF,EAAAlW,UAAAqW,UAAA,SAAArB,GACA,MAAAvQ,GAAAsO,KAAAoD,UAAAnB,EAAAmB,YACA1R,EAAAsO,KAAAqD,SAAApB,EAAAoB,WAEAF,KC7CAI,GAAAvD,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,QASAiD,GAAA,WACA,QAAAC,GAAApL,EAAAqL,EAAA7Y,GACAmV,KAAA2D,KAAAtL,EAAAqL,EAAA7Y,GA0HA,MAnHA4Y,GAAAxW,UAAA0W,KAAA,SAAAtL,EAAAqL,EAAA7Y,OACA8C,KAAA+V,EACAA,EAAA,EAEAA,EAAArL,EAAAxN,QACAsB,EAAA,UAAAuX,EAAA,iBAAArL,EAAAxN,YAEA8C,KAAA9C,EACAA,EAAAwN,EAAAxN,OAAA6Y,EAEA7Y,EAAAwN,EAAAxN,OAAA6Y,GACAvX,EAAA,UAAAtB,EAAA,kBAAAwN,EAAAxN,OAAA6Y,IAEA1D,KAAA3H,WACA2H,KAAA0D,SACA1D,KAAA4D,IAAA/Y,GAOA4Y,EAAAxW,UAAA4W,UAAA,SAAAxL,EAAAqL,EAAA7Y,GACA,GAAA0L,GAAAjJ,OAAAkT,OAAAlT,OAAAkD,eAAAwP,MAEA,OADAzJ,GAAAoN,KAAAtL,EAAAqL,EAAA7Y,GACA0L,GAEAjJ,OAAAqS,eAAA8D,EAAAxW,UAAA,UACAwK,IAAA,WACA,MAAAuI,MAAA4D,KAEAlB,YAAA,EACAC,cAAA,IAEAc,EAAAxW,UAAA6E,QAAA,SAAAmQ,GACA,WAAAwB,EAAAK,WAAA9D,KAAAiC,IAEAwB,EAAAxW,UAAA8W,MAAA,SAAAC,GACA,GAAA3L,GAAA2H,KAAA3H,SAAA4L,MAAAjE,KAAA0D,OAAA1D,KAAAkE,QAYA,OAXAF,aAAAP,GACAO,EAAAhW,QAAA,SAAA0J,GACAW,EAAApI,KAAAyH,KAGA,gBAAAsM,GACA3L,EAAApI,KAAA+T,GAGA7X,EAAA,4CAAA6X,GAEAhE,KAAA6D,UAAAxL,IAGAoL,EAAAxW,UAAAiX,MAAA,WACA,MAAAlE,MAAA0D,OAAA1D,KAAAnV,QAEA4Y,EAAAxW,UAAAkX,SAAA,SAAAC,GAGA,MAFAA,OAAAzW,KAAAyW,EAAA,EAAAA,EACA7X,EAAAyT,KAAAnV,QAAAuZ,EAAA,4CACApE,KAAA6D,UAAA7D,KAAA3H,SAAA2H,KAAA0D,OAAAU,EAAApE,KAAAnV,OAAAuZ,IAEAX,EAAAxW,UAAAoX,QAAA,WAEA,MADA9X,IAAAyT,KAAA/R,UAAA,sCACA+R,KAAA6D,UAAA7D,KAAA3H,SAAA2H,KAAA0D,OAAA1D,KAAAnV,OAAA,IAEA4Y,EAAAxW,UAAAqX,aAAA,WAEA,MADA/X,IAAAyT,KAAA/R,UAAA,2CACA+R,KAAA3H,SAAA2H,KAAA0D,SAEAD,EAAAxW,UAAAsX,YAAA,WAEA,MADAhY,IAAAyT,KAAA/R,UAAA,0CACA+R,KAAA3H,SAAA2H,KAAAkE,QAAA,IAEAT,EAAAxW,UAAAwK,IAAA,SAAA+M,GAEA,MADAjY,GAAAiY,EAAAxE,KAAAnV,OAAA,sBACAmV,KAAA3H,SAAA2H,KAAA0D,OAAAc,IAEAf,EAAAxW,UAAAgB,QAAA,WACA,WAAA+R,KAAAnV,QAEA4Y,EAAAxW,UAAAwX,WAAA,SAAAxC,GACA,GAAAA,EAAApX,OAAAmV,KAAAnV,OACA,QAEA,QAAAmH,GAAA,EAAuBA,EAAAgO,KAAAnV,OAAiBmH,IACxC,GAAAgO,KAAAvI,IAAAzF,KAAAiQ,EAAAxK,IAAAzF,GACA,QAGA,WAEAyR,EAAAxW,UAAAe,QAAA,SAAAH,GACA,OAAAmE,GAAAgO,KAAA0D,OAAAlL,EAAAwH,KAAAkE,QAAqDlS,EAAAwG,EAASxG,IAC9DnE,EAAAmS,KAAA3H,SAAArG,KAGAyR,EAAAxW,UAAAqO,QAAA,WACA,MAAA0E,MAAA3H,SAAA4L,MAAAjE,KAAA0D,OAAA1D,KAAAkE,UAEAT,EAAAK,WAAA,SAAAY,EAAAC,GAEA,OADAf,GAAA3C,KAAA2D,IAAAF,EAAA7Z,OAAA8Z,EAAA9Z,QACAmH,EAAA,EAAuBA,EAAA4R,EAAS5R,IAAA,CAChC,GAAAL,GAAA+S,EAAAjN,IAAAzF,GACAJ,EAAA+S,EAAAlN,IAAAzF,EACA,IAAAL,EAAAC,EACA,QACA,IAAAD,EAAAC,EACA,SAEA,MAAA8S,GAAA7Z,OAAA8Z,EAAA9Z,QACA,EACA6Z,EAAA7Z,OAAA8Z,EAAA9Z,OACA,EACA,GAEA4Y,KAOAvL,GAAA,SAAAuI,GAEA,QAAAoE,KACA,cAAApE,KAAAjV,MAAAwU,KAAApV,YAAAoV,KA2BA,MA7BAuD,IAAAsB,EAAApE,GAIAoE,EAAA5X,UAAA6X,gBAAA,WAIA,MAAA9E,MAAA1E,UAAAlL,KAAA,MAEAyU,EAAA5X,UAAA0T,SAAA,WACA,MAAAX,MAAA8E,mBAKAD,EAAAE,WAAA,SAAAxO,GAIA,GAAAA,EAAAhF,QAAA,SACA,SAAAzE,IAAAC,GAAAC,iBAAA,iBAAAuJ,EAAA,wCAKA,WAAAsO,GADAtO,EAAAK,MAAA,KAAAoO,OAAA,SAAAtN,GAAkE,MAAAA,GAAA7M,OAAA,MAGlEga,EAAA1M,WAAA,GAAA0M,OACAA,GACCrB,IAEDyB,GAAA,2BAEAC,GAAA,SAAAzE,GAEA,QAAA0E,KACA,cAAA1E,KAAAjV,MAAAwU,KAAApV,YAAAoV,KA2FA,MA7FAuD,IAAA4B,EAAA1E,GAQA0E,EAAAC,kBAAA,SAAA1N,GACA,MAAAuN,IAAAI,KAAA3N,IAEAyN,EAAAlY,UAAA6X,gBAAA,WACA,MAAA9E,MAAA1E,UACAlQ,IAAA,SAAAqG,GAKA,MAJAA,KAAA6T,QAAA,aAAAA,QAAA,WACAH,EAAAC,kBAAA3T,KACAA,EAAA,IAAAA,EAAA,KAEAA,IAEArB,KAAA,MAEA+U,EAAAlY,UAAA0T,SAAA,WACA,MAAAX,MAAA8E,mBAKAK,EAAAlY,UAAAsY,WAAA,WACA,WAAAvF,KAAAnV,QAxMA,aAwMAmV,KAAAvI,IAAA,IAKA0N,EAAAK,SAAA,WACA,UAAAL,IA9MA,cA0NAA,EAAAM,iBAAA,SAAAlP,GAaA,IAZA,GAAA8B,MACAqN,EAAA,GACA1T,EAAA,EACA2T,EAAA,WACA,OAAAD,EAAA7a,OACA,SAAAiC,IAAAC,GAAAC,iBAAA,uBAAAuJ,EAAA,4EAGA8B,GAAApI,KAAAyV,GACAA,EAAA,IAEAE,GAAA,EACA5T,EAAAuE,EAAA1L,QAAA,CACA,GAAA+M,GAAArB,EAAAvE,EACA,WAAA4F,EAAA,CACA,GAAA5F,EAAA,IAAAuE,EAAA1L,OACA,SAAAiC,IAAAC,GAAAC,iBAAA,uCAAAuJ,EAEA,IAAAsP,GAAAtP,EAAAvE,EAAA,EACA,WAAA6T,GAAA,MAAAA,GAAA,MAAAA,EACA,SAAA/Y,IAAAC,GAAAC,iBAAA,qCAAAuJ,EAEAmP,IAAAG,EACA7T,GAAA,MAEA,MAAA4F,GACAgO,KACA5T,KAEA,MAAA4F,GAAAgO,GAKAF,GAAA9N,EACA5F,MALA2T,IACA3T,KAQA,GADA2T,IACAC,EACA,SAAA9Y,IAAAC,GAAAC,iBAAA,2BAAAuJ,EAEA,WAAA4O,GAAA9M,IAEA8M,EAAAhN,WAAA,GAAAgN,OACAA,GACC3B,ICnRDsC,GAAA,WACA,QAAAC,GAAAxP,GACAyJ,KAAAzJ,OACAhK,EAAAwZ,EAAAC,cAAAzP,GAAA,uDACAA,EAAA+E,UAAAlL,KAAA,MAkCA,MAhCA2V,GAAA9Y,UAAA6E,QAAA,SAAAmQ,GACA,cAAAA,GAAA,IAAA/J,GAAA4L,WAAA9D,KAAAzJ,KAAA0L,EAAA1L,OAEAwP,EAAA9Y,UAAA0T,SAAA,WACA,MAAAX,QAAAzJ,MAEAwP,EAAAjC,WAAA,SAAAmC,EAAAC,GACA,MAAAhO,IAAA4L,WAAAmC,EAAA1P,KAAA2P,EAAA3P,OAEAwP,EAAAC,cAAA,SAAAzP,GACA,MAAAA,GAAA1L,OAAA,MAQAkb,EAAAI,aAAA,SAAA9N,GACA,UAAA0N,GAAA,GAAA7N,IAAAG,EAAA4L,WASA8B,EAAAK,eAAA,SAAA7P,GACA,UAAAwP,GAAA7N,GAAA6M,WAAAxO,KAEAwP,EAAAM,MAAA,GAAAN,GAAA,GAAA7N,SACA6N,KCtCAO,GAAA,WACA,QAAAC,GAAAlZ,EAAAmZ,EAAAC,EAAArV,GACA4O,KAAA3S,MACA2S,KAAAwG,UACAxG,KAAAyG,OACAzG,KAAA0G,kBAAAtV,EAAAsV,kBAoCA,MAlCAH,GAAAtZ,UAAAqG,MAAA,SAAAiD,GACA,MAAAyJ,MAAAyG,KAAAnT,MAAAiD,IAEAgQ,EAAAtZ,UAAA0Z,WAAA,SAAApQ,GACA,GAAAjD,GAAA0M,KAAA1M,MAAAiD,EACA,OAAAjD,KAAA7F,YAAAE,IAEA4Y,EAAAtZ,UAAAQ,MAAA,WACA,MAAAuS,MAAAyG,KAAAhZ,SAEA8Y,EAAAtZ,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAsE,IACAvG,KAAA3S,IAAAyE,QAAAmQ,EAAA5U,MACA2S,KAAAwG,QAAA1U,QAAAmQ,EAAAuE,UACAxG,KAAAyG,KAAA3U,QAAAmQ,EAAAwE,OACAzG,KAAA0G,oBAAAzE,EAAAyE,mBAEAH,EAAAtZ,UAAA0T,SAAA,WACA,kBAAAX,KAAA3S,IAAA,KAAA2S,KAAAwG,QAAA,KAAAxG,KAAAyG,KAAA,yBACezG,KAAA0G,kBAAA,MAEfH,EAAAK,aAAA,SAAAC,EAAAC,GACA,MAAAhB,IAAAhC,WAAA+C,EAAAxZ,IAAAyZ,EAAAzZ,MAEAkZ,EAAAQ,eAAA,SAAAzT,EAAAuT,EAAAC,GACA,GAAAE,GAAAH,EAAAvT,SACA2T,EAAAH,EAAAxT,QACA,YAAA3F,KAAAqZ,OAAArZ,KAAAsZ,EACAD,EAAA1D,UAAA2D,GAGA9a,EAAA,2DAGAoa,KAQAW,GAAA,WACA,QAAAC,GAAA9Z,EAAAmZ,GACAxG,KAAA3S,MACA2S,KAAAwG,UAaA,MAXAW,GAAAla,UAAA0T,SAAA,WACA,oBAAAX,KAAA3S,IAAA,KAAA2S,KAAAwG,QAAA,KAEAW,EAAAla,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,IACAA,EAAAuE,QAAA1U,QAAAkO,KAAAwG,UACAvE,EAAA5U,IAAAyE,QAAAkO,KAAA3S,MAEA8Z,EAAAP,aAAA,SAAAC,EAAAC,GACA,MAAAhB,IAAAhC,WAAA+C,EAAAxZ,IAAAyZ,EAAAzZ,MAEA8Z,KChEAC,GAAA,WACA,QAAAA,GAAAtD,EAAAuD,GACArH,KAAA8D,aACA9D,KAAAqH,QAAAC,GAAAjB,MA2GA,MAxGAe,GAAAna,UAAAsa,OAAA,SAAAla,EAAAI,GACA,UAAA2Z,GAAApH,KAAA8D,WAAA9D,KAAAqH,KACAE,OAAAla,EAAAI,EAAAuS,KAAA8D,YACA0D,KAAA,UAAAF,GAAAG,MAAA,aAGAL,EAAAna,UAAAya,OAAA,SAAAra,GACA,UAAA+Z,GAAApH,KAAA8D,WAAA9D,KAAAqH,KACAK,OAAAra,EAAA2S,KAAA8D,YACA0D,KAAA,UAAAF,GAAAG,MAAA,aAGAL,EAAAna,UAAAwK,IAAA,SAAApK,GAEA,IADA,GAAAsa,GAAA3H,KAAAqH,MACAM,EAAA1Z,WAAA,CACA,GAAA2Z,GAAA5H,KAAA8D,WAAAzW,EAAAsa,EAAAta,IACA,QAAAua,EACA,MAAAD,GAAAla,KAEAma,GAAA,EACAD,IAAAhW,KAEAiW,EAAA,IACAD,IAAA/V,OAGA,aAIAwV,EAAAna,UAAAsE,QAAA,SAAAlE,GAIA,IAFA,GAAAwa,GAAA,EACAF,EAAA3H,KAAAqH,MACAM,EAAA1Z,WAAA,CACA,GAAA2Z,GAAA5H,KAAA8D,WAAAzW,EAAAsa,EAAAta,IACA,QAAAua,EACA,MAAAC,GAAAF,EAAAhW,KAAAyS,IAEAwD,GAAA,EACAD,IAAAhW,MAIAkW,GAAAF,EAAAhW,KAAAyS,KAAA,EACAuD,IAAA/V,OAIA,UAEAwV,EAAAna,UAAAgB,QAAA,WACA,MAAA+R,MAAAqH,KAAApZ,WAEAX,OAAAqS,eAAAyH,EAAAna,UAAA,QAEAwK,IAAA,WACA,MAAAuI,MAAAqH,KAAAjD,MAEA1B,YAAA,EACAC,cAAA,IAGAyE,EAAAna,UAAA6a,OAAA,WACA,MAAA9H,MAAAqH,KAAAS,UAGAV,EAAAna,UAAA8a,OAAA,WACA,MAAA/H,MAAAqH,KAAAU,UAMAX,EAAAna,UAAA+a,iBAAA,SAAAC,GACA,MAAAjI,MAAAqH,KAAAW,iBAAAC,IAEAb,EAAAna,UAAAe,QAAA,SAAAH,GACAmS,KAAAgI,iBAAA,SAAAE,EAAAC,GAEA,MADAta,GAAAqa,EAAAC,IACA,KAQAf,EAAAna,UAAAmb,iBAAA,SAAAH,GACA,MAAAjI,MAAAqH,KAAAe,iBAAAH,IAGAb,EAAAna,UAAAob,YAAA,WACA,UAAAC,IAAAtI,KAAAqH,KAAA,KAAArH,KAAA8D,YAAA,IAEAsD,EAAAna,UAAAsb,gBAAA,SAAAlb,GACA,UAAAib,IAAAtI,KAAAqH,KAAAha,EAAA2S,KAAA8D,YAAA,IAEAsD,EAAAna,UAAAub,mBAAA,WACA,UAAAF,IAAAtI,KAAAqH,KAAA,KAAArH,KAAA8D,YAAA,IAEAsD,EAAAna,UAAAwb,uBAAA,SAAApb,GACA,UAAAib,IAAAtI,KAAAqH,KAAAha,EAAA2S,KAAA8D,YAAA,IAEAsD,KAIAkB,GAAA,WACA,QAAAI,GAAAf,EAAAgB,EAAA7E,EAAA8E,GACA5I,KAAA4I,YACA5I,KAAA6I,YAEA,KADA,GAAAjB,GAAA,GACAD,EAAA1Z,WAKA,GAJA2Z,EAAAe,EAAA7E,EAAA6D,EAAAta,IAAAsb,GAAA,EAEAC,IACAhB,IAAA,GACAA,EAAA,EAGAD,EADA3H,KAAA4I,UACAjB,EAAAhW,KAGAgW,EAAA/V,UAGA,QAAAgW,EAAA,CAGA5H,KAAA6I,UAAA5Y,KAAA0X,EACA,OAKA3H,KAAA6I,UAAA5Y,KAAA0X,GAEAA,EADA3H,KAAA4I,UACAjB,EAAA/V,MAGA+V,EAAAhW,MAkCA,MA7BA+W,GAAAzb,UAAA6b,QAAA,WACAvc,EAAAyT,KAAA6I,UAAAhe,OAAA,0DACA,IAAA8c,GAAA3H,KAAA6I,UAAAE,MACA5a,GAAsBd,IAAAsa,EAAAta,IAAAI,MAAAka,EAAAla,MACtB,IAAAuS,KAAA4I,UAEA,IADAjB,IAAAhW,MACAgW,EAAA1Z,WACA+R,KAAA6I,UAAA5Y,KAAA0X,GACAA,IAAA/V,UAKA,KADA+V,IAAA/V,OACA+V,EAAA1Z,WACA+R,KAAA6I,UAAA5Y,KAAA0X,GACAA,IAAAhW,IAGA,OAAAxD,IAEAua,EAAAzb,UAAA+b,QAAA,WACA,MAAAhJ,MAAA6I,UAAAhe,OAAA,GAEA6d,EAAAzb,UAAAgc,KAAA,WACA,OAAAjJ,KAAA6I,UAAAhe,OACA,WACA,IAAA8c,GAAA3H,KAAA6I,UAAA7I,KAAA6I,UAAAhe,OAAA,EACA,QAAgBwC,IAAAsa,EAAAta,IAAAI,MAAAka,EAAAla,QAEhBib,KAIApB,GAAA,WACA,QAAA4B,GAAA7b,EAAAI,EAAA0b,EAAAxX,EAAAC,GACAoO,KAAA3S,MACA2S,KAAAvS,QACAuS,KAAAmJ,MAAA,MAAAA,IAAAD,EAAAE,IACApJ,KAAArO,KAAA,MAAAA,IAAAuX,EAAA7C,MACArG,KAAApO,MAAA,MAAAA,IAAAsX,EAAA7C,MACArG,KAAAoE,KAAApE,KAAArO,KAAAyS,KAAA,EAAApE,KAAApO,MAAAwS,KAkLA,MA/KA8E,GAAAjc,UAAAua,KAAA,SAAAna,EAAAI,EAAA0b,EAAAxX,EAAAC,GACA,UAAAsX,GAAA,MAAA7b,IAAA2S,KAAA3S,IAAA,MAAAI,IAAAuS,KAAAvS,MAAA,MAAA0b,IAAAnJ,KAAAmJ,MAAA,MAAAxX,IAAAqO,KAAArO,KAAA,MAAAC,IAAAoO,KAAApO,QAEAsX,EAAAjc,UAAAgB,QAAA,WACA,UAMAib,EAAAjc,UAAA+a,iBAAA,SAAAC,GACA,MAAAjI,MAAArO,KAAAqW,iBAAAC,IACAA,EAAAjI,KAAA3S,IAAA2S,KAAAvS,QACAuS,KAAApO,MAAAoW,iBAAAC,IAMAiB,EAAAjc,UAAAmb,iBAAA,SAAAH,GACA,MAAAjI,MAAApO,MAAAwW,iBAAAH,IACAA,EAAAjI,KAAA3S,IAAA2S,KAAAvS,QACAuS,KAAArO,KAAAyW,iBAAAH,IAGAiB,EAAAjc,UAAA2X,IAAA,WACA,MAAA5E,MAAArO,KAAA1D,UACA+R,KAGAA,KAAArO,KAAAiT,OAIAsE,EAAAjc,UAAA6a,OAAA,WACA,MAAA9H,MAAA4E,MAAAvX,KAGA6b,EAAAjc,UAAA8a,OAAA,WACA,MAAA/H,MAAApO,MAAA3D,UACA+R,KAAA3S,IAGA2S,KAAApO,MAAAmW,UAIAmB,EAAAjc,UAAAsa,OAAA,SAAAla,EAAAI,EAAAqW,GACA,GAAAuF,GAAArJ,KACA4H,EAAA9D,EAAAzW,EAAAgc,EAAAhc,IAUA,OARAgc,GADAzB,EAAA,EACAyB,EAAA7B,KAAA,eAAA6B,EAAA1X,KAAA4V,OAAAla,EAAAI,EAAAqW,GAAA,MAEA,IAAA8D,EACAyB,EAAA7B,KAAA,KAAA/Z,EAAA,gBAGA4b,EAAA7B,KAAA,oBAAA6B,EAAAzX,MAAA2V,OAAAla,EAAAI,EAAAqW,IAEAuF,EAAAC,SAEAJ,EAAAjc,UAAAsc,UAAA,WACA,GAAAvJ,KAAArO,KAAA1D,UACA,MAAAib,GAAA7C,KAEA,IAAAgD,GAAArJ,IAIA,OAHAqJ,GAAA1X,KAAA6X,SAAAH,EAAA1X,UAAA6X,UACAH,IAAAI,eACAJ,IAAA7B,KAAA,eAAA6B,EAAA1X,KAAA4X,YAAA,MACAF,EAAAC,SAGAJ,EAAAjc,UAAAya,OAAA,SAAAra,EAAAyW,GACA,GAAA4F,GACAL,EAAArJ,IACA,IAAA8D,EAAAzW,EAAAgc,EAAAhc,KAAA,EACAgc,EAAA1X,KAAA1D,WAAAob,EAAA1X,KAAA6X,SAAAH,EAAA1X,UAAA6X,UACAH,IAAAI,eAEAJ,IAAA7B,KAAA,eAAA6B,EAAA1X,KAAA+V,OAAAra,EAAAyW,GAAA,UAEA,CAMA,GALAuF,EAAA1X,KAAA6X,UACAH,IAAAM,eACAN,EAAAzX,MAAA3D,WAAAob,EAAAzX,MAAA4X,SAAAH,EAAAzX,MAAAD,KAAA6X,UACAH,IAAAO,gBAEA,IAAA9F,EAAAzW,EAAAgc,EAAAhc,KAAA,CACA,GAAAgc,EAAAzX,MAAA3D,UACA,MAAAib,GAAA7C,KAGAqD,GAAAL,EAAAzX,MAAAgT,MACAyE,IAAA7B,KAAAkC,EAAArc,IAAAqc,EAAAjc,MAAA,UAAA4b,EAAAzX,MAAA2X,aAGAF,IAAA7B,KAAA,oBAAA6B,EAAAzX,MAAA8V,OAAAra,EAAAyW,IAEA,MAAAuF,GAAAC,SAEAJ,EAAAjc,UAAAuc,MAAA,WACA,MAAAxJ,MAAAmJ,OAGAD,EAAAjc,UAAAqc,MAAA,WACA,GAAAD,GAAArJ,IAOA,OANAqJ,GAAAzX,MAAA4X,UAAAH,EAAA1X,KAAA6X,UACAH,IAAAQ,cACAR,EAAA1X,KAAA6X,SAAAH,EAAA1X,UAAA6X,UACAH,IAAAM,eACAN,EAAA1X,KAAA6X,SAAAH,EAAAzX,MAAA4X,UACAH,IAAAS,aACAT,GAEAH,EAAAjc,UAAAwc,YAAA,WACA,GAAAJ,GAAArJ,KAAA8J,WAMA,OALAT,GAAAzX,MAAAD,KAAA6X,UACAH,IAAA7B,KAAA,oBAAA6B,EAAAzX,MAAA+X,eACAN,IAAAQ,aACAR,IAAAS,aAEAT,GAEAH,EAAAjc,UAAA2c,aAAA,WACA,GAAAP,GAAArJ,KAAA8J,WAKA,OAJAT,GAAA1X,UAAA6X,UACAH,IAAAM,cACAN,IAAAS,aAEAT,GAEAH,EAAAjc,UAAA4c,WAAA,WACA,GAAAE,GAAA/J,KAAAwH,KAAA,UAAA0B,EAAAE,IAAA,KAAApJ,KAAApO,MAAAD,KACA,OAAAqO,MAAApO,MAAA4V,KAAA,UAAAxH,KAAAmJ,MAAAY,EAAA,OAEAb,EAAAjc,UAAA0c,YAAA,WACA,GAAAK,GAAAhK,KAAAwH,KAAA,UAAA0B,EAAAE,IAAApJ,KAAArO,KAAAC,MAAA,KACA,OAAAoO,MAAArO,KAAA6V,KAAA,UAAAxH,KAAAmJ,MAAA,KAAAa,IAEAd,EAAAjc,UAAA6c,UAAA,WACA,GAAAnY,GAAAqO,KAAArO,KAAA6V,KAAA,WAAAxH,KAAArO,KAAAwX,MAAA,WACAvX,EAAAoO,KAAApO,MAAA4V,KAAA,WAAAxH,KAAApO,MAAAuX,MAAA,UACA,OAAAnJ,MAAAwH,KAAA,WAAAxH,KAAAmJ,MAAAxX,EAAAC,IAGAsX,EAAAjc,UAAAgd,cAAA,WACA,GAAAC,GAAAlK,KAAAmK,OACA,OAAAlJ,MAAAmJ,IAAA,EAAAF,IAAAlK,KAAAoE,KAAA,GASA8E,EAAAjc,UAAAkd,MAAA,WACA,GAAAnK,KAAAwJ,SAAAxJ,KAAArO,KAAA6X,QACA,KAAArd,GAAA,0BAAA6T,KAAA3S,IAAA,IAAA2S,KAAAvS,MAAA,IAEA,IAAAuS,KAAApO,MAAA4X,QACA,KAAArd,GAAA,mBAAA6T,KAAA3S,IAAA,IAAA2S,KAAAvS,MAAA,WAEA,IAAAyc,GAAAlK,KAAArO,KAAAwY,OACA,IAAAD,IAAAlK,KAAApO,MAAAuY,QACA,KAAAhe,GAAA,sBAGA,OAAA+d,IAAAlK,KAAAwJ,QAAA,MAIAN,EAAA7C,MAAA,KACA6C,EAAAE,KAAA,EACAF,EAAAzB,OAAA,EACAyB,KAIAmB,GAAA,WACA,QAAAA,KACArK,KAAAoE,KAAA,EAuCA,MApCAiG,GAAApd,UAAAua,KAAA,SAAAna,EAAAI,EAAA0b,EAAAxX,EAAAC,GACA,MAAAoO,OAGAqK,EAAApd,UAAAsa,OAAA,SAAAla,EAAAI,EAAAqW,GACA,UAAAwD,IAAAja,EAAAI,IAGA4c,EAAApd,UAAAya,OAAA,SAAAra,EAAAyW,GACA,MAAA9D,OAEAqK,EAAApd,UAAAgB,QAAA,WACA,UAEAoc,EAAApd,UAAA+a,iBAAA,SAAAC,GACA,UAEAoC,EAAApd,UAAAmb,iBAAA,SAAAH,GACA,UAEAoC,EAAApd,UAAA6a,OAAA,WACA,aAEAuC,EAAApd,UAAA8a,OAAA,WACA,aAEAsC,EAAApd,UAAAuc,MAAA,WACA,UAGAa,EAAApd,UAAAgd,cAAA,WACA,UAEAI,EAAApd,UAAAkd,MAAA,WACA,UAEAE,IAGA/C,IAAAjB,MAAA,GAAAgE,G7BraA,IAcAC,IAdAC,GAAAvK,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,SAQA,SAAA+J,GAEAA,IAAA,yBACAA,IAAA,+BACAA,IAAA,6BACAA,IAAA,mCACAA,IAAA,6BACAA,IAAA,yBACAA,IAAA,uBACAA,IAAA,iCACAA,IAAA,2BACAA,IAAA,8BACCA,YAED,IAAAE,KACA,SAAAA,GACAA,IAAA,qBACAA,IAAA,uBACAA,IAAA,wBACCA,YAED,I8BjCAC,I9BiCAC,GAAA,WACA,QAAAC,GAAAC,GACA5K,KAAA4K,0BAgBA,MAdAD,GAAAE,oBAAA,SAAAzZ,GACA,OAAAA,EAAAyM,kBACA,eACA,UAAA8M,GAAAH,GAAAM,SACA,gBACA,UAAAH,GAAAH,GAAAO,SACA,YACA,SAAApd,GACA,MAAAgd,GAAAK,cACA,SACA,MAAA7e,GAAA,wDAGAwe,EAAAK,eAAA,GAAAL,GAAAH,GAAAS,SACAN,KAMAO,GAAA,WACA,QAAAC,MAWA,MATAA,GAAAle,UAAA0T,SAAA,WACA,GAAA3Q,GAAAgQ,KAAAvS,OACA,eAAAuC,EAAA,OAAAA,MAEAmb,EAAAle,UAAAme,iBAAA,SAAAnJ,GAGA,MAFA1V,GAAAyT,KAAAqL,YAAApJ,EAAAoJ,UAAA,iEACA3Z,EAAAsO,KAAAqL,UAAApJ,EAAAoJ,YAGAF,KAGA3X,GAAA,SAAAiN,GAEA,QAAAjN,KACA,GAAAkN,GAAAD,EAAAlT,KAAAyS,WAKA,OAJAU,GAAA2K,UAAAf,GAAA9W,UAGAkN,EAAA4K,cAAA,KACA5K,EAeA,MAtBA6J,IAAA/W,EAAAiN,GASAjN,EAAAvG,UAAAQ,MAAA,SAAA2D,GACA,aAEAoC,EAAAvG,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAzO,IAEAA,EAAAvG,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAAzO,GACA,EAEAwM,KAAAoL,iBAAAnJ,IAEAzO,EAAAC,SAAA,GAAAD,GACAA,GACC0X,IAEDK,GAAA,SAAA9K,GAEA,QAAA+K,GAAAF,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAAkB,aACA9K,EAoBA,MAzBA6J,IAAAiB,EAAA/K,GAOA+K,EAAAve,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,eAEAE,EAAAve,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAuJ,IACAxL,KAAAsL,gBAAArJ,EAAAqJ,eAEAE,EAAAve,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAAuJ,GACA9Z,EAAAsO,KAAAiC,GAEAjC,KAAAoL,iBAAAnJ,IAEAuJ,EAAAC,GAAA,SAAAhe,GACA,MAAAA,GAAA+d,EAAAE,KAAAF,EAAAG,OAEAH,EAAAE,KAAA,GAAAF,IAAA,GACAA,EAAAG,MAAA,GAAAH,IAAA,GACAA,GACCN,IAGDU,GAAA,SAAAnL,GAEA,QAAAmL,GAAAN,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAAsB,YACAlL,EAWA,MAhBA6J,IAAAqB,EAAAnL,GAOAmL,EAAA3e,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,eAEAM,EAAA3e,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAA2J,GACA9Y,EAAAkN,KAAAsL,cAAArJ,EAAAqJ,eAEAtL,KAAAoL,iBAAAnJ,IAEA2J,GACCV,IAuCDW,GAAA,SAAApL,GAEA,QAAAoL,GAAAP,GACA,MAAA7K,GAAAlT,KAAAyS,KAAAsL,IAAAtL,KAYA,MAdAuK,IAAAsB,EAAApL,GAIAoL,EAAA5e,UAAA6E,QAAA,SAAAmQ,GAGA,MAAAA,aAAA4J,IACA9Y,EAAAiN,KAAAsL,cAAArJ,EAAAqJ,gBAMAO,GACCD,IAED/X,GAAA,SAAA4M,GAEA,QAAA5M,GAAAyX,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,KAAAsL,IAAAtL,IAEA,OADAU,GAAA4K,gBACA5K,EAeA,MAnBA6J,IAAA1W,EAAA4M,GAMA5M,EAAA5G,UAAA6E,QAAA,SAAAmQ,GAGA,MAAAA,aAAApO,IACAd,EAAAiN,KAAAsL,cAAArJ,EAAAqJ,gBAMAzX,EAAAC,IAAA,GAAAD,GAAAiY,KACAjY,EAAAkY,kBAAA,GAAAlY,GAAAmY,KACAnY,EAAAoY,kBAAA,GAAApY,IAAA,KACAA,GACC+X,IAGDM,GAAA,SAAAzL,GAEA,QAAA0L,GAAAb,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAA6B,YACAzL,EAcA,MAnBA6J,IAAA4B,EAAA1L,GAOA0L,EAAAlf,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,eAEAa,EAAAlf,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAkK,IAAAnM,KAAAsL,gBAAArJ,EAAAqJ,eAEAa,EAAAlf,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAAkK,GACAza,EAAAsO,KAAAsL,cAAArJ,EAAAqJ,eAEAtL,KAAAoL,iBAAAnJ,IAEAkK,GACCjB,IAEDkB,GAAA,SAAA3L,GAEA,QAAA2L,GAAAd,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAA8B,eACA1L,EAqBA,MA1BA6J,IAAA6B,EAAA3L,GAOA2L,EAAAnf,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,cAAAe,UAEAD,EAAAnf,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAmK,IACApM,KAAAsL,cAAAxZ,QAAAmQ,EAAAqJ,gBAEAc,EAAAnf,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAAmK,GACApM,KAAAsL,cAAAhI,UAAArB,EAAAqJ,eAEArJ,YAAAqK,KAEA,EAGAtM,KAAAoL,iBAAAnJ,IAGAmK,GACClB,IAgBDoB,GAAA,SAAA7L,GAEA,QAAA6L,GAAAC,EAAAC,GACA,GAAA9L,GAAAD,EAAAlT,KAAAyS,WAIA,OAHAU,GAAA6L,iBACA7L,EAAA8L,gBACA9L,EAAA2K,UAAAf,GAAA8B,eACA1L,EAkCA,MAxCA6J,IAAA+B,EAAA7L,GAQA6L,EAAArf,UAAAQ,MAAA,SAAA2D,GACA,MAAAA,IACAA,EAAAwZ,0BAAAJ,GAAAM,SACA9K,KAAAuM,eAAAF,SAEAjb,GACAA,EAAAwZ,0BAAAJ,GAAAO,UACA/K,KAAAwM,cAAAxM,KAAAwM,cAAA/e,MAAA2D,GAGA,MAGAkb,EAAArf,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAqK,IACAtM,KAAAuM,eAAAza,QAAAmQ,EAAAsK,iBAEAD,EAAArf,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAAqK,GACAtM,KAAAuM,eAAAjJ,UAAArB,EAAAsK,gBAEAtK,YAAAmK,IAEA,EAGApM,KAAAoL,iBAAAnJ,IAGAqK,EAAArf,UAAA0T,SAAA,WACA,oCAAAX,KAAAuM,eAAA,KAEAD,GACCpB,IAEDuB,GAAA,SAAAhM,GAEA,QAAAgM,GAAAnB,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAAmC,UACA/L,EAeA,MApBA6J,IAAAkC,EAAAhM,GAOAgM,EAAAxf,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,eAEAmB,EAAAxf,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAwK,IACAzM,KAAAsL,cAAAxZ,QAAAmQ,EAAAqJ,gBAEAmB,EAAAxf,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAAwK,GACAzM,KAAAsL,cAAApJ,EAAAD,EAAAqJ,eAEAtL,KAAAoL,iBAAAnJ,IAEAwK,GACCvB,IAEDwB,GAAA,SAAAjM,GAEA,QAAAkM,GAAA9J,EAAAxV,GACA,GAAAqT,GAAAD,EAAAlT,KAAAyS,WAIA,OAHAU,GAAAmC,aACAnC,EAAArT,MACAqT,EAAA2K,UAAAf,GAAAqC,SACAjM,EAoBA,MA1BA6J,IAAAoC,EAAAlM,GAQAkM,EAAA1f,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAA3S,KAEAsf,EAAA1f,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAA0K,IACA3M,KAAA3S,IAAAyE,QAAAmQ,EAAA5U,MAAA2S,KAAA6C,WAAA/Q,QAAAmQ,EAAAY,aAMA8J,EAAA1f,UAAAqW,UAAA,SAAArB,GACA,GAAAA,YAAA0K,GAAA,CACA,GAAA/E,GAAA5H,KAAA6C,WAAAS,UAAArB,EAAAY,WACA,YAAA+E,IAAA9B,GAAAhC,WAAA9D,KAAA3S,IAAA4U,EAAA5U,KAEA,MAAA2S,MAAAoL,iBAAAnJ,IAEA0K,GACCzB,IAED0B,GAAA,SAAAnM,GAEA,QAAAmM,GAAAtB,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAAsC,cACAlM,EAeA,MApBA6J,IAAAqC,EAAAnM,GAOAmM,EAAA3f,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,eAEAsB,EAAA3f,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAA2K,IACA5M,KAAAsL,cAAAxZ,QAAAmQ,EAAAqJ,gBAEAsB,EAAA3f,UAAAqW,UAAA,SAAArB,GACA,MAAAA,aAAA2K,GACA5M,KAAAsL,cAAApJ,EAAAD,EAAAqJ,eAEAtL,KAAAoL,iBAAAnJ,IAEA2K,GACC1B,IAED2B,GAAA,SAAApM,GAEA,QAAAqM,GAAAxB,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAAwC,YACApM,EAyGA,MA9GA6J,IAAAuC,EAAArM,GAOAqM,EAAA7f,UAAAQ,MAAA,SAAA2D,GACA,GAAAjD,KAIA,OAHA6R,MAAAsL,cAAAtD,iBAAA,SAAA3a,EAAA2C,GACA7B,EAAAd,GAAA2C,EAAAvC,MAAA2D,KAEAjD,GAEA2e,EAAA7f,UAAAe,QAAA,SAAAia,GACAjI,KAAAsL,cAAAtD,iBAAAC,IAEA6E,EAAA7f,UAAA6E,QAAA,SAAAmQ,GACA,GAAAA,YAAA6K,GAAA,CAGA,IAFA,GAAAC,GAAA/M,KAAAsL,cAAAjD,cACA2E,EAAA/K,EAAAqJ,cAAAjD,cACA0E,EAAA/D,WAAAgE,EAAAhE,WAAA,CACA,GAAAiE,GAAAF,EAAAjE,UACAoE,EAAAF,EAAAlE,SACA,IAAAmE,EAAA5f,MAAA6f,EAAA7f,MAAA4f,EAAAxf,MAAAqE,QAAAob,EAAAzf,OACA,SAGA,OAAAsf,EAAA/D,YAAAgE,EAAAhE,UAEA,UAEA8D,EAAA7f,UAAAqW,UAAA,SAAArB,GACA,GAAAA,YAAA6K,GAAA,CAGA,IAFA,GAAAC,GAAA/M,KAAAsL,cAAAjD,cACA2E,EAAA/K,EAAAqJ,cAAAjD,cACA0E,EAAA/D,WAAAgE,EAAAhE,WAAA,CACA,GAAAiE,GAAAF,EAAAjE,UACAoE,EAAAF,EAAAlE,UACAlB,EAAAlW,EAAAub,EAAA5f,IAAA6f,EAAA7f,MACA4f,EAAAxf,MAAA6V,UAAA4J,EAAAzf,MACA,IAAAma,EACA,MAAAA,GAIA,MAAAlW,GAAAqb,EAAA/D,UAAAgE,EAAAhE,WAGA,MAAAhJ,MAAAoL,iBAAAnJ,IAGA6K,EAAA7f,UAAAkgB,IAAA,SAAA5W,EAAA6W,GAEA,GADA7gB,GAAAgK,EAAAtI,UAAA,kDACA,IAAAsI,EAAA1L,OACA,MAAAmV,MAAAqN,SAAA9W,EAAA+N,eAAA8I,EAGA,IAAArJ,GAAA/D,KAAA+D,MAAAxN,EAAA+N,eACAP,aAAA+I,KACA/I,EAAA+I,EAAAzG,MAEA,IAAAiH,GAAAvJ,EAAAoJ,IAAA5W,EAAA4N,WAAAiJ,EACA,OAAApN,MAAAqN,SAAA9W,EAAA+N,eAAAgJ,IAGAR,EAAA7f,UAAA+R,OAAA,SAAAzI,GAEA,GADAhK,GAAAgK,EAAAtI,UAAA,qDACA,IAAAsI,EAAA1L,OACA,UAAAiiB,GAAA9M,KAAAsL,cAAA5D,OAAAnR,EAAA+N,gBAIA,IAAAP,GAAA/D,KAAA+D,MAAAxN,EAAA+N,eACA,IAAAP,YAAA+I,GAAA,CACA,GAAAQ,GAAAvJ,EAAA/E,OAAAzI,EAAA4N,WACA,WAAA2I,GAAA9M,KAAAsL,cAAA/D,OAAAhR,EAAA+N,eAAAgJ,IAIA,MAAAtN,OAIA8M,EAAA7f,UAAAG,SAAA,SAAAmJ,GACA,WAAA5I,KAAAqS,KAAA1M,MAAAiD,IAEAuW,EAAA7f,UAAAqG,MAAA,SAAAiD,GACAhK,GAAAgK,EAAAtI,UAAA,gCACA,IAAAqF,GAAA0M,IASA,OARAzJ,GAAAvI,QAAA,SAAAuf,GAEAja,EADAA,YAAAwZ,GACAxZ,EAAAgY,cAAA7T,IAAA8V,QAAA5f,OAGAA,KAGA2F,GAEAwZ,EAAA7f,UAAA0T,SAAA,WACA,MAAAjQ,MAAAC,UAAAqP,KAAAvS,UAEAqf,EAAA7f,UAAA8W,MAAA,SAAAyJ,GACA,MAAAxN,MAAAsL,cAAA7T,IAAA+V,QAAA7f,IAEAmf,EAAA7f,UAAAogB,SAAA,SAAAG,EAAA/f,GACA,UAAAqf,GAAA9M,KAAAsL,cAAA/D,OAAAiG,EAAA/f,KAEAqf,EAAAzG,MAAA,GAAAyG,GAAA,GAAA1F,IAAA1V,IACAob,GACC5B,IAEDuC,GAAA,SAAAhN,GAEA,QAAAiN,GAAApC,GACA,GAAA5K,GAAAD,EAAAlT,KAAAyS,WAGA,OAFAU,GAAA4K,gBACA5K,EAAA2K,UAAAf,GAAAoD,WACAhN,EAwCA,MA7CA6J,IAAAmD,EAAAjN,GAOAiN,EAAAzgB,UAAAQ,MAAA,SAAA2D,GACA,MAAA4O,MAAAsL,cAAAlgB,IAAA,SAAA+c,GAAoD,MAAAA,GAAA1a,MAAA2D,MAEpDsc,EAAAzgB,UAAAe,QAAA,SAAAia,GACAjI,KAAAsL,cAAAtd,QAAAia,IAEAyF,EAAAzgB,UAAA6E,QAAA,SAAAmQ,GACA,GAAAA,YAAAyL,GAAA,CACA,GAAA1N,KAAAsL,cAAAzgB,SAAAoX,EAAAqJ,cAAAzgB,OACA,QAEA,QAAAmH,GAAA,EAA2BA,EAAAgO,KAAAsL,cAAAzgB,OAA+BmH,IAC1D,IAAAgO,KAAAsL,cAAAtZ,GAAAF,QAAAmQ,EAAAqJ,cAAAtZ,IACA,QAGA,UAEA,UAEA0b,EAAAzgB,UAAAqW,UAAA,SAAArB,GACA,GAAAA,YAAAyL,GAAA,CAEA,OADAC,GAAA1M,KAAA2D,IAAA5E,KAAAsL,cAAAzgB,OAAAoX,EAAAqJ,cAAAzgB,QACAmH,EAAA,EAA2BA,EAAA2b,EAAe3b,IAAA,CAC1C,GAAA4V,GAAA5H,KAAAsL,cAAAtZ,GAAAsR,UAAArB,EAAAqJ,cAAAtZ,GACA,IAAA4V,EACA,MAAAA,GAGA,MAAAlW,GAAAsO,KAAAsL,cAAAzgB,OAAAoX,EAAAqJ,cAAAzgB,QAGA,MAAAmV,MAAAoL,iBAAAnJ,IAGAyL,EAAAzgB,UAAA0T,SAAA,WACA,MAAAjQ,MAAAC,UAAAqP,KAAAvS,UAEAigB,GACCxC,IClkBD0C,GAAAC,OAKAza,GAAAwa,GAAAxa,oBAAA6N,KAAAmJ,IAAA,SAKAjX,GAAAya,GAAAza,kBAAA8N,KAAAmJ,IAAA,QAOAlX,GAAA0a,GAAA1a,WACA,SAAAzF,GACA,sBAAAA,IACA8U,SAAA9U,IACAwT,KAAAC,MAAAzT,QChBAqgB,GAAA,WACA,QAAAC,GAAAxX,EAAAyX,EAAAC,EAAA/J,EAAAgK,EAAAC,OACA,KAAAH,IAAyCA,UACzC,KAAAC,IAAiCA,UACjC,KAAA/J,IAA+BA,EAAA,UAC/B,KAAAgK,IAAiCA,EAAA,UACjC,KAAAC,IAA+BA,EAAA,MAC/BnO,KAAAzJ,OACAyJ,KAAAgO,kBACAhO,KAAAiO,UACAjO,KAAAkE,QACAlE,KAAAkO,UACAlO,KAAAmO,QACAnO,KAAAoO,oBAAA,KACApO,KAAAqO,gBAAA,KACArO,KAAAkO,SACAlO,KAAAsO,iBAAAtO,KAAAkO,SAEAlO,KAAAmO,OACAnO,KAAAsO,iBAAAtO,KAAAmO,OA+PA,MA5PAJ,GAAAQ,OAAA,SAAAhY,GACA,UAAAwX,GAAAxX,IAEAjJ,OAAAqS,eAAAoO,EAAA9gB,UAAA,WACAwK,IAAA,WACA,UAAAuI,KAAAqO,gBAAA,CACA,GAAAG,GAAAxO,KAAAyO,2BACAC,EAAA1O,KAAA2O,sBACA,WAAAH,GAAA,OAAAE,EAIAF,EAAAjJ,aACAvF,KAAAqO,iBAAAO,IAGA5O,KAAAqO,iBACA,GAAAQ,IAAAL,GACAI,QAIA,CACAriB,EAAA,OAAAiiB,GACA,OAAAE,GACAF,EAAA1c,QAAA4c,GAAA,gDACA1O,KAAAqO,kBAEA,QADAS,IAAA,EACAnkB,EAAA,EAAAokB,EAAA/O,KAAAgO,gBAA+DrjB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAC/E,GAAAqkB,GAAAD,EAAApkB,EACAqV,MAAAqO,gBAAApe,KAAA+e,GACAA,EAAA1b,MAAAiS,eACAuJ,GAAA,GAGA,IAAAA,EAAA,CAGA,GAAAG,GAAAjP,KAAAgO,gBAAAnjB,OAAA,EACAmV,KAAAgO,gBAAAhO,KAAAgO,gBAAAnjB,OAAA,GAAAqkB,IACAC,GAAAC,SACApP,MAAAqO,gBAAApe,KAAAgf,IAAAE,GAAAC,UACAR,GACAS,MAIA,MAAArP,MAAAqO,iBAEA3L,YAAA,EACAC,cAAA,IAEAoL,EAAA9gB,UAAAqiB,UAAA,SAAAtK,GACAzY,EAAA,MAAAyT,KAAAyO,8BACAzJ,YAAAhR,OACAgR,EAAAuK,gBACAvK,EAAA1R,MAAAxB,QAAAkO,KAAAyO,4BAAA,8CACAliB,GAAAuZ,GAAAE,cAAAhG,KAAAzJ,MAAA,0CACA,IAAAiZ,GAAAxP,KAAAiO,QAAAviB,QAAAsZ,GACA,WAAA+I,GAAA/N,KAAAzJ,KAAAyJ,KAAAgO,gBAAA/J,QAAAuL,EAAAxP,KAAAkE,MAAAlE,KAAAkO,QAAAlO,KAAAmO,QAEAJ,EAAA9gB,UAAAwiB,WAAA,SAAAT,GACAziB,GAAAuZ,GAAAE,cAAAhG,KAAAzJ,MAAA,0CACAhK,GAAAyT,KAAAkO,UAAAlO,KAAAmO,MAAA,mCAEA,IAAAuB,GAAA1P,KAAAgO,gBAAAtiB,QAAAsjB,GACA,WAAAjB,GAAA/N,KAAAzJ,KAAAmZ,EAAA1P,KAAAiO,QAAAhK,QAAAjE,KAAAkE,MAAAlE,KAAAkO,QAAAlO,KAAAmO,QAEAJ,EAAA9gB,UAAA0iB,UAAA,SAAAzL,GACA,UAAA6J,GAAA/N,KAAAzJ,KAAAyJ,KAAAgO,gBAAA/J,QAAAjE,KAAAiO,QAAAhK,QAAAC,EAAAlE,KAAAkO,QAAAlO,KAAAmO,QAEAJ,EAAA9gB,UAAA2iB,YAAA,SAAAC,GACA,UAAA9B,GAAA/N,KAAAzJ,KAAAyJ,KAAAgO,gBAAA/J,QAAAjE,KAAAiO,QAAAhK,QAAAjE,KAAAkE,MAAA2L,EAAA7P,KAAAmO,QAEAJ,EAAA9gB,UAAA6iB,UAAA,SAAAD,GACA,UAAA9B,GAAA/N,KAAAzJ,KAAAyJ,KAAAgO,gBAAA/J,QAAAjE,KAAAiO,QAAAhK,QAAAjE,KAAAkE,MAAAlE,KAAAkO,QAAA2B,IAKA9B,EAAA9gB,UAAA8iB,YAAA,WACA,UAAA/P,KAAAoO,oBAAA,CACA,GAAA2B,GAAA/P,KAAAzJ,KAAAuO,iBACAiL,IAAA,KACA,QAAAplB,GAAA,EAAAokB,EAAA/O,KAAAiO,QAA+CtjB,EAAAokB,EAAAlkB,OAAgBF,IAE/DolB,GADAhB,EAAApkB,GACAolB,cACAA,GAAA,GAEAA,IAAA,MAEA,QAAAC,GAAA,EAAAC,EAAAjQ,KAAAgP,QAA+CgB,EAAAC,EAAAplB,OAAgBmlB,IAE/DD,GADAE,EAAAD,GACAD,cACAA,GAAA,GAEA/c,GAAAgN,KAAAkE,SACA6L,GAAA,MACAA,GAAA/P,KAAAkE,OAEAlE,KAAAkO,UACA6B,GAAA,OACAA,GAAA/P,KAAAkO,QAAA6B,eAEA/P,KAAAmO,QACA4B,GAAA,OACAA,GAAA/P,KAAAmO,MAAA4B,eAEA/P,KAAAoO,oBAAA2B,EAEA,MAAA/P,MAAAoO,qBAEAL,EAAA9gB,UAAA0T,SAAA,WACA,GAAAlP,GAAA,SAAAuO,KAAAzJ,KAAAuO,iBAgBA,OAfA9E,MAAAiO,QAAApjB,OAAA,IACA4G,GAAA,eAAAuO,KAAAiO,QAAA7d,KAAA,WAEA4C,EAAAgN,KAAAkE,SACAzS,GAAA,YAAAuO,KAAAkE,OAEAlE,KAAAgO,gBAAAnjB,OAAA,IACA4G,GAAA,eAAAuO,KAAAgO,gBAAA5d,KAAA,WAEA4P,KAAAkO,UACAzc,GAAA,cAAAuO,KAAAkO,QAAA6B,eAEA/P,KAAAmO,QACA1c,GAAA,YAAAuO,KAAAmO,MAAA4B,eAEAte,EAAA,KAEAsc,EAAA9gB,UAAA6E,QAAA,SAAAmQ,GACA,GAAAjC,KAAAkE,QAAAjC,EAAAiC,MACA,QAEA,IAAAlE,KAAAgP,QAAAnkB,SAAAoX,EAAA+M,QAAAnkB,OACA,QAEA,QAAAmH,GAAA,EAAuBA,EAAAgO,KAAAgP,QAAAnkB,OAAyBmH,IAChD,IAAAgO,KAAAgP,QAAAhd,GAAAF,QAAAmQ,EAAA+M,QAAAhd,IACA,QAGA,IAAAgO,KAAAiO,QAAApjB,SAAAoX,EAAAgM,QAAApjB,OACA,QAEA,QAAAmH,GAAA,EAAuBA,EAAAgO,KAAAiO,QAAApjB,OAAyBmH,IAChD,IAAAgO,KAAAiO,QAAAjc,GAAAF,QAAAmQ,EAAAgM,QAAAjc,IACA,QAGA,SAAAgO,KAAAzJ,KAAAzE,QAAAmQ,EAAA1L,SAGA,OAAAyJ,KAAAkO,SACAlO,KAAAkO,QAAApc,QAAAmQ,EAAAiM,SACA,OAAAjM,EAAAiM,WAGA,OAAAlO,KAAAmO,MACAnO,KAAAmO,MAAArc,QAAAmQ,EAAAkM,OACA,OAAAlM,EAAAkM,QAEAJ,EAAA9gB,UAAA2R,cAAA,SAAAiI,EAAAC,GAEA,OADAoJ,IAAA,EACAvlB,EAAA,EAAAokB,EAAA/O,KAAAgP,QAA2CrkB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAC3D,GAAAqkB,GAAAD,EAAApkB,GACAwlB,EAAAnB,EAAAoB,QAAAvJ,EAAAC,EACA,QAAAqJ,EACA,MAAAA,EACAD,MAAAlB,EAAA1b,MAAAiS,aAIA,MADAhZ,GAAA2jB,EAAA,kDACA,GAEAnC,EAAA9gB,UAAAojB,QAAA,SAAA7R,GACA,MAAAwB,MAAAsQ,gBAAA9R,IACAwB,KAAAuQ,eAAA/R,IACAwB,KAAAwQ,eAAAhS,IACAwB,KAAAyQ,cAAAjS,IAEAuP,EAAA9gB,UAAAyjB,SAAA,WACA,OAAA1d,EAAAgN,KAAAkE,QAEA6J,EAAA9gB,UAAA0hB,qBAAA,WACA,MAAA3O,MAAAgO,gBAAAnjB,OAAA,EACAmV,KAAAgO,gBAAA,GAAA1a,MACA,MAEAya,EAAA9gB,UAAAwhB,yBAAA,WACA,OAAA9jB,GAAA,EAAAokB,EAAA/O,KAAAiO,QAA2CtjB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAC3D,GAAAqa,GAAA+J,EAAApkB,EACA,IAAAqa,YAAAhR,KAAAgR,EAAAuK,eACA,MAAAvK,GAAA1R,MAGA,aAEAya,EAAA9gB,UAAAsO,gBAAA,WACA,MAAAuK,IAAAE,cAAAhG,KAAAzJ,OAAA,IAAAyJ,KAAAiO,QAAApjB,QAEAkjB,EAAA9gB,UAAAqjB,gBAAA,SAAA9R,GACA,GAAAmS,GAAAnS,EAAAnR,IAAAkJ,IACA,OAAAuP,IAAAE,cAAAhG,KAAAzJ,MAEAyJ,KAAAzJ,KAAAzE,QAAA6e,GAIA3Q,KAAAzJ,KAAAkO,WAAAkM,IAAA3Q,KAAAzJ,KAAA1L,SAAA8lB,EAAA9lB,OAAA,GAOAkjB,EAAA9gB,UAAAsjB,eAAA,SAAA/R,GACA,OAAA7T,GAAA,EAAAokB,EAAA/O,KAAAgO,gBAAmDrjB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACnE,GAAAqkB,GAAAD,EAAApkB,EAEA,KAAAqkB,EAAA1b,MAAAiS,kBACA5X,KAAA6Q,EAAAlL,MAAA0b,EAAA1b,OACA,SAGA,UAEAya,EAAA9gB,UAAAujB,eAAA,SAAAhS,GACA,OAAA7T,GAAA,EAAAokB,EAAA/O,KAAAiO,QAA2CtjB,EAAAokB,EAAAlkB,OAAgBF,IAE3D,IADAokB,EAAApkB,GACA0lB,QAAA7R,GACA,QAGA,WAKAuP,EAAA9gB,UAAAwjB,cAAA,SAAAjS,GACA,QAAAwB,KAAAkO,UAAAlO,KAAAkO,QAAA0C,oBAAA5Q,KAAAgP,QAAAxQ,IAGAwB,KAAAmO,OAAAnO,KAAAmO,MAAAyC,oBAAA5Q,KAAAgP,QAAAxQ,KAKAuP,EAAA9gB,UAAAqhB,iBAAA,SAAAuB,GACAtjB,EAAAsjB,EAAA3gB,SAAArE,QAAAmV,KAAAgP,QAAAnkB,OAAA,iCAEAkjB,KAGAra,GAAA,WACA,QAAAmd,GAAAhiB,GACAmR,KAAAnR,OA6BA,MA3BAgiB,GAAA9L,WAAA,SAAAxR,GACA,OAAAA,GACA,QACA,MAAAsd,GAAAC,SACA,UACA,MAAAD,GAAAE,kBACA,UACA,MAAAF,GAAAld,KACA,UACA,MAAAkd,GAAAG,qBACA,SACA,MAAAH,GAAAI,YACA,SACA,MAAA9kB,GAAA,qBAAAoH,KAGAsd,EAAA5jB,UAAA0T,SAAA,WACA,MAAAX,MAAAnR,MAEAgiB,EAAA5jB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAnR,OAAAoT,EAAApT,MAEAgiB,EAAAC,UAAA,GAAAD,GAAA,KACAA,EAAAE,mBAAA,GAAAF,GAAA,MACAA,EAAAld,MAAA,GAAAkd,GAAA,MACAA,EAAAI,aAAA,GAAAJ,GAAA,KACAA,EAAAG,sBAAA,GAAAH,GAAA,MACAA,KAGA7c,GAAA,WACA,QAAAkd,GAAA5d,EAAAC,EAAA9F,GACAuS,KAAA1M,QACA0M,KAAAzM,KACAyM,KAAAvS,QA2DA,MAzDAyjB,GAAAjkB,UAAAojB,QAAA,SAAA7R,GACA,GAAAwB,KAAA1M,MAAAiS,aAAA,CACAhZ,EAAAyT,KAAAvS,gBAAAif,IAAA,oDACA,IAAAyE,GAAAnR,KAAAvS,MACA2jB,EAAAtL,GAAAhC,WAAAtF,EAAAnR,IAAA8jB,EAAA9jB,IACA,OAAA2S,MAAAqR,kBAAAD,GAGA,GAAAphB,GAAAwO,EAAAlL,MAAA0M,KAAA1M,MACA,YAAA3F,KAAAqC,GAAAgQ,KAAAsR,aAAAthB,IAGAkhB,EAAAjkB,UAAAqkB,aAAA,SAAA7jB,GAEA,MAAAuS,MAAAvS,MAAA4d,YAAA5d,EAAA4d,WAGArL,KAAAqR,kBAAA5jB,EAAA6V,UAAAtD,KAAAvS,SAEAyjB,EAAAjkB,UAAAokB,kBAAA,SAAAD,GACA,OAAApR,KAAAzM,IACA,IAAAG,IAAAod,UACA,MAAAM,GAAA,CACA,KAAA1d,IAAAqd,mBACA,MAAAK,IAAA,CACA,KAAA1d,IAAAC,MACA,WAAAyd,CACA,KAAA1d,IAAAud,aACA,MAAAG,GAAA,CACA,KAAA1d,IAAAsd,sBACA,MAAAI,IAAA,CACA,SACA,MAAAjlB,GAAA,sBAAA6T,KAAAzM,MAGA2d,EAAAjkB,UAAAsiB,aAAA,WACA,MAAAvP,MAAAzM,KAAAG,GAAAC,OAEAud,EAAAjkB,UAAA8iB,YAAA,WAIA,MAAA/P,MAAA1M,MAAAwR,kBAAA9E,QAAAzM,GAAAyM,KAAAvS,OAEAyjB,EAAAjkB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAiP,IACAlR,KAAAzM,GAAAzB,QAAAmQ,EAAA1O,KACAyM,KAAA1M,MAAAxB,QAAAmQ,EAAA3O,QACA0M,KAAAvS,MAAAqE,QAAAmQ,EAAAxU,QAMAyjB,EAAAjkB,UAAA0T,SAAA,WACA,MAAAX,MAAA1M,MAAAwR,kBAAA,IAAA9E,KAAAzM,GAAA,IAAAyM,KAAAvS,eAEAyjB,KAMAtd,GAAA,WACA,QAAAA,GAAAN,GACA0M,KAAA1M,QAoBA,MAlBAM,GAAA3G,UAAAojB,QAAA,SAAA7R,GACA,GAAAxO,GAAAwO,EAAAlL,MAAA0M,KAAA1M,MACA,YAAA3F,KAAAqC,GAAA,OAAAA,EAAAvC,SAEAmG,EAAA3G,UAAA8iB,YAAA,WACA,MAAA/P,MAAA1M,MAAAwR,kBAAA,YAEAlR,EAAA3G,UAAA0T,SAAA,WACA,MAAAX,MAAA1M,MAAAwR,kBAAA,YAEAlR,EAAA3G,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAArO,IACAoM,KAAA1M,MAAAxB,QAAAmQ,EAAA3O,QAMAM,KAMAG,GAAA,WACA,QAAAA,GAAAT,GACA0M,KAAA1M,QAoBA,MAlBAS,GAAA9G,UAAAojB,QAAA,SAAA7R,GACA,GAAAxO,GAAAwO,EAAAlL,MAAA0M,KAAA1M,OAAA7F,OACA,uBAAAuC,IAAAjC,MAAAiC,IAEA+D,EAAA9G,UAAA8iB,YAAA,WACA,MAAA/P,MAAA1M,MAAAwR,kBAAA,WAEA/Q,EAAA9G,UAAA0T,SAAA,WACA,MAAAX,MAAA1M,MAAAwR,kBAAA,WAEA/Q,EAAA9G,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAlO,IACAiM,KAAA1M,MAAAxB,QAAAmQ,EAAA3O,QAMAS,KA0BAob,GAAA,WACA,QAAAA,GAAAtgB,GACAmR,KAAAnR,OAOA,MALAsgB,GAAAliB,UAAA0T,SAAA,WACA,MAAAX,MAAAnR,MAEAsgB,EAAAC,UAAA,GAAAD,GAAA,OACAA,EAAAoC,WAAA,GAAApC,GAAA,QACAA,KAiBAqC,GAAA,WACA,QAAAC,GAAAviB,EAAAwiB,GACA1R,KAAA9Q,WACA8Q,KAAA0R,SAsDA,MApDAD,GAAAxkB,UAAA8iB,YAAA,WAGA,OADAA,GAAA/P,KAAA0R,OAAA,UACA/mB,EAAA,EAAAokB,EAAA/O,KAAA9Q,SAA4CvE,EAAAokB,EAAAlkB,OAAgBF,IAE5DolB,GAAA4B,GADA5C,EAAApkB,EAGA,OAAAolB,IAMA0B,EAAAxkB,UAAA2jB,oBAAA,SAAA5B,EAAAxQ,GACAjS,EAAAyT,KAAA9Q,SAAArE,QAAAmkB,EAAAnkB,OAAA,iDAEA,QADAumB,GAAA,EACApf,EAAA,EAAuBA,EAAAgO,KAAA9Q,SAAArE,OAA0BmH,IAAA,CACjD,GAAA4f,GAAA5C,EAAAhd,GACA2f,EAAA3R,KAAA9Q,SAAA8C,EACA,IAAA4f,EAAAte,MAAAiS,aACAhZ,EAAAolB,YAAAjF,IAAA,+DACA0E,EAAAtL,GAAAhC,WAAA6N,EAAAtkB,IAAAmR,EAAAnR,SAEA,CACA,GAAAwkB,GAAArT,EAAAlL,MAAAse,EAAAte,MACA/G,OAAAoB,KAAAkkB,EAAA,kEACAT,EAAAO,EAAArO,UAAAuO,GAKA,GAHAD,EAAA1C,MAAAC,GAAAoC,aACAH,IAAA,GAEA,IAAAA,EACA,MAGA,MAAApR,MAAA0R,OAAAN,GAAA,EAAAA,EAAA,GAEAK,EAAAxkB,UAAA6E,QAAA,SAAAmQ,GACA,UAAAA,EACA,QAEA,IAAAjC,KAAA0R,SAAAzP,EAAAyP,QACA1R,KAAA9Q,SAAArE,SAAAoX,EAAA/S,SAAArE,OACA,QAEA,QAAAmH,GAAA,EAAuBA,EAAAgO,KAAA9Q,SAAArE,OAA0BmH,IAAA,CACjD,GAAA8f,GAAA9R,KAAA9Q,SAAA8C,GACA+f,EAAA9P,EAAA/S,SAAA8C,EACA,OAAA8f,GAAAhgB,QAAAigB,GAEA,UAEAN,KAMA5C,GAAA,WACA,QAAAmD,GAAA1e,EAAA4b,GACAlP,KAAA1M,YACA3F,KAAAuhB,IACAA,EAAAC,GAAAC,WAEApP,KAAAkP,MACAlP,KAAAiS,aAAA3e,EAAAiS,aAyBA,MAvBAyM,GAAA/kB,UAAAmjB,QAAA,SAAAvJ,EAAAC,GACA,GAAAsK,GAAApR,KAAAiS,aACA3L,GAAAM,aAAAC,EAAAC,GACAR,GAAAS,eAAA/G,KAAA1M,MAAAuT,EAAAC,EACA,QAAA9G,KAAAkP,KACA,IAAAC,IAAAC,UACA,MAAAgC,EACA,KAAAjC,IAAAoC,WACA,SAAAH,CACA,SACA,MAAAjlB,GAAA,sBAAA6T,KAAAkP,OAGA8C,EAAA/kB,UAAA8iB,YAAA,WAEA,MAAA/P,MAAA1M,MAAAwR,kBAAA9E,QAAAkP,KAEA8C,EAAA/kB,UAAA0T,SAAA,WACA,MAAAX,MAAA1M,MAAAwR,kBAAA,KAAA9E,KAAAkP,IAAA,KAEA8C,EAAA/kB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAkP,MAAAjN,EAAAiN,KAAAlP,KAAA1M,MAAAxB,QAAAmQ,EAAA3O,QAEA0e,KAGApD,GAAA,GAAAC,IAAA3J,GAAAM,WAAA2J,GAAAC,WACAC,GAAA,GAAAR,IAAA3J,GAAAM,WAAA2J,GAAAoC,Y6BzkBAW,GAAAC,OAAA,iDACAC,GAAA,WACA,QAAAC,GAAAC,EAAAC,GACAvS,KAAAsS,UACAtS,KAAAuS,QACAhmB,EAAAgmB,GAAA,yCAAAA,GACAhmB,EAAAgmB,EAAA,yCAAAA,GAEAhmB,EAAA+lB,IAAA,+CAAAA,GAEA/lB,EAAA+lB,EAAA,8CAAAA,GAiDA,MA/CAD,GAAAG,IAAA,WACA,MAAAH,GAAAI,sBAAAxnB,KAAAunB,QAEAH,EAAAK,SAAA,SAAAC,GACA,MAAAN,GAAAI,sBAAAE,EAAAC,YAEAP,EAAAI,sBAAA,SAAAI,GACA,GAAAP,GAAArR,KAAAC,MAAA2R,EAAA,IAEA,WAAAR,GAAAC,EADA,KAAAO,EAAA,IAAAP,KAGAD,EAAAS,cAAA,SAAAC,GAIA,GAAAR,GAAA,EACAS,EAAAd,GAAAjhB,KAAA8hB,EAEA,IADAxmB,IAAAymB,EAAA,sBAAAD,GACAC,EAAA,IAEA,GAAAC,GAAAD,EAAA,EACAC,MAAA,aAAAC,OAAA,KACAX,GAAAU,EAGA,GAAAN,GAAA,GAAA1nB,MAAA8nB,EAEA,WAAAV,GADApR,KAAAC,MAAAyR,EAAAC,UAAA,KACAL,IAEAF,EAAAplB,UAAAof,OAAA,WACA,UAAAphB,MAAA+U,KAAAmT,wBAEAd,EAAAplB,UAAAkmB,oBAAA,WACA,WAAAnT,KAAAsS,QAAAtS,KAAAuS,MAAA,KAEAF,EAAAplB,UAAAqW,UAAA,SAAArB,GACA,MAAAjC,MAAAsS,UAAArQ,EAAAqQ,QACA5gB,EAAAsO,KAAAuS,MAAAtQ,EAAAsQ,OAEA7gB,EAAAsO,KAAAsS,QAAArQ,EAAAqQ,UAEAD,EAAAplB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,GAAAqQ,UAAAtS,KAAAsS,SAAArQ,EAAAsQ,QAAAvS,KAAAuS,OAEAF,EAAAplB,UAAA0T,SAAA,WACA,2BAAAX,KAAAsS,QAAA,WAAAtS,KAAAuS,MAAA,KAEAF,KCzDAe,GAAA,WACA,QAAAC,GAAAC,GACAtT,KAAAsT,YAiCA,MA7BAD,GAAAE,iBAAA,SAAA9lB,GACA,GAAA6kB,GAAArR,KAAAC,MAAAzT,EAAA,IAEA,WAAA4lB,GAAA,GAAAjB,IAAAE,EADA7kB,EAAA,WAGA4lB,EAAAG,cAAA,SAAA/lB,GACA,UAAA4lB,GAAA5lB,IAEA4lB,EAAAI,cAAA,WACA,MAAAJ,GAAAK,KAEAL,EAAApmB,UAAAqW,UAAA,SAAArB,GACA,MAAAjC,MAAAsT,UAAAhQ,UAAArB,EAAAqR,YAEAD,EAAApmB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAsT,UAAAxhB,QAAAmQ,EAAAqR,YAGAD,EAAApmB,UAAA0mB,eAAA,WAEA,WAAA3T,KAAAsT,UAAAhB,QAAAtS,KAAAsT,UAAAf,MAAA,KAEAc,EAAApmB,UAAA0T,SAAA,WACA,yBAAAX,KAAAsT,UAAA,KAEAD,EAAApmB,UAAA2mB,YAAA,WACA,MAAA5T,MAAAsT,WAEAD,EAAAK,IAAA,GAAAL,GAAA,GAAAjB,IAAA,MACAiB,MFpCA,SAAA5I,GAEAA,IAAA,mBAIAA,IAAA,qDAEAA,IAAA,sCACCA,YAID,IG+DAoJ,IH/DAC,GAAA,WACA,QAAAC,GAEApV,EAKAqV,EAEAC,EAEAC,EAOAhe,OACA,KAAAge,IAAyCA,EAAAd,GAAAM,SACzC,KAAAxd,IAAqCA,EAAAzJ,KACrCuT,KAAArB,QACAqB,KAAAgU,WACAhU,KAAAiU,UACAjU,KAAAkU,kBACAlU,KAAA9J,cAgBA,MAVA6d,GAAA9mB,UAAAknB,OAAA,SAAAC,GACA,UAAAL,GAAA/T,KAAArB,MAAAqB,KAAAgU,SAAAhU,KAAAiU,QAAAG,EAAAF,gBAAAE,EAAAle,cAEA6d,EAAA9mB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAgU,WAAA/R,EAAA+R,UACAhU,KAAAiU,UAAAhS,EAAAgS,SACAjU,KAAAkU,gBAAApiB,QAAAmQ,EAAAiS,kBACAlU,KAAA9J,cAAA+L,EAAA/L,aACA8J,KAAArB,MAAA7M,QAAAmQ,EAAAtD,QAEAoV,KG3DAM,GAAArU,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,QAkBA+T,GAAA,WACA,QAAAC,GAAAC,GACAxU,KAAAwU,SAMA,MAHAD,GAAAtnB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAlQ,GAAAiO,KAAAwU,OAAAvS,EAAAuS,SAEAD,KAIAE,GAAA,WACA,QAAAA,MAMA,MAJAA,GAAAxnB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAwS,IAEAA,EAAA/U,SAAA,GAAA+U,GACAA,KAIAC,GAAA,WACA,QAAAA,GAAAphB,EAAAqhB,GACA3U,KAAA1M,QACA0M,KAAA2U,YAKA,MAHAD,GAAAznB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAA1M,MAAAxB,QAAAmQ,EAAA3O,QAAA0M,KAAA2U,UAAA7iB,QAAAmQ,EAAA0S,YAEAD,KAIAE,GAAA,WACA,QAAAA,GAIApO,EAQAqO,GACA7U,KAAAwG,UACAxG,KAAA6U,mBAEA,MAAAD,OAIA,SAAAf,GACAA,IAAA,aACAA,IAAA,iBACAA,IAAA,yBACAA,IAAA,oBACCA,YAMD,I9B/EAze,I8B+EA0f,GAAA,WACA,QAAAC,GAAAC,EAAAC,GACAjV,KAAAgV,aACAhV,KAAAiV,SACA1oB,MAAAoB,KAAAqnB,OAAArnB,KAAAsnB,EAAA,kEA6CA,MA1CAF,GAAAE,OAAA,SAAAA,GACA,UAAAF,OAAApnB,GAAAsnB,IAGAF,EAAAC,WAAA,SAAAxO,GACA,UAAAuO,GAAAvO,IAEAlZ,OAAAqS,eAAAoV,EAAA9nB,UAAA,UAEAwK,IAAA,WACA,WAAA9J,KAAAqS,KAAAgV,gBAAArnB,KAAAqS,KAAAiV,QAEAvS,YAAA,EACAC,cAAA,IAMAoS,EAAA9nB,UAAAioB,WAAA,SAAAC,GACA,WAAAxnB,KAAAqS,KAAAgV,WACAG,YAAA7O,KACA6O,EAAA3O,QAAA1U,QAAAkO,KAAAgV,gBAEArnB,KAAAqS,KAAAiV,OACAjV,KAAAiV,OACAE,YAAA7O,IAGA,OAAA6O,eAAAjO,KAIA3a,EAAAyT,KAAAoV,OAAA,iCACA,IAGAL,EAAA9nB,UAAA6E,QAAA,SAAAmQ,GACA,MAAApQ,GAAAmO,KAAAgV,WAAA/S,EAAA+S,aACAhV,KAAAiV,SAAAhT,EAAAgT,QAEAF,EAAAM,KAAA,GAAAN,GACAA,KAyCAO,GAAA,WACA,QAAAC,MAqBA,MAnBAA,GAAAtoB,UAAAuoB,iBAAA,SAAAL,GACA,MAAAA,GACA5oB,EAAA4oB,EAAA9nB,IAAAyE,QAAAkO,KAAA3S,KAAA,8DASAkoB,EAAAE,uBAAA,SAAAN,GACA,MAAAA,aAAA7O,IACA6O,EAAA3O,QAGA4M,GAAAM,KAGA6B,KAOAG,GAAA,SAAAjV,GAEA,QAAAkV,GAAAtoB,EAAAI,EAAAmoB,GACA,GAAAlV,GAAAD,EAAAlT,KAAAyS,WAKA,OAJAU,GAAArT,MACAqT,EAAAjT,QACAiT,EAAAkV,eACAlV,EAAAzR,KAAA4kB,GAAApX,IACAiE,EA6BA,MApCA2T,IAAAsB,EAAAlV,GASAkV,EAAA1oB,UAAA4oB,sBAAA,SAAAV,EAAAW,GACA9V,KAAAwV,iBAAAL,GACA5oB,EAAA,MAAAupB,EAAAjB,iBAAA,6CAIA,IAAArO,GAAA8O,GAAAG,uBAAAN,EACA,WAAA7O,IAAAtG,KAAA3S,IAAAmZ,EAAAxG,KAAAvS,OACAiZ,mBAAA,KAGAiP,EAAA1oB,UAAA8oB,iBAAA,SAAAZ,EAAAa,EAAAzJ,GAEA,GADAvM,KAAAwV,iBAAAL,IACAnV,KAAA4V,aAAAV,WAAAC,GACA,MAAAA,EAEA,IAAA3O,GAAA8O,GAAAG,uBAAAN,EACA,WAAA7O,IAAAtG,KAAA3S,IAAAmZ,EAAAxG,KAAAvS,OACAiZ,mBAAA,KAGAiP,EAAA1oB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAA0T,IACA3V,KAAA3S,IAAAyE,QAAAmQ,EAAA5U,MACA2S,KAAAvS,MAAAqE,QAAAmQ,EAAAxU,QACAuS,KAAA4V,aAAA9jB,QAAAmQ,EAAA2T,eAEAD,GACCL,IAeDW,GAAA,SAAAxV,GAEA,QAAAyV,GAAA7oB,EAAAoZ,EAAA0P,EAAAP,GACA,GAAAlV,GAAAD,EAAAlT,KAAAyS,WAMA,OALAU,GAAArT,MACAqT,EAAA+F,OACA/F,EAAAyV,YACAzV,EAAAkV,eACAlV,EAAAzR,KAAA4kB,GAAAuC,MACA1V,EAiEA,MAzEA2T,IAAA6B,EAAAzV,GAUAyV,EAAAjpB,UAAA4oB,sBAAA,SAAAV,EAAAW,GASA,GARA9V,KAAAwV,iBAAAL,GACA5oB,EAAA,MAAAupB,EAAAjB,iBAAA,iDAOA7U,KAAA4V,aAAAV,WAAAC,GACA,MAAAA,EAEA,IAAA3O,GAAA8O,GAAAG,uBAAAN,GACAkB,EAAArW,KAAAsW,cAAAnB,EACA,WAAA7O,IAAAtG,KAAA3S,IAAAmZ,EAAA6P,GACA3P,mBAAA,KAGAwP,EAAAjpB,UAAA8oB,iBAAA,SAAAZ,EAAAa,EAAAzJ,GAEA,GADAvM,KAAAwV,iBAAAL,IACAnV,KAAA4V,aAAAV,WAAAC,GACA,MAAAA,EAEA,IAAA3O,GAAA8O,GAAAG,uBAAAN,GACAkB,EAAArW,KAAAsW,cAAAnB,EACA,WAAA7O,IAAAtG,KAAA3S,IAAAmZ,EAAA6P,GACA3P,mBAAA,KAGAwP,EAAAjpB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAiU,IACAlW,KAAA3S,IAAAyE,QAAAmQ,EAAA5U,MACA2S,KAAAmW,UAAArkB,QAAAmQ,EAAAkU,YACAnW,KAAA4V,aAAA9jB,QAAAmQ,EAAA2T,eAOAM,EAAAjpB,UAAAqpB,cAAA,SAAAnB,GACA,GAAA1O,EAOA,OALAA,GADA0O,YAAA7O,IACA6O,EAAA1O,KAGAoG,GAAAxG,MAEArG,KAAAuW,YAAA9P,IAEAyP,EAAAjpB,UAAAspB,YAAA,SAAA9P,GACA,OAAA9b,GAAA,EAAAokB,EAAA/O,KAAAmW,UAAA3B,OAAoD7pB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACpE,GAAA6rB,GAAAzH,EAAApkB,GACA8rB,EAAAzW,KAAAyG,KAAAnT,MAAAkjB,EAEA/P,OADA9Y,KAAA8oB,EACAhQ,EAAA0G,IAAAqJ,EAAAC,GAGAhQ,EAAAzH,OAAAwX,GAGA,MAAA/P,IAEAyP,GACCZ,IAWDoB,GAAA,SAAAjW,GAEA,QAAAkW,GAAAtpB,EAAAupB,GACA,GAAAlW,GAAAD,EAAAlT,KAAAyS,WAQA,OAPAU,GAAArT,MACAqT,EAAAkW,kBACAlW,EAAAzR,KAAA4kB,GAAAgD,UAIAnW,EAAAkV,aAAAd,GAAAG,QAAA,GACAvU,EA8FA,MAxGA2T,IAAAsC,EAAAlW,GAYAkW,EAAA1pB,UAAA4oB,sBAAA,SAAAV,EAAAW,GACA9V,KAAAwV,iBAAAL,GACA5oB,EAAA,MAAAupB,EAAAjB,iBAAA,mDACA,IAAAA,GAAAiB,EAAAjB,gBAOA,KAAA7U,KAAA4V,aAAAV,WAAAC,GACA,MAAAA,EAEA,IAAA3W,GAAAwB,KAAA8W,gBAAA3B,GACAkB,EAAArW,KAAA+W,gBAAAvY,EAAAiI,KAAAoO,EACA,WAAAvO,IAAAtG,KAAA3S,IAAAmR,EAAAgI,QAAA6P,GACA3P,mBAAA,KAGAiQ,EAAA1pB,UAAA8oB,iBAAA,SAAAZ,EAAAa,EAAAzJ,GAEA,GADAvM,KAAAwV,iBAAAL,IACAnV,KAAA4V,aAAAV,WAAAC,GACA,MAAAA,EAEA,IAAA3W,GAAAwB,KAAA8W,gBAAA3B,GACAN,EAAA7U,KAAAgX,sBAAAzK,EAAAyJ,GACAK,EAAArW,KAAA+W,gBAAAvY,EAAAiI,KAAAoO,EACA,WAAAvO,IAAAtG,KAAA3S,IAAAmR,EAAAgI,QAAA6P,GACA3P,mBAAA,KAGAiQ,EAAA1pB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAA0U,IACA3W,KAAA3S,IAAAyE,QAAAmQ,EAAA5U,MACA0E,EAAAiO,KAAA4W,gBAAA3U,EAAA2U,kBACA5W,KAAA4V,aAAA9jB,QAAAmQ,EAAA2T,eAQAe,EAAA1pB,UAAA6pB,gBAAA,SAAA3B,GACA5oB,EAAA4oB,YAAA7O,IAAA,8BAAA6O,EACA,IAAA3W,GAAA2W,CAEA,OADA5oB,GAAAiS,EAAAnR,IAAAyE,QAAAkO,KAAA3S,KAAA,mDACAmR,GAYAmY,EAAA1pB,UAAA+pB,sBAAA,SAAAzK,EAAAyJ,GAEA,OADAnB,MACAlqB,EAAA,EAAAokB,EAAA/O,KAAA4W,gBAAmDjsB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACnE,GAAAssB,GAAAlI,EAAApkB,GACAgqB,EAAAsC,EAAAtC,SACA,MAAAA,YAAAF,KAQA,MAAAtoB,GAAA,kCAAAwoB,EAPA,IAAAnI,GAAA,IACAwJ,aAAA1P,MACAkG,EAAAwJ,EAAA1iB,MAAA2jB,EAAA3jB,QAAA,MAEAuhB,EAAA5kB,KAAA,GAAAqc,IAAAC,EAAAC,IAMA,MAAAqI,IAEA8B,EAAA1pB,UAAA8pB,gBAAA,SAAAtQ,EAAAoO,GACAtoB,EAAAsoB,EAAAhqB,SAAAmV,KAAA4W,gBAAA/rB,OAAA,oCACA,QAAAmH,GAAA,EAAuBA,EAAAgO,KAAA4W,gBAAA/rB,OAAiCmH,IAAA,CACxD,GAAAilB,GAAAjX,KAAA4W,gBAAA5kB,GACA2iB,EAAAsC,EAAAtC,UACA6B,EAAAS,EAAA3jB,KACA,MAAAqhB,YAAAF,KAIA,MAAAtoB,GAAA,kCAAAwoB,EAHAlO,KAAA0G,IAAAqJ,EAAA3B,EAAA7iB,IAMA,MAAAyU,IAEAkQ,GACCrB,IAGD4B,GAAA,SAAAzW,GAEA,QAAA0W,GAAA9pB,EAAAuoB,GACA,GAAAlV,GAAAD,EAAAlT,KAAAyS,WAIA,OAHAU,GAAArT,MACAqT,EAAAkV,eACAlV,EAAAzR,KAAA4kB,GAAAuD,OACA1W,EAyBA,MA/BA2T,IAAA8C,EAAA1W,GAQA0W,EAAAlqB,UAAA4oB,sBAAA,SAAAV,EAAAW,GAMA,MALA9V,MAAAwV,iBAAAL,GACA5oB,EAAA,MAAAupB,EAAAjB,iBAAA,iDAIA,GAAA3N,IAAAlH,KAAA3S,IAAA+lB,GAAAM,MAEAyD,EAAAlqB,UAAA8oB,iBAAA,SAAAZ,EAAAa,EAAAzJ,GAEA,MADAvM,MAAAwV,iBAAAL,GACAnV,KAAA4V,aAAAV,WAAAC,IAGAA,GACA5oB,EAAA4oB,EAAA9nB,IAAAyE,QAAAkO,KAAA3S,KAAA,qDAEA,GAAA6Z,IAAAlH,KAAA3S,IAAA+lB,GAAAK,kBALA0B,GAOAgC,EAAAlqB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,aAAAkV,IACAnX,KAAA3S,IAAAyE,QAAAmQ,EAAA5U,MACA2S,KAAA4V,aAAA9jB,QAAAmQ,EAAA2T,eAEAuB,GACC7B,IC5eD+B,GAAA,WAEA,QAAAA,GAAAC,GACAtX,KAAAsX,QAKA,MAHAD,GAAApqB,UAAA6E,QAAA,SAAAmQ,GACA,MAAAA,MAAAqV,QAAAtX,KAAAsX,OAEAD,M/BMA,SAAAjiB,GACAA,IAAA,WACAA,IAAA,yBACAA,IAAA,qBACAA,IAAA,uCACAA,IAAA,yCACAA,IAAA,yBACAA,IAAA,mCACAA,IAAA,yCACAA,IAAA,sCACAA,IAAA,2CACAA,IAAA,6CACAA,IAAA,sBACAA,IAAA,gCACAA,IAAA,kCACAA,IAAA,wBACAA,IAAA,8BACAA,IAAA,2BACCA,YgCxBD,ICkDAmiB,IDlDAC,GAAA,WACA,QAAAC,GAAA3T,GACA9D,KAAA8D,aACA9D,KAAAyG,KAAA,GAAAW,IAAApH,KAAA8D,YAqHA,MA/GA2T,GAAAC,YAAA,SAAAtsB,GACA,GAAAusB,GAAA,GAAAF,GAAArsB,EAAA0Y,WAIA,OAHA1Y,GAAA4C,QAAA,SAAAX,GACAsqB,IAAA1Y,IAAA5R,KAEAsqB,GAEAF,EAAAxqB,UAAA2qB,IAAA,SAAAC,GACA,cAAA7X,KAAAyG,KAAAhP,IAAAogB,IAEAJ,EAAAxqB,UAAA6qB,MAAA,WACA,MAAA9X,MAAAyG,KAAAqB,UAEA2P,EAAAxqB,UAAA8qB,KAAA,WACA,MAAA/X,MAAAyG,KAAAsB,UAEAza,OAAAqS,eAAA8X,EAAAxqB,UAAA,QACAwK,IAAA,WACA,MAAAuI,MAAAyG,KAAArC,MAEA1B,YAAA,EACAC,cAAA,IAEA8U,EAAAxqB,UAAAsE,QAAA,SAAAsmB,GACA,MAAA7X,MAAAyG,KAAAlV,QAAAsmB,IAGAJ,EAAAxqB,UAAAe,QAAA,SAAAgqB,GACAhY,KAAAyG,KAAAuB,iBAAA,SAAAE,EAAAC,GAEA,MADA6P,GAAA9P,IACA,KAIAuP,EAAAxqB,UAAAgrB,eAAA,SAAAC,EAAAF,GAEA,IADA,GAAAG,GAAAnY,KAAAyG,KAAA8B,gBAAA2P,EAAA,IACAC,EAAAnP,WAAA,CACA,GAAA6O,GAAAM,EAAArP,SACA,IAAA9I,KAAA8D,WAAA+T,EAAAxqB,IAAA6qB,EAAA,OACA,MACAF,GAAAH,EAAAxqB,OAMAoqB,EAAAxqB,UAAAmrB,aAAA,SAAAJ,EAAAzf,GACA,GAAA4f,EAOA,KALAA,MADAxqB,KAAA4K,EACAyH,KAAAyG,KAAA8B,gBAAAhQ,GAGAyH,KAAAyG,KAAA4B,cAEA8P,EAAAnP,WAGA,IADAgP,EADAG,EAAArP,UACAzb,KAEA,QAIAoqB,EAAAxqB,UAAAorB,kBAAA,SAAAR,GACA,GAAAM,GAAAnY,KAAAyG,KAAA8B,gBAAAsP,EACA,OAAAM,GAAAnP,UAAAmP,EAAArP,UAAAzb,IAAA,MAGAoqB,EAAAxqB,UAAAgS,IAAA,SAAA4Y,GACA,MAAA7X,MAAAwH,KAAAxH,KAAAyG,KAAAiB,OAAAmQ,GAAAtQ,OAAAsQ,GAAA,KAGAJ,EAAAxqB,UAAA+R,OAAA,SAAA6Y,GACA,MAAA7X,MAAA4X,IAAAC,GAEA7X,KAAAwH,KAAAxH,KAAAyG,KAAAiB,OAAAmQ,IADA7X,MAGAyX,EAAAxqB,UAAAgB,QAAA,WACA,MAAA+R,MAAAyG,KAAAxY,WAEAwpB,EAAAxqB,UAAAqrB,UAAA,SAAArW,GACA,GAAA9T,GAAA6R,IAIA,OAHAiC,GAAAjU,QAAA,SAAA6pB,GACA1pB,IAAA8Q,IAAA4Y,KAEA1pB,GAEAspB,EAAAxqB,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAAwV,IACA,QACA,IAAAzX,KAAAoE,OAAAnC,EAAAmC,KACA,QAGA,KAFA,GAAAmU,GAAAvY,KAAAyG,KAAA4B,cACAmQ,EAAAvW,EAAAwE,KAAA4B,cACAkQ,EAAAvP,WAAA,CACA,GAAAyP,GAAAF,EAAAzP,UAAAzb,IACAqrB,EAAAF,EAAA1P,UAAAzb,GACA,QAAA2S,KAAA8D,WAAA2U,EAAAC,GACA,SAEA,UAEAjB,EAAAxqB,UAAA0T,SAAA,WACA,GAAAxS,KAEA,OADA6R,MAAAhS,QAAA,SAAA6pB,GAAsC,MAAA1pB,GAAA8B,KAAA4nB,KACtC,aAAA1pB,EAAA,KAEAspB,EAAAxqB,UAAAua,KAAA,SAAAf,GACA,GAAAtY,GAAA,GAAAspB,GAAAzX,KAAA8D,WAEA,OADA3V,GAAAsY,OACAtY,GAEAspB,K/B7HAhiB,GAAA,GAAA2R,IAAAtB,GAAAhC,YAIAnO,GAAA,GAAAyR,IAAAtB,GAAAhC,YAIAjO,GAAA,GAAAuR,IAAAtB,GAAAhC,YAIA/N,GAAA,GAAAyhB,IAAA1R,GAAAhC,YgCPA6U,GAAA,WACA,QAAAC,GAIA1E,EAIA2E,EAKAC,GACA9Y,KAAAkU,kBACAlU,KAAA6Y,gBACA7Y,KAAA8Y,kBAwBA,MAtBAF,GAAA3rB,UAAA8rB,kBAAA,SAAAva,GACAwB,KAAA8Y,gBAAA9Y,KAAA8Y,gBAAAvR,OAAA/I,EAAAnR,IAAAmR,IAEAoa,EAAA3rB,UAAA+rB,8BAAA,SAAAhF,GAYAhU,KAAA6Y,cAAA7E,IACAiF,QAAA,GAAAC,IACAhF,gBAAAd,GAAAM,IACAyF,oBAAA5B,GAAA6B,eACAljB,YAAAzJ,MAGAmsB,MAUA,SAAArB,GAEAA,IAAA,eAEAA,IAAA,mCAEAA,IAAA,8BACCA,YACD,I/B3BA8B,I+B2BAC,GAAAxjB,KACAojB,GAAA,WACA,QAAAA,KACAlZ,KAAAuZ,KAAAD,GAkBA,MAhBAhsB,QAAAqS,eAAAuZ,EAAAjsB,UAAA,aACAwK,IAAA,WACA,MAAAuI,MAAAuZ,MAEA7W,YAAA,EACAC,cAAA,IAEAuW,EAAAjsB,UAAAgS,IAAA,SAAA5R,GACA2S,KAAAuZ,KAAAvZ,KAAAuZ,KAAAta,IAAA5R,IAEA6rB,EAAAjsB,UAAA+R,OAAA,SAAA3R,GACA2S,KAAAuZ,KAAAvZ,KAAAuZ,KAAAva,OAAA3R,IAEA6rB,EAAAjsB,UAAA6E,QAAA,SAAAmQ,GACA,cAAAA,GAAAjC,KAAAuZ,KAAAznB,QAAAmQ,EAAAsX,OAEAL,KAGAM,GAAA,WACA,QAAAA,KACAxZ,KAAAyZ,eAAAH,GACAtZ,KAAA0Z,iBAAAJ,GAqBA,MAnBAE,GAAAvsB,UAAA0sB,cAAA,SAAAhC,GACA,GAAAxpB,GAAAwpB,CAGA,OAFA3X,MAAAyZ,eAAAzrB,QAAA,SAAAX,GAAoD,MAAAc,KAAA8Q,IAAA5R,KACpD2S,KAAA0Z,iBAAA1rB,QAAA,SAAAX,GAAsD,MAAAc,KAAA6Q,OAAA3R,KACtDc,GAEAqrB,EAAAvsB,UAAAgS,IAAA,SAAA5R,GACA2S,KAAAyZ,eAAAzZ,KAAAyZ,eAAAxa,IAAA5R,GACA2S,KAAA0Z,iBAAA1Z,KAAA0Z,iBAAA1a,OAAA3R,IAEAmsB,EAAAvsB,UAAA+R,OAAA,SAAA3R,GACA2S,KAAAyZ,eAAAzZ,KAAAyZ,eAAAza,OAAA3R,GACA2S,KAAA0Z,iBAAA1Z,KAAA0Z,iBAAAza,IAAA5R,IAEAmsB,EAAAvsB,UAAA6E,QAAA,SAAAmQ,GACA,cAAAA,GACAjC,KAAAyZ,eAAA3nB,QAAAmQ,EAAAwX,iBACAzZ,KAAA0Z,iBAAA5nB,QAAAmQ,EAAAyX,mBAEAF,K/BxGAI,GAAA,WACA,QAAAA,GAEAC,EAEAC,EAEAzsB,EAKA0sB,GACA/Z,KAAA6Z,mBACA7Z,KAAA8Z,mBACA9Z,KAAA3S,MACA2S,KAAA+Z,SAEA,MAAAH,MAGAI,GAAA,WACA,QAAAA,GAAAhG,EAAAiG,GACAja,KAAAgU,WACAhU,KAAAia,kBAEA,MAAAD,OAIA,SAAAX,GACAA,IAAA,uBACAA,IAAA,iBACAA,IAAA,qBACAA,IAAA,qBACAA,IAAA,kBACCA,YACD,IAAAa,IAAA,WACA,QAAAC,GAEAC,EAEAC,EAOAnkB,EAEAokB,OACA,KAAApkB,IAAqCA,EAAAzJ,SACrC,KAAA6tB,IAA+BA,EAAA,MAC/Bta,KAAAoa,QACApa,KAAAqa,YACAra,KAAA9J,cACA8J,KAAAsa,QAEA,MAAAH,MAOAI,GAAA,WACA,QAAAC,GAAAtG,EAAAuG,EAAAC,GACA1a,KAAAkU,kBACAlU,KAAAya,gBAEAza,KAAA2a,oBAEA3a,KAAA6Y,iBAEA7Y,KAAA8Y,gBAAAtjB,KAEAwK,KAAA4a,QAAA,EACA5a,KAAA0a,uBAAAxsB,EAAAwsB,GAmKA,MAhKAF,GAAAvtB,UAAAgS,IAAA,SAAA4b,GACAtuB,GAAAyT,KAAA4a,OAAA,kDACAC,YAAAjB,IACA5Z,KAAA8a,kBAAAD,GAEAA,YAAAX,IACAla,KAAA+a,gBAAAF,GAEAA,YAAAb,IACAha,KAAAgb,yBAAAH,GAGA1uB,EAAA,yBAAA0uB,IAIAL,EAAAvtB,UAAAguB,WAAA,SAAAC,GACA,GAAAxa,GAAAV,IACAzT,IAAAyT,KAAA4a,OAAA,kDACAM,EAAAltB,QAAA,SAAAiI,GAAgD,MAAAyK,GAAAzB,IAAAhJ,MAMhDukB,EAAAvtB,UAAAkuB,kBAAA,WACA,GAAAza,GAAAV,KACA6Y,EAAA7Y,KAAA6Y,aASA,OAPAjrB,GAAAoS,KAAA6Y,cAAA,SAAA7E,GACAtT,EAAA0a,eAAApH,UACA6E,GAAA7E,KAIAhU,KAAA4a,QAAA,EACA,GAAAjC,IAAA3Y,KAAAkU,gBAAA2E,EAAA7Y,KAAA8Y,kBAEA0B,EAAAvtB,UAAAouB,mBAAA,SAAArH,GACA,GAAA/d,GAAA+J,KAAA6Y,cAAA7E,EAWA,OAVA/d,KAEAA,GACAkjB,oBAAA5B,GAAA+D,KACApH,gBAAAlU,KAAAkU,gBACA+E,QAAA,GAAAO,IACAtjB,YAAAzJ,KAEAuT,KAAA6Y,cAAA7E,GAAA/d,GAEAA,GAUAukB,EAAAvtB,UAAAmuB,eAAA,SAAApH,GACA,OAAA5mB,EAAA4S,KAAA0a,uBAAA1G,IACA5mB,EAAA4S,KAAAya,cAAAzG,IAEAwG,EAAAvtB,UAAA6tB,kBAAA,SAAAS,GAEA,OADAC,IAAA,EACA7wB,EAAA,EAAAokB,EAAAwM,EAAA1B,iBAAyDlvB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACzE,GAAAqpB,GAAAjF,EAAApkB,EACA,IAAAqV,KAAAob,eAAApH,GAAA,CACA,GAAA/d,GAAA+J,KAAAqb,mBAAArH,EACA/d,GAAAgjB,QAAAha,IAAAsc,EAAAluB,KACAmuB,GAAA,GAGA,OAAAxL,GAAA,EAAAC,EAAAsL,EAAAzB,iBAAyD9J,EAAAC,EAAAplB,OAAgBmlB,IAAA,CACzE,GAAAgE,GAAA/D,EAAAD,EACA,IAAAhQ,KAAAob,eAAApH,GAAA,CACA,GAAA/d,GAAA+J,KAAAqb,mBAAArH,EACA/d,GAAAgjB,QAAAja,OAAAuc,EAAAluB,KACAmuB,GAAA,GAMAD,EAAAxB,QAAAyB,IACAxb,KAAA8Y,gBAAA9Y,KAAA8Y,gBAAAvR,OAAAgU,EAAAluB,IAAAkuB,EAAAxB,UAGAS,EAAAvtB,UAAA8tB,gBAAA,SAAAU,GACA,GAAA/a,GAAAV,IACAyb,GAAApB,UAAArsB,QAAA,SAAAgmB,GACA,GAAA/d,GAAAyK,EAAA2a,mBAAArH,EACA,QAAAyH,EAAArB,OACA,IAAAf,IAAAqC,SACAhb,EAAA0a,eAAApH,IAEAhe,GAAAC,EAAAwlB,EAAAvlB,YAEA,MACA,KAAAmjB,IAAAniB,MAGAwJ,EAAAib,qBAAA3H,GACA5mB,EAAAsT,EAAAga,uBAAA1G,KAIA/d,EAAAgjB,QAAA,GAAAO,IACAvjB,EAAAkjB,oBAAA5B,GAAA+D,WACA5a,GAAAia,iBAAA3G,IAEAhe,GAAAC,EAAAwlB,EAAAvlB,YACA,MACA,KAAAmjB,IAAAhiB,QAKAqJ,EAAAib,qBAAA3H,GACAznB,GAAAkvB,EAAAnB,MAAA,wDACA,MACA,KAAAjB,IAAAuC,QACAlb,EAAA0a,eAAApH,KACA/d,EAAAkjB,oBAAA5B,GAAAsE,YACA7lB,GAAAC,EAAAwlB,EAAAvlB,aAEA,MACA,KAAAmjB,IAAAyC,MACApb,EAAA0a,eAAApH,KAIA/d,EAAAgjB,QAAA,GAAAC,IACAljB,GAAAC,EAAAwlB,EAAAvlB,aAEA,MACA,SACA/J,EAAA,sCAAAsvB,EAAArB,WAQAI,EAAAvtB,UAAA0uB,qBAAA,SAAA3H,GACA,GAAA+H,IAAA/b,KAAA0a,uBAAA1G,IAAA,IACA,KAAA+H,QACA/b,MAAA0a,uBAAA1G,GAGAhU,KAAA0a,uBAAA1G,GAAA+H,GAGAvB,EAAAvtB,UAAA+tB,yBAAA,SAAA/kB,GACA+J,KAAAob,eAAAnlB,EAAA+d,YACAhU,KAAA2a,iBAAA1kB,EAAA+d,UAAA/d,EAAAgkB,kBAGAO,KCzOAwB,GAAA,WACA,GAAAC,KAGA,OAFAA,GAAA9M,GAAAC,UAAAvgB,MAAA,YACAotB,EAAA9M,GAAAoC,WAAA1iB,MAAA,aACAotB,KAEAC,GAAA,WACA,GAAAC,KAMA,OALAA,GAAAzoB,GAAAod,UAAAjiB,MAAA,YACAstB,EAAAzoB,GAAAqd,mBAAAliB,MAAA,qBACAstB,EAAAzoB,GAAAud,aAAApiB,MAAA,eACAstB,EAAAzoB,GAAAsd,sBAAAniB,MAAA,wBACAstB,EAAAzoB,GAAAC,MAAA9E,MAAA,QACAstB,KAuBAC,GAAA,WACA,QAAAC,GAAAxZ,EAAAzR,GACA4O,KAAA6C,aACA7C,KAAA5O,UAs+BA,MAp+BAirB,GAAApvB,UAAAR,gBAAA,WACA,MAAAuT,MAAA5O,QAAAkrB,cACA,GAGA,GAAA5pB,YAAA,IAGA2pB,EAAApvB,UAAAsvB,0BAAA,SAAAC,GAGA,MAAAA,IAEAH,EAAApvB,UAAAwvB,cAAA,SAAAtnB,GACA,GAAAjB,OAAAvG,KAAAwH,EAAAjB,KACAnH,GAAAsH,QACAgB,EAAAF,EAAAjB,KACA,WAAApH,IAAAoH,EAAAiB,EAAA9I,SAAA,KAUAgwB,EAAApvB,UAAAyvB,aAAA,SAAA1sB,GACA,MAAAgD,GAAAhD,OAKA,IAHoBvC,MAAAuC,IAapBqsB,EAAApvB,UAAA0vB,eAAA,SAAA3sB,GACA,GAAA7B,EAUA,OAPAA,GAFA,gBAAA6B,GAEAA,EAAAvC,MAKAuC,EAEAgD,EAAA7E,GAAA,KAAAA,GASAkuB,EAAApvB,UAAA2mB,YAAA,SAAAN,GACA,OACAhB,QAAAgB,EAAAhB,QACAC,MAAAe,EAAAf,QAIA8J,EAAApvB,UAAAumB,cAAA,SAAAb,GAIA,mBAAAA,GAIA,MAAAP,IAAAU,cAAAH,EAGApmB,KAAAomB,EAAA,kDAIA,IAAAL,GAAAlc,GAAAuc,EAAAL,SAAA,KACAC,EAAAI,EAAAJ,OAAA,CACA,WAAAH,IAAAE,EAAAC,IAUA8J,EAAApvB,UAAA2vB,QAAA,SAAAC,GACA,MAAA7c,MAAA5O,QAAAkrB,cACAO,EAAAhb,WAIA7B,KAAAuc,0BAAAM,EAAA9a,iBAQAsa,EAAApvB,UAAA6vB,SAAA,SAAAC,GACA,sBAAAA,IACAxwB,EAAAyT,KAAA5O,QAAAkrB,cAAA,2EACAvf,GAAAwE,iBAAAwb,KAGAxwB,GAAAyT,KAAA5O,QAAAkrB,cAAA,6EACAvf,GAAA2E,eAAAqb,KAGAV,EAAApvB,UAAA+vB,UAAA,SAAAxW,GACA,MAAAxG,MAAA4T,YAAApN,EAAAoN,gBAEAyI,EAAApvB,UAAAgwB,YAAA,SAAAzW,GAEA,MADAja,KAAAia,EAAA,gDACA4M,GAAAI,cAAAxT,KAAAwT,cAAAhN,KAEA6V,EAAApvB,UAAAiwB,eAAA,SAAAra,EAAAtM,GACA,MAAAyJ,MAAAmd,yBAAAta,GACAkB,MAAA,aACAA,MAAAxN,GACAuO,mBAEAuX,EAAApvB,UAAAmwB,iBAAA,SAAAvuB,GACA,GAAAwuB,GAAAnlB,GAAA6M,WAAAlW,EAEA,OADAtC,GAAAyT,KAAAsd,oBAAAD,GAAA,oCAAAA,GACAA,GAEAhB,EAAApvB,UAAAswB,OAAA,SAAAlwB,GACA,MAAA2S,MAAAkd,eAAAld,KAAA6C,WAAAxV,EAAAkJ,OAEA8lB,EAAApvB,UAAAuwB,SAAA,SAAA3uB,GACA,GAAAwuB,GAAArd,KAAAod,iBAAAvuB,EAUA,OATAtC,GAAA8wB,EAAA5lB,IAAA,KAAAuI,KAAA6C,WAAAO,UAAA,oDACAia,EAAA5lB,IAAA,GACA,OACAuI,KAAA6C,WAAAO,WACA7W,GAAA8wB,EAAA5lB,IAAA,KAAAuI,KAAA6C,WAAAQ,UACAga,EAAA5lB,IAAA,KAAAuI,KAAA6C,WAAAQ,SAAA,qDACAga,EAAA5lB,IAAA,GACA,OACAuI,KAAA6C,WAAAQ,UACA,GAAAyC,IAAA9F,KAAAyd,iCAAAJ,KAEAhB,EAAApvB,UAAAywB,YAAA,SAAAnnB,GACA,WAAAA,EAAA1L,OAGAmV,KAAA2d,kBAEA3d,KAAAkd,eAAAld,KAAA6C,WAAAtM,IAEA8lB,EAAApvB,UAAA2wB,cAAA,SAAA/uB,GACA,GAAAgvB,GAAA7d,KAAAod,iBAAAvuB,EACA,YAAAgvB,EAAAhzB,OACAqN,GAAAC,WAEA6H,KAAAyd,iCAAAI,IAEAvwB,OAAAqS,eAAA0c,EAAApvB,UAAA,qBACAwK,IAAA,WAOA,MANA,IAAAS,KACA,WACA8H,KAAA6C,WAAAO,UACA,YACApD,KAAA6C,WAAAQ,WAEAyB,mBAEApC,YAAA,EACAC,cAAA,IAEA0Z,EAAApvB,UAAAkwB,yBAAA,SAAAta,GACA,UAAA3K,KACA,WACA2K,EAAAO,UACA,YACAP,EAAAQ,YAGAgZ,EAAApvB,UAAAwwB,iCAAA,SAAAI,GAEA,MADAtxB,GAAAsxB,EAAAhzB,OAAA,iBAAAgzB,EAAApmB,IAAA,uCAAAomB,GACAA,EAAA1Z,SAAA,IAEAkY,EAAApvB,UAAAqwB,oBAAA,SAAA/mB,GAEA,MAAAA,GAAA1L,QAAA,GACA,aAAA0L,EAAAkB,IAAA,IACA,cAAAlB,EAAAkB,IAAA,IAEA4kB,EAAApvB,UAAA6wB,QAAA,SAAA9tB,GACA,GAAAA,YAAAwD,IACA,OAAoBuqB,UAAA,aAEpB,IAAA/tB,YAAAub,IACA,OAAoByS,aAAAhuB,EAAAvC,QAEpB,IAAAuC,YAAA6b,IACA,OAAoBoS,aAAA,GAAAjuB,EAAAvC,QAEpB,IAAAuC,YAAA6D,IAAA,CACA,GAAAqqB,GAAAluB,EAAAvC,OACA,IAAAuS,KAAA5O,QAAAkrB,cAAA,CAIA,GAAAvuB,MAAAmwB,GACA,OAA4BA,YAAA,MAE5B,IAAAA,IAAAlS,IACA,OAA4BkS,YAAA,WAE5B,IAAAA,KAAA,IACA,OAA4BA,YAAA,aAG5B,OAAoBA,YAAAluB,EAAAvC,SAEpB,MAAAuC,aAAAkc,KACoBiS,YAAAnuB,EAAAvC,SAEpBuC,YAAA6c,KACoBuR,SAAApe,KAAAqe,WAAAruB,IAEpBA,YAAAyd,KACoB6Q,WAAAte,KAAAue,aAAAvuB,IAEpBA,YAAAoc,KAEAoS,eAAAxe,KAAA4T,YAAA5jB,EAAAsb,gBAGAtb,YAAA4c,KAEA6R,eACApc,SAAArS,EAAAvC,QAAA4U,SACAC,UAAAtS,EAAAvC,QAAA6U,YAIAtS,YAAAyc,KAEAiS,WAAA1e,KAAA4c,QAAA5sB,EAAAvC,UAGAuC,YAAA0c,KAEAiS,eAAA3e,KAAAkd,eAAAltB,EAAA6S,WAAA7S,EAAA3C,IAAAkJ,OAIApK,EAAA,sBAAAuE,KAAAC,UAAAX,KAGAqsB,EAAApvB,UAAA2xB,UAAA,SAAAl0B,GACA,GAAAgW,GAAAV,KAEA/Q,EAAAvE,EAAA,UACA,IAAA2L,GAAA3L,EAAAuE,EAAA,aACA,MAAAuE,IAAAC,QAEA,IAAA4C,GAAA3L,EAAAuE,EAAA,gBACA,MAAAsc,IAAAE,GAAA/gB,EAAAszB,aAEA,IAAA3nB,GAAA3L,EAAAuE,EAAA,gBACA,UAAA4c,IAAAzV,GAAA1L,EAAAuzB,cAEA,IAAA5nB,GAAA3L,EAAAuE,EAAA,gBACA,GAAA+Q,KAAA5O,QAAAkrB,cAAA,CAEA,WAAA5xB,EAAAwzB,YACA,MAAArqB,IAAAC,GAEA,iBAAApJ,EAAAwzB,YACA,MAAArqB,IAAAkY,iBAEA,kBAAArhB,EAAAwzB,YACA,MAAArqB,IAAAoY,kBAGA,UAAApY,IAAAnJ,EAAAwzB,aAEA,GAAA7nB,GAAA3L,EAAAuE,EAAA,eACA,UAAAid,IAAAxhB,EAAAyzB,YAEA,IAAA9nB,GAAA3L,EAAAuE,EAAA,YACA,MAAA+Q,MAAA6e,WAAAn0B,EAAA0zB,SAAA5J,WAEA,IAAAne,GAAA3L,EAAAuE,EAAA,eAEAkH,GAAAzL,EAAA4zB,WAAA,aACA,IAAAQ,GAAAp0B,EAAA4zB,WAAAQ,UACA,WAAArR,IAAAqR,EAAA1zB,IAAA,SAAA+c,GAAsE,MAAAzH,GAAAke,UAAAzW,MAEtE,GAAA9R,GAAA3L,EAAAuE,EAAA,kBAEA,MADAkH,IAAAzL,EAAA8zB,eAAA,kBACA,GAAApS,IAAApM,KAAAwT,cAAA9oB,EAAA8zB,gBAEA,IAAAnoB,GAAA3L,EAAAuE,EAAA,kBACAkH,GAAAzL,EAAA+zB,cAAA,gBACA,IAAApc,GAAA3X,EAAA+zB,cAAApc,UAAA,EACAC,EAAA5X,EAAA+zB,cAAAnc,WAAA,CACA,WAAAsK,IAAA,GAAA9P,IAAAuF,EAAAC,IAEA,GAAAjM,GAAA3L,EAAAuE,EAAA,eACAkH,GAAAzL,EAAAg0B,WAAA,aACA,IAAA3B,GAAA/c,KAAA8c,SAAApyB,EAAAg0B,WACA,WAAAjS,IAAAsQ,GAEA,GAAA1mB,GAAA3L,EAAAuE,EAAA,mBACAkH,GAAAzL,EAAAi0B,eAAA,iBACA,IAAAd,GAAA7d,KAAAod,iBAAA1yB,EAAAi0B,gBACAI,EAAA,GAAA7b,IAAA2a,EAAApmB,IAAA,GAAAomB,EAAApmB,IAAA,IACApK,EAAA,GAAAyY,IAAA9F,KAAAyd,iCAAAI,GACA,WAAAnR,IAAAqS,EAAA1xB,GAGA,MAAAlB,GAAA,uBAAAuE,KAAAC,UAAAjG,KAIA2xB,EAAApvB,UAAA+xB,mBAAA,SAAA3xB,EAAAmnB,GACA,OACA3lB,KAAAmR,KAAAud,OAAAlwB,GACAmnB,OAAAxU,KAAAif,SAAAzK,KAGA6H,EAAApvB,UAAAiyB,WAAA,SAAAC,GAEA,MADA5yB,IAAA4yB,EAAAzY,kBAAA,8CAEA7X,KAAAmR,KAAAud,OAAA4B,EAAA9xB,KACAmnB,OAAAxU,KAAAif,SAAAE,EAAA1Y,MACAuO,WAAAhV,KAAA4T,YAAAuL,EAAA3Y,QAAAoN,iBAGAyI,EAAApvB,UAAAmyB,aAAA,SAAAD,GACA,UAAA7Y,IAAAtG,KAAAwd,SAAA2B,EAAAtwB,MAAAmR,KAAAid,YAAAkC,EAAAnK,YAAAhV,KAAA6e,WAAAM,EAAA3K,aAA0I9N,mBAAA,KAE1I2V,EAAApvB,UAAAgyB,SAAA,SAAAzK,GACA,GAAA9T,GAAAV,KACA7R,IAIA,OAHAqmB,GAAAxmB,QAAA,SAAAX,EAAAI,GACAU,EAAAd,GAAAqT,EAAAod,QAAArwB,KAEAU,GAEAkuB,EAAApvB,UAAA4xB,WAAA,SAAA1iB,GACA,GAAAuE,GAAAV,KAEA5U,EAAA+Q,EACAhO,EAAA0e,GAAAxG,KAIA,OAHArY,GAAA5C,EAAA,SAAAiC,EAAAI,GACAU,IAAAgf,IAAA,GAAAjI,KAAA7X,IAAAqT,EAAAke,UAAAnxB,MAEAU,GAEAkuB,EAAApvB,UAAAoxB,WAAA,SAAAjzB,GACA,OACAopB,OAAAxU,KAAAif,SAAA7zB,KAGAixB,EAAApvB,UAAAsxB,aAAA,SAAA5c,GACA,GAAAjB,GAAAV,KACA7R,IAIA,OAHAwT,GAAA3T,QAAA,SAAAP,GACAU,EAAA8B,KAAAyQ,EAAAod,QAAArwB,OAEgBqxB,OAAA3wB,IAEhBkuB,EAAApvB,UAAAoyB,UAAA,SAAA7gB,GACAjS,IAAAiS,EAAA8gB,MAAA,kEACAnpB,GAAAqI,EAAA8gB,MAAAzwB,KAAA,kBACAsH,GAAAqI,EAAA8gB,MAAAtK,WAAA,uBACA,IAAA3nB,GAAA2S,KAAAwd,SAAAhf,EAAA8gB,MAAAzwB,MACA2X,EAAAxG,KAAAid,YAAAze,EAAA8gB,MAAAtK,YACAR,EAAAxU,KAAA6e,WAAArgB,EAAA8gB,MAAA9K,WACA,WAAAlO,IAAAjZ,EAAAmZ,EAAAgO,GAAmD9N,mBAAA,KAEnD2V,EAAApvB,UAAAsyB,YAAA,SAAApxB,GACA5B,IAAA4B,EAAAqxB,QAAA,kEACAjzB,IAAA4B,EAAAsxB,SAAA,+DACA,IAAApyB,GAAA2S,KAAAwd,SAAArvB,EAAAqxB,SACAhZ,EAAAxG,KAAAid,YAAA9uB,EAAAsxB,SACA,WAAAvY,IAAA7Z,EAAAmZ,IAEA6V,EAAApvB,UAAAyyB,kBAAA,SAAAvxB,GAEA,GAAAc,GAAAd,EAAA,MACA,OAAAkI,IAAAlI,EAAAc,EAAA,SACA+Q,KAAAqf,UAAAlxB,GAEAkI,GAAAlI,EAAAc,EAAA,WACA+Q,KAAAuf,YAAApxB,GAEAhC,EAAA,+BAAAuE,KAAAC,UAAAxC,KAEAkuB,EAAApvB,UAAA0yB,yBAAA,SAAAvF,GACA,OAAAA,GACA,IAAAf,IAAAniB,MACA,WACA,KAAAmiB,IAAAuC,QACA,eACA,KAAAvC,IAAAqC,SACA,iBACA,KAAArC,IAAAhiB,QACA,cACA,KAAAgiB,IAAAyC,MACA,aACA,SACA,MAAA3vB,GAAA,mCAAAiuB,KAGAiC,EAAApvB,UAAA2yB,kBAAA,SAAA/E,GACA,GAAAA,YAAAb,IACA,OACAhV,QACAsS,MAAAuD,EAAAZ,gBAAA3C,MACAtD,SAAA6G,EAAA7G,UAIA,IAAA6G,YAAAjB,IAAA,CACA,GAAAiB,EAAAd,iBAAAzT,IAAA,CACA,GAAA9H,GAAAqc,EAAAd,MACA,QACA8F,gBACAV,UACAtwB,KAAAmR,KAAAud,OAAA/e,EAAAnR,KACAmnB,OAAAxU,KAAAif,SAAAzgB,EAAAiI,MACAuO,WAAAhV,KAAAgd,UAAAxe,EAAAgI,UAEA6T,UAAAQ,EAAAhB,iBACAC,iBAAAe,EAAAf,mBAIA,GAAAe,EAAAd,iBAAA7S,IAAA,CACA,GAAA1I,GAAAqc,EAAAd,MACA,QACA+F,gBACAX,SAAAnf,KAAAud,OAAA/e,EAAAnR,KACAoyB,SAAAzf,KAAAgd,UAAAxe,EAAAgI,SACAsT,iBAAAe,EAAAf,mBAIA,UAAAe,EAAAd,OACA,OACAgG,gBACAZ,SAAAnf,KAAAud,OAAA1C,EAAAxtB,KACAysB,iBAAAe,EAAAf,mBAKA,GAAAe,YAAAX,IAAA,CACA,GAAAI,OAAA3sB,EAOA,OANAktB,GAAAP,QACAA,GACApmB,KAAAoB,EAAAulB,EAAAP,MAAApmB,MACA7H,QAAAwuB,EAAAP,MAAAjuB,WAIAovB,cACAuE,iBAAAhgB,KAAA2f,yBAAA9E,EAAAT,OACAC,UAAAQ,EAAAR,UACAnkB,YAAA8J,KAAAuc,0BAAA1B,EAAA3kB,aACAokB,UAIA,MAAAnuB,GAAA,8BAAAuE,KAAAC,UAAAkqB,KAEAwB,EAAApvB,UAAAgzB,gBAAA,SAAAhqB,GAEA,GACA4kB,GADA5rB,EAAAgH,EAAA,aAEA,IAAAI,GAAAJ,EAAAhH,EAAA,iBACAkH,GAAAF,EAAAwlB,aAAA,eAGA,IAAArB,GAAApa,KAAAkgB,2BAAAjqB,EAAAwlB,aAAAuE,kBAAA,aACA3F,EAAApkB,EAAAwlB,aAAApB,cACAnkB,EAAAD,EAAAwlB,aAAAvlB,aAAA8J,KAAAvT,kBACA0zB,EAAAlqB,EAAAwlB,aAAAnB,MACAA,EAAA6F,GAAAngB,KAAAyc,cAAA0D,EACAtF,GAAA,GAAAX,IAAAE,EAAAC,EAAAnkB,EAAAokB,GAAA,UAEA,IAAAjkB,GAAAJ,EAAAhH,EAAA,mBACAkH,GAAAF,EAAA4pB,eAAA,kBACA1pB,GAAAF,EAAA4pB,eAAAV,SAAA,uBACAhpB,GAAAF,EAAA4pB,eAAAV,SAAAtwB,KAAA,gCACAsH,GAAAF,EAAA4pB,eAAAV,SAAAnK,WAAA,qCACA,IAAAoL,GAAAnqB,EAAA4pB,eACAxyB,EAAA2S,KAAAwd,SAAA4C,EAAAjB,SAAAtwB,MACA2X,EAAAxG,KAAAid,YAAAmD,EAAAjB,SAAAnK,YACAR,EAAAxU,KAAA6e,WAAAuB,EAAAjB,SAAA3K,YACAhW,EAAA,GAAA8H,IAAAjZ,EAAAmZ,EAAAgO,GACA9N,mBAAA,IAEAmT,EAAAuG,EAAA/F,cACAP,EAAAsG,EAAAtG,oBACAe,GAAA,GAAAjB,IAAAC,EAAAC,EAAAtb,EAAAnR,IAAAmR,OAEA,IAAAnI,GAAAJ,EAAAhH,EAAA,mBACAkH,GAAAF,EAAA6pB,eAAA,kBACA3pB,GAAAF,EAAA6pB,eAAAX,SAAA,0BACA,IAAAkB,GAAApqB,EAAA6pB,eACAzyB,EAAA2S,KAAAwd,SAAA6C,EAAAlB,UACA3Y,EAAA6Z,EAAAZ,SACAzf,KAAAid,YAAAoD,EAAAZ,UACArM,GAAAK,gBACAjV,EAAA,GAAA0I,IAAA7Z,EAAAmZ,GACAsT,EAAAuG,EAAAvG,oBACAe,GAAA,GAAAjB,OAAAE,EAAAtb,EAAAnR,IAAAmR,OAEA,IAAAnI,GAAAJ,EAAAhH,EAAA,mBACAkH,GAAAF,EAAA8pB,eAAA,kBACA5pB,GAAAF,EAAA8pB,eAAAZ,SAAA,iBACA,IAAAmB,GAAArqB,EAAA8pB,eACA1yB,EAAA2S,KAAAwd,SAAA8C,EAAAnB,UACArF,EAAAwG,EAAAxG,oBACAe,GAAA,GAAAjB,OAAAE,EAAAzsB,EAAA,UAEA,KAAAgJ,GAAAJ,EAAAhH,EAAA,UAWA,MAAA9C,GAAA,uBAAAuE,KAAAC,UAAAsF,GATAE,IAAAF,EAAA+O,OAAA,UACA7O,GAAAF,EAAA+O,OAAAgP,SAAA,kBACA,IAAAhP,GAAA/O,EAAA+O,OACAsS,EAAAtS,EAAAsS,OAAA,EACA2C,EAAA,GAAA5C,IAAAC,GACAtD,EAAAhP,EAAAgP,QACA6G,GAAA,GAAAb,IAAAhG,EAAAiG,GAKA,MAAAY,IAEAwB,EAAApvB,UAAAizB,2BAAA,SAAA9F,GACA,oBAAAA,EACAf,GAAAqC,SAEA,QAAAtB,EACAf,GAAAniB,MAEA,WAAAkjB,EACAf,GAAAhiB,QAEA,YAAA+iB,EACAf,GAAAuC,QAEA,UAAAxB,EACAf,GAAAyC,MAGA3vB,EAAA,sCAAAiuB,IAGAiC,EAAApvB,UAAAszB,0BAAA,SAAAtqB,GAMA,IAAAI,GAAAJ,EADAA,EAAA,cACA,gBACA,MAAAmd,IAAAM,GAEA,IAAA+H,GAAAxlB,EAAAwlB,YACA,OAAAA,GAAApB,WAAAoB,EAAApB,UAAAxvB,OACAuoB,GAAAM,IAEA+H,EAAAgE,SAGAzf,KAAAid,YAAAxB,EAAAgE,UAFArM,GAAAM,KAIA2I,EAAApvB,UAAAuzB,WAAA,SAAAC,GACA,GACAtyB,GADAuS,EAAAV,IAEA,IAAAygB,YAAA/K,IACAvnB,GACAgmB,OAAAnU,KAAAgf,mBAAAyB,EAAApzB,IAAAozB,EAAAhzB,YAGA,IAAAgzB,YAAAvJ,IACA/oB,GAAsB6Q,OAAAgB,KAAAud,OAAAkD,EAAApzB,UAEtB,IAAAozB,YAAAxK,IACA9nB,GACAgmB,OAAAnU,KAAAgf,mBAAAyB,EAAApzB,IAAAozB,EAAAha,MACAia,WAAA1gB,KAAA2gB,eAAAF,EAAAtK,gBAGA,MAAAsK,YAAA/J,KAWA,MAAAvqB,GAAA,yBAAAs0B,EAAAxxB,KAVAd,IACAwmB,WACAwK,SAAAnf,KAAAud,OAAAkD,EAAApzB,KACAupB,gBAAA6J,EAAA7J,gBAAAxrB,IAAA,SAAAupB,GACA,MAAAjU,GAAAkgB,iBAAAjM,OAWA,MAHA8L,GAAA7K,aAAAR,SACAjnB,EAAA0yB,gBAAA7gB,KAAA8gB,eAAAL,EAAA7K,eAEAznB,GAEAkuB,EAAApvB,UAAA8zB,aAAA,SAAAC,GACA,GAAAtgB,GAAAV,KACA4V,EAAAoL,EAAAH,gBACA7gB,KAAAihB,iBAAAD,EAAAH,iBACA/L,GAAAO,IACA,IAAA2L,EAAA7M,OAAA,CACAhe,GAAA6qB,EAAA7M,OAAAtlB,KAAA,OACA,IAAAxB,GAAA2S,KAAAwd,SAAAwD,EAAA7M,OAAAtlB,MACApB,EAAAuS,KAAA6e,WAAAmC,EAAA7M,OAAAK,WACA,IAAAwM,EAAAN,WAAA,CACA,GAAAvK,GAAAnW,KAAAkhB,iBAAAF,EAAAN,WACA,WAAAzK,IAAA5oB,EAAAI,EAAA0oB,EAAAP,GAGA,UAAAF,IAAAroB,EAAAI,EAAAmoB,GAGA,GAAAoL,EAAAhiB,OAAA,CACA,GAAA3R,GAAA2S,KAAAwd,SAAAwD,EAAAhiB,OACA,WAAAkY,IAAA7pB,EAAAuoB,GAEA,GAAAoL,EAAArM,UAAA,CACA,GAAAtnB,GAAA2S,KAAAwd,SAAAwD,EAAArM,UAAAwK,UACAvI,EAAAoK,EAAArM,UAAAiC,gBAAAxrB,IAAA,SAAAupB,GACA,MAAAjU,GAAAygB,mBAAAxM,IAGA,OADApoB,IAAA,IAAAqpB,EAAAX,OAAA,yDACA,GAAAyB,IAAArpB,EAAAupB,GAGA,MAAAzqB,GAAA,2BAAAuE,KAAAC,UAAAqwB,KAGA3E,EAAApvB,UAAA6zB,eAAA,SAAAlL,GAEA,MADArpB,IAAAqpB,EAAAR,OAAA,6CACAznB,KAAAioB,EAAAZ,YAEAA,WAAAhV,KAAAgd,UAAApH,EAAAZ,iBAGArnB,KAAAioB,EAAAX,QACoBA,OAAAW,EAAAX,QAGpB9oB,EAAA,yBAGAkwB,EAAApvB,UAAAg0B,iBAAA,SAAArL,GACA,WAAAjoB,KAAAioB,EAAAZ,WACAF,GAAAE,WAAAhV,KAAAid,YAAArH,EAAAZ,iBAEArnB,KAAAioB,EAAAX,OACAH,GAAAG,OAAAW,EAAAX,QAGAH,GAAAO,MAGAgH,EAAApvB,UAAAm0B,gBAAA,SAAAJ,GACA,GAAAtgB,GAAAV,KAEAwG,EAAAwa,EAAAhM,WACAhV,KAAAid,YAAA+D,EAAAhM,YACA,KACAH,EAAA,IAMA,OALAmM,GAAAnM,kBAAAmM,EAAAnM,iBAAAhqB,OAAA,IACAgqB,EAAAmM,EAAAnM,iBAAAzpB,IAAA,SAAA+C,GACA,MAAAuS,GAAAke,UAAAzwB,MAGA,GAAAymB,IAAApO,EAAAqO,IAEAwH,EAAApvB,UAAAo0B,iBAAA,SAAAC,GACA,GAAA5gB,GAAAV,IACA,QAAAshB,OAAAl2B,IAAA,SAAA41B,GAAoD,MAAAtgB,GAAA0gB,gBAAAJ,MAEpD3E,EAAApvB,UAAA2zB,iBAAA,SAAA3J,GAEA,MADA1qB,GAAA0qB,EAAAtC,oBAAAF,IAAA,sBAAAwC,EAAAtC,YAEA6B,UAAAS,EAAA3jB,MAAAwR,kBACAyc,iBAAA,iBAGAlF,EAAApvB,UAAAk0B,mBAAA,SAAAH,GACAz0B,EAAA,iBAAAy0B,EAAAO,iBAAA,4BAAA7wB,KAAAC,UAAAqwB,GACA,IAAAxK,GAAAtR,GAAAO,iBAAAub,EAAAxK,UACA,WAAA9B,IAAA8B,EAAA/B,GAAA/U,WAEA2c,EAAApvB,UAAAu0B,kBAAA,SAAA7iB,GACA,OAAgBlD,WAAAuE,KAAA0d,YAAA/e,EAAApI,SAEhB8lB,EAAApvB,UAAAw0B,oBAAA,SAAAC,GACA,GAAApK,GAAAoK,EAAAjmB,UAAA5Q,MACA0B,GAAA,IAAA+qB,EAAA,oDAAAA,EACA,IAAAzoB,GAAA6yB,EAAAjmB,UAAA,EACA,OAAAqS,IAAAS,OAAAvO,KAAA4d,cAAA/uB,KAEAwtB,EAAApvB,UAAA00B,cAAA,SAAAhjB,GAEA,GAAAxQ,IAAsByzB,mBACtB,IAAAjjB,EAAApI,KAAAtI,UACAE,EAAA0zB,OAAA7hB,KAAA0d,YAAAxlB,GAAAC,gBAEA,CACA,GAAA5B,GAAAoI,EAAApI,IACAhK,GAAAgK,EAAA1L,OAAA,yDACAsD,EAAA0zB,OAAA7hB,KAAA0d,YAAAnnB,EAAA8N,WACAlW,EAAAyzB,gBAAAE,OAA4CC,aAAAxrB,EAAAgO,gBAE5C,GAAAyd,GAAAhiB,KAAAiiB,SAAAtjB,EAAAsP,QACA+T,KACA7zB,EAAAyzB,gBAAAI,QAEA,IAAAhT,GAAAhP,KAAAkiB,QAAAvjB,EAAAqQ,QACAA,KACA7gB,EAAAyzB,gBAAA5S,UAEA,IAAA9K,GAAAlE,KAAA0c,aAAA/d,EAAAuF,MAUA,YATAvW,KAAAuW,IACA/V,EAAAyzB,gBAAA1d,SAEAvF,EAAAuP,UACA/f,EAAAyzB,gBAAA1T,QAAAlO,KAAAmiB,SAAAxjB,EAAAuP,UAEAvP,EAAAwP,QACAhgB,EAAAyzB,gBAAAzT,MAAAnO,KAAAmiB,SAAAxjB,EAAAwP,QAEAhgB,GAEAkuB,EAAApvB,UAAAm1B,gBAAA,SAAA/nB,GACA,GAAA9D,GAAAyJ,KAAA4d,cAAAvjB,EAAAwnB,QACAljB,EAAAtE,EAAAunB,gBACAS,EAAA1jB,EAAAmjB,KAAAnjB,EAAAmjB,KAAAj3B,OAAA,CACA,IAAAw3B,EAAA,GACA91B,EAAA,IAAA81B,EAAA,uEACA,IAAAP,GAAAnjB,EAAAmjB,KAAA,EACAvrB,KAAAwN,MAAA+d,EAAAC,cAEA,GAAAO,KACA3jB,GAAAqjB,QACAM,EAAAtiB,KAAAuiB,WAAA5jB,EAAAqjB,OAEA,IAAAhT,KACArQ,GAAAqQ,UACAA,EAAAhP,KAAAwiB,UAAA7jB,EAAAqQ,SAEA,IAAA9K,GAAA,IACAvF,GAAAuF,QACAA,EAAAlE,KAAA2c,eAAAhe,EAAAuF,OAEA,IAAAgK,GAAA,IACAvP,GAAAuP,UACAA,EAAAlO,KAAAyiB,WAAA9jB,EAAAuP,SAEA,IAAAC,GAAA,IAIA,OAHAxP,GAAAwP,QACAA,EAAAnO,KAAAyiB,WAAA9jB,EAAAwP,QAEA,GAAAL,IAAAvX,EAAAyY,EAAAsT,EAAApe,EAAAgK,EAAAC,IAEAkO,EAAApvB,UAAAy1B,sBAAA,SAAAC,GACA,GAAAl1B,GAAAuS,KAAA4iB,QAAAD,EAAA1O,QACA,cAAAxmB,EACA,MAIAo1B,mBAAAp1B,IAIA4uB,EAAApvB,UAAA21B,QAAA,SAAA3O,GACA,OAAAA,GACA,IAAAxJ,IAAAqY,OACA,WACA,KAAArY,IAAAsY,wBACA,iCACA,KAAAtY,IAAAuY,gBACA,sBACA,SACA,MAAA72B,GAAA,+BAAA8nB,KAGAoI,EAAApvB,UAAAg2B,SAAA,SAAAN,GACA,GAAAx0B,GACAwQ,EAAAgkB,EAAAhkB,KAWA,OATAxQ,GADAwQ,EAAApD,mBACsBE,UAAAuE,KAAAwhB,kBAAA7iB,KAGAA,MAAAqB,KAAA2hB,cAAAhjB,IAEtBxQ,EAAA6lB,SAAA2O,EAAA3O,SACA2O,EAAAzsB,YAAArL,OAAA,IACAsD,EAAA+H,YAAA8J,KAAAuc,0BAAAoG,EAAAzsB,cAEA/H,GAEAkuB,EAAApvB,UAAAg1B,SAAA,SAAAhU,GACA,GAAAvN,GAAAV,IACA,QAAAiO,EAAApjB,OAAA,CAEA,GAAAy2B,GAAArT,EAAA7iB,IAAA,SAAA4Z,GACA,MAAAA,aAAAhR,IACA0M,EAAAwiB,iBAAAle,GACAtE,EAAAyiB,cAAAne,IAEA,YAAAsc,EAAAz2B,OACAy2B,EAAA,IAEgB8B,iBAAmB7vB,GAAA,MAAA0a,QAAAqT,MAEnCjF,EAAApvB,UAAAs1B,WAAA,SAAAvd,GACA,GAAAtE,GAAAV,IACA,OAAAgF,OAGArX,KAAAqX,EAAAqe,aACArjB,KAAAsjB,gBAAAte,QAEArX,KAAAqX,EAAA3R,aACA2M,KAAAujB,mBAAAve,QAEArX,KAAAqX,EAAAoe,gBACApe,EAAAoe,gBAAAnV,QACA7iB,IAAA,SAAAo4B,GAAmC,MAAA9iB,GAAA6hB,WAAAiB,KACnCC,OAAA,SAAAC,EAAAhe,GAAmD,MAAAge,GAAAh4B,OAAAga,KAGnDvZ,EAAA,mBAAAuE,KAAAC,UAAAqU,QAGAqX,EAAApvB,UAAAi1B,QAAA,SAAAyB,GACA,GAAAjjB,GAAAV,IACA,QAAA2jB,EAAA94B,OAEA,MAAA84B,GAAAv4B,IAAA,SAAA4L,GAA8C,MAAA0J,GAAAkjB,gBAAA5sB,MAE9CqlB,EAAApvB,UAAAu1B,UAAA,SAAAmB,GACA,GAAAjjB,GAAAV,IACA,OAAA2jB,GAAAv4B,IAAA,SAAA4L,GAA8C,MAAA0J,GAAAmjB,kBAAA7sB,MAE9CqlB,EAAApvB,UAAAk1B,SAAA,SAAA2B,GACA,GAAApjB,GAAAV,IACA,QACA0R,OAAAoS,EAAApS,OACAoN,OAAAgF,EAAA50B,SAAA9D,IAAA,SAAAumB,GAA8D,MAAAjR,GAAAod,QAAAnM,OAG9D0K,EAAApvB,UAAAw1B,WAAA,SAAAqB,GACA,GAAApjB,GAAAV,KACA0R,IAAAoS,EAAApS,OACAxiB,EAAA40B,EAAAhF,OAAA1zB,IAAA,SAAAumB,GAA+D,MAAAjR,GAAAke,UAAAjN,IAC/D,WAAAH,IAAAtiB,EAAAwiB,IAGA2K,EAAApvB,UAAA82B,YAAA,SAAA7U,GACA,MAAA8M,IAAA9M,EAAArgB,OAGAwtB,EAAApvB,UAAA+2B,cAAA,SAAA9U,GACA,OAAAA,GACA,gBACA,MAAAC,IAAAC,SACA,kBACA,MAAAD,IAAAoC,UACA,SACA,SAIA8K,EAAApvB,UAAAg3B,eAAA,SAAA1wB,GACA,MAAA2oB,IAAA3oB,EAAA1E,OAEAwtB,EAAApvB,UAAAi3B,iBAAA,SAAA3wB,GACA,OAAAA,GACA,YACA,MAAAG,IAAAC,KACA,oBACA,MAAAD,IAAAud,YACA,6BACA,MAAAvd,IAAAsd,qBACA,iBACA,MAAAtd,IAAAod,SACA,0BACA,MAAApd,IAAAqd,kBACA,4BACA,MAAA5kB,GAAA,uBACA,SACA,MAAAA,GAAA,sBAGAkwB,EAAApvB,UAAAk3B,qBAAA,SAAA5tB,GACA,OAAgBigB,UAAAjgB,EAAAuO,oBAEhBuX,EAAApvB,UAAAm3B,uBAAA,SAAAC,GACA,MAAAnf,IAAAO,iBAAA4e,EAAA7N,YAGA6F,EAAApvB,UAAA22B,gBAAA,SAAA5U,GACA,OACA1b,MAAA0M,KAAAmkB,qBAAAnV,EAAA1b,OACAgxB,UAAAtkB,KAAA+jB,YAAA/U,EAAAE,OAGAmN,EAAApvB,UAAA42B,kBAAA,SAAA7U,GACA,UAAAH,IAAA7O,KAAAokB,uBAAApV,EAAA1b,OAAA0M,KAAAgkB,cAAAhV,EAAAsV,aAGAjI,EAAApvB,UAAAi2B,iBAAA,SAAAle,GACA,MAAAA,aAAAhR,KAEAX,aACAC,MAAA0M,KAAAmkB,qBAAAnf,EAAA1R,OACAC,GAAAyM,KAAAikB,eAAAjf,EAAAzR,IACA9F,MAAAuS,KAAA8d,QAAA9Y,EAAAvX,SAKAtB,EAAA,wBAAAuE,KAAAC,UAAAqU,KAGAqX,EAAApvB,UAAAs2B,mBAAA,SAAAve,GACA,UAAAhR,IAAAgM,KAAAokB,uBAAApf,EAAA3R,YAAAC,OAAA0M,KAAAkkB,iBAAAlf,EAAA3R,YAAAE,IAAAyM,KAAA4e,UAAA5Z,EAAA3R,YAAA5F,SAGA4uB,EAAApvB,UAAAk2B,cAAA,SAAAne,GACA,MAAAA,aAAAjR,KAEAsvB,aACA/vB,MAAA0M,KAAAmkB,qBAAAnf,EAAA1R,OACAC,GAAA,WAIAyR,YAAApR,KAEAyvB,aACA/vB,MAAA0M,KAAAmkB,qBAAAnf,EAAA1R,OACAC,GAAA,YAKApH,EAAA,wBAAAuE,KAAAC,UAAAqU,KAGAqX,EAAApvB,UAAAq2B,gBAAA,SAAAte,GACA,OAAAA,EAAAqe,YAAA9vB,IACA,aACA,GAAAgxB,GAAAvkB,KAAAokB,uBAAApf,EAAAqe,YAAA/vB,MACA,WAAAS,IAAAwwB,EACA,eACA,GAAAC,GAAAxkB,KAAAokB,uBAAApf,EAAAqe,YAAA/vB,MACA,WAAAM,IAAA4wB,EACA,4BACA,MAAAr4B,GAAA,qBACA,SACA,MAAAA,GAAA,oBAGAkwB,EAAApvB,UAAA0zB,eAAA,SAAAxK,GACA,OACAsO,WAAAtO,EAAA3B,OAAAppB,IAAA,SAAAkI,GAA+D,MAAAA,GAAAwR,sBAG/DuX,EAAApvB,UAAAi0B,iBAAA,SAAAF,GACA,GAAA0D,GAAA1D,EAAAyD,eACAjQ,EAAAkQ,EAAAt5B,IAAA,SAAAmL,GAAgD,MAAA2O,IAAAO,iBAAAlP,IAChD,WAAA+d,IAAAE,IAEA6H,KhB23JIsI,GAAO36B,EAAoB,K+Cr5L/B46B,GAAA,WACA,QAAAC,GAAA15B,GACA6U,KAAA8kB,OAAA35B,EAAA25B,OACA9kB,KAAA+kB,QAAA55B,EAAA45B,QAgCA,MA9BAF,GAAA53B,UAAA+3B,OAAA,SAAAC,GACA14B,GAAAyT,KAAAklB,cAAA,kCACAllB,KAAAklB,cAAAD,GAEAJ,EAAA53B,UAAAk4B,QAAA,SAAAF,GACA14B,GAAAyT,KAAAolB,eAAA,mCACAplB,KAAAolB,eAAAH,GAEAJ,EAAA53B,UAAAo4B,UAAA,SAAAJ,GACA14B,GAAAyT,KAAAslB,iBAAA,qCACAtlB,KAAAslB,iBAAAL,GAEAJ,EAAA53B,UAAAs4B,MAAA,WACAvlB,KAAA+kB,WAEAF,EAAA53B,UAAAu4B,KAAA,SAAA/6B,GACAuV,KAAA8kB,OAAAr6B,IAEAo6B,EAAA53B,UAAAw4B,WAAA,WACAl5B,MAAAoB,KAAAqS,KAAAklB,cAAA,kDACAllB,KAAAklB,iBAEAL,EAAA53B,UAAAy4B,YAAA,SAAAC,GACAp5B,MAAAoB,KAAAqS,KAAAolB,eAAA,mDACAplB,KAAAolB,eAAAO,IAEAd,EAAA53B,UAAA24B,cAAA,SAAAn7B,GACA8B,MAAAoB,KAAAqS,KAAAslB,iBAAA,qDACAtlB,KAAAslB,iBAAA76B,IAEAo6B,KClCAgB,GAAA,aAIAC,IACAC,kBAAA,WACAC,OAAA,UAKAC,GAAA,eAAAx6B,GAEAy6B,GAAA,WACA,QAAAC,GAAAC,GACApmB,KAAA6C,WAAAujB,EAAAvjB,WACA7C,KAAAqmB,KAAA,GAAA1B,IAAA,SACA,IAAA3D,GAAAoF,EAAApjB,IAAA,cACAhD,MAAAsmB,QAAAtF,EAAA,MAAAoF,EAAArjB,KAiPA,MA3OAojB,GAAAl5B,UAAAs5B,wBAAA,SAAAC,EAAAhsB,GACA,GAAAA,EACA,OAAAisB,KAAAjsB,GAAAksB,YACAlsB,EAAAksB,YAAAv5B,eAAAs5B,KACAD,EAAAC,GAAAjsB,EAAAksB,YAAAD,GAIAD,GAAA,qBAAAP,GAGAO,EAAA,gCACA,YAAAxmB,KAAA6C,WAAAO,UAAA,cACApD,KAAA6C,WAAAQ,UAEA8iB,EAAAl5B,UAAA05B,UAAA,SAAAC,EAAA7sB,EAAAS,GACA,GAAAkG,GAAAV,KACA6mB,EAAA7mB,KAAA8mB,QAAAF,EACA,WAAAG,SAAA,SAAA9sB,EAAAC,GAEAwG,EAAA2lB,KAAAW,UAAA,SAAAC,GACAA,EAAAC,WAAAvC,GAAA,UAAAwC,SAAA,WACA,IACA,OAAAF,EAAAG,oBACA,IAAAzC,IAAA,UAAA0C,SACA,GAAAC,GAAAL,EAAAM,iBACAh9B,GAAAs7B,GAAA,gBAAAn1B,KAAAC,UAAA22B,IACArtB,EAAAqtB,EACA,MACA,KAAA3C,IAAA,UAAA6C,QACAj9B,EAAAs7B,GAAA,QAAAe,EAAA,eACA1sB,EAAA,GAAApN,IAAAC,GAAAuH,kBAAA,oBACA,MACA,KAAAqwB,IAAA,UAAA8C,WACA,GAAAC,GAAAT,EAAAU,WACAp9B,GAAAs7B,GAAA,QAAAe,EAAA,wBAAAc,EAAA,iBAAAT,EAAAW,mBACAF,EAAA,EACAxtB,EAAA,GAAApN,IAAAyI,EAAAmyB,GAAA,gCAAAT,EAAAY,mBAKAt9B,EAAAs7B,GAAA,QAAAe,EAAA,YACA1sB,EAAA,GAAApN,IAAAC,GAAA0H,YAAA,uBAEA,MACA,SACAtI,EAAA,QACAy6B,EACA,gDAEAK,EAAAG,mBACA,KACAH,EAAAa,eACA,iBAGA,QACAv9B,EAAAs7B,GAAA,QAAAe,EAAA,gBACAlmB,EAAA2lB,KAAA0B,cAAAd,KAGA,IAAAe,GAAAt3B,KAAAC,UAAAoJ,EACAxP,GAAAs7B,GAAA,gBAAAgB,EAAA,IAAAmB,EAMA,IAAAxB,IAA+ByB,eAAA,aAC/BvnB,GAAA6lB,wBAAAC,EAAAhsB,GACAysB,EAAAzB,KAAAqB,EAAA,OAAAmB,EAAAxB,EAnFA,SAuFAL,EAAAl5B,UAAAi7B,mBAAA,SAAAtB,EAAA7sB,EAAAS,GAGA,MAAAwF,MAAA2mB,UAAAC,EAAA7sB,EAAAS,IAEA2rB,EAAAl5B,UAAAk7B,WAAA,SAAAvB,EAAApsB,GACA,GAAA4tB,IACApoB,KAAAsmB,QACA,IA1GA,qCA4GA,IACAM,EACA,YAEAyB,EAAA/6B,OAAAq3B,GAAA,6BACA5qB,GAKAuuB,uBAAA,EAGAC,mBAAA,aACAC,sBAIAC,0BAAA,eACAC,aAAA,EACAC,wBAAA,EAEA3oB,MAAAumB,wBAAAxsB,EAAAyuB,mBAAAhuB,EACA,IAAAqsB,GAAAuB,EAAAh4B,KAAA,GACA7F,GAAAs7B,GAAA,wBAAAgB,EAAA,IAAA9sB,EAEA,IAAA6uB,GAAAP,EAAAQ,iBAAAhC,EAAA9sB,GAMA+uB,GAAA,EAIAC,GAAA,EACAC,EAAA,GAAApE,KACAE,OAAA,SAAAr6B,GACAs+B,EAUAx+B,EAAAs7B,GAAA,4CAAAp7B,IATAq+B,IACAv+B,EAAAs7B,GAAA,iCACA+C,EAAAK,OACAH,GAAA,GAEAv+B,EAAAs7B,GAAA,sBAAAp7B,GACAm+B,EAAApD,KAAA/6B,KAMAs6B,QAAA,WAAkC,MAAA6D,GAAArD,WAMlC2D,EAAA,SAAAj6B,EAAApB,GAGA+6B,EAAAO,OAAAl6B,EAAA,SAAAm6B,GACA,IACAv7B,EAAAu7B,GAEA,MAAAl9B,GACAm9B,WAAA,WACA,KAAAn9B,IACqB,MAkErB,OA9DAg9B,GAAAvE,GAAA,WAAA2E,UAAAC,KAAA,WACAR,GACAx+B,EAAAs7B,GAAA,kCAGAqD,EAAAvE,GAAA,WAAA2E,UAAAE,MAAA,WACAT,IACAA,GAAA,EACAx+B,EAAAs7B,GAAA,+BACAmD,EAAAtD,iBAGAwD,EAAAvE,GAAA,WAAA2E,UAAA19B,MAAA,SAAA+5B,GACAoD,IACAA,GAAA,EACAx+B,EAAAs7B,GAAA,gCAAAF,GACAqD,EAAAtD,YAAA,GAAA54B,IAAAC,GAAA0H,YAAA,4CAGAy0B,EAAAvE,GAAA,WAAA2E,UAAAG,QAAA,SAAAh/B,GACA,IAAAs+B,EAAA,CACA,GAAAW,GAAAj/B,EAAAgc,KAAA,EACAla,KAAAm9B,EAAA,yCAKA,IAAA79B,GAEA69B,EAAA79B,OAAA69B,EAAA,IAAAA,EAAA,GAAA79B,KACA,IAAAA,EAAA,CACAtB,EAAAs7B,GAAA,6BAAAh6B,EAEA,IAAA89B,GAAA99B,EAAAsJ,OACAjB,EAAAgB,EAAAy0B,GACAt9B,EAAAR,EAAAQ,YACAsB,KAAAuG,IACAA,EAAAnH,GAAAyH,SACAnI,EACA,yBACAs9B,EACA,iBACA99B,EAAAQ,SAGA08B,GAAA,EACAC,EAAAtD,YAAA,GAAA54B,IAAAoH,EAAA7H,IACAu8B,EAAArD,YAGAh7B,GAAAs7B,GAAA,uBAAA6D,GACAV,EAAApD,cAAA8D,MAIAL,WAAA,WAKAL,EAAAvD,cACS,GACTuD,GAGA7C,EAAAl5B,UAAA65B,QAAA,SAAAF,GACA,GAAAgD,GAAA9D,GAAAc,EACAr6B,OAAAoB,KAAAi8B,EAAA,6BAAAhD,EACA,IAAAC,IAAA7mB,KAAAsmB,QAAA,IAvPA,UA+PA,OAPAO,GAAA52B,KAAA,cACA42B,EAAA52B,KAAA+P,KAAA6C,WAAAO,WACAyjB,EAAA52B,KAAA,eACA42B,EAAA52B,KAAA+P,KAAA6C,WAAAQ,UACAwjB,EAAA52B,KAAA,cACA42B,EAAA52B,KAAA,KACA42B,EAAA52B,KAAA25B,GACA/C,EAAAz2B,KAAA,KAEA+1B,KCxQA0D,GAAA,WACA,QAAAC,KACA9pB,KAAAvT,gBAAA,GACAuT,KAAAnN,gBAAA,mBAAA4O,MAiBA,MAfAqoB,GAAA78B,UAAA88B,eAAA,SAAAC,GACA,MAAAjD,SAAA9sB,QAAA,GAAAisB,IAAA8D,KAEAF,EAAA78B,UAAAg9B,cAAA,SAAApnB,GACA,UAAAuZ,IAAAvZ,GAAoDyZ,eAAA,KAEpDwN,EAAA78B,UAAAhB,WAAA,SAAAwB,GACA,MAAAiD,MAAAC,UAAAlD,IAEAq8B,EAAA78B,UAAAwU,KAAA,SAAAyoB,GACA,MAAAzoB,MAAAyoB,IAEAJ,EAAA78B,UAAA6U,KAAA,SAAAqoB,GACA,MAAAroB,MAAAqoB,IAEAL,ICbA/9B,IAAA+T,YAAA,GAAA+pB,IjCGA,IkCLAO,IlCKA1zB,GAAA,WAOA,QAAAyO,KAEA,OADAklB,MACA1/B,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/C0/B,EAAA1/B,GAAAC,UAAAD,EAEAiE,GAAA,YAAAy7B,EAAA,eACA,QAAAr4B,GAAA,EAAuBA,EAAAq4B,EAAAx/B,SAAuBmH,EAE9C,GADAhD,EAAA,qBAAAgD,EAAAq4B,EAAAr4B,IACA,IAAAq4B,EAAAr4B,GAAAnH,OACA,SAAAiC,IAAAC,GAAAC,iBAAA,0EAIAgT,MAAAzC,EAAA,GAAA2H,IAAAmlB,GAkBA,MAhBAllB,GAAAmlB,WAAA,WACA,MAAAnlB,GAAAolB,GAEAplB,EAAAlY,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAAkD,IACA,KAAA3T,GAAA,wBAAAyQ,EAEA,OAAAjC,MAAAzC,EAAAzL,QAAAmQ,EAAA1E,IAQA4H,EAAAolB,EAAA,GAAAplB,GAAAD,GAAAM,WAAAV,mBACAK,KAMA1O,GAAA0b,OAAA,kBkChDA,SAAAiY,GAOAA,IAAA,qBAMAA,IAAA,qBAMAA,IAAA,oBACCA,YCzBD,IAAAnzB,KACA,SAAAA,GACAA,IAAA,iBACAA,IAAA,qBACAA,IAAA,uBACAA,IAAA,wBACCA,YACD,IAAAuzB,KACA,SAAAA,GACAA,IAAA,iBACAA,IAAA,oBACCA,YAKD,IClBAC,IDkBAC,GAAA,WACA,QAAAC,KACA3qB,KAAA4qB,UAAA,GAAAxjB,IAAAtB,GAAAhC,YA0EA,MAxEA6mB,GAAA19B,UAAA49B,MAAA,SAAA50B,GACA,GAAA5I,GAAA4I,EAAAuI,IAAAnR,IACAy9B,EAAA9qB,KAAA4qB,UAAAnzB,IAAApK,EACA,KAAAy9B,EAEA,YADA9qB,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,EAAA4I,GAIAA,GAAAhH,OAAAgI,GAAAC,OACA4zB,EAAA77B,OAAAgI,GAAAG,SACA4I,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,EAAA4I,GAEAA,EAAAhH,OAAAgI,GAAAG,UACA0zB,EAAA77B,OAAAgI,GAAAI,QACA2I,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,GACA4B,KAAA67B,EAAA77B,KACAuP,IAAAvI,EAAAuI,MAGAvI,EAAAhH,OAAAgI,GAAAE,UACA2zB,EAAA77B,OAAAgI,GAAAE,SACA6I,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,GACA4B,KAAAgI,GAAAE,SACAqH,IAAAvI,EAAAuI,MAGAvI,EAAAhH,OAAAgI,GAAAE,UACA2zB,EAAA77B,OAAAgI,GAAAC,MACA8I,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,GACA4B,KAAAgI,GAAAC,MACAsH,IAAAvI,EAAAuI,MAGAvI,EAAAhH,OAAAgI,GAAAI,SACAyzB,EAAA77B,OAAAgI,GAAAC,MACA8I,KAAA4qB,UAAA5qB,KAAA4qB,UAAAljB,OAAAra,GAEA4I,EAAAhH,OAAAgI,GAAAI,SACAyzB,EAAA77B,OAAAgI,GAAAE,SACA6I,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,GACA4B,KAAAgI,GAAAI,QACAmH,IAAAssB,EAAAtsB,MAGAvI,EAAAhH,OAAAgI,GAAAC,OACA4zB,EAAA77B,OAAAgI,GAAAI,QACA2I,KAAA4qB,UAAA5qB,KAAA4qB,UAAArjB,OAAAla,GACA4B,KAAAgI,GAAAE,SACAqH,IAAAvI,EAAAuI,MAWArS,EAAA,uCACAuE,KAAAC,UAAAsF,GACA,UACAvF,KAAAC,UAAAm6B,KAGAH,EAAA19B,UAAA89B,WAAA,WACA,GAAAC,KAIA,OAHAhrB,MAAA4qB,UAAA5iB,iBAAA,SAAA3a,EAAA4I,GACA+0B,EAAA/6B,KAAAgG,KAEA+0B,GAEAL,KAGAM,GAAA,WACA,QAAAA,GAAAtsB,EAAA4a,EAAAnb,EAAAG,EAAAG,EAAAwsB,EAAAC,GACAnrB,KAAArB,QACAqB,KAAAuZ,OACAvZ,KAAA5B,UACA4B,KAAAzB,aACAyB,KAAAtB,YACAsB,KAAAkrB,mBACAlrB,KAAAmrB,mBAwBA,MAtBAF,GAAAh+B,UAAA6E,QAAA,SAAAmQ,GACA,GAAAjC,KAAAtB,YAAAuD,EAAAvD,WACAsB,KAAAkrB,mBAAAjpB,EAAAipB,kBACAlrB,KAAAmrB,mBAAAlpB,EAAAkpB,mBACAnrB,KAAArB,MAAA7M,QAAAmQ,EAAAtD,SACAqB,KAAAuZ,KAAAznB,QAAAmQ,EAAAsX,QACAvZ,KAAA5B,QAAAtM,QAAAmQ,EAAA7D,SACA,QAEA,IAAA4sB,GAAAhrB,KAAAzB,WACA6sB,EAAAnpB,EAAA1D,UACA,IAAAysB,EAAAngC,SAAAugC,EAAAvgC,OACA,QAEA,QAAAmH,GAAA,EAAuBA,EAAAg5B,EAAAngC,OAAoBmH,IAC3C,GAAAg5B,EAAAh5B,GAAA/C,OAAAm8B,EAAAp5B,GAAA/C,OACA+7B,EAAAh5B,GAAAwM,IAAA1M,QAAAs5B,EAAAp5B,GAAAwM,KACA,QAGA,WAEAysB,KEzHAI,GAAA,WAEA,QAAAC,GAAAnb,GAIAnQ,KAAA8D,WADAqM,EACA,SAAAtJ,EAAAC,GACA,MAAAqJ,GAAAtJ,EAAAC,IAAAhB,GAAAhC,WAAA+C,EAAAxZ,IAAAyZ,EAAAzZ,MAIA,SAAAwZ,EAAAC,GACA,MAAAhB,IAAAhC,WAAA+C,EAAAxZ,IAAAyZ,EAAAzZ,MAGA2S,KAAAurB,SAAA71B,KACAsK,KAAAwrB,UAAA,GAAApkB,IAAApH,KAAA8D,YA8FA,MAxFAwnB,GAAAG,SAAA,SAAAC,GACA,UAAAJ,GAAAI,EAAA5nB,aAEAwnB,EAAAr+B,UAAA2qB,IAAA,SAAAvqB,GACA,aAAA2S,KAAAurB,SAAA9zB,IAAApK,IAEAi+B,EAAAr+B,UAAAwK,IAAA,SAAApK,GACA,MAAA2S,MAAAurB,SAAA9zB,IAAApK,IAEAi+B,EAAAr+B,UAAA6qB,MAAA,WACA,MAAA9X,MAAAwrB,UAAA1jB,UAEAwjB,EAAAr+B,UAAA8qB,KAAA,WACA,MAAA/X,MAAAwrB,UAAAzjB,UAEAujB,EAAAr+B,UAAAgB,QAAA,WACA,MAAA+R,MAAAwrB,UAAAv9B,WAMAq9B,EAAAr+B,UAAAsE,QAAA,SAAAlE,GACA,GAAAmR,GAAAwB,KAAAurB,SAAA9zB,IAAApK,EACA,OAAAmR,GAAAwB,KAAAwrB,UAAAj6B,QAAAiN,IAAA,GAEAlR,OAAAqS,eAAA2rB,EAAAr+B,UAAA,QACAwK,IAAA,WACA,MAAAuI,MAAAwrB,UAAApnB,MAEA1B,YAAA,EACAC,cAAA,IAGA2oB,EAAAr+B,UAAAe,QAAA,SAAAgqB,GACAhY,KAAAwrB,UAAAxjB,iBAAA,SAAAE,EAAAC,GAEA,MADA6P,GAAA9P,IACA,KAIAojB,EAAAr+B,UAAAgS,IAAA,SAAAT,GAEA,GAAA2O,GAAAnN,KAAAhB,OAAAR,EAAAnR,IACA,OAAA8f,GAAA3F,KAAA2F,EAAAoe,SAAAhkB,OAAA/I,EAAAnR,IAAAmR,GAAA2O,EAAAqe,UAAAjkB,OAAA/I,EAAA,QAGA8sB,EAAAr+B,UAAA+R,OAAA,SAAA3R,GACA,GAAAmR,GAAAwB,KAAAvI,IAAApK,EACA,OAAAmR,GAGAwB,KAAAwH,KAAAxH,KAAAurB,SAAA7jB,OAAAra,GAAA2S,KAAAwrB,UAAA9jB,OAAAlJ,IAFAwB,MAIAsrB,EAAAr+B,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAAqpB,IACA,QACA,IAAAtrB,KAAAoE,OAAAnC,EAAAmC,KACA,QAGA,KAFA,GAAAmU,GAAAvY,KAAAwrB,UAAAnjB,cACAmQ,EAAAvW,EAAAupB,UAAAnjB,cACAkQ,EAAAvP,WAAA,CACA,GAAA2iB,GAAApT,EAAAzP,UAAAzb,IACAu+B,EAAApT,EAAA1P,UAAAzb,GACA,KAAAs+B,EAAA75B,QAAA85B,GACA,SAEA,UAEAN,EAAAr+B,UAAA0T,SAAA,WACA,GAAAkrB,KAIA,OAHA7rB,MAAAhS,QAAA,SAAAwQ,GACAqtB,EAAA57B,KAAAuO,QAEA,IAAAqtB,EAAAhhC,OACA,iBAGA,oBAAAghC,EAAAz7B,KAAA,eAGAk7B,EAAAr+B,UAAAua,KAAA,SAAA+jB,EAAAC,GACA,GAAAM,GAAA,GAAAR,EAIA,OAHAQ,GAAAhoB,WAAA9D,KAAA8D,WACAgoB,EAAAP,WACAO,EAAAN,YACAM,GAEAR,KChHAS,GAAA,WACA,QAAAC,GAAAC,GACAjsB,KAAAisB,WAOAjsB,KAAAksB,SAqEA,MAlEAF,GAAA/+B,UAAAwK,IAAA,SAAApK,GACA,GAAA8+B,GAAAnsB,KAAAisB,SAAA5+B,GACAgjB,EAAArQ,KAAAksB,MAAAC,EACA,QAAAx+B,KAAA0iB,EAGA,OAAA1lB,GAAA,EAAAyhC,EAAA/b,EAA6C1lB,EAAAyhC,EAAAvhC,OAAuBF,IAAA,CACpE,GAAAokB,GAAAqd,EAAAzhC,GAAA0hC,EAAAtd,EAAA,GAAAthB,EAAAshB,EAAA,EACA,IAAAsd,EAAAv6B,QAAAzE,GACA,MAAAI,KAKAu+B,EAAA/+B,UAAA2qB,IAAA,SAAAvqB,GACA,WAAAM,KAAAqS,KAAAvI,IAAApK,IAGA2+B,EAAA/+B,UAAAkgB,IAAA,SAAA9f,EAAAI,GACA,GAAA0+B,GAAAnsB,KAAAisB,SAAA5+B,GACAgjB,EAAArQ,KAAAksB,MAAAC,EACA,QAAAx+B,KAAA0iB,EAEA,YADArQ,KAAAksB,MAAAC,KAAA9+B,EAAAI,IAGA,QAAAuE,GAAA,EAAuBA,EAAAqe,EAAAxlB,OAAoBmH,IAC3C,GAAAqe,EAAAre,GAAA,GAAAF,QAAAzE,GAEA,YADAgjB,EAAAre,IAAA3E,EAAAI,GAIA4iB,GAAApgB,MAAA5C,EAAAI,KAKAu+B,EAAA/+B,UAAA+R,OAAA,SAAA3R,GACA,GAAA8+B,GAAAnsB,KAAAisB,SAAA5+B,GACAgjB,EAAArQ,KAAAksB,MAAAC,EACA,QAAAx+B,KAAA0iB,EACA,QAEA,QAAAre,GAAA,EAAuBA,EAAAqe,EAAAxlB,OAAoBmH,IAC3C,GAAAqe,EAAAre,GAAA,GAAAF,QAAAzE,GAOA,MANA,KAAAgjB,EAAAxlB,aACAmV,MAAAksB,MAAAC,GAGA9b,EAAAic,OAAAt6B,EAAA,IAEA,CAGA,WAEAg6B,EAAA/+B,UAAAe,QAAA,SAAAH,GACAG,EAAAgS,KAAAksB,MAAA,SAAA56B,EAAAi7B,GACA,OAAA5hC,GAAA,EAAA6hC,EAAAD,EAAiD5hC,EAAA6hC,EAAA3hC,OAAuBF,IAAA,CACxE,GAAAokB,GAAAyd,EAAA7hC,GAAAud,EAAA6G,EAAA,GAAA5G,EAAA4G,EAAA,EACAlhB,GAAAqa,EAAAC,OAIA6jB,EAAA/+B,UAAAgB,QAAA,WACA,MAAAA,GAAA+R,KAAAksB,QAEAF,KC5EAS,GAAA,WACA,QAAAA,KACAzsB,KAAA0sB,aAEA,MAAAD,MAOAE,GAAA,WACA,QAAAC,GAAAC,GACA7sB,KAAA6sB,aACA7sB,KAAA8sB,QAAA,GAAAf,IAAA,SAAAgB,GACA,MAAAA,GAAAhd,gBAEA/P,KAAAgtB,YAAA5C,GAAA6C,QACAjtB,KAAA6sB,WAAAK,UAAAltB,KAAAmtB,SAAAx2B,KAAAqJ,WAAAotB,QAAAz2B,KAAAqJ,OA+EA,MA7EA4sB,GAAA3/B,UAAAk8B,OAAA,SAAAkE,GACA,GAAA1uB,GAAA0uB,EAAA1uB,MACA2uB,GAAA,EACAC,EAAAvtB,KAAA8sB,QAAAr1B,IAAAkH,EAUA,OATA4uB,KACAD,GAAA,EACAC,EAAA,GAAAd,IACAzsB,KAAA8sB,QAAA3f,IAAAxO,EAAA4uB,IAEAA,EAAAb,UAAAz8B,KAAAo9B,GACAA,EAAAG,uBAAAxtB,KAAAgtB,aACAO,EAAAE,UACAJ,EAAAK,eAAAH,EAAAE,UACAH,EACAttB,KAAA6sB,WAAA1D,OAAAxqB,GAAAgvB,KAAA,SAAA3Z,GAEA,MADAuZ,GAAAvZ,WACAA,IAIA+S,QAAA9sB,QAAAszB,EAAAvZ,WAGA4Y,EAAA3/B,UAAA2gC,SAAA,SAAAP,GACA,GAAA1uB,GAAA0uB,EAAA1uB,MACAkvB,GAAA,EACAN,EAAAvtB,KAAA8sB,QAAAr1B,IAAAkH,EACA,IAAA4uB,EAAA,CACA,GAAAv7B,GAAAu7B,EAAAb,UAAAn7B,QAAA87B,EACAr7B,IAAA,IACAu7B,EAAAb,UAAAJ,OAAAt6B,EAAA,GACA67B,EAAA,IAAAN,EAAAb,UAAA7hC,QAGA,MAAAgjC,IACA7tB,KAAA8sB,QAAA9tB,OAAAL,GACAqB,KAAA6sB,WAAAe,SAAAjvB,IAGAooB,QAAA9sB,WAGA2yB,EAAA3/B,UAAAkgC,SAAA,SAAAW,GACA,OAAAnjC,GAAA,EAAAojC,EAAAD,EAAiDnjC,EAAAojC,EAAAljC,OAAyBF,IAAA,CAC1E,GAAA8iC,GAAAM,EAAApjC,GACAgU,EAAA8uB,EAAA9uB,MACA4uB,EAAAvtB,KAAA8sB,QAAAr1B,IAAAkH,EACA,IAAA4uB,EAAA,CACA,OAAAxe,GAAA,EAAAiB,EAAAud,EAAAb,UAA0D3d,EAAAiB,EAAAnlB,OAAgBkkB,IAC1EiB,EAAAjB,GACA2e,eAAAD,EAEAF,GAAAE,cAIAb,EAAA3/B,UAAAmgC,QAAA,SAAAzuB,EAAA9S,GACA,GAAA0hC,GAAAvtB,KAAA8sB,QAAAr1B,IAAAkH,EACA,IAAA4uB,EACA,OAAA5iC,GAAA,EAAAokB,EAAAwe,EAAAb,UAAsD/hC,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACtE,GAAA0iC,GAAAte,EAAApkB,EACA0iC,GAAAD,QAAAvhC,GAKAmU,KAAA8sB,QAAA9tB,OAAAL,IAEAiuB,EAAA3/B,UAAAugC,uBAAA,SAAAR,GACAhtB,KAAAgtB,cACAhtB,KAAA8sB,QAAA9+B,QAAA,SAAAsD,EAAAi8B,GACA,OAAA5iC,GAAA,EAAAokB,EAAAwe,EAAAb,UAAsD/hC,EAAAokB,EAAAlkB,OAAgBF,IACtEokB,EAAApkB,GACA6iC,uBAAAR,MAIAJ,KASAoB,GAAA,WACA,QAAAC,GAAAtvB,EAAAuvB,EAAA98B,GACA4O,KAAArB,QACAqB,KAAAkuB,gBAKAluB,KAAAmuB,oBAAA,EACAnuB,KAAAgtB,YAAA5C,GAAA6C,QACAjtB,KAAA5O,cAqFA,MAnFA68B,GAAAhhC,UAAAygC,eAAA,SAAAU,GAEA,GADA7hC,EAAA6hC,EAAA7vB,WAAA1T,OAAA,GAAAujC,EAAAjD,iBAAA,2CACAnrB,KAAA5O,QAAAi9B,+BAAA,CAGA,OADA9vB,MACA5T,EAAA,EAAAokB,EAAAqf,EAAA7vB,WAAkD5T,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAClE,GAAA4wB,GAAAxM,EAAApkB,EACA4wB,GAAAtsB,OAAAgI,GAAAG,UACAmH,EAAAtO,KAAAsrB,GAGA6S,EAAA,GAAAnD,IAAAmD,EAAAzvB,MAAAyvB,EAAA7U,KAAA6U,EAAAhwB,QAAAG,EAAA6vB,EAAA1vB,UAAA0vB,EAAAlD,iBAAAkD,EAAAjD,kBAEAnrB,KAAAmuB,mBAKAnuB,KAAAsuB,iBAAAF,IACApuB,KAAAkuB,cAAAroB,KAAAuoB,GALApuB,KAAAuuB,wBAAAH,EAAApuB,KAAAgtB,cACAhtB,KAAAwuB,kBAAAJ,GAMApuB,KAAAouB,QAEAH,EAAAhhC,UAAAmgC,QAAA,SAAAvhC,GACAmU,KAAAkuB,cAAAriC,UAEAoiC,EAAAhhC,UAAAugC,uBAAA,SAAAR,GACAhtB,KAAAgtB,cACAhtB,KAAAouB,OACApuB,KAAAmuB,oBACAnuB,KAAAuuB,wBAAAvuB,KAAAouB,KAAApB,IACAhtB,KAAAwuB,kBAAAxuB,KAAAouB,OAGAH,EAAAhhC,UAAAshC,wBAAA,SAAAH,EAAApB,GAGA,GAFAzgC,GAAAyT,KAAAmuB,mBAAA,yEAEAC,EAAA1vB,UACA,QAIA,IAAA+vB,GAAAzB,IAAA5C,GAAAsE,MAGA,OAAA1uB,MAAA5O,QAAAu9B,uBAAAF,GACAliC,EAAA6hC,EAAA1vB,UAAA,qDACA,IAGA0vB,EAAA7U,KAAAtrB,WAAA++B,IAAA5C,GAAAsE,QAEAT,EAAAhhC,UAAAqhC,iBAAA,SAAAF,GAKA,GAAAA,EAAA7vB,WAAA1T,OAAA,EACA,QAEA,IAAA+jC,GAAA5uB,KAAAouB,MAAApuB,KAAAouB,KAAAlD,mBAAAkD,EAAAlD,gBACA,UAAAkD,EAAAjD,mBAAAyD,KACA,IAAA5uB,KAAA5O,QAAAy9B,6BAOAZ,EAAAhhC,UAAAuhC,kBAAA,SAAAJ,GACA7hC,GAAAyT,KAAAmuB,mBAAA,kDACAC,EAAA,GAAAnD,IAAAmD,EAAAzvB,MAAAyvB,EAAA7U,KAAA8R,GAAAI,SAAA2C,EAAA7U,MAAA0U,EAAAa,sBAAAV,KAAA1vB,UAAA0vB,EAAAlD,kBAAA,GACAlrB,KAAAmuB,oBAAA,EACAnuB,KAAAkuB,cAAAroB,KAAAuoB,IAGAH,EAAAa,sBAAA,SAAAV,GACA,GAAAjgC,KAIA,OAHAigC,GAAA7U,KAAAvrB,QAAA,SAAAwQ,GACArQ,EAAA8B,MAAyBhB,KAAAgI,GAAAC,MAAAsH,UAEzBrQ,GAEA8/B,KCpMAj0B,GAAA,WACA,QAAA+0B,GAAA9J,GACA,GAAAvkB,GAAAV,IAIAA,MAAAgvB,aAAA,KAEAhvB,KAAAivB,cAAA,KAEAjvB,KAAA7R,WAAAR,GACAqS,KAAAnU,UAAA8B,GACAqS,KAAAkvB,QAAA,EAGAlvB,KAAAmvB,kBAAA,EACAlK,EAAA,SAAAx3B,GACAiT,EAAAwuB,QAAA,EACAxuB,EAAAvS,OAAAV,EACAiT,EAAAsuB,cAGAtuB,EAAAsuB,aAAAvhC,IAES,SAAA5B,GACT6U,EAAAwuB,QAAA,EACAxuB,EAAA7U,QACA6U,EAAAuuB,eACAvuB,EAAAuuB,cAAApjC,KA+GA,MA3GAkjC,GAAA9hC,UAAAmiC,MAAA,SAAAvhC,GACA,MAAAmS,MAAA6F,SAAAlY,GAAAE,IAEAkhC,EAAA9hC,UAAA4Y,KAAA,SAAAwpB,EAAAC,GACA,GAAA5uB,GAAAV,IAKA,OAJAA,MAAAmvB,kBACAhjC,EAAA,yDAEA6T,KAAAmvB,kBAAA,EACAnvB,KAAAkvB,OACAlvB,KAAAnU,MAIAmU,KAAAuvB,YAAAD,EAAAtvB,KAAAnU,OAHAmU,KAAAwvB,YAAAH,EAAArvB,KAAA7R,QAOA,GAAA4gC,GAAA,SAAA90B,EAAAC,GACAwG,EAAAsuB,aAAA,SAAAvhC,GACAiT,EAAA8uB,YAAAH,EAAA5hC,GAAAoY,KAAA5L,EAAAC,IAEAwG,EAAAuuB,cAAA,SAAApjC,GACA6U,EAAA6uB,YAAAD,EAAAzjC,GAAAga,KAAA5L,EAAAC,OAKA60B,EAAA9hC,UAAAwiC,UAAA,WACA,GAAA/uB,GAAAV,IACA,WAAA+mB,SAAA,SAAA9sB,EAAAC,GACAwG,EAAAmF,KAAA5L,EAAAC,MAGA60B,EAAA9hC,UAAAyiC,iBAAA,SAAA7hC,GACA,IACA,GAAAM,GAAAN,GACA,OAAAM,aAAA4gC,GACA5gC,EAGA4gC,EAAA90B,QAAA9L,GAGA,MAAAjC,GACA,MAAA6iC,GAAA70B,OAAAhO,KAGA6iC,EAAA9hC,UAAAuiC,YAAA,SAAAH,EAAA5hC,GACA,MAAA4hC,GACArvB,KAAA0vB,iBAAA,WAAsD,MAAAL,GAAA5hC,KAMtDshC,EAAA90B,QAAAxM,IAGAshC,EAAA9hC,UAAAsiC,YAAA,SAAAD,EAAAzjC,GACA,MAAAyjC,GACAtvB,KAAA0vB,iBAAA,WAAsD,MAAAJ,GAAAzjC,KAGtDkjC,EAAA70B,OAAArO,IAGAkjC,EAAA90B,QAAA,SAAA9L,GACA,UAAA4gC,GAAA,SAAA90B,EAAAC,GACAD,EAAA9L,MAGA4gC,EAAA70B,OAAA,SAAArO,GACA,UAAAkjC,GAAA,SAAA90B,EAAAC,GACAA,EAAArO,MAGAkjC,EAAAY,QAAA,SAEAC,GACA,MAAAA,GAAAnM,OAAA,SAAAoM,EAAAC,EAAAC,GACA,MAAAF,GAAAhqB,KAAA,WACA,MAAAiqB,MAESf,EAAA90B,YAET80B,EAAA3jC,IAAA,SAAAwkC,GACA,GAAA5+B,MACA8mB,GAAA,EAGAkY,EAAAjB,EAAA90B,QAAA,KACA,OAAA21B,GACAnM,OAAA,SAAAoM,EAAAC,GACA,MAAAD,GAAAhqB,KAAA,SAAA1X,GAKA,MAJA2pB,IACA9mB,EAAAf,KAAA9B,GAEA2pB,GAAA,EACAgY,KAESE,GACTnqB,KAAA,SAAA1X,GAEA,MADA6C,GAAAf,KAAA9B,GACA6C,KAGA+9B,KC9IAkB,GAAA,WACA,QAAAC,KACAlwB,KAAAmwB,SAAA,EAIAnwB,KAAAowB,WAKApwB,KAAAqwB,iBAAAv6B,KA8CA,MA5CAo6B,GAAAjjC,UAAAqjC,iBAAA,SAAAC,GACAvwB,KAAAowB,QAAAngC,KAAAsgC,GACAA,EAAAC,oBAAAxwB,OAEAkwB,EAAAjjC,UAAAwjC,oBAAA,SAAAF,GACAvwB,KAAAowB,QAAA9D,OAAAtsB,KAAAowB,QAAA7+B,QAAAg/B,GAAA,GACAA,EAAAC,oBAAA,OAEAN,EAAAjjC,UAAAyjC,uBAAA,SAAArjC,GACA2S,KAAAqwB,iBAAArwB,KAAAqwB,iBAAApxB,IAAA5R,IAEA6iC,EAAAjjC,UAAA0jC,eAAA,SAAAj2B,GACA,GAAAgG,GAAAV,KACA4wB,KACAC,EAAA/6B,IAaA,OAZAkK,MAAAqwB,iBAAAriC,QAAA,SAAAX,GACA,GAAAyjC,GAAApwB,EAAAqwB,yBAAAr2B,EAAArN,EACAujC,GAAA3gC,KAAA6gC,EAAAjrB,KAAA,SAAAmrB,GAKA,MAHAA,KACAH,IAAA5xB,IAAA5R,IAEA2M,GAAAC,eAIA+F,KAAAqwB,iBAAAv6B,KACAkE,GAAA21B,QAAAiB,GAAA/qB,KAAA,WAAsE,MAAAgrB,MAEtEX,EAAAjjC,UAAA8jC,yBAAA,SAAAr2B,EAAArN,GACA,GAAA2iC,GAAAh2B,GAAAC,SAAA,EACA,OAAA+F,MAAAowB,QACAhlC,IAAA,SAAA6lC,GAAoC,kBAAqB,MAAAA,GAAAC,YAAAx2B,EAAArN,MACzDo2B,OAAA,SAAAoM,EAAAC,GACA,MAAAD,GAAAhqB,KAAA,SAAA1X,GACA,MAAAA,GACA6L,GAAAC,SAAA,GAGA61B,OAGSE,IAETE,KC7DAiB,GAAA,WACA,QAAAC,GAAAzyB,EAAA0yB,EAAAC,GACAtxB,KAAArB,QACAqB,KAAAqxB,YACArxB,KAAAsxB,cAmBA,MAjBAF,GAAAG,aAAA,SAAAC,GAGA,OAFAH,GAAAv7B,KACAw7B,EAAAx7B,KACAnL,EAAA,EAAAokB,EAAAyiB,EAAAjzB,WAAsD5T,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACtE,GAAA4wB,GAAAxM,EAAApkB,EACA,QAAA4wB,EAAAtsB,MACA,IAAAgI,IAAAC,MACAm6B,IAAApyB,IAAAsc,EAAA/c,IAAAnR,IACA,MACA,KAAA4J,IAAAI,QACAi6B,IAAAryB,IAAAsc,EAAA/c,IAAAnR,MAKA,UAAA+jC,GAAAI,EAAA7yB,MAAA0yB,EAAAC,IAEAF,KCVAK,GAAA,WACA,QAAAC,KAEA1xB,KAAA2xB,UAAA,GAAAna,IAAAoa,GAAAhrB,cAEA5G,KAAA6xB,aAAA,GAAAra,IAAAoa,GAAAE,mBAEA9xB,KAAA+xB,iBAAA,KAsEA,MAnEAL,GAAAzkC,UAAAgB,QAAA,WACA,MAAA+R,MAAA2xB,UAAA1jC,WAGAyjC,EAAAzkC,UAAA+kC,aAAA,SAAA3kC,EAAA8+B,GACA,GAAA8F,GAAA,GAAAL,IAAAvkC,EAAA8+B,EACAnsB,MAAA2xB,UAAA3xB,KAAA2xB,UAAA1yB,IAAAgzB,GACAjyB,KAAA6xB,aAAA7xB,KAAA6xB,aAAA5yB,IAAAgzB,IAGAP,EAAAzkC,UAAAilC,cAAA,SAAAva,EAAAwU,GACA,GAAAzrB,GAAAV,IACA2X,GAAA3pB,QAAA,SAAAX,GAAqC,MAAAqT,GAAAsxB,aAAA3kC,EAAA8+B,MAMrCuF,EAAAzkC,UAAAklC,gBAAA,SAAA9kC,EAAA8+B,GACAnsB,KAAAoyB,UAAA,GAAAR,IAAAvkC,EAAA8+B,KAEAuF,EAAAzkC,UAAAolC,iBAAA,SAAA1a,EAAAwU,GACA,GAAAzrB,GAAAV,IACA2X,GAAA3pB,QAAA,SAAAX,GAAqC,MAAAqT,GAAAyxB,gBAAA9kC,EAAA8+B,MAMrCuF,EAAAzkC,UAAAqlC,sBAAA,SAAAnG,GACA,GAAAzrB,GAAAV,KACAuyB,EAAAzsB,GAAAO,MACAmsB,EAAA,GAAAZ,IAAAW,EAAApG,GACAsG,EAAA,GAAAb,IAAAW,EAAApG,EAAA,EACAnsB,MAAA6xB,aAAA5Z,gBAAAua,EAAAC,GAAA,SAAAR,GACAvxB,EAAA0xB,UAAAH,MAGAP,EAAAzkC,UAAAylC,oBAAA,WACA,GAAAhyB,GAAAV,IACAA,MAAA2xB,UAAA3jC,QAAA,SAAAikC,GAA+C,MAAAvxB,GAAA0xB,UAAAH,MAE/CP,EAAAzkC,UAAAmlC,UAAA,SAAAH,GACAjyB,KAAA2xB,UAAA3xB,KAAA2xB,UAAA3yB,OAAAizB,GACAjyB,KAAA6xB,aAAA7xB,KAAA6xB,aAAA7yB,OAAAizB,GACA,OAAAjyB,KAAA+xB,kBACA/xB,KAAA+xB,iBAAArB,uBAAAuB,EAAA5kC,MAGAqkC,EAAAzkC,UAAA0lC,gBAAA,SAAAxG,GACA,GAAAoG,GAAAzsB,GAAAO,MACAmsB,EAAA,GAAAZ,IAAAW,EAAApG,GACAsG,EAAA,GAAAb,IAAAW,EAAApG,EAAA,GACAxU,EAAA7hB,IAIA,OAHAkK,MAAA6xB,aAAA5Z,gBAAAua,EAAAC,GAAA,SAAAR,GACAta,IAAA1Y,IAAAgzB,EAAA5kC,OAEAsqB,GAEA+Z,EAAAzkC,UAAAujC,oBAAA,SAAAuB,GACA/xB,KAAA+xB,oBAEAL,EAAAzkC,UAAAikC,YAAA,SAAAx2B,EAAArN,GACA,GAAA4kC,GAAA,GAAAL,IAAAvkC,EAAA,GACAulC,EAAA5yB,KAAA2xB,UAAAtZ,kBAAA4Z,EACA,OAAAj4B,IAAAC,QAAA,OAAA24B,GAAAvlC,EAAAyE,QAAA8gC,EAAAvlC,OAEAqkC,KAGAE,GAAA,WACA,QAAAiB,GAAAxlC,EAAAylC,GACA9yB,KAAA3S,MACA2S,KAAA8yB,kBAYA,MATAD,GAAAjsB,aAAA,SAAAjV,EAAAC,GACA,MAAAkU,IAAAhC,WAAAnS,EAAAtE,IAAAuE,EAAAvE,MACAqE,EAAAC,EAAAmhC,gBAAAlhC,EAAAkhC,kBAGAD,EAAAf,kBAAA,SAAAngC,EAAAC,GACA,MAAAF,GAAAC,EAAAmhC,gBAAAlhC,EAAAkhC,kBACAhtB,GAAAhC,WAAAnS,EAAAtE,IAAAuE,EAAAvE,MAEAwlC,KPnHAE,GAAA,GAEA,SAAAtI,GACAA,IAAA,2BACAA,IAAA,4BACCA,YAQD,IQJAuI,IRIAC,GAAA,WACA,QAAAA,GAAAC,EAAAC,OACA,KAAAA,IAAmCA,EAAA,GACnCnzB,KAAAkzB,aAEA,IAAAE,GAAAD,GAAAJ,OACAM,EAAAF,EAAAC,CASApzB,MAAAszB,WARAD,GAAAH,EAQAE,EAAApzB,KAAAkzB,aAWAE,EAAApzB,KAAAkzB,cAAA,GAAAH,IAcA,MAXAE,GAAAhmC,UAAA4Y,KAAA,WAEA,MADA7F,MAAAszB,YAAA,GAAAP,GACA/yB,KAAAszB,YAEAL,EAAAM,cAAA,SAAAJ,GAEA,WADA,KAAAA,IAAmCA,EAAA,GACnC,GAAAF,GAAAxI,GAAA+I,WAAAL,IAEAF,EAAAQ,cAAA,WACA,UAAAR,GAAAxI,GAAAiJ,aAEAT,KnC9CAU,GAAA,WACA,QAAAA,GAAAtmC,GACA2S,KAAA3S,MAEA,MAAAsmC,MAGAC,GAAA,WACA,QAAAA,GAAAvmC,GACA2S,KAAA3S,MAEA,MAAAumC,MAQAC,GAAA,WACA,QAAAC,GAAAn1B,EAEAo1B,GACA/zB,KAAArB,QACAqB,KAAA+zB,kBACA/zB,KAAAg0B,UAAA,KAOAh0B,KAAA0F,SAAA,EAEA1F,KAAAi0B,eAAAn+B,KAEAkK,KAAAk0B,YAAAp+B,KACAkK,KAAAm0B,YAAA,GAAA9I,IAAA1sB,EAAAC,cAAAjI,KAAAgI,IAyPA,MA7OAm1B,GAAA7mC,UAAAmnC,kBAAA,SAAA71B,EAAA81B,GACA,GAAA3zB,GAAAV,KACAs0B,EAAAD,EACAA,EAAAC,UACA,GAAA5J,IACA6J,EAAAF,EACAA,EAAAF,YACAn0B,KAAAm0B,YACAK,EAAAH,EACAA,EAAAH,YACAl0B,KAAAk0B,YACAO,EAAAF,EACAG,GAAA,EAUAC,EAAA30B,KAAArB,MAAA+R,YAAA6jB,EAAAnwB,OAAApE,KAAArB,MAAAuF,MACAqwB,EAAAxc,OACA,IA0DA,IAzDAxZ,EAAAyJ,iBAAA,SAAA3a,EAAAunC,GACA,GAAAC,GAAAN,EAAA98B,IAAApK,GACA0sB,EAAA6a,YAAAtuB,IAAAsuB,EAAA,IAsBA,IArBA7a,IACAxtB,EAAAc,EAAAyE,QAAAioB,EAAA1sB,KAAA,+CACAA,EACA,OACA0sB,EAAA1sB,KACA0sB,EAAArZ,EAAA/B,MAAA0R,QAAA0J,KAAA,MAEAA,GACA0a,IAAAx1B,IAAA8a,GAEAya,EADAza,EAAArT,kBACA8tB,EAAAv1B,IAAA5R,GAGAmnC,EAAAx1B,OAAA3R,KAIAonC,IAAAz1B,OAAA3R,GACAmnC,IAAAx1B,OAAA3R,IAGAwnC,GAAA9a,EAAA,CACA,GAAA+a,GAAAD,EAAApuB,KAAA3U,QAAAioB,EAAAtT,KACAquB,IACAD,EAAAnuB,oBAAAqT,EAAArT,oBAEAouB,EACAR,EAAAzJ,OAAyC57B,KAAAgI,GAAAG,SAAAoH,IAAAub,IAGzCua,EAAAzJ,OAAyC57B,KAAAgI,GAAAE,SAAAqH,IAAAub,IAEzC4a,GACAj0B,EAAA/B,MAAAC,cAAAmb,EAAA4a,GAAA,IAIAD,GAAA,SAIAG,GAAA9a,EACAua,EAAAzJ,OAAiC57B,KAAAgI,GAAAC,MAAAsH,IAAAub,IAEjC8a,IAAA9a,IACAua,EAAAzJ,OAAiC57B,KAAAgI,GAAAI,QAAAmH,IAAAq2B,IACjCF,IAIAD,GAAA,MAIA10B,KAAArB,MAAA+R,WAEA,KAAA+jB,EAAArwB,KAAApE,KAAArB,MAAAuF,OAAA,CACA,GAAA2wB,GAAAJ,EAAA1c,MACA0c,KAAAz1B,OAAA61B,EAAAxnC,KACAinC,EAAAzJ,OAAiC57B,KAAAgI,GAAAI,QAAAmH,IAAAq2B,IAIjC,MADAtoC,IAAAmoC,IAAAL,EAAA,mEAEAF,YAAAM,EACAH,YACAI,cACAR,YAAAM,IAWAV,EAAA7mC,UAAA8nC,aAAA,SAAAx2B,EAAAkd,GACA,GAAA/a,GAAAV,IACAzT,IAAAgS,EAAAm2B,YAAA,0CACA,IAAAt2B,GAAA4B,KAAAm0B,WACAn0B,MAAAm0B,YAAA51B,EAAA41B,YACAn0B,KAAAk0B,YAAA31B,EAAA21B,WAEA,IAAAlJ,GAAAzsB,EAAA+1B,UAAAvJ,YACAC,GAAAgK,KAAA,SAAAl+B,EAAAC,GACA,MAAAF,IAAAC,EAAA7H,KAAA8H,EAAA9H,OACAyR,EAAA/B,MAAAC,cAAA9H,EAAA0H,IAAAzH,EAAAyH,OAEAwB,KAAAi1B,kBAAAxZ,EACA,IAAAyZ,GAAAl1B,KAAAm1B,uBACAC,EAAA,IAAAp1B,KAAAi0B,eAAA7vB,MAAApE,KAAA0F,QACA2vB,EAAAD,EAAA5K,GAAA8K,OAAA9K,GAAA+K,MACApK,EAAAkK,IAAAr1B,KAAAg0B,SAEA,OADAh0B,MAAAg0B,UAAAqB,EACA,IAAArK,EAAAngC,QAAAsgC,GAOAhtB,SAFA,GAAA8sB,IAAAjrB,KAAArB,MAAAJ,EAAA41B,YAAA/1B,EAAA4sB,EAAAqK,IAAA7K,GAAA+K,OAAAh3B,EAAA21B,YAAAjmC,UAAAk9B,GAGA+J,iBANoBA,iBAcpBpB,EAAA7mC,UAAAugC,uBAAA,SAAAR,GACA,MAAAhtB,MAAA0F,SAAAsnB,IAAA5C,GAAAsE,QAKA1uB,KAAA0F,SAAA,EACA1F,KAAA+0B,cACAZ,YAAAn0B,KAAAm0B,YACAG,UAAA,GAAA5J,IACAwJ,YAAAl0B,KAAAk0B,YACAQ,aAAA,MAKoBQ,kBAMpBpB,EAAA7mC,UAAAuoC,gBAAA,SAAAnoC,GAEA,OAAA2S,KAAA+zB,gBAAAnc,IAAAvqB,MAIA2S,KAAAm0B,YAAAvc,IAAAvqB,KAOA2S,KAAAm0B,YAAA18B,IAAApK,GAAAqZ,mBAUAotB,EAAA7mC,UAAAgoC,kBAAA,SAAAxZ,GACA,GAAAA,EAAA,CACA,GAAAga,GAAAha,EAAAxC,OAOA,QANAwc,YAAAvc,IACAlZ,KAAA+zB,gBAAA0B,EAAAh6B,UAEAg6B,YAAAjc,MACAxZ,KAAA+zB,gBAAA0B,EAAA9b,cAAA3Z,KAAA+zB,kBAEAtY,EAAAtC,qBACA,IAAA5B,IAAAsE,YACA7b,KAAA0F,SAAA,CACA,MACA,KAAA6R,IAAA6B,eACApZ,KAAA0F,SAAA,CACA,MACA,KAAA6R,IAAA+D,KACA,KACA,SACAnvB,EAAA,kCAAAsvB,EAAAtC,wBAIA2a,EAAA7mC,UAAAkoC,qBAAA,WACA,GAAAz0B,GAAAV,IAEA,KAAAA,KAAA0F,QACA,QAIA,IAAAgwB,GAAA11B,KAAAi0B,cACAj0B,MAAAi0B,eAAAn+B,KACAkK,KAAAm0B,YAAAnmC,QAAA,SAAAwQ,GACAkC,EAAA80B,gBAAAh3B,EAAAnR,OACAqT,EAAAuzB,eAAAvzB,EAAAuzB,eAAAh1B,IAAAT,EAAAnR,OAIA,IAAA29B,KAWA,OAVA0K,GAAA1nC,QAAA,SAAAX,GACAqT,EAAAuzB,eAAArc,IAAAvqB,IACA29B,EAAA/6B,KAAA,GAAA2jC,IAAAvmC,MAGA2S,KAAAi0B,eAAAjmC,QAAA,SAAAX,GACAqoC,EAAA9d,IAAAvqB,IACA29B,EAAA/6B,KAAA,GAAA0jC,IAAAtmC,MAGA29B,GAEA8I,K4C9QA6B,GAAA,WACA,QAAAA,GAIAh3B,EAKAqV,EAMA9d,EAOA0/B,GACA51B,KAAArB,QACAqB,KAAAgU,WACAhU,KAAA9J,cACA8J,KAAA41B,OAEA,MAAAD,MAgBAE,GAAA,WACA,QAAAnC,GAAAoC,EAAAC,EAAAC,GACAh2B,KAAA81B,aACA91B,KAAA+1B,cACA/1B,KAAAg2B,cACAh2B,KAAAi2B,YAAA,KACAj2B,KAAAk2B,aAAA,KACAl2B,KAAAm2B,kBAAA,GAAApK,IAAA,SAAAgB,GACA,MAAAA,GAAAhd,gBAEA/P,KAAAo2B,sBACAp2B,KAAAq2B,kBAAA,GAAAjvB,IAAAtB,GAAAhC,YACA9D,KAAAs2B,qBACAt2B,KAAAu2B,kBAAA,GAAA9E,IACAzxB,KAAAw2B,eAAA,GAAAvG,IAEAjwB,KAAAy2B,yBACAz2B,KAAA02B,kBAAAzD,GAAAQ,gBAyYA,MAtYAC,GAAAzmC,UAAAigC,UAAA,SAAA+I,EAAAC,GACA3pC,EAAA,OAAA0pC,GAAA,OAAAC,EAAA,0CACA3pC,EAAA,OAAAyT,KAAAi2B,aAAA,OAAAj2B,KAAAk2B,aAAA,wCACAl2B,KAAAi2B,cACAj2B,KAAAk2B,eACAl2B,KAAAw2B,eAAAlG,iBAAAtwB,KAAAu2B,oBAOA7C,EAAAzmC,UAAAk8B,OAAA,SAAAxqB,GACA,GAAA+B,GAAAV,IAGA,OAFAA,MAAA22B,iBAAA,YACApqC,GAAAyT,KAAAm2B,kBAAAve,IAAAjZ,GAAA,mCAAAA,GACAqB,KAAA81B,WAAAc,cAAAj4B,GAAAgvB,KAAA,SAAAhL,GACA,MAAAjiB,GAAAo1B,WACAe,aAAAl4B,GACAgvB,KAAA,SAAApU,GACA,MAAA7Y,GAAAo1B,WACAgB,mBAAAnU,EAAA3O,UACA2Z,KAAA,SAAAoJ,GACA,GAAAnB,GAAA,GAAA/B,IAAAl1B,EAAAo4B,GACAC,EAAApB,EAAAxB,kBAAA7a,GACA0d,EAAArB,EAAAb,aAAAiC,EACAzqC,GAAA,IAAA0qC,EAAA/B,aAAArqC,OAAA,+DACA0B,IAAA0qC,EAAA94B,SAAA,4DACA,IAAAsI,GAAA,GAAAkvB,IAAAh3B,EAAAgkB,EAAA3O,SAAA2O,EAAAzsB,YAAA0/B,EACAl1B,GAAAy1B,kBAAAhpB,IAAAxO,EAAA8H,GACA/F,EAAA01B,mBAAAzT,EAAA3O,UAAAvN,EACA/F,EAAAu1B,aAAAgB,EAAA94B,WACAuC,EAAAq1B,YAAA5M,OAAAxG,OAGAgL,KAAA,WACA,MAAAhL,GAAA3O,cAKA0f,EAAAzmC,UAAA2gC,SAAA,SAAAjvB,GACA,GAAA+B,GAAAV,IACAA,MAAA22B,iBAAA,aACA,IAAAO,GAAAl3B,KAAAm2B,kBAAA1+B,IAAAkH,EAEA,OADApS,KAAA2qC,EAAA,yCAAAv4B,GACAqB,KAAA81B,WAAAqB,aAAAx4B,GAAAgvB,KAAA,WAEA,MADAjtB,GAAAq1B,YAAAnI,SAAAsJ,EAAAljB,UACAtT,EAAA02B,sBAAAF,GAAAvJ,KAAA,WACA,MAAAjtB,GAAAo1B,WAAAnF,sBAcA+C,EAAAzmC,UAAAoqC,MAAA,SAAAC,EAAAC,GACA,GAAA72B,GAAAV,IAEA,OADAA,MAAA22B,iBAAA,WACA32B,KAAA81B,WACA0B,WAAAF,GACA3J,KAAA,SAAAx/B,GAEA,MADAuS,GAAA+2B,oBAAAtpC,EAAAupC,QAAAH,GACA72B,EAAAi3B,gCAAAxpC,EAAA68B,WAEA2C,KAAA,WACA,MAAAjtB,GAAAq1B,YAAA6B,uBAIAlE,EAAAzmC,UAAA4qC,wBAAA,SAAAhsC,GACA,MAAAA,IAmBA6nC,EAAAzmC,UAAA6qC,eAAA,SAAAC,EAAAC,GACA,GAAAt3B,GAAAV,SACA,KAAAg4B,IAAiCA,EAAA,GACjCzrC,EAAAyrC,GAAA,oDACA,IAAAC,GAAAj4B,KAAA+1B,YAAAmC,mBAiBA,OAhBA,YACA,IACA,GAAAC,GAAAJ,EAAAE,EACA,QAAAjlC,EAAAmlC,IACAA,EAAA/I,OACA+I,EAAAxK,KAGAwK,EAAA/I,MAAA,SAAAljC,GACA,MAAA66B,SAAA7sB,OAAAwG,EAAAm3B,wBAAA3rC,MAHA66B,QAAA7sB,OAAA5N,MAAA,+CAMA,MAAAJ,GACA,MAAA66B,SAAA7sB,OAAAwG,EAAAm3B,wBAAA3rC,QAGAyhC,KAAA,SAAAx/B,GACA,MAAA8pC,GACAG,SACAzK,KAAA,WACA,MAAAx/B,KAEAihC,MAAA,SAAAvjC,GACA,WAAAmsC,EACAjR,QAAA7sB,OAAArO,GAGA6U,EAAAo3B,eAAAC,EAAAC,EAAA,QAIAtE,EAAAzmC,UAAAorC,iBAAA,SAAAC,GACA,GAAA53B,GAAAV,IAoCA,OAnCAA,MAAA22B,iBAAA,sBAEA/oC,EAAA0qC,EAAAzf,cAAA,SAAA7E,EAAAyH,GACA,GAAA8c,GAAA73B,EAAA41B,kBAAAtiB,EACAukB,IACA9c,EAAAtC,sBACA5B,GAAAsE,cACAyc,EAAAxf,gBAAArhB,IAAA8gC,IAyBAD,EAAAvf,kBAAA,GAAA7R,IAAAqxB,EAAAD,EAAApkB,oBAGAlU,KAAA81B,WAAAuC,iBAAAC,GAAA3K,KAAA,SAAA3C,GACA,MAAAtqB,GAAAi3B,gCAAA3M,EAAAsN,MAOA5E,EAAAzmC,UAAAugC,uBAAA,SAAAR,GACA,GAAAwL,KACAx4B,MAAAm2B,kBAAAnoC,QAAA,SAAA2Q,EAAAu4B,GACA,GAAAD,GAAAC,EAAAtB,KAAApI,uBAAAR,EACAzgC,GAAA,IAAA0qC,EAAA/B,aAAArqC,OAAA,kDACAosC,EAAA94B,UACAq6B,EAAAvoC,KAAAgnC,EAAA94B,YAGA6B,KAAAi2B,YAAAuC,IAEA9E,EAAAzmC,UAAAwrC,aAAA,SAAAzkB,EAAA2R,GACA,GAAAjlB,GAAAV,IACAA,MAAA22B,iBAAA,kBACA,IAAA4B,GAAAv4B,KAAAs2B,kBAAAtiB,EACA,IAAAukB,EAAA,CAGAv4B,KAAAq2B,kBAAAr2B,KAAAq2B,kBAAA3uB,OAAA6wB,SACAv4B,MAAAs2B,kBAAAtiB,EAOA,IAAA0kB,GAAA,GAAAtxB,IAAAtB,GAAAhC,WACA40B,KAAAnxB,OAAAgxB,EAAA,GAAArxB,IAAAqxB,EAAAnlB,GAAAK,iBACA,IAAAklB,GAAA,GAAAhgB,IAAAvF,GAAAM,OAAiEglB,EACjE,OAAA14B,MAAAq4B,iBAAAM,GAGA,GAAAC,GAAA54B,KAAAo2B,mBAAApiB,EAEA,OADAznB,KAAAqsC,EAAA,qBAAA5kB,GACAhU,KAAA81B,WAAAqB,aAAAyB,EAAAj6B,OAAAgvB,KAAA,WACA,MAAAjtB,GAAA02B,sBAAAwB,GAAAjL,KAAA,WACAjtB,EAAAw1B,aAAA0C,EAAAj6B,MAAAgnB,QAKA+N,EAAAzmC,UAAA4rC,qBAAA,SAAAC,GACA,GAAAp4B,GAAAV,IAQA,OAPAA,MAAA22B,iBAAA,0BAKA32B,KAAA+4B,oBAAAD,EAAAxB,MAAAI,QACA,MACA13B,KAAA81B,WACAkD,iBAAAF,GACAnL,KAAA,SAAA3C,GACA,MAAAtqB,GAAAi3B,gCAAA3M,MAGA0I,EAAAzmC,UAAAgsC,kBAAA,SAAAvB,EAAA7rC,GACA,GAAA6U,GAAAV,IAOA,OANAA,MAAA22B,iBAAA,uBAKA32B,KAAA+4B,oBAAArB,EAAA7rC,GACAmU,KAAA81B,WAAAoD,YAAAxB,GAAA/J,KAAA,SAAA3C,GACA,MAAAtqB,GAAAi3B,gCAAA3M,MAGA0I,EAAAzmC,UAAAwqC,oBAAA,SAAAC,EAAAzS,GACA,GAAAkU,GAAAn5B,KAAAy2B,sBAAAz2B,KAAAg2B,YAAAoD,QACAD,KACAA,EAAA,GAAA/xB,IAAA1V,IAEAynC,IAAA5xB,OAAAmwB,EAAAzS,GACAjlB,KAAAy2B,sBAAAz2B,KAAAg2B,YAAAoD,SAAAD,GAMAzF,EAAAzmC,UAAA8rC,oBAAA,SAAArB,EAAA7rC,GACA,GAAAstC,GAAAn5B,KAAAy2B,sBAAAz2B,KAAAg2B,YAAAoD,QAGA,IAAAD,EAAA,CACA,GAAAlU,GAAAkU,EAAA1hC,IAAAigC,EACAzS,KACA14B,EAAAmrC,IAAAyB,EAAArxB,SAAA,8CACAjc,EACAo5B,EAAA/qB,OAAArO,GAGAo5B,EAAAhrB,UAEAk/B,IAAAzxB,OAAAgwB,IAEA13B,KAAAy2B,sBAAAz2B,KAAAg2B,YAAAoD,SAAAD,IAGAzF,EAAAzmC,UAAAmqC,sBAAA,SAAAF,GAIA,MAHAl3B,MAAAm2B,kBAAAn3B,OAAAk4B,EAAAv4B,aACAqB,MAAAo2B,mBAAAc,EAAAljB,UACAhU,KAAAu2B,kBAAAjE,sBAAA4E,EAAAljB,UACAhU,KAAAq5B,oBAEA3F,EAAAzmC,UAAAqsC,oBAAA,SAAAtlB,EAAAkhB,GACA,OAAAvqC,GAAA,EAAA4uC,EAAArE,EAAuDvqC,EAAA4uC,EAAA1uC,OAA4BF,IAAA,CACnF,GAAA6uC,GAAAD,EAAA5uC,EACA6uC,aAAA7F,KACA3zB,KAAAu2B,kBAAAvE,aAAAwH,EAAAnsC,IAAA2mB,GACAhU,KAAAy5B,iBAAAD,IAEAA,YAAA5F,KACArpC,EAzWA,aAyWA,gCAAAivC,EAAAnsC,KACA2S,KAAAu2B,kBAAApE,gBAAAqH,EAAAnsC,IAAA2mB,IAGA7nB,EAAA,yBAAAuE,KAAAC,UAAA6oC,IAGA,MAAAx5B,MAAAq5B,oBAEA3F,EAAAzmC,UAAAwsC,iBAAA,SAAAD,GACA,GAAAnsC,GAAAmsC,EAAAnsC,GACA,KAAA2S,KAAAq2B,kBAAA5+B,IAAApK,GAAA,CACA9C,EArXA,aAqXA,0BAAA8C,EACA,IAAAqsC,GAAA15B,KAAA02B,kBAAA7wB,OACAlH,EAAAmP,GAAAS,OAAAlhB,EAAAkJ,KACAyJ,MAAAs2B,kBAAAoD,GAAArsC,EACA2S,KAAA+1B,YAAA5M,OAAA,GAAArV,IAAAnV,EAAA+6B,EAAAjvB,GAAAqY,SACA9iB,KAAAq2B,kBAAAr2B,KAAAq2B,kBAAA9uB,OAAAla,EAAAqsC,KAGAhG,EAAAzmC,UAAAosC,iBAAA,WACA,GAAA34B,GAAAV,IAGA,OAAAA,MAAAw2B,eACA7F,eAAA,MACA9qB,KAAA,SAAA8R,GACAA,EAAA3pB,QAAA,SAAAX,GACA,GAAAqsC,GAAAh5B,EAAA21B,kBAAA5+B,IAAApK,EACA,QAAAqsC,IAIAh5B,EAAAq1B,YAAAnI,SAAA8L,GACAh5B,EAAA21B,kBAAA31B,EAAA21B,kBAAA3uB,OAAAra,SACAqT,GAAA41B,kBAAAoD,QAGAjK,aAGAiE,EAAAzmC,UAAA0sC,iBAAA,WACA,MAAA35B,MAAAq2B,mBAEA3C,EAAAzmC,UAAA0qC,gCAAA,SAAA3M,EAAAsN,GACA,GAAA53B,GAAAV,KACA45B,KACAC,KACAC,IA2BA,OA1BA95B,MAAAm2B,kBAAAnoC,QAAA,SAAAsD,EAAA4lC,GACA4C,EAAA7pC,KAAA82B,QAAA9sB,UACA0zB,KAAA,WACA,GAAAqJ,GAAAE,EAAAtB,KAAAxB,kBAAApJ,EACA,OAAAgM,GAAAtC,YAMAh0B,EAAAo1B,WAAAe,aAAAK,EAAAv4B,OAAAgvB,KAAA,SAAApU,GACA,MAAA2d,GAAAtB,KAAAxB,kBAAA7a,EAAAyd,KANAA,IASArJ,KAAA,SAAAqJ,GACA,GAAAvb,GAAA6c,KAAAzf,cAAAqe,EAAAljB,UACAijB,EAAAC,EAAAtB,KAAAb,aAAAiC,EAAAvb,EACA,OAAA/a,GAAA44B,oBAAApC,EAAAljB,SAAAijB,EAAA/B,cAAAvH,KAAA,WACA,GAAAsJ,EAAA94B,SAAA,CACAy7B,EAAA3pC,KAAAgnC,EAAA94B,SACA,IAAAI,GAAA4yB,GAAAI,aAAA0F,EAAA94B,SACA07B,GAAA5pC,KAAAsO,WAKAwoB,QAAA6I,IAAAkK,GACAnM,KAAA,WAEA,MADAjtB,GAAAu1B,YAAA2D,GACAl5B,EAAAo1B,WAAAiE,uBAAAF,KAEAlM,KAAA,WACA,MAAAjtB,GAAAo1B,WAAAnF,oBAGA+C,EAAAzmC,UAAA0pC,iBAAA,SAAAqD,GACAztC,EAAA,OAAAyT,KAAAi2B,aAAA,OAAAj2B,KAAAk2B,aAAA,kBAAA8D,EAAA,iCAEAtG,EAAAzmC,UAAAgtC,iBAAA,SAAAC,GACA,GAAAx5B,GAAAV,IAEA,OADAA,MAAAg2B,YAAAkE,EACAl6B,KAAA81B,WACAmE,iBAAAC,GACAvM,KAAA,SAAA3C,GACA,MAAAtqB,GAAAi3B,gCAAA3M,KAEA2C,KAAA,WACA,MAAAjtB,GAAAq1B,YAAAkE,iBAAAC,MAGAxG,KC3dAyG,IAAA,EAIAC,GAAA,WACA,QAAAC,GAAA3C,EAAAnrB,EAAA+tB,GACAt6B,KAAA03B,UACA13B,KAAAuM,iBACAvM,KAAAs6B,YAyEA,MA9DAD,GAAAptC,UAAA4oB,sBAAA,SAAAxa,EAAA8Z,EAAAolB,GACAplB,GACA5oB,EAAA4oB,EAAA9nB,IAAAyE,QAAAuJ,GAAA,8BAAAA,EAAA,uCAAA8Z,EAAA9nB,IAEA,IAAAmtC,GAAAD,EAAAC,eACAjuC,GAAAiuC,EAAA3vC,SAAAmV,KAAAs6B,UAAAzvC,OAAA,6CAAAmV,KAAAs6B,UAAAzvC,OAAA,yCAAA2vC,EAAA3vC,OAAA,KACA,QAAAmH,GAAA,EAAuBA,EAAAgO,KAAAs6B,UAAAzvC,OAA2BmH,IAAA,CAClD,GAAAyuB,GAAAzgB,KAAAs6B,UAAAtoC,EACA,IAAAyuB,EAAApzB,IAAAyE,QAAAuJ,GAAA,CACA,GAAAya,GAAA0kB,EAAAxoC,EACAmjB,GAAAsL,EAAA5K,sBAAAV,EAAAW,IAGA,MAAAX,IASAklB,EAAAptC,UAAA8oB,iBAAA,SAAA1a,EAAA8Z,GACAA,GACA5oB,EAAA4oB,EAAA9nB,IAAAyE,QAAAuJ,GAAA,6BAAAA,EAAA,uCAAA8Z,EAAA9nB,IAGA,QADA2oB,GAAAb,EACAnjB,EAAA,EAAuBA,EAAAgO,KAAAs6B,UAAAzvC,OAA2BmH,IAAA,CAClD,GAAAyuB,GAAAzgB,KAAAs6B,UAAAtoC,EACAyuB,GAAApzB,IAAAyE,QAAAuJ,KACA8Z,EAAAsL,EAAA1K,iBAAAZ,EAAAa,EAAAhW,KAAAuM,iBAGA,MAAA4I,IAEAklB,EAAAptC,UAAA0qB,KAAA,WAEA,OADA8iB,GAAA3kC,KACAnL,EAAA,EAAAokB,EAAA/O,KAAAs6B,UAA6C3vC,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAC7D,GAAA81B,GAAA1R,EAAApkB,EACA8vC,KAAAx7B,IAAAwhB,EAAApzB,KAEA,MAAAotC,IAEAJ,EAAAptC,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAA03B,UAAAz1B,EAAAy1B,SACA3lC,EAAAiO,KAAAs6B,UAAAr4B,EAAAq4B,YAUAD,EAAAptC,UAAAytC,YAAA,WACA,WAAA16B,KAAAs6B,UAAAzvC,QAGAwvC,EAAAptC,UAAA0tC,YAAA,WACA,UAAAN,GAAAr6B,KAAA03B,QAAA13B,KAAAuM,oBAEA8tB,KAIAO,GAAA,WACA,QAAAC,GAAAvD,EAAAwD,EAAAN,EAAAO,EAKAC,GACAh7B,KAAAs3B,QACAt3B,KAAA86B,gBACA96B,KAAAw6B,kBACAx6B,KAAA+6B,cACA/6B,KAAAg7B,cAyBA,MAlBAH,GAAA/Y,KAAA,SAAAwV,EAAAwD,EAAA9pC,EAAA+pC,GACAxuC,EAAA+qC,EAAAgD,UAAAzvC,SAAAmG,EAAAnG,OAAA,kBACAysC,EAAAgD,UAAAzvC,OACA,gCACAmG,EAAAnG,OAGA,QAFAowC,GAAArlC,KACA0kC,EAAAhD,EAAAgD,UACAtoC,EAAA,EAAuBA,EAAAsoC,EAAAzvC,OAAsBmH,IAAA,CAC7C,GAAAwU,GAAAxV,EAAAgB,GAAAwU,OACA,QAAAA,IAGAA,EAAAs0B,GAEAG,IAAA1zB,OAAA+yB,EAAAtoC,GAAA3E,IAAAmZ,GAEA,UAAAq0B,GAAAvD,EAAAwD,EAAA9pC,EAAA+pC,EAAAE,IAEAJ,K5C1HAhjC,GAAA,IACAG,GAAA,IACAF,GAAA,IACAC,GAAA,IC4BAmjC,GAAA,WACA,QAAAA,GAAA5oB,EAAAC,GACAvS,KAAAsS,UACAtS,KAAAuS,QAEA,MAAA2oB,MAWAthC,GAAA,WACA,QAAAA,GAAAuhC,EAAAC,GACAp7B,KAAAm7B,UACAn7B,KAAAo7B,mBAIA,MADAxhC,GAAAb,MAAA,QACAa,KASAd,GAAA,WACA,QAAAA,GAIAuiC,EAOAC,EAUAC,GACAv7B,KAAAq7B,SACAr7B,KAAAs7B,0BACAt7B,KAAAu7B,kBAMA,MAHAziC,GAAAC,MAAA,iBAEAD,EAAAE,QAAA,SACAF,KAUAG,GAAA,WACA,QAAAA,GAIAoiC,EAKA3D,EAKA8D,EAMAlB,GACAt6B,KAAAq7B,SACAr7B,KAAA03B,UACA13B,KAAAw7B,mBACAx7B,KAAAs6B,YAMA,MAHArhC,GAAAF,MAAA,YAEAE,EAAAD,SAAA,oBACAC,KAUAS,GAAA,WACA,QAAA+hC,MA+BA,MAzBAA,GAAAC,cAAA,SAAAL,GACA,OAAAA,IAMAI,EAAAE,cAAA,SAAAN,EAAA9kC,GACA,OAAA8kC,EAAA/jC,GAAAf,KAMAklC,EAAApuC,IAAA,SAAAguC,EAAA9kC,EAAAmhC,GACA,OAAA2D,EAAA/jC,GAAAf,GAAAmhC,IAEA+D,EAAA1iC,MAAA,oBAOA0iC,EAAAG,YAAA,GAAAH,GACAA,KAOAI,GAAA,WACA,QAAAA,GAAAtlC,EAAAkpB,GACAzf,KAAAzJ,OACAyJ,KAAAyf,WAEA,MAAAoc,MAWAliC,GAAA,WACA,QAAAA,GAKAmiC,EAKA3c,GACAnf,KAAA87B,aACA97B,KAAAmf,WAGA,MADAxlB,GAAAZ,MAAA,kBACAY,KAYAJ,GAAA,WACA,QAAAA,GASAya,EAIAjE,EAMA0P,EAkBAvpB,EAeA6lC,EAQAp9B,GACAqB,KAAAgU,WACAhU,KAAA+P,cACA/P,KAAAyf,WACAzf,KAAA9J,cACA8J,KAAA+7B,2BACA/7B,KAAArB,QAaA,MAXApF,GAAAR,MAAA,UAEAQ,EAAAP,QAAA,WAEAO,EAAAC,sBAAA,oBAMAD,EAAAE,qBAAA,0BACAF,KAQAL,GAAA,WACA,QAAAA,GAIA8a,EAIAzd,GACAyJ,KAAAgU,WACAhU,KAAAzJ,OAUA,MAPA2C,GAAAH,MAAA,kBAEAG,EAAAF,SAAA,mBAEAE,EAAAE,qBAAA,uBAEAF,EAAAG,wBAAA,mBACAH,KASAW,GAAA,WACA,QAAAA,GAMAmiC,EAMAC,EASAC,GACAl8B,KAAAg8B,kBACAh8B,KAAAi8B,8BACAj8B,KAAAk8B,4BAQA,MAFAriC,GAAAxM,IAAA,kBACAwM,EAAAd,MAAA,eACAc,KAOAsiC,IACArjC,GAAAC,MACAE,GAAAF,MACAW,GAAAX,MACAY,GAAAZ,MACAQ,GAAAR,MACAa,GAAAb,MACAc,GAAAd,MACAG,GAAAH,OCjYAqjC,GAAA,WACA,QAAAC,GAAA1jC,GACAqH,KAAArH,KAoFA,MAjFA0jC,GAAAC,aAAA,SAAAztC,EAAA2X,EAAA+1B,GAGA,MAFAhwC,GAAA8vC,EAAAG,cAAA,mDACAjyC,EAfA,WAeA,oBAAAsE,GACA,GAAAmL,IAAA,SAAAC,EAAAC,GAKA,GAAAH,GAAA0iC,OAAAC,UAAAzT,KAAAp6B,EAAA2X,EACAzM,GAAAI,UAAA,SAAAC,GACA,GAAAzB,GAAAyB,EAAAC,OAAAlM,MACA8L,GAAA,GAAAoiC,GAAA1jC,KAEAoB,EAAAO,QAAA,SAAAF,GACAF,EAAAE,EAAAC,OAAAxO,QAEAkO,EAAA4iC,gBAAA,SAAAviC,GACA7P,EA9BA,WA8BA,aAAAsE,EAAA,mCAAAuL,EAAAxB,WAOA,IAAAD,GAAAyB,EAAAC,OAAAlM,MACAouC,GAAA5jC,EAAAyB,EAAAxB,eAES62B,aAGT4M,EAAAr9B,OAAA,SAAAnQ,GAEA,MADAtE,GA5CA,WA4CA,qBAAAsE,GACAiL,GAAA2iC,OAAAC,UAAAE,eAAA/tC,IAAA4gC,aAGA4M,EAAAG,YAAA,WACA,sBAAAC,SAAA,MAAAA,OAAAC,UACA,QASA,IAAAG,GAAAJ,OAAAK,UAAAC,SAQA,SAAAF,EAAAtrC,QAAA,YACAsrC,EAAAtrC,QAAA,eACAsrC,EAAAtrC,QAAA,aAOA8qC,EAAApvC,UAAA6qC,eAAA,SAAAkF,EAAAC,EAAAC,GACA,GAAAjF,GAAA,GAAAn9B,IAAAkF,KAAArH,GAAAqkC,EAAAC,GACAE,EAAAD,EAAAjF,GACA7I,MAAA,SAAAvjC,GAIA,MADAosC,GAAAmF,QACApjC,GAAAE,OAAArO,KAEA4jC,WAIA,OAAAwI,GAAAoF,kBAAA1P,KAAA,WAA+D,MAAAwP,MAE/Dd,EAAApvC,UAAAs4B,MAAA,WACAvlB,KAAArH,GAAA4sB,SAEA8W,KAQAiB,GAAA,WACA,QAAAA,GAAAC,GACAv9B,KAAAu9B,WACAv9B,KAAAw9B,YAAA,EACAx9B,KAAAy9B,QAAA,KA4CA,MA1CAnwC,QAAAqS,eAAA29B,EAAArwC,UAAA,UACAwK,IAAA,WACA,MAAAuI,MAAAw9B,YAEA96B,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAA29B,EAAArwC,UAAA,aACAwK,IAAA,WACA,MAAAuI,MAAAy9B,SAEA/6B,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAA29B,EAAArwC,UAAA,UACAkgB,IAAA,SAAA1f,GACAuS,KAAAu9B,SAAA9vC,GAEAiV,YAAA,EACAC,cAAA,IAKA26B,EAAArwC,UAAAywC,KAAA,WACA19B,KAAAw9B,YAAA,GAMAF,EAAArwC,UAAA0wC,KAAA,SAAAtwC,GACA2S,KAAAy9B,QAAApwC,GAOAiwC,EAAArwC,UAAA+R,OAAA,WACA,MAAAlF,IAAAkG,KAAAu9B,SAAAv+B,WAEAs+B,KAOAxiC,GAAA,WACA,QAAA8iC,GAAAjlC,EAAAqkC,EAAAa,GACA,GAAAn9B,GAAAV,IACAA,MAAA89B,SAAA,EACA99B,KAAAi4B,YAAAt/B,EAAAs/B,YAAA4F,EAAAb,GACAh9B,KAAAq9B,kBAAA,GAAAtW,SAAA,SAAA9sB,EAAAC,GAGAwG,EAAAu3B,YAAA8F,QAAAr9B,EAAAu3B,YAAA+F,WAAA,SAAA5jC,GACAH,KAEAyG,EAAAu3B,YAAA39B,QAAA,SAAAF,GACAF,EAAAE,EAAAC,OAAAxO,UAyBA,MArBA+xC,GAAA3wC,UAAAmwC,MAAA,WACAp9B,KAAA89B,UACAvzC,EA/KA,WA+KA,yBACAyV,KAAA89B,SAAA,EACA99B,KAAAi4B,YAAAmF,UAYAQ,EAAA3wC,UAAA8L,MAAA,SAAAklC,GACA,GAAAllC,GAAAiH,KAAAi4B,YAAAiG,YAAAD,EAEA,OADA1xC,KAAAwM,EAAA,yCAAAklC,GACA,GAAAE,IAAAplC,IAEA6kC,KAaAO,GAAA,WACA,QAAAC,GAAArlC,GACAiH,KAAAjH,QAyIA,MAvIAqlC,GAAAnxC,UAAAoxC,IAAA,SAAAC,EAAA7wC,GACA,GAAAsM,EASA,YARApM,KAAAF,GACAlD,EAtNA,WAsNA,MAAAyV,KAAAjH,MAAAlK,KAAAyvC,EAAA7wC,GACAsM,EAAAiG,KAAAjH,MAAAslC,IAAA5wC,EAAA6wC,KAGA/zC,EA1NA,WA0NA,MAAAyV,KAAAjH,MAAAlK,KAAA,aAAAyvC,GACAvkC,EAAAiG,KAAAjH,MAAAslC,IAAAC,IAEAxkC,GAAAC,IASAqkC,EAAAnxC,UAAAwK,IAAA,SAAApK,GACA,GAAAqT,GAAAV,IAGA,OAAAlG,IAFAkG,KAAAjH,MAAAtB,IAAApK,IAEAwY,KAAA,SAAA1X,GAMA,WAJAR,KAAAQ,IACAA,EAAA,MAEA5D,EA/OA,WA+OA,MAAAmW,EAAA3H,MAAAlK,KAAAxB,EAAAc,GACAA,KAGAiwC,EAAAnxC,UAAA+R,OAAA,SAAA3R,GAGA,MAFA9C,GApPA,WAoPA,SAAAyV,KAAAjH,MAAAlK,KAAAxB,GAEAyM,GADAkG,KAAAjH,MAAAiG,OAAA3R,KAGA+wC,EAAAnxC,UAAAsxC,QAAA,SAAAC,EAAAtmB,GACA,GAAA4L,GAAA9jB,KAAA8jB,OAAA9jB,KAAA5O,QAAAotC,EAAAtmB,IACAlnB,IACA,OAAAgP,MAAAy+B,cAAA3a,EAAA,SAAAz2B,EAAAI,GACAuD,EAAAf,KAAAxC,KACSoY,KAAA,WACT,MAAA7U,MAGAotC,EAAAnxC,UAAAyxC,UAAA,SAAAF,EAAAtmB,GACA3tB,EAlQA,WAkQA,aAAAyV,KAAAjH,MAAAlK,KACA,IAAAuC,GAAA4O,KAAA5O,QAAAotC,EAAAtmB,EACA9mB,GAAAutC,UAAA,CACA,IAAA7a,GAAA9jB,KAAA8jB,OAAA1yB,EACA,OAAA4O,MAAAy+B,cAAA3a,EAAA,SAAAz2B,EAAAI,EAAAmxC,GAOA,MAAAA,GAAA5/B,YAGAo/B,EAAAnxC,UAAA4xC,QAAA,SAAAC,EAAA7Z,GACA,GAAA7zB,EACA6zB,GAKA7zB,EAAA0tC,GAJA1tC,KACA6zB,EAAA6Z,EAKA,IAAAhb,GAAA9jB,KAAA8jB,OAAA1yB,EACA,OAAA4O,MAAAy+B,cAAA3a,EAAAmB,IAEAmZ,EAAAnxC,UAAAwxC,cAAA,SAAAM,EAAAlxC,GACA,GAAAmD,KACA,WAAAgJ,IAAA,SAAAC,EAAAC,GACA6kC,EAAAzkC,QAAA,SAAAF,GACAF,EAAAE,EAAAC,OAAAxO,QAEAkzC,EAAA5kC,UAAA,SAAAC,GACA,GAAA0pB,GAAA1pB,EAAAC,OAAAlM,MACA,KAAA21B,EAEA,WADA7pB,IAGA,IAAA+kC,GAAA,GAAA1B,IAAAxZ,GACAmb,EAAApxC,EAAAi2B,EAAAob,WAAApb,EAAAr2B,MAAAuxC,EACAC,aAAAjlC,KACAhJ,EAAAf,KAAAgvC,GAEAD,EAAA9P,OACAj1B,IAEA,OAAA+kC,EAAAG,UACArb,EAAAsb,WAGAtb,EAAAsb,SAAAJ,EAAAG,cAGSt5B,KAAA,WACT,MAAA7L,IAAA21B,QAAA3+B,MAGAotC,EAAAnxC,UAAAmE,QAAA,SAAAotC,EAAAtmB,GACA,GAAAmnB,OAAA1xC,EAUA,YATAA,KAAA6wC,IACA,gBAAAA,GACAa,EAAAb,GAGAjyC,MAAAoB,KAAAuqB,EAAA,uDACAA,EAAAsmB,KAGgBh6B,MAAA66B,EAAAnnB,UAEhBkmB,EAAAnxC,UAAA62B,OAAA,SAAA1yB,GACA,GAAAkzB,GAAA,MAIA,IAHAlzB,EAAAkuC,UACAhb,EAAA,QAEAlzB,EAAAoT,MAAA,CACA,GAAAA,GAAAxE,KAAAjH,MAAAyL,MAAApT,EAAAoT,MACA,OAAApT,GAAAutC,SACAn6B,EAAA+6B,cAAAnuC,EAAA8mB,MAAAoM,GAGA9f,EAAAg7B,WAAApuC,EAAA8mB,MAAAoM,GAIA,MAAAtkB,MAAAjH,MAAAymC,WAAApuC,EAAA8mB,MAAAoM,IAGA8Z,KCpVAqB,GAAA,WACA,QAAAC,GAKArE,EAAAsE,GACA3/B,KAAAq7B,SACAr7B,KAAA2/B,aACA3/B,KAAA+xB,iBAAA,KA4VA,MArVA2N,GAAAE,QAAA,SAAA1F,EAAAyF,GAOA,MAFApzC,GAAA,KAAA2tC,EAAA2F,IAAA,uCAEA,GAAAH,GADAxF,EAAA4F,kBAAA5F,EAAA2F,IAAA,GACAF,IAEAD,EAAAzyC,UAAAsL,MAAA,SAAA0/B,GACA,GAAAv3B,GAAAV,IACA,OAAA0/B,GAAAK,sBAAA9H,GACApyB,KAAA,SAAAm6B,GAEA,MADAt/B,GAAAs/B,cACAnlC,GAAAo9B,GAAAxgC,IAAAiJ,EAAA26B,UAEAx1B,KAAA,SAAAo6B,GAWA,MAVAA,KACAA,EAAA,GAAAnnC,IAAA4H,EAAA26B,OAAAlB,GACA,KAEAz5B,EAAAu/B,WAMAv/B,EAAAu/B,SAAA3E,yBAAA56B,EAAAs/B,YACAt/B,EAAAw/B,WAAAjI,GAAApyB,KAAA,SAAAs6B,GAGA,MAFA5zC,GAAA4zC,EAAA,8DACAz/B,EAAAu/B,SAAA3E,wBAAAnB,GACAt/B,GAAAo9B,GAAAoG,IAAA39B,EAAAu/B,YAIAjmC,GAAAC,aAQAylC,EAAAK,sBAAA,SAAArlC,GACA,GAAA0lC,GAAAjG,EACA,OAAA1/B,IAAAC,GACAmkC,SAAsBS,SAAA,GAAgB,SAAAjyC,EAAAiqC,EAAAsH,GACtC,GAAAvD,GAAAhuC,EAAA,EAIA,IAJAA,EAAA,GACA+yC,IACAA,EAAA9I,EAAAI,SAEA,KAAA2D,EAIAuD,EAAAlB,WAEA,CACA,GAAA2C,GAAApuC,EAAAopC,EACAuD,GAAAjB,MAAA0C,OAGAx6B,KAAA,WAA+B,MAAAu6B,GAAA,KAE/BV,EAAAzyC,UAAAizC,WAAA,SAAAjI,GACA,GAAAkI,IAAA,EACAjoB,EAAAooB,YAAAzwB,MAAA7P,KAAAugC,cAAA1yB,OAAA5B,mBAAAjM,KAAAugC,cAAA1yB,OAAA9B,mBACA,OAAAtR,IAAAw9B,GACA4G,SAAsB3mB,SAAe,SAAA7qB,EAAAI,EAAAmxC,GACrCuB,GAAA,EACAvB,EAAAlB,SAEA73B,KAAA,WAA+B,MAAAs6B,MAE/BT,EAAAzyC,UAAAuzC,eAAA,SAAAvI,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAggC,cAEAN,EAAAzyC,UAAAwzC,8BAAA,SAAAxI,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAigC,SAAA3E,0BAEAoE,EAAAzyC,UAAA+rC,iBAAA,SAAAf,EAAAX,EAAAyD,GACA,GAAArD,GAAAJ,EAAAI,OAIA,OAHAnrC,GAAAmrC,EAAA13B,KAAAigC,SAAA3E,wBAAA,mDACAt7B,KAAAigC,SAAA3E,wBAAA5D,EACA13B,KAAAigC,SAAA1E,gBAAAhhC,GAAAwgC,GACAlgC,GAAAo9B,GAAAoG,IAAAr+B,KAAAigC,WAEAP,EAAAzyC,UAAAyzC,mBAAA,SAAAzI,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAigC,SAAA1E,kBAEAmE,EAAAzyC,UAAA0zC,mBAAA,SAAA1I,EAAA8C,GAEA,MADA/6B,MAAAigC,SAAA1E,gBAAAhhC,GAAAwgC,GACAlgC,GAAAo9B,GAAAoG,IAAAr+B,KAAAigC,WAEAP,EAAAzyC,UAAA2zC,iBAAA,SAAA3I,EAAA1rB,EAAA+tB,GACA,GAAA55B,GAAAV,KACA03B,EAAA13B,KAAAggC,WACAhgC,MAAAggC,aACA,IAAA1I,GAAA,GAAA8C,IAAA1C,EAAAnrB,EAAA+tB,GACAuG,EAAA7gC,KAAA2/B,WAAAmB,kBAAA9gC,KAAAq7B,OAAA/D,EACA,OAAA78B,IAAAw9B,GACAoG,IAAAwC,GACAh7B,KAAA,WAEA,OADA+qB,MACAjmC,EAAA,EAAAo2C,EAAAzG,EAAqD3vC,EAAAo2C,EAAAl2C,OAAyBF,IAAA,CAC9E,GAAA81B,GAAAsgB,EAAAp2C,GACAq2C,EAAAtnC,GAAArM,IAAAqT,EAAA26B,OAAA5a,EAAApzB,IAAAkJ,KAAAmhC,EACA98B,IAAAq9B,GAAAoG,IAAA2C,EAAAtnC,GAAAkiC,aAEA,MAAA5hC,IAAA21B,QAAAiB,KAEA/qB,KAAA,WACA,MAAAyxB,MAGAoI,EAAAzyC,UAAAg0C,oBAAA,SAAAhJ,EAAAP,GACA,GAAAh3B,GAAAV,IACA,OAAAvF,IAAAw9B,GACAxgC,IAAAuI,KAAAugC,cAAA7I,IACA7xB,KAAA,SAAAg7B,GACA,MAAAA,GAAAngC,EAAAi/B,WAAAuB,oBAAAL,GAAA,QAGAnB,EAAAzyC,UAAAk0C,iCAAA,SAAAlJ,EAAAP,GACA,GAAAh3B,GAAAV,KACAkY,EAAAooB,YAAAc,WAAAphC,KAAAugC,cAAA7I,EAAA,IACA2J,EAAA,IACA,OAAA5mC,IAAAw9B,GACA4G,SAAsB3mB,SAAe,SAAA7qB,EAAAwzC,EAAAjC,GACrCiC,EAAAxF,SAAA36B,EAAA26B,SACA9uC,EAAAs0C,EAAAnJ,UAAA,oCAAAA,GACA2J,EAAA3gC,EAAAi/B,WAAAuB,oBAAAL,IAEAjC,EAAAlB,SAEA73B,KAAA,WAA+B,MAAAw7B,MAE/B3B,EAAAzyC,UAAAq0C,sBAAA,SAAArJ,GACA,GAAAv3B,GAAAV,KACAkY,EAAAooB,YAAAzwB,MAAA7P,KAAAugC,cAAApG,IAAAn6B,KAAAugC,cAAA1yB,OAAA9B,mBACA,OAAAtR,IAAAw9B,GACAsG,QAAArmB,GACArS,KAAA,SAAA07B,GACA,MAAAA,GAAAn2C,IAAA,SAAAy1C,GAAqD,MAAAngC,GAAAi/B,WAAAuB,oBAAAL,QAGrDnB,EAAAzyC,UAAAu0C,oCAAA,SAAAvJ,EAAAP,GACA,GAAAh3B,GAAAV,KACAkY,EAAAooB,YAAAzwB,MAAA7P,KAAAugC,cAAApG,IAAAn6B,KAAAugC,cAAA7I,GACA,OAAAj9B,IAAAw9B,GACAsG,QAAArmB,GACArS,KAAA,SAAA07B,GACA,MAAAA,GAAAn2C,IAAA,SAAAy1C,GAAqD,MAAAngC,GAAAi/B,WAAAuB,oBAAAL,QAGrDnB,EAAAzyC,UAAAw0C,0CAAA,SAAAxJ,EAAAyJ,GACA,GAAAhhC,GAAAV,KAGA2hC,EAAAjoC,GAAAiiC,cAAA37B,KAAAq7B,OAAAqG,EAAAnrC,MACAqrC,EAAAtB,YAAAc,WAAAO,GACA3wC,IACA,OAAA4J,IAAAq9B,GACA4G,SAAsB3mB,MAAA0pB,GAAoB,SAAAZ,EAAA1vC,EAAAstC,GAC1C,GAAAiD,GAAAb,EAAA,GAAAc,EAAAd,EAAA,GAAAe,EAAAf,EAAA,GAQAzqC,EAAA0B,GAAA6pC,EACA,IAAAD,IAAAnhC,EAAA26B,SAAAqG,EAAAnrC,KAAAzE,QAAAyE,GAEA,WADAqoC,GAAAlB,MAGA,IAAAsE,GAAAthC,EAAA6/B,cAAAwB,EAKA,OAAAtnC,IAAAw9B,GACAxgC,IAAAuqC,GACAn8B,KAAA,SAAAg7B,GACA,OAAAA,GACA10C,EAAA,+CACA60C,EACA,oBACAgB,GAEAhxC,EAAAf,KAAAyQ,EAAAi/B,WAAAuB,oBAAAL,QAGAh7B,KAAA,WAA+B,MAAA7U,MAE/B0uC,EAAAzyC,UAAAg1C,oCAAA,SAAAhK,EAAAt5B,GACA,GAAA+B,GAAAV,IACAzT,IAAAoS,EAAApD,kBAAA,+CACA,IAAA2mC,GAAAvjC,EAAApI,KACA4rC,EAAAD,EAAAr3C,OAAA,EAYA82C,EAAAjoC,GAAAiiC,cAAA37B,KAAAq7B,OAAA6G,GACAN,EAAAtB,YAAAc,WAAAO,GAIAS,EAAA,GAAA5qB,IAAA9lB,EACA,OAAAkJ,IAAAq9B,GACA4G,SAAsB3mB,MAAA0pB,GAAoB,SAAAZ,EAAA1vC,EAAAstC,GAC1C,GAAAiD,GAAAb,EAAA,GAAAc,EAAAd,EAAA,GAAAe,EAAAf,EAAA,GACAzqC,EAAA0B,GAAA6pC,EACA,IAAAD,IAAAnhC,EAAA26B,SAAA6G,EAAAz9B,WAAAlO,GAEA,WADAqoC,GAAAlB,MAQAnnC,GAAA1L,SAAAs3C,IAGAC,IAAAnjC,IAAA8iC,MAEAl8B,KAAA,WACA,GAAA7U,MACA4/B,IAeA,OAbAwR,GAAAp0C,QAAA,SAAA+zC,GACA,GAAAC,GAAAthC,EAAA6/B,cAAAwB,EACAnR,GAAA3gC,KAAAwK,GAAAw9B,GACAxgC,IAAAuqC,GACAn8B,KAAA,SAAA4a,GACA,OAAAA,GACAt0B,EAAA,+DAEA61C,GAEAhxC,EAAAf,KAAAyQ,EAAAi/B,WAAAuB,oBAAAzgB,SAGAzmB,GAAA21B,QAAAiB,GAAA/qB,KAAA,WAA0E,MAAA7U,QAG1E0uC,EAAAzyC,UAAAo1C,sBAAA,SAAApK,EAAAqK,GAyBA,OAxBA5nC,GAAAD,GAAAw9B,GACAsK,EAAA3nC,GAAAq9B,GACArH,KAqBA4R,EAAAxiC,KACArV,EAAA,EAAA83C,EAAAH,EAA6C33C,EAAA83C,EAAA53C,OAAuBF,IAAA,CACpE,GAAA2sC,GAAAmL,EAAA93C,IAtBA,SAAA2sC,GACA,GAAApf,GAAAooB,YAAAoC,KAAAF,EAAAjC,cAAAjJ,EAAAI,UACAiL,EAAA,EACAC,EAAAloC,EAAAmkC,SAA6C3mB,SAAe,SAAA7qB,EAAAI,EAAAmxC,GAE5D,MADA+D,KACA/D,EAAA5/B,UAEA4xB,GAAA3gC,KAAA2yC,EAAA/8B,KAAA,WACAtZ,EAAA,IAAAo2C,EAAA,6DACArL,EAAAI,WAEA,QAAA/sC,GAAA,EAAAokB,EAAAuoB,EAAAgD,UAAkD3vC,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAClE,GAAA81B,GAAA1R,EAAApkB,GACAq2C,EAAAtnC,GAAArM,IAAAm1C,EAAAnH,OAAA5a,EAAApzB,IAAAkJ,KAAA+gC,EAAAI,QACA9G,GAAA3gC,KAAAsyC,EAAAvjC,OAAAgiC,IACA,OAAAwB,EAAAzQ,kBACAyQ,EAAAzQ,iBAAArB,uBAAAjQ,EAAApzB,OAOAiqC,GAEA,MAAAt9B,IAAA21B,QAAAiB,IAEA8O,EAAAzyC,UAAA41C,wBAAA,SAAAnoC,GACA,GAAAgG,GAAAV,IACA,OAAAA,MAAAkgC,WAAAxlC,GAAAmL,KAAA,SAAAs6B,GACA,IAAAA,EACA,MAAAnmC,IAAAC,SAIA,IAAA6oC,GAAAxC,YAAAc,WAAA1nC,GAAAgiC,cAAAh7B,EAAA26B,SACA0H,IACA,OAAAnoC,IAAAF,GACAmkC,SAA0B3mB,MAAA4qB,GAAoB,SAAAz1C,EAAAiE,EAAAstC,GAE9C,GADAvxC,EAAA,KACAqT,EAAA26B,OAEA,WADAuD,GAAAlB,MAIA,IAAAnnC,GAAA0B,GAAA5K,EAAA,GACA01C,GAAA9yC,KAAAsG,KAGAsP,KAAA,WACAtZ,EAAA,IAAAw2C,EAAAl4C,OAAA,8FACAk4C,EAAA33C,IAAA,SAAAkV,GAAiE,MAAAA,GAAAwE,0BAIjE46B,EAAAzyC,UAAAujC,oBAAA,SAAAwS,GACAhjC,KAAA+xB,iBAAAiR,GAEAtD,EAAAzyC,UAAAikC,YAAA,SAAAx2B,EAAArN,GACA,GAAAqT,GAAAV,KACAghC,EAAAtnC,GAAAiiC,cAAA37B,KAAAq7B,OAAAhuC,EAAAkJ,MACAurC,EAAAd,EAAA,GACA8B,EAAAxC,YAAAc,WAAAJ,GACA9P,GAAA,CACA,OAAAt2B,IAAAF,GACAmkC,SAAsB3mB,MAAA4qB,EAAAnE,UAAA,GAAoC,SAAAtxC,EAAAI,EAAAmxC,GAC1D,GAAAiD,GAAAx0C,EAAA,GAAA2L,EAAA3L,EAAA,EAAAA,GAAA,GACAw0C,IAAAnhC,EAAA26B,QAAAriC,IAAA8oC,IACA5Q,GAAA,GAEA0N,EAAAlB,SAEA73B,KAAA,WAA+B,MAAAqrB,MAM/BwO,EAAAzyC,UAAAszC,cAAA,SAAA7I,GACA,OAAA13B,KAAAq7B,OAAA3D,IAEAgI,KCpWAuD,GAAA,WACA,QAAAC,GAAAvD,GACA3/B,KAAA2/B,aAKA3/B,KAAAk8B,0BAAA9oB,GAAAM,IAIA1T,KAAAigC,SAAA,GAAApmC,IACA,EACA,EAAAuZ,GAAAM,IAAAE,eAEA5T,KAAA+xB,iBAAA,KA0JA,MAxJAmR,GAAAj2C,UAAAsL,MAAA,SAAA0/B,GACA,GAAAv3B,GAAAV,IACA,OAAA/E,IAAAg9B,GACAxgC,IAAAoC,GAAAxM,KACAwY,KAAA,SAAAo6B,GACA,UAAAA,EAAA,CACAv/B,EAAAu/B,UACA,IAAAkD,GAAAlD,EAAA/D,yBACAx7B,GAAAw7B,0BAAA9oB,GAAAI,cAAA,GAAApB,IAAA+wB,EAAA7wB,QAAA6wB,EAAA5wB,QAEA,MAAAvY,IAAAC,aAGAipC,EAAAj2C,UAAAm2C,mBAAA,WACA,MAAApjC,MAAAigC,SAAAjE,iBAEAkH,EAAAj2C,UAAAo2C,6BAAA,WACA,MAAArjC,MAAAk8B,2BAEAgH,EAAAj2C,UAAAq2C,6BAAA,SAAArL,EAAA/jB,GAGA,MAFAlU,MAAAk8B,0BAAAhoB,EACAlU,KAAAigC,SAAA/D,0BAAAhoB,EAAAN,cACA3Y,GAAAg9B,GAAAoG,IAAAxkC,GAAAxM,IAAA2S,KAAAigC,WAEAiD,EAAAj2C,UAAAs2C,aAAA,SAAAtL,EAAAtV,GACA,GAAAjiB,GAAAV,KACAgU,EAAA2O,EAAA3O,SACAwvB,EAAAzoC,GAAAk9B,GAAAoG,IAAAr+B,KAAA2/B,WAAA8D,WAAA9gB,GACA,OAAA3O,GAAAhU,KAAAigC,SAAAjE,iBACAh8B,KAAAigC,SAAAjE,gBAAAhoB,EACAwvB,EAAA39B,KAAA,WACA,MAAA5K,IAAAg9B,GAAAoG,IAAAxkC,GAAAxM,IAAAqT,EAAAu/B,aAIAuD,GAGAN,EAAAj2C,UAAAy2C,gBAAA,SAAAzL,EAAAtV,GACA,MAAA3iB,MAAA2jC,8BAAA1L,EAAAtV,EAAA3O,UAAAnO,KAAA,WACA9K,GAAAk9B,GAAAj5B,OAAA2jB,EAAA3O,aAGAkvB,EAAAj2C,UAAA22C,aAAA,SAAA3L,EAAAt5B,GACA,GAAA+B,GAAAV,KAIA+P,EAAApR,EAAAoR,cACAmI,EAAAooB,YAAAzwB,OAAAE,EAAAlC,OAAA5B,oBAAA8D,EAAAlC,OAAA9B,oBACA5d,EAAA,IACA,OAAA4M,IAAAk9B,GACA4G,SAAsB3mB,QAAA1T,MAAAjL,GAAAC,uBAAsD,SAAAnM,EAAAI,EAAAmxC,GAC5E,GAAAtf,GAAA5e,EAAAi/B,WAAAkE,aAAAp2C,EAGAkR,GAAA7M,QAAAwtB,EAAA3gB,SACAxQ,EAAAmxB,EACAsf,EAAAlB,UAGA73B,KAAA,WAA+B,MAAA1X,MAE/B+0C,EAAAj2C,UAAA62C,gBAAA,SAAAppC,EAAAid,EAAA3D,GAGA,GAAA4c,MACA73B,EAAAmC,GAAAR,EAKA,OAJAid,GAAA3pB,QAAA,SAAAX,GACA,GAAAkJ,GAAAe,GAAAjK,EAAAkJ,KACAq6B,GAAA3gC,KAAA8I,EAAAslC,IAAA,GAAAnlC,IAAA8a,EAAAzd,OAEAyD,GAAA21B,QAAAiB,IAEAsS,EAAAj2C,UAAA82C,mBAAA,SAAArpC,EAAAid,EAAA3D,GACA,GAAAtT,GAAAV,KAGA4wB,KACA73B,EAAAmC,GAAAR,EAQA,OAPAid,GAAA3pB,QAAA,SAAAX,GACA,GAAAkJ,GAAAe,GAAAjK,EAAAkJ,KACAq6B,GAAA3gC,KAAA8I,EAAAiG,QAAAgV,EAAAzd,KACA,OAAAmK,EAAAqxB,kBACArxB,EAAAqxB,iBAAArB,uBAAArjC,KAGA2M,GAAA21B,QAAAiB,IAEAsS,EAAAj2C,UAAA02C,8BAAA,SAAAjpC,EAAAsZ,GACA,GAAAjb,GAAAmC,GAAAR,GACAwd,EAAAooB,YAAAzwB,OAAAmE,MAAA,IACA,GACA,EACA,OAAAhU,MAAAgkC,uBAAAtpC,EAAAwd,GAAArS,KAAA,WACA,MAAA9M,GAAAiG,OAAAkZ,MAGAgrB,EAAAj2C,UAAA+2C,uBAAA,SAAAtpC,EAAAwd,GACA,GAAAxX,GAAAV,KACAjH,EAAAmC,GAAAR,EACA,eAAAsF,KAAA+xB,kBAAA/xB,KAAA+xB,iBAAA5B,QAGAp3B,EAAA8lC,SAAkC3mB,QAAAymB,UAAA,GAA+B,SAAAtxC,EAAAiE,EAAAstC,GACjE,GAAAroC,GAAA0B,GAAA5K,EAAA,IACAgO,EAAA,GAAAyK,IAAAvP,EAGAhK,GAAA,OAAAmU,EAAAqxB,iBAAA,oEACArxB,EAAAqxB,iBAAArB,uBAAAr1B,KAIArB,GAAAC,WAGAipC,EAAAj2C,UAAAg3C,2BAAA,SAAAvpC,EAAAsZ,GACA,GAAAkE,GAAAooB,YAAAzwB,OAAAmE,MAAA,IACA,GACA,GACAjb,EAAAmC,GAAAR,GACAvM,EAAA2H,IACA,OAAAiD,GACA8lC,SAAsB3mB,QAAAymB,UAAA,GAA+B,SAAAtxC,EAAAiE,EAAAstC,GACrD,GAAAroC,GAAA0B,GAAA5K,EAAA,IACAgO,EAAA,GAAAyK,IAAAvP,EACApI,KAAA8Q,IAAA5D,KAEAwK,KAAA,WAA+B,MAAA1X,MAE/B+0C,EAAAj2C,UAAAujC,oBAAA,SAAAwS,GACAhjC,KAAA+xB,iBAAAiR,GAEAE,EAAAj2C,UAAAikC,YAAA,SAAAx2B,EAAArN,GACAd,EAAA,OAAAmO,EAAA,qEACA,IAAAnE,GAAAe,GAAAjK,EAAAkJ,MACA2hB,EAAAooB,YAAAzwB,OAAAtZ,IAAA/D,EAAA+D,KACA,GACA,GACA+gB,EAAA,CACA,OAAApc,IAAAR,GACAmkC,SACAr6B,MAAAtL,GAAAE,qBACAulC,UAAA,EACAzmB,SACS,SAAA7qB,EAAAiE,EAAAstC,GACTtnB,IACAsnB,EAAAlB,SAEA73B,KAAA,WAA+B,MAAAyR,GAAA,KAE/B4rB,KC9KAgB,GAAA,WACA,QAAAC,GAAAxE,GACA3/B,KAAA2/B,aAqCA,MAnCAwE,GAAAl3C,UAAAm3C,SAAA,SAAAnM,EAAAoM,GACA,MAAAlpC,IAAA88B,GAAAoG,IAAAjjC,GAAAipC,EAAAh3C,KAAA2S,KAAA2/B,WAAA2E,mBAAAD,KAEAF,EAAAl3C,UAAAs3C,YAAA,SAAAtM,EAAAyJ,GACA,MAAAvmC,IAAA88B,GAAAj5B,OAAA5D,GAAAsmC,KAEAyC,EAAAl3C,UAAAu3C,SAAA,SAAAvM,EAAAyJ,GACA,GAAAhhC,GAAAV,IACA,OAAA7E,IAAA88B,GACAxgC,IAAA2D,GAAAsmC,IACA77B,KAAA,SAAA4+B,GACA,MAAAA,GACA/jC,EAAAi/B,WAAA+E,qBAAAD,GACA,QAGAN,EAAAl3C,UAAA03C,0BAAA,SAAA1M,EAAAt5B,GACA,GAAA+B,GAAAV,KACAhP,EAAA0E,KAGAiT,EAAAhK,EAAApI,KAAA+E,UACA4c,EAAAooB,YAAAc,WAAAz4B,EACA,OAAAxN,IAAA88B,GACA4G,SAAsB3mB,SAAe,SAAA7qB,EAAAo3C,EAAA7F,GACrC,GAAAzpB,GAAAzU,EAAAi/B,WAAA+E,qBAAAD,EACA9lC,GAAApI,KAAAkO,WAAA0Q,EAAA9nB,IAAAkJ,MAGA4e,YAAA7O,KAAA3H,EAAA0R,QAAA8E,KACAnkB,IAAAuW,OAAA4N,EAAA9nB,IAAA8nB,IAHAypB,EAAAlB,SAMA73B,KAAA,WAA+B,MAAA7U,MAE/BmzC,KCnCAS,GAAA,WACA,QAAAC,GAAAC,GACA9kC,KAAA8kC,mBAgFA,MA7EAD,GAAA53C,UAAAy3C,qBAAA,SAAAK,GACA,GAAAA,EAAA5lB,SACA,MAAAnf,MAAA8kC,iBAAA1lB,aAAA2lB,EAAA5lB,SAEA,IAAA4lB,EAAAjJ,WAAA,CACA,GAAAzuC,GAAAyY,GAAAK,aAAA4+B,EAAAjJ,WAAAvlC,MACAkpB,EAAAslB,EAAAjJ,WAAArc,SACAnM,EAAA,GAAAlB,IAAAqN,EAAAnN,QAAAmN,EAAAlN,MACA,WAAArL,IAAA7Z,EAAA+lB,GAAAI,cAAAF,IAGA,MAAAnnB,GAAA,gCAIA04C,EAAA53C,UAAAq3C,mBAAA,SAAAnvB,GACA,GAAAA,YAAA7O,IAAA,CACA,GAAA9H,GAAAwB,KAAA8kC,iBAAA5lB,WAAA/J,EACA,WAAAxb,IAAA,KAAA6E,GAGA,GAAAjI,GAAA4e,EAAA9nB,IAAAkJ,KAAA+E,UACAgY,EAAA6B,EAAA3O,QAAAoN,cACA6L,EAAA,GAAAyb,IAAA5nB,EAAAhB,QAAAgB,EAAAf,MACA,WAAA5Y,IAAA,GAAAkiC,IAAAtlC,EAAAkpB,GAAA,OAIAolB,EAAA53C,UAAA6zC,kBAAA,SAAAzF,EAAA/D,GACA,GAAA52B,GAAAV,KACAglC,EAAA1N,EAAAgD,UAAAlvC,IAAA,SAAA65C,GACA,MAAAvkC,GAAAokC,iBAAAtkB,WAAAykB,IAEA,WAAAhsC,IAAAoiC,EAAA/D,EAAAI,QAAAJ,EAAA/qB,eAAA4G,sBAAA6xB,IAGAH,EAAA53C,UAAAi0C,oBAAA,SAAAL,GACA,GAAAngC,GAAAV,KACAs6B,EAAAuG,EAAAvG,UAAAlvC,IAAA,SAAA65C,GACA,MAAAvkC,GAAAokC,iBAAA/jB,aAAAkkB,KAEA3xB,EAAAlB,GAAAK,sBAAAouB,EAAArF,iBACA,WAAApB,IAAAyG,EAAAnJ,QAAApkB,EAAAgnB,IAGAuK,EAAA53C,UAAA42C,aAAA,SAAAqB,GACA,GAEAvmC,GAFA8gB,EAAA,GAAArN,IAAA8yB,EAAAzlB,SAAAnN,QAAA4yB,EAAAzlB,SAAAlN,OACA/L,EAAA4M,GAAAI,cAAAiM,EAQA,OALA9gB,GADApD,GAAA2pC,EAAAvmC,OACAqB,KAAA8kC,iBAAArjB,oBAAAyjB,EAAAvmC,OAGAqB,KAAA8kC,iBAAA1iB,gBAAA8iB,EAAAvmC,OAEA,GAAAmV,IAAAnV,EAAAumC,EAAAlxB,SAAAvJ,GAAAqY,OAAAtc,EAAA0+B,EAAAhvC,cAGA2uC,EAAA53C,UAAAw2C,WAAA,SAAA9gB,GACAp2B,EAAAke,GAAAqY,SAAAH,EAAA1O,QAAA,6BACAxJ,GAAAqY,OACA,uBACAH,EAAA1O,QACA,IAEAkxB,GAFA7xB,EAAAqP,EAAAzO,gBAAAN,cACAwxB,EAAA,GAAAlK,IAAA5nB,EAAAhB,QAAAgB,EAAAf,MAGA4yB,GADAxiB,EAAAhkB,MAAApD,kBACAyE,KAAA8kC,iBAAAtjB,kBAAAmB,EAAAhkB,OAGAqB,KAAA8kC,iBAAAnjB,cAAAgB,EAAAhkB,OAEApS,EAAA,gBAAAo2B,GAAAzsB,YAAA,oDACA,IAAAA,GAAAysB,EAAAzsB,WAEA,WAAAqD,IAAAopB,EAAA3O,SAAA2O,EAAAhkB,MAAAoR,cAAAq1B,EAAAlvC,EAAA,EAAAivC,IAEAN,KuCvEAQ,GAAA,oKAmCAC,GAAA,WACA,QAAAC,GAAAC,EAAA7F,GACA3/B,KAAAm7B,QAAAn7B,KAAAylC,kBACAzlC,KAAA0lC,OAAAF,EAAAD,EAAAI,cACA3lC,KAAA2/B,WAAA,GAAAiF,IAAAjF,GACA3/B,KAAA4lC,mBAAAJ,EAwQA,MAtQAD,GAAAt4C,UAAAsL,MAAA,WACA,GAAAmI,GAAAV,IACA,OAAAulC,GAAA/I,eAIAjwC,GAAAyT,KAAA6lC,QAAA,wCACA7lC,KAAA6lC,SAAA,EACAzJ,GAAAE,aAAAt8B,KAAA0lC,O5CpEA,E4CoEAhtC,IACAi1B,KAAA,SAAAh1B,GACA+H,EAAAolC,SAAAntC,IAEAg1B,KAAA,WAA+B,MAAAjtB,GAAAqlC,yBAC/BpY,KAAA,WACAjtB,EAAAslC,8BACAtlC,EAAAulC,6BAZAjmC,KAAAkmC,iBAAA,GAAAp5C,IAAAC,GAAA4F,cA1CA,sIA2CAo0B,QAAA7sB,OAAA8F,KAAAkmC,oBAcAX,EAAAt4C,UAAAk5C,SAAA,WACA,GAAAzlC,GAAAV,IAKA,OAJAzT,GAAAyT,KAAA6lC,QAAA,gDACA7lC,KAAA6lC,SAAA,EACA7lC,KAAAomC,yBACApmC,KAAAqmC,0BACArmC,KAAAsmC,oBAAA3Y,KAAA,WACAjtB,EAAAolC,SAAAvgB,WAGAggB,EAAAt4C,UAAAs5C,iBAAA,SAAArM,GACA,MAAAuF,IAAAG,QAAA1F,EAAAl6B,KAAA2/B,aAEA4F,EAAAt4C,UAAAu5C,cAAA,WACA,UAAAvD,IAAAjjC,KAAA2/B,aAEA4F,EAAAt4C,UAAAw5C,uBAAA,WACA,UAAAvC,IAAAlkC,KAAA2/B,aAEA4F,EAAAt4C,UAAA6qC,eAAA,SAAA7vB,EAAAy+B,GACA,GAAAhmC,GAAAV,IACA,OAAAA,MAAAkmC,iBACAnf,QAAA7sB,OAAA8F,KAAAkmC,mBAEA37C,EA5FA,uBA4FA,wBAAA0d,GAGAjI,KAAA8lC,SAAAhO,eAAA,YAAAqE,GAAA,SAAAzhC,GAEA,MAAAgG,GAAAimC,iBAAAjsC,GAAAmL,KAAA,WAAiE,MAAA6gC,GAAAhsC,SAGjE6qC,EAAA/I,YAAA,WACA,MAAAJ,IAAAI,eAMA+I,EAAAqB,mBAAA,SAAA5c,GAQA,GAAA3mB,GAAA2mB,EAAAnnB,WAAAO,SAIA,OAHA4mB,GAAAnnB,WAAAgkC,oBACAxjC,GAAA,IAAA2mB,EAAAnnB,WAAAQ,UAEA,aAAA2mB,EAAAlnB,eAAA,IAAAO,EAAA,KAMAkiC,EAAAt4C,UAAA84C,qBAAA,WACA,GAAArlC,GAAAV,IAGA,OAAAA,MAAA8lC,SAAAhO,eAAA,aAAAl+B,GAAAb,OAAA,SAAA2B,GACA,GAAA3B,GAAA2B,EAAA3B,MAAAa,GAAAb,MACA,OAAAA,GAAAtB,IAAA,SAAAoO,KAAA,SAAAihC,GACA,GAAApmC,EAAAqmC,WAAAD,GAQA,MAFAv8C,GA1IA,uBA0IA,+CAAAu8C,GACApmC,EAAAwlC,iBAAA,GAAAp5C,IAAAC,GAAA+H,oBAAAuwC,IACArrC,GAAAE,OAAAwG,EAAAwlC,iBAPA,IAAAc,GAAA,GAAAptC,IAAA8G,EAAAy6B,QAAAlwC,KAAAunB,MAEA,OADAjoB,GAtIA,uBAsIA,wDAAAu8C,EAAA,aAAAE,GACAjuC,EAAAslC,IAAA,QAAA2I,QAWAzB,EAAAt4C,UAAAq5C,kBAAA,WACA,GAAA5lC,GAAAV,IAGA,OAAAA,MAAA8lC,SAAAhO,eAAA,aAAAl+B,GAAAb,OAAA,SAAA2B,GACA,GAAA3B,GAAA2B,EAAA3B,MAAAa,GAAAb,MACA,OAAAA,GAAAtB,IAAA,SAAAoO,KAAA,SAAAihC,GACA,cAAAA,KAAA3L,UAAAz6B,EAAAy6B,SACA5wC,EA1JA,uBA0JA,0BACAwO,EAAAiG,OAAA,UAGAhF,GAAAC,eAUAsrC,EAAAt4C,UAAA05C,iBAAA,SAAAjsC,GACA,GAAAgG,GAAAV,IAEA,OADAtF,GAAA3B,MAAAa,GAAAb,OACAtB,IAAA,SAAAoO,KAAA,SAAAihC,GACA,cAAAA,KAAA3L,UAAAz6B,EAAAy6B,SACAz6B,EAAAwlC,iBAAA,GAAAp5C,IAAAC,GAAA+H,oBAAAuwC,IACArrC,GAAAE,OAAAwG,EAAAwlC,mBAGAlsC,GAAAC,aAWAsrC,EAAAt4C,UAAA85C,WAAA,SAAAD,GACA,GAAAt0B,GAAAvnB,KAAAunB,MACAy0B,EAAAz0B,EA5LA,IA6LA00B,EAAA10B,CACA,gBAAAs0B,GAGAA,EAAA1L,iBAAA6L,IAGAH,EAAA1L,iBAAA8L,GACAv7C,EAAA,wDAAAm7C,GACA,GAEAA,EAAA3L,UAAAn7B,KAAAmnC,uBAWA5B,EAAAt4C,UAAA+4C,4BAAA,WACA,GAAAtlC,GAAAV,IAIAA,MAAAonC,wBAAAC,YAAA,WACA3mC,EAAAo3B,eAAA,mCAAAp9B,GAIA,MADAA,GAAA3B,MAAAa,GAAAb,OACAslC,IAAA,WAAAzkC,IAAA8G,EAAAy6B,QAAAlwC,KAAAunB,UAEA4c,MAAA,SAAAkY,GAGA37C,EAAA27C,GACA5mC,EAAA2lC,6BAjOA,MAqOAd,EAAAt4C,UAAAo5C,wBAAA,WACArmC,KAAAonC,0BACAG,cAAAvnC,KAAAonC,yBACApnC,KAAAonC,wBAAA,OAYA7B,EAAAt4C,UAAAg5C,uBAAA,WACA,GAAAvlC,GAAAV,IACAA,MAAAwnC,oBAAA,WAEA9mC,EAAA+mC,kBAAA/mC,EAAAy6B,SAGAz6B,EAAAylC,YAEA1J,OAAAiL,iBAAA,SAAA1nC,KAAAwnC,sBAEAjC,EAAAt4C,UAAAm5C,uBAAA,WACApmC,KAAAwnC,sBACA/K,OAAAkL,oBAAA,SAAA3nC,KAAAwnC,qBACAxnC,KAAAwnC,oBAAA,OAQAjC,EAAAt4C,UAAAk6C,kBAAA,WACA,IACA,GAAAS,GAAAnL,OAAAoL,aAAAC,QAAA9nC,KAAA+nC,8BAEA,OADAx9C,GAjRA,uBAiRA,qCAAAq9C,GACAA,EAEA,MAAA17C,GAGA,MADAP,GAAA,iCAAAO,GACA,OAOAq5C,EAAAt4C,UAAAw6C,kBAAA,SAAAO,GACA,IACA,OAAAA,EACAvL,OAAAoL,aAAAI,WAAAjoC,KAAA+nC,+BAGAtL,OAAAoL,aAAAK,QAAAloC,KAAA+nC,8BAAAC,GAGA,MAAA97C,GAEAP,EAAA,iCAAAO,KAGAq5C,EAAAt4C,UAAA86C,4BAAA,WACA,MAAA/nC,MAAA4lC,mBAvSA,kBAySAL,EAAAt4C,UAAAw4C,gBAAA,WAEA,MAAA7kC,IAAAE,SAMAykC,EAAAI,cAAA,OACAJ,KCxTA4C,GAAA,WACA,QAAAC,GAAAC,EAAAC,GACAtoC,KAAAqoC,sBACAroC,KAAAsoC,gBA2JA,MAnJAF,GAAAn7C,UAAAs7C,YAAA,SAAAtQ,EAAA5qC,GACA,GAAAqT,GAAAV,IACA,OAAAA,MAAAqoC,oBACA7D,SAAAvM,EAAA5qC,GACAwY,KAAA,SAAAk/B,GACA,MAAArkC,GAAA8nC,qBAAAvQ,EAAA5qC,EAAA03C,MASAqD,EAAAn7C,UAAAw7C,aAAA,SAAAxQ,EAAAtgB,GACA,GAAAjX,GAAAV,KACA4wB,KACA5/B,EAAAwE,IAUA,OATAmiB,GAAA3pB,QAAA,SAAAX,GACAujC,EAAA3gC,KAAAyQ,EAAA6nC,YAAAtQ,EAAA5qC,GAAAwY,KAAA,SAAAsP,GAEAA,IACAA,EAAA,GAAAjO,IAAA7Z,EAAA+lB,GAAAK,kBAEAziB,IAAAuW,OAAAla,EAAA8nB,QAGAnb,GAAA21B,QAAAiB,GAAA/qB,KAAA,WAAsE,MAAA7U,MAGtEo3C,EAAAn7C,UAAA03C,0BAAA,SAAA1M,EAAAt5B,GACA,MAAAmH,IAAAE,cAAArH,EAAApI,MACAyJ,KAAA0oC,kCAAAzQ,EAAAt5B,EAAApI,MAGAyJ,KAAA2oC,oCAAA1Q,EAAAt5B,IAGAypC,EAAAn7C,UAAAy7C,kCAAA,SAAAzQ,EAAAtnB,GAEA,MAAA3Q,MAAAuoC,YAAAtQ,EAAA,GAAAnyB,IAAA6K,IAAA9K,KAAA,SAAAsP,GACA,GAAAhnB,GAAAuH,IAIA,OAHAyf,aAAA7O,MACAnY,IAAAoZ,OAAA4N,EAAA9nB,IAAA8nB,IAEAhnB,KAGAi6C,EAAAn7C,UAAA07C,oCAAA,SAAA1Q,EAAAt5B,GACA,GAKA3N,GALA0P,EAAAV,IAMA,OAAAA,MAAAqoC,oBACA1D,0BAAA1M,EAAAt5B,GACAkH,KAAA,SAAA+iC,GACA,MAAAloC,GAAAmoC,sBAAA5Q,EAAA2Q,KAEA/iC,KAAA,SAAAijC,GAIA,MAHA93C,GAAA83C,EAGApoC,EAAA4nC,cAAArG,oCAAAhK,EAAAt5B,KAEAkH,KAAA,SAAAkjC,GAEA,OADAC,GAAAlzC,KACAnL,EAAA,EAAAs+C,EAAAF,EAAiFp+C,EAAAs+C,EAAAp+C,OAAuCF,IAExH,OADA2sC,GAAA2R,EAAAt+C,GACAokB,EAAA,EAAAiB,EAAAsnB,EAAAgD,UAAsDvrB,EAAAiB,EAAAnlB,OAAgBkkB,IAAA,CACtE,GAAA0R,GAAAzQ,EAAAjB,EAGA/d,GAAAyG,IAAAgpB,EAAApzB,OACA27C,IAAA/pC,IAAAwhB,EAAApzB,MAKA,GAAAujC,KAQA,OAPAoY,GAAAh7C,QAAA,SAAAX,GACAujC,EAAA3gC,KAAAyQ,EAAA6nC,YAAAtQ,EAAA5qC,GAAAwY,KAAA,SAAArH,GACAA,YAAA8H,MACAtV,IAAAuW,OAAA/I,EAAAnR,IAAAmR,SAIAxE,GAAA21B,QAAAiB,KAEA/qB,KAAA,WAQA,MALA7U,GAAAhD,QAAA,SAAAX,EAAAmR,GACAG,EAAA0R,QAAA7R,KACAxN,IAAA0W,OAAAra,MAGA2D,KAYAo3C,EAAAn7C,UAAAu7C,qBAAA,SAAAvQ,EAAAyJ,EAAAviB,GACA,MAAAnf,MAAAsoC,cACA7G,0CAAAxJ,EAAAyJ,GACA77B,KAAA,SAAAy8B,GACA,OAAA33C,GAAA,EAAA83C,EAAAH,EAAiD33C,EAAA83C,EAAA53C,OAAuBF,IAAA,CACxE,GAAA2sC,GAAAmL,EAAA93C,EACAw0B,GAAAmY,EAAAvhB,iBAAA2rB,EAAAviB,GAEA,MAAAA,MAWAipB,EAAAn7C,UAAA47C,sBAAA,SAAA5Q,EAAAx8B,GACA,GAAAiF,GAAAV,KACA4wB,IAcA,OAbAn1B,GAAAzN,QAAA,SAAAX,EAAAmR,GACAoyB,EAAA3gC,KAAAyQ,EAAA8nC,qBAAAvQ,EAAA5qC,EAAAmR,GAAAqH,KAAA,SAAAqjC,GACAA,YAAA5iC,IACA7K,IAAA8L,OAAA2hC,EAAA77C,IAAA67C,GAEAA,YAAAhiC,IACAzL,IAAAiM,OAAAwhC,EAAA77C,KAGAlB,EAAA,0BAAA+8C,QAIAlvC,GAAA21B,QAAAiB,GAAA/qB,KAAA,WAAsE,MAAApK,MAEtE2sC,KC3JAe,GAAA,WACA,QAAAC,GAAAf,GACAroC,KAAAqoC,sBACAroC,KAAAgrB,QAAAx1B,KAiDA,MA9CA4zC,GAAAn8C,UAAAm3C,SAAA,SAAAC,GACA,GAAArZ,GAAAhrB,KAAAqpC,eACArpC,MAAAgrB,UAAAzjB,OAAA88B,EAAAh3C,IAAAg3C,IAcA+E,EAAAn8C,UAAAu3C,SAAA,SAAAvM,EAAAyJ,GACA,GAAA1W,GAAAhrB,KAAAqpC,gBACAC,EAAAte,EAAAvzB,IAAAiqC,EACA,OAAA4H,GACAtvC,GAAAC,QAAAqvC,GAGAtpC,KAAAqoC,oBAAA7D,SAAAvM,EAAAyJ,IAOA0H,EAAAn8C,UAAAzB,MAAA,SAAAysC,GACA,GAAAv3B,GAAAV,KACAgrB,EAAAhrB,KAAAqpC,gBACAzY,IAMA,OALA5F,GAAAh9B,QAAA,SAAAX,EAAA8nB,GACAyb,EAAA3gC,KAAAyQ,EAAA2nC,oBAAAjE,SAAAnM,EAAA9iB,MAGAnV,KAAAgrB,QAAA,KACAhxB,GAAA21B,QAAAiB,IAGAwY,EAAAn8C,UAAAo8C,cAAA,WAEA,MADA98C,GAAA,OAAAyT,KAAAgrB,QAAA,sCACAhrB,KAAAgrB,SAEAoe,KCDAG,GAAA,WACA,QAAA/V,GAEAgW,EAAAC,EAMA1X,GACA/xB,KAAAwpC,cACAxpC,KAAA+xB,mBAIA/xB,KAAA0pC,oBAAA,GAAAjY,IAEAzxB,KAAAqa,aAEAra,KAAA02B,kBAAAzD,GAAAM,gBAWAvzB,KAAA2pC,oBACA3pC,KAAAsoC,cAAAkB,EAAAjD,iBAAAkD,GACAzpC,KAAA4pC,gBAAAJ,EAAA/C,yBACAzmC,KAAA6pC,WAAAL,EAAAhD,gBACAxmC,KAAA8pC,eAAA,GAAA3B,IAAAnoC,KAAA4pC,gBAAA5pC,KAAAsoC,eACAtoC,KAAA+xB,iBAAAzB,iBAAAtwB,KAAA0pC,qBACA1pC,KAAA+xB,iBAAAzB,iBAAAtwB,KAAA6pC,YACA7pC,KAAA+xB,iBAAAzB,iBAAAtwB,KAAAsoC,eAgjBA,MA7iBA9U,GAAAvmC,UAAAsL,MAAA,WACA,GAAAmI,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,4BAAAp9B,GACA,MAAAgG,GAAAqpC,mBAAArvC,GAAAmL,KAAA,WAAmE,MAAAnF,GAAAspC,gBAAAtvC,QASnE84B,EAAAvmC,UAAAgtC,iBAAA,SAAAC,GACA,GAAAx5B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,8BAAAp9B,GAGA,GAAAuvC,EACA,OAAAvpC,GAAA4nC,cACAhH,sBAAA5mC,GACAmL,KAAA,SAAAqkC,GAKA,MAJAD,GAAAC,EACAxpC,EAAAqxB,iBAAAtB,oBAAA/vB,EAAA4nC,eACA5nC,EAAA4nC,cAAA5nC,EAAA8oC,YAAAjD,iBAAArM,GACAx5B,EAAAqxB,iBAAAzB,iBAAA5vB,EAAA4nC,eACA5nC,EAAAqpC,mBAAArvC,KAEAmL,KAAA,WAIA,MADAnF,GAAAopC,eAAA,GAAA3B,IAAAznC,EAAAkpC,gBAAAlpC,EAAA4nC,eACA5nC,EAAA4nC,cAAAhH,sBAAA5mC,KAEAmL,KAAA,SAAAskC,GAGA,OADAC,GAAAt0C,KACAnL,EAAA,EAAAokB,GAAAk7B,EAAAE,GAA+Dx/C,EAAAokB,EAAAlkB,OAAgBF,IAE/E,OADA23C,GAAAvzB,EAAApkB,GACAqlB,EAAA,EAAAyyB,EAAAH,EAAyDtyB,EAAAyyB,EAAA53C,OAAuBmlB,IAEhF,OADAsnB,GAAAmL,EAAAzyB,GACAC,EAAA,EAAAo6B,EAAA/S,EAAAgD,UAA8DrqB,EAAAo6B,EAAAx/C,OAAgBolB,IAAA,CAC9E,GAAAwQ,GAAA4pB,EAAAp6B,EACAm6B,KAAAnrC,IAAAwhB,EAAApzB,KAMA,MAAAqT,GAAAopC,eAAArB,aAAA/tC,EAAA0vC,QAIA5W,EAAAvmC,UAAA+8C,gBAAA,SAAAtvC,GACA,GAAAgG,GAAAV,IACA,OAAAA,MAAA6pC,WAAAtxC,MAAAmC,GAAAmL,KAAA,WACA,GAAAmO,GAAAtT,EAAAmpC,WAAAzG,oBACA1iC,GAAAg2B,kBAAAzD,GAAAM,cAAAvf,MAGAwf,EAAAvmC,UAAA88C,mBAAA,SAAArvC,GACA,GAAAgG,GAAAV,IACA,OAAAA,MAAAsoC,cACA/vC,MAAAmC,GACAmL,KAAA,WAOA,MADAnF,GAAAipC,oBACAjpC,EAAA4nC,cAAA7H,8BAAA/lC,KAEAmL,KAAA,SAAAykC,GAIA,MAAAA,KAAAnQ,GACAz5B,EAAA4nC,cAAA9G,oCAAA9mC,EAAA4vC,GAGAtwC,GAAAC,cAGA4L,KAAA,SAAA0kC,GACA,MAAAA,GAAA1/C,OAAA,EACA6V,EAAA4nC,cAAAjG,sBAAA3nC,EAAA6vC,GAGAvwC,GAAAC,aAKAu5B,EAAAvmC,UAAAuqC,WAAA,SAAA8C,GACA,GAAA55B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,mCAAAp9B,GACA,GAAA48B,GACA/qB,EAAA6F,GAAAI,KACA,OAAA9R,GAAA4nC,cACA1H,iBAAAlmC,EAAA6R,EAAA+tB,GACAz0B,KAAA,SAAA2kC,GACAlT,EAAAkT,CAIA,IAAA7yB,GAAA2f,EAAA3f,MACA,OAAAjX,GAAAopC,eAAArB,aAAA/tC,EAAAid,KAEA9R,KAAA,SAAA4kC,GACA,OAAwB/S,QAAAJ,EAAAI,QAAA1M,QAAAyf,QAkBxBjX,EAAAvmC,UAAA+rC,iBAAA,SAAAuB,GACA,GAAA75B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,6BAAAp9B,GACA,GAAAgwC,EACA,OAAAhqC,GAAA4nC,cACAtP,iBAAAt+B,EAAA6/B,EAAAjD,MAAAiD,EAAAQ,aACAl1B,KAAA,WACA,GAAAnF,EAAAiqC,sBAAApQ,EAAAO,eAGA,MAFAp6B,GAAAipC,iBAAA15C,KAAAsqC,GACAmQ,EAAA50C,KACAkE,GAAAC,SAGA,IAAA2wC,GAAA,GAAAzB,IAAAzoC,EAAAkpC,gBACA,OAAAlpC,GAAAmqC,oBAAAnwC,GAAA6/B,GAAAqQ,GAAA/kC,KAAA,SAAAilC,GAEA,MADAJ,GAAAI,EACAF,EAAAp/C,MAAAkP,OAIAmL,KAAA,WACA,MAAAnF,GAAA4nC,cAAAzF,wBAAAnoC,KAEAmL,KAAA,WACA,MAAAnF,GAAAopC,eAAArB,aAAA/tC,EAAAgwC,QAUAlX,EAAAvmC,UAAAisC,YAAA,SAAAxB,GACA,GAAAh3B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,wBAAAp9B,GACA,GAAAqwC,GACAC,CACA,OAAAtqC,GAAA4nC,cACArH,oBAAAvmC,EAAAg9B,GACA7xB,KAAA,SAAAolC,GAGA,MAFA1+C,GAAA,MAAA0+C,EAAA,wCACAF,EAAAE,EACAvqC,EAAA4nC,cACA7H,8BAAA/lC,GACAmL,KAAA,SAAAqlC,GAEA,MADA3+C,GAAAmrC,EAAAwT,EAAA,2CACAH,MAGAllC,KAAA,WACA,MAAAnF,GAAAyqC,oBAAAzwC,EAAAqwC,KAEAllC,KAAA,SAAAilC,GAEA,MADAE,GAAAF,EACApqC,EAAA4nC,cAAAzF,wBAAAnoC,KAEAmL,KAAA,WACA,MAAAnF,GAAAopC,eAAArB,aAAA/tC,EAAAswC,QAKAxX,EAAAvmC,UAAAyzC,mBAAA,WACA,GAAAhgC,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,iCAAAp9B,GACA,MAAAgG,GAAA4nC,cAAA5H,mBAAAhmC,MAQA84B,EAAAvmC,UAAA0zC,mBAAA,SAAA5F,GACA,GAAAr6B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,iCAAAp9B,GACA,MAAAgG,GAAA4nC,cAAA3H,mBAAAjmC,EAAAqgC,MAOAvH,EAAAvmC,UAAAo2C,6BAAA,WACA,MAAArjC,MAAA6pC,WAAAxG,gCAUA7P,EAAAvmC,UAAAorC,iBAAA,SAAAC,GACA,GAAA53B,GAAAV,KACAorC,EAAA,GAAAjC,IAAAnpC,KAAA4pC,gBACA,OAAA5pC,MAAAwpC,YAAA1R,eAAA,8BAAAp9B,GACA,GAAAk2B,KACAhjC,GAAA0qC,EAAAzf,cAAA,SAAA7E,EAAA/d,GAEA,GAAA0sB,GAAAjiB,EAAA2Z,UAAArG,EACA,IAAA2O,EAAA,CAEA,GAAA1J,GAAAhjB,EAAAgjB,OACA,IAAAA,EAEA,GAAAA,YAAAC,IACA0X,EAAA3gC,KAAAyQ,EAAAmpC,WACAlG,8BAAAjpC,EAAAsZ,GACAnO,KAAA,WACA,MAAAnF,GAAAmpC,WAAA/F,gBAAAppC,EAAAue,EAAAxd,UAAAuY,UAGA,MAAAiF,YAAAO,KAQA,MAAArtB,GAAA,yBAAAuE,KAAAC,UAAAsoB,GAPA2X,GAAA3gC,KAAAyQ,EAAAmpC,WACA9F,mBAAArpC,EAAAue,EAAAS,iBAAA1F,GACAnO,KAAA,WACA,MAAAnF,GAAAmpC,WAAA/F,gBAAAppC,EAAAue,EAAAQ,eAAAzF,MASA,GAAA9d,GAAAD,EAAAC,WACAA,GAAArL,OAAA,IACA83B,IAAAxO,QACAje,cACAge,gBAAAje,EAAAie,kBAEAxT,EAAA2Z,UAAArG,GAAA2O,EACAiO,EAAA3gC,KAAAyQ,EAAAmpC,WAAAtG,aAAA7oC,EAAAioB,OAGA,IAAA0oB,GAAAv1C,IACAwiC,GAAAxf,gBAAA9qB,QAAA,SAAAX,EAAAmR,GACA6sC,IAAApsC,IAAA5R,GACAujC,EAAA3gC,KAAAm7C,EAAA5G,SAAA9pC,EAAArN,GAAAwY,KAAA,SAAAylC,GAKA,MAAAA,GACA9sC,EAAAgI,QAAA1U,QAAAshB,GAAAM,MACAlV,EAAAgI,QAAAlD,UAAAgoC,EAAA9kC,UAAA,EACA4kC,EAAAhH,SAAA5lC,GAGAjU,EApXA,aAoXA,sCAAA8C,EAAA,qBAAAi+C,EAAA9kC,QAAA,kBAAAhI,EAAAgI,SAIA9F,EAAAqxB,iBAAArB,uBAAArjC,OAOA,IAAAk+C,GAAA7qC,EAAAmpC,WAAAxG,+BACAmI,EAAAlT,EAAApkB,eACAs3B,GAAA15C,QAAAshB,GAAAM,OACAnnB,EAAAi/C,EAAAloC,UAAAioC,IAAA,kDACAC,EACA,MACAD,GACA3a,EAAA3gC,KAAAyQ,EAAAmpC,WAAAvG,6BAAA5oC,EAAA8wC,IAEA,IAAAC,EACA,OAAAzxC,IAAA21B,QAAAiB,GACA/qB,KAAA,WAAmC,MAAAnF,GAAAgrC,wBAAAhxC,EAAA0wC,KACnCvlC,KAAA,SAAA8lC,GAEA,MADAF,GAAAE,EACAP,EAAA5/C,MAAAkP,KAEAmL,KAAA,WACA,MAAAnF,GAAAopC,eAAArB,aAAA/tC,EAAA2wC,EAAA/yB,UAAAmzB,SAOAjY,EAAAvmC,UAAA8sC,uBAAA,SAAA6R,GACA,GAAAlrC,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,qCAAAp9B,GAYA,OAXAk2B,MAWAjmC,EAAA,EAAAkhD,EAAAD,EAAyDjhD,EAAAkhD,EAAAhhD,OAA2BF,IAAA,CACpF,GAAAirC,GAAAiW,EAAAlhD,IAXA,SAAAirC,GACAhF,EAAA3gC,KAAAyQ,EAAAmpC,WACAjG,aAAAlpC,EAAAk7B,EAAAj3B,OACAkH,KAAA,SAAA8c,GACAp2B,EAAA,OAAAo2B,EAAA,gDACA,IAAA3O,GAAA2O,EAAA3O,QACAtT,GAAAgpC,oBAAAxX,cAAA0D,EAAAvE,UAAArd,GACAtT,EAAAgpC,oBAAArX,iBAAAuD,EAAAtE,YAAAtd,OAKA4hB,GAEA,MAAA57B,IAAA21B,QAAAiB,MASA4C,EAAAvmC,UAAA6+C,kBAAA,SAAAC,GACA,GAAArrC,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,mCAAAp9B,GAIA,WAHA/M,KAAAo+C,IACAA,EAAA5R,IAEAz5B,EAAA4nC,cAAAnH,iCAAAzmC,EAAAqxC,MAOAvY,EAAAvmC,UAAA++C,aAAA,SAAA3+C,GACA,GAAAqT,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,yBAAAp9B,GACA,MAAAgG,GAAAopC,eAAAvB,YAAA7tC,EAAArN,MAQAmmC,EAAAvmC,UAAA2pC,cAAA,SAAAj4B,GACA,GAAA+B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,0BAAAp9B,GACA,GAAAioB,EACA,OAAAjiB,GAAAmpC,WACAjG,aAAAlpC,EAAAiE,GACAkH,KAAA,SAAAomC,GACA,GAAAA,EAKA,MADAtpB,GAAAspB,EACAjyC,GAAAC,SAGA,IAAA+Z,GAAAtT,EAAAg2B,kBAAA7wB,MAEA,OADA8c,GAAA,GAAA7O,IAAAnV,EAAAqV,EAAAvJ,GAAAqY,QACApiB,EAAAmpC,WAAAtG,aAAA7oC,EAAAioB,KAGA9c,KAAA,WAGA,MAFAtZ,IAAAmU,EAAA2Z,UAAAsI,EAAA3O,UAAA,iDAAArV,GACA+B,EAAA2Z,UAAAsI,EAAA3O,UAAA2O,EACAA,OAKA6Q,EAAAvmC,UAAAkqC,aAAA,SAAAx4B,GACA,GAAA+B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,yBAAAp9B,GACA,MAAAgG,GAAAmpC,WACAjG,aAAAlpC,EAAAiE,GACAkH,KAAA,SAAA8c,GAIA,MAHAp2B,GAAA,MAAAo2B,EAAA,uCAAAhkB,GACA+B,EAAAgpC,oBAAApX,sBAAA3P,EAAA3O,gBACAtT,GAAA2Z,UAAAsI,EAAA3O,UACAtT,EAAAqxB,iBAAA5B,QACAzvB,EAAAmpC,WAAAnG,gBAAAhpC,EAAAioB,GAGA3oB,GAAAC,YAGA4L,KAAA,WAGA,GAAA5X,EAAAyS,EAAA2Z,WAAA,CACA,GAAA6xB,GAAA,GAAA/C,IAAAzoC,EAAAkpC,gBACA,OAAAlpC,GAAAgrC,wBAAAhxC,EAAAwxC,GAAArmC,KAAA,WACAqmC,EAAA1gD,MAAAkP,KAIA,MAAAV,IAAAC,eASAu5B,EAAAvmC,UAAA4pC,aAAA,SAAAl4B,GACA,GAAA+B,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,yBAAAp9B,GACA,MAAAgG,GAAAopC,eAAAnF,0BAAAjqC,EAAAiE,MAOA60B,EAAAvmC,UAAA6pC,mBAAA,SAAA9iB,GACA,GAAAtT,GAAAV,IACA,OAAAA,MAAAwpC,YAAA1R,eAAA,gCAAAp9B,GACA,MAAAgG,GAAAmpC,WAAA5F,2BAAAvpC,EAAAsZ,MASAwf,EAAAvmC,UAAA0jC,eAAA,WACA,GAAAjwB,GAAAV,IAGA,OAAAA,MAAAwpC,YAAA1R,eAAA,8BAAAp9B,GACA,MAAAgG,GAAAqxB,iBAAApB,eAAAj2B,GAAAmL,KAAA,SAAAsmC,GACA,GAAAvb,KAIA,OAHAub,GAAAn+C,QAAA,SAAAX,GACAujC,EAAA3gC,KAAAyQ,EAAAkpC,gBAAArF,YAAA7pC,EAAArN,MAEA2M,GAAA21B,QAAAiB,QAIA4C,EAAAvmC,UAAAy+C,wBAAA,SAAAhxC,EAAA0wC,GAEA,OADAgB,MACAzhD,EAAA,EAAAokB,EAAA/O,KAAA2pC,iBAAoDh/C,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACpE,GAAA4vC,GAAAxrB,EAAApkB,EACA,KAAAqV,KAAAqsC,oBAAA9R,EAAAO,eACA,KAEAsR,GAAAn8C,KAAAsqC,GAEA,WAAA6R,EAAAvhD,OACAmP,GAAAC,QAAAnE,OAGAkK,KAAA2pC,iBAAArd,OAAA,EAAA8f,EAAAvhD,QACAmV,KAAA6qC,oBAAAnwC,EAAA0xC,EAAAhB,KAGA5X,EAAAvmC,UAAAo/C,oBAAA,SAAA7lC,GAGA,GAAA+kC,GAAAvrC,KAAA6pC,WAAAxG,8BACA,OAAA78B,GAAAlD,UAAAioC,IAAA,GACAt9C,EAAA+R,KAAAqa,YAEAmZ,EAAAvmC,UAAA09C,sBAAA,SAAAnkC,GAEA,OAAAxG,KAAAqsC,oBAAA7lC,IAAAxG,KAAA2pC,iBAAA9+C,OAAA,GAEA2oC,EAAAvmC,UAAA49C,oBAAA,SAAAnwC,EAAA4xC,EAAAlB,GAQA,OAPA1qC,GAAAV,KACAusC,EAAAvyC,GAAAC,UAMAtP,EAAA,EAAA6hD,EAAAF,EAAuD3hD,EAAA6hD,EAAA3hD,OAA4BF,IAAA,CACnF,GAAA4vC,GAAAiS,EAAA7hD,IANA,SAAA4vC,GACAgS,IAAA1mC,KAAA,WACA,MAAAnF,GAAA+rC,4BAAA/xC,EAAA6/B,EAAA6Q,MAKA7Q,GAEA,MAAAgS,GAAA1mC,KAAA,WACA,MAAAnF,GAAA2hC,sBAAA3nC,EAAA4xC,EAAAlhD,IAAA,SAAA+C,GAAwF,MAAAA,GAAAmpC,YAGxF9D,EAAAvmC,UAAAk+C,oBAAA,SAAAzwC,EAAA48B,GACA,MAAAt3B,MAAAqiC,sBAAA3nC,GAAA48B,KAGA9D,EAAAvmC,UAAAo1C,sBAAA,SAAA3nC,EAAA4nC,GAEA,OADAoK,GAAA52C,KACAnL,EAAA,EAAAgiD,EAAArK,EAA6C33C,EAAAgiD,EAAA9hD,OAAuBF,IAEpE,OADA2sC,GAAAqV,EAAAhiD,GACAokB,EAAA,EAAAiB,EAAAsnB,EAAAgD,UAAkDvrB,EAAAiB,EAAAnlB,OAAgBkkB,IAAA,CAClE,GAAA0R,GAAAzQ,EAAAjB,GACA1hB,EAAAozB,EAAApzB,GACAq/C,KAAAztC,IAAA5R,GAGA,MAAA2S,MAAAsoC,cACAjG,sBAAA3nC,EAAA4nC,GACAz8B,KAAA,WAA+B,MAAA6mC,MAE/BlZ,EAAAvmC,UAAAw/C,4BAAA,SAAA/xC,EAAA6/B,EAAA6Q,GACA,GAAA9T,GAAAiD,EAAAjD,MACAsV,EAAAtV,EAAA3f,OACA40B,EAAAvyC,GAAAC,SAyBA,OAxBA2yC,GAAA5+C,QAAA,SAAAqN,GACAkxC,IACA1mC,KAAA,WACA,MAAAulC,GAAA5G,SAAA9pC,EAAAW,KAEAwK,KAAA,SAAAk/B,GACA,GAAAvmC,GAAAumC,EACA8H,EAAAtS,EAAAS,YAAAvjC,IAAA4D,EACA9O,GAAA,OAAAsgD,EAAA,wDACAruC,KAAAgI,QAAAlD,UAAAupC,GAAA,KACAruC,EAAA84B,EAAAzhB,sBAAAxa,EAAAmD,EAAA+7B,GACA/7B,EAQA4sC,EAAAhH,SAAA5lC,GAPAjS,GAAAw4C,EAAA,kBACAzN,EACA,wBACAyN,EACA,0BAQAwH,GAEA/Y,KC/oBAsZ,GAAA,WACA,QAAAC,KAKA/sC,KAAAsoC,iBAEAtoC,KAAAggC,YAAA,EAEAhgC,KAAAgtC,2BAAA7S,GAKAn6B,KAAAu7B,gBAAA9uC,IAEAuT,KAAA+xB,iBAAA,KAEA/xB,KAAAitC,qBAAA,GAAAz1B,IAAAoa,GAAAhrB,cAySA,MAvSAmmC,GAAA9/C,UAAAsL,MAAA,SAAA0/B,GAWA,MALA,KAAAj4B,KAAAsoC,cAAAz9C,SACAmV,KAAAggC,YAAA,EACAhgC,KAAAgtC,2BAAA7S,IAEA5tC,EAAAyT,KAAAgtC,2BAAAhtC,KAAAggC,YAAA,gEACAhmC,GAAAC,WAEA8yC,EAAA9/C,UAAAizC,WAAA,SAAAjI,GACA,MAAAj+B,IAAAC,QAAA,IAAA+F,KAAAsoC,cAAAz9C,SAEAkiD,EAAA9/C,UAAAuzC,eAAA,SAAAvI,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAggC,cAEA+M,EAAA9/C,UAAAwzC,8BAAA,SAAAxI,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAgtC,6BAEAD,EAAA9/C,UAAA+rC,iBAAA,SAAAf,EAAAX,EAAAyD,GACA,GAAArD,GAAAJ,EAAAI,OACAnrC,GAAAmrC,EAAA13B,KAAAgtC,2BAAA,kDACA,IAAAE,GAAAltC,KAAAmtC,uBAAAzV,EAAA,gBAEAvtB,EAAAnK,KAAAsoC,cAAA4E,EAQA,OAPA3gD,GAAAmrC,IAAAvtB,EAAAutB,QAAA,0CACAA,EACA,eACAvtB,EAAAutB,SACAnrC,GAAA4d,EAAAuwB,cAAA,gDACA16B,KAAAgtC,2BAAAtV,EACA13B,KAAAu7B,gBAAAR,EACA/gC,GAAAC,WAEA8yC,EAAA9/C,UAAAyzC,mBAAA,SAAAzI,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAu7B,kBAEAwR,EAAA9/C,UAAA0zC,mBAAA,SAAA1I,EAAA8C,GAEA,MADA/6B,MAAAu7B,gBAAAR,EACA/gC,GAAAC,WAEA8yC,EAAA9/C,UAAA2zC,iBAAA,SAAA3I,EAAA1rB,EAAA+tB,GACA/tC,EAAA,IAAA+tC,EAAAzvC,OAAA,uCACA,IAAA6sC,GAAA13B,KAAAggC,WACAhgC,MAAAggC,cACAhgC,KAAAsoC,cAAAz9C,OAAA,GAEA0B,EADAyT,KAAAsoC,cAAAtoC,KAAAsoC,cAAAz9C,OAAA,GACA6sC,UAAA,2DAEA,IAAAJ,GAAA,GAAA8C,IAAA1C,EAAAnrB,EAAA+tB,EACAt6B,MAAAsoC,cAAAr4C,KAAAqnC,EAEA,QAAA3sC,GAAA,EAAAo2C,EAAAzG,EAAiD3vC,EAAAo2C,EAAAl2C,OAAyBF,IAAA,CAC1E,GAAA81B,GAAAsgB,EAAAp2C,EACAqV,MAAAitC,qBAAAjtC,KAAAitC,qBAAAhuC,IAAA,GAAA2yB,IAAAnR,EAAApzB,IAAAqqC,IAEA,MAAA19B,IAAAC,QAAAq9B,IAEAyV,EAAA9/C,UAAAg0C,oBAAA,SAAAhJ,EAAAP,GACA,MAAA19B,IAAAC,QAAA+F,KAAAotC,kBAAA1V,KAEAqV,EAAA9/C,UAAAk0C,iCAAA,SAAAlJ,EAAAP,GACA,GAAAtzB,GAAApE,KAAAsoC,cAAAz9C,MAIA6sC,GAAAz2B,KAAAosC,IAAA3V,EAAA,EAAA13B,KAAAgtC,2BAMA,KAHA,GAAAM,GAAAttC,KAAAutC,eAAA7V,GACAlzB,EAAA8oC,EAAA,IAAAA,EAEc9oC,EAAAJ,EAAcI,IAAA,CAC5B,GAAA8yB,GAAAt3B,KAAAsoC,cAAA9jC,EACA,KAAA8yB,EAAAoD,cACA,MAAA1gC,IAAAC,QAAAq9B,GAGA,MAAAt9B,IAAAC,QAAA,OAEA8yC,EAAA9/C,UAAAq0C,sBAAA,SAAArJ,GACA,MAAAj+B,IAAAC,QAAA+F,KAAAwtC,qCAAAxtC,KAAAsoC,cAAAz9C,UAEAkiD,EAAA9/C,UAAAu0C,oCAAA,SAAAvJ,EAAAP,GACA,GAAApgB,GAAAtX,KAAAsoC,cAAAz9C,OACA4iD,EAAAztC,KAAAutC,eAAA7V,EAYA,OAXA+V,GAAA,EACAA,EAAA,EAEAA,GAAAn2B,EACAm2B,EAAAn2B,EAKAm2B,IAEAzzC,GAAAC,QAAA+F,KAAAwtC,qCAAAC,KAEAV,EAAA9/C,UAAAw0C,0CAAA,SAAAxJ,EAAAyJ,GACA,GAAAhhC,GAAAV,KACAzH,EAAA,GAAAq5B,IAAA8P,EAAA,GACAlpC,EAAA,GAAAo5B,IAAA8P,EAAA7zB,OAAA9B,mBACA5d,IAOA,OANA6R,MAAAitC,qBAAAh1B,gBAAA1f,EAAAC,GAAA,SAAAy5B,GACA1lC,EAAAm1C,EAAA5vC,QAAAmgC,EAAA5kC,KAAA,kDACA,IAAAiqC,GAAA52B,EAAA0sC,kBAAAnb,EAAAa,gBACAvmC,GAAA,OAAA+qC,EAAA,qDACAnpC,EAAA8B,KAAAqnC,KAEAt9B,GAAAC,QAAA9L,IAEA4+C,EAAA9/C,UAAAg1C,oCAAA,SAAAhK,EAAAt5B,GACA,GAAA+B,GAAAV,KAGAwlC,EAAA7mC,EAAApI,KACAm3C,EAAAlI,EAAA36C,OAAA,EAKA8iD,EAAAnI,CACA1/B,IAAAE,cAAA2nC,KACAA,IAAA5pC,MAAA,IAEA,IAAAxL,GAAA,GAAAq5B,IAAA,GAAA9rB,IAAA6nC,GAAA,GAGAvL,EAAA,GAAA5qB,IAAA9lB,EACAsO,MAAAitC,qBAAA70B,aAAA,SAAA6Z,GACA,GAAA2b,GAAA3b,EAAA5kC,IAAAkJ,IACA,SAAAivC,EAAA/gC,WAAAmpC,KASAA,EAAA/iD,SAAA6iD,IACAtL,IAAAnjC,IAAAgzB,EAAAa,mBAEA,IAESv6B,EAGT,IAAApK,KAOA,OANAi0C,GAAAp0C,QAAA,SAAA0pC,GACA,GAAAJ,GAAA52B,EAAA0sC,kBAAA1V,EACA,QAAAJ,GACAnpC,EAAA8B,KAAAqnC,KAGAt9B,GAAAC,QAAA9L,IAEA4+C,EAAA9/C,UAAAo1C,sBAAA,SAAApK,EAAAqK,GACA,GAAAuL,GAAAvL,EAAAz3C,MACA0B,GAAAshD,EAAA,iDACA,IAAAC,GAAAxL,EAAA,GAAA5K,QACAqW,EAAA/tC,KAAAsoC,cAAAz9C,OAGAmjD,EAAAhuC,KAAAmtC,uBAAAW,EAAA,UACAvhD,GAAAyT,KAAAsoC,cAAA0F,GAAAtW,UAAAoW,EAAA,0CAIA,KAFA,GAAAZ,GAAA,EACAe,EAAAD,EAAA,EACAd,EAAAW,GAAAI,EAAAF,GAAA,CACA,GAAAzW,GAAAt3B,KAAAsoC,cAAA2F,EACA3W,GAAAoD,cACAuT,KAGA1hD,EAAA+qC,EAAAI,UAAA4K,EAAA4K,GAAAxV,QAAA,mDACAwV,IACAe,KAKA,OAAAD,EAAA,CACA,KAAkBC,EAAAF,EAAyBE,IAAA,CAC3C,GAAA3W,GAAAt3B,KAAAsoC,cAAA2F,EACA,KAAA3W,EAAAoD,cACA,MAGA,GAAAwT,GAAAD,EAAAD,CACAhuC,MAAAsoC,cAAAhc,OAAA0hB,EAAAE,OAIA,QAAAl8C,GAAAg8C,EAAoCh8C,EAAAi8C,EAAgBj8C,IACpDgO,KAAAsoC,cAAAt2C,GAAAgO,KAAAsoC,cAAAt2C,GAAA2oC,aAIA,QADAwT,GAAAnuC,KAAAitC,qBACAtiD,EAAA,EAAA83C,EAAAH,EAA6C33C,EAAA83C,EAAA53C,OAAuBF,IAGpE,OAFA2sC,GAAAmL,EAAA93C,GACA+sC,EAAAJ,EAAAI,QACA3oB,EAAA,EAAAiB,EAAAsnB,EAAAgD,UAAkDvrB,EAAAiB,EAAAnlB,OAAgBkkB,IAAA,CAClE,GAAA0R,GAAAzQ,EAAAjB,GACA1hB,EAAAozB,EAAApzB,GACA,QAAA2S,KAAA+xB,kBACA/xB,KAAA+xB,iBAAArB,uBAAArjC,EAEA,IAAA4kC,GAAA,GAAAL,IAAAvkC,EAAAqqC,EACAyW,KAAAnvC,OAAAizB,GAIA,MADAjyB,MAAAitC,qBAAAkB,EACAn0C,GAAAC,WAEA8yC,EAAA9/C,UAAAujC,oBAAA,SAAAuB,GACA/xB,KAAA+xB,oBAEAgb,EAAA9/C,UAAAikC,YAAA,SAAAx2B,EAAArN,GACA,GAAA4kC,GAAA,GAAAL,IAAAvkC,EAAA,GACAulC,EAAA5yB,KAAAitC,qBAAA50B,kBAAA4Z,EACA,OAAAj4B,IAAAC,QAAA5M,EAAAyE,QAAA8gC,KAAAvlC,OAEA0/C,EAAA9/C,UAAA41C,wBAAA,SAAAnoC,GAIA,MAHA,KAAAsF,KAAAsoC,cAAAz9C,QACA0B,EAAAyT,KAAAitC,qBAAAh/C,UAAA,+EAEA+L,GAAAC,WAOA8yC,EAAA9/C,UAAAugD,qCAAA,SAAAC,GAEA,OADAt/C,MACA6D,EAAA,EAAuBA,EAAAy7C,EAAcz7C,IAAA,CACrC,GAAAslC,GAAAt3B,KAAAsoC,cAAAt2C,EACAslC,GAAAoD,eACAvsC,EAAA8B,KAAAqnC,GAGA,MAAAnpC,IAUA4+C,EAAA9/C,UAAAkgD,uBAAA,SAAAzV,EAAAzvB,GACA,GAAAzD,GAAAxE,KAAAutC,eAAA7V,EAEA,OADAnrC,GAAAiY,GAAA,GAAAA,EAAAxE,KAAAsoC,cAAAz9C,OAAA,4BAAAod,GACAzD,GAWAuoC,EAAA9/C,UAAAsgD,eAAA,SAAA7V,GACA,WAAA13B,KAAAsoC,cAAAz9C,OAEA,EAOA6sC,EADA13B,KAAAsoC,cAAA,GAAA5Q,SAOAqV,EAAA9/C,UAAAmgD,kBAAA,SAAA1V,GACA,GAAAlzB,GAAAxE,KAAAutC,eAAA7V,EACA,IAAAlzB,EAAA,GAAAA,GAAAxE,KAAAsoC,cAAAz9C,OACA,WAEA,IAAAysC,GAAAt3B,KAAAsoC,cAAA9jC,EAEA,OADAjY,GAAA+qC,EAAAI,YAAA,6BACAJ,EAAAoD,cAAA,KAAApD,GAEAyV,KChUAqB,GAAA,WACA,QAAAC,KAIAruC,KAAA8sB,QAAA,GAAAf,IAAA,SAAAgB,GAAmD,MAAAA,GAAAhd,gBAEnD/P,KAAAk8B,0BAAA9oB,GAAAM,IAEA1T,KAAAg8B,gBAAA,EAKAh8B,KAAAmuC,WAAA,GAAA1c,IAuDA,MArDA4c,GAAAphD,UAAAsL,MAAA,SAAA0/B,GAEA,MAAAj+B,IAAAC,WAEAo0C,EAAAphD,UAAAo2C,6BAAA,WACA,MAAArjC,MAAAk8B,2BAEAmS,EAAAphD,UAAAm2C,mBAAA,WACA,MAAApjC,MAAAg8B,iBAEAqS,EAAAphD,UAAAq2C,6BAAA,SAAArL,EAAA/jB,GAEA,MADAlU,MAAAk8B,0BAAAhoB,EACAla,GAAAC,WAEAo0C,EAAAphD,UAAAs2C,aAAA,SAAAtL,EAAAtV,GACA3iB,KAAA8sB,QAAA3f,IAAAwV,EAAAhkB,MAAAgkB,EACA,IAAA3O,GAAA2O,EAAA3O,QAIA,OAHAA,GAAAhU,KAAAg8B,kBACAh8B,KAAAg8B,gBAAAhoB,GAEAha,GAAAC,WAEAo0C,EAAAphD,UAAAy2C,gBAAA,SAAAzL,EAAAtV,GAGA,MAFA3iB,MAAA8sB,QAAA9tB,OAAA2jB,EAAAhkB,OACAqB,KAAAmuC,WAAA7b,sBAAA3P,EAAA3O,UACAha,GAAAC,WAEAo0C,EAAAphD,UAAA22C,aAAA,SAAA3L,EAAAt5B,GACA,GAAAgkB,GAAA3iB,KAAA8sB,QAAAr1B,IAAAkH,IAAA,IACA,OAAA3E,IAAAC,QAAA0oB,IAEA0rB,EAAAphD,UAAA62C,gBAAA,SAAAppC,EAAAid,EAAA3D,GAEA,MADAhU,MAAAmuC,WAAAjc,cAAAva,EAAA3D,GACAha,GAAAC,WAEAo0C,EAAAphD,UAAA82C,mBAAA,SAAArpC,EAAAid,EAAA3D,GAEA,MADAhU,MAAAmuC,WAAA9b,iBAAA1a,EAAA3D,GACAha,GAAAC,WAEAo0C,EAAAphD,UAAA02C,8BAAA,SAAAjpC,EAAAsZ,GAEA,MADAhU,MAAAmuC,WAAA7b,sBAAAte,GACAha,GAAAC,WAEAo0C,EAAAphD,UAAAg3C,2BAAA,SAAAvpC,EAAAsZ,GACA,GAAAg1B,GAAAhpC,KAAAmuC,WAAAxb,gBAAA3e,EACA,OAAAha,IAAAC,QAAA+uC,IAEAqF,EAAAphD,UAAAujC,oBAAA,SAAAwS,GACAhjC,KAAAmuC,WAAA3d,oBAAAwS,IAEAqL,EAAAphD,UAAAikC,YAAA,SAAAx2B,EAAArN,GACA,MAAA2S,MAAAmuC,WAAAjd,YAAAx2B,EAAArN,IAEAghD,KCrEAC,GAAA,WACA,QAAAC,KACAvuC,KAAAuZ,KAAA/jB,KA8BA,MA5BA+4C,GAAAthD,UAAAm3C,SAAA,SAAAnM,EAAAoM,GAEA,MADArkC,MAAAuZ,KAAAvZ,KAAAuZ,KAAAhS,OAAA88B,EAAAh3C,IAAAg3C,GACArqC,GAAAC,WAEAs0C,EAAAthD,UAAAs3C,YAAA,SAAAtM,EAAAyJ,GAEA,MADA1hC,MAAAuZ,KAAAvZ,KAAAuZ,KAAA7R,OAAAg6B,GACA1nC,GAAAC,WAEAs0C,EAAAthD,UAAAu3C,SAAA,SAAAvM,EAAAyJ,GACA,MAAA1nC,IAAAC,QAAA+F,KAAAuZ,KAAA9hB,IAAAiqC,KAEA6M,EAAAthD,UAAA03C,0BAAA,SAAA1M,EAAAt5B,GAMA,IALA,GAAA3N,GAAA0E,KAGA8vC,EAAA,GAAA1/B,IAAAnH,EAAApI,KAAAwN,MAAA,KACAyqC,EAAAxuC,KAAAuZ,KAAAhR,gBAAAi9B,GACAgJ,EAAAxlC,WAAA,CACA,GAAA+F,GAAAy/B,EAAA1lC,UAAAzb,EAAA0hB,EAAA1hB,IAAA8nB,EAAApG,EAAAthB,KACA,KAAAkR,EAAApI,KAAAkO,WAAApX,EAAAkJ,MACA,KAEA4e,aAAA7O,KAAA3H,EAAA0R,QAAA8E,KACAnkB,IAAAuW,OAAA4N,EAAA9nB,IAAA8nB,IAGA,MAAAnb,IAAAC,QAAAjJ,IAEAu9C,KC1BAE,GAAA,WACA,QAAAC,KAQA1uC,KAAA2uC,kBACA3uC,KAAAqoC,oBAAA,GAAAiG,IACAtuC,KAAA6pC,WAAA,GAAAuE,IACApuC,KAAA6lC,SAAA,EAgCA,MA9BA6I,GAAAzhD,UAAAsL,MAAA,WAIA,MAHAhM,IAAAyT,KAAA6lC,QAAA,qCACA7lC,KAAA6lC,SAAA,EAEA9e,QAAA9sB,WAEAy0C,EAAAzhD,UAAAk5C,SAAA,WAIA,MAFA55C,GAAAyT,KAAA6lC,QAAA,6CACA7lC,KAAA6lC,SAAA,EACA9e,QAAA9sB,WAEAy0C,EAAAzhD,UAAAs5C,iBAAA,SAAArM,GACA,GAAA0U,GAAA5uC,KAAA2uC,eAAAzU,EAAAd,QAKA,OAJAwV,KACAA,EAAA,GAAA9B,IACA9sC,KAAA2uC,eAAAzU,EAAAd,SAAAwV,GAEAA,GAEAF,EAAAzhD,UAAAu5C,cAAA,WACA,MAAAxmC,MAAA6pC,YAEA6E,EAAAzhD,UAAAw5C,uBAAA,WACA,MAAAzmC,MAAAqoC,qBAEAqG,EAAAzhD,UAAA6qC,eAAA,SAAA7vB,EAAAy+B,GAEA,MADAn8C,GA9CA,oBA8CA,wBAAA0d,GACAy+B,EAAA,GAAAmI,KAAApf,aAEAif,KAIAG,GAAA,WACA,QAAAA,MAEA,MAAAA,MCtDAC,GAAA,WACA,QAAAC,KACA/uC,KAAAmwB,SAAA,EAcA,MAZA4e,GAAA9hD,UAAAqjC,iBAAA,SAAAC,KAGAwe,EAAA9hD,UAAAwjC,oBAAA,SAAAF,KAGAwe,EAAA9hD,UAAAyjC,uBAAA,SAAArjC,KAGA0hD,EAAA9hD,UAAA0jC,eAAA,SAAAj2B,GACA,MAAAV,IAAAC,QAAAnE,OAEAi5C,KCvBAC,GAAA,WACA,QAAAA,KACA,GAAAtuC,GAAAV,IACAA,MAAA6vB,QAAA,GAAA9I,SAAA,SAAA9sB,EAAAC,GACAwG,EAAAzG,UACAyG,EAAAxG,WAGA,MAAA80C,OZEA,SAAAhc,GACAA,IAAA,uCACAA,IAAA,mDACAA,IAAA,qCACAA,IAAA,kDACCA,YAQD,IaNAic,IbMAC,GAAA,WACA,QAAAC,GAAAC,EAAAC,EAAAC,EAAA/7C,EAAAg8C,GACAvvC,KAAAovC,aACApvC,KAAAqvC,UACArvC,KAAAsvC,eACAtvC,KAAAzM,KACAyM,KAAAuvC,kBACAvvC,KAAAwvC,SAAA,GAAAR,IACAhvC,KAAA2tB,KAAA3tB,KAAAwvC,SAAA3f,QAAAlC,KAAAh3B,KAAAqJ,KAAAwvC,SAAA3f,SACA7vB,KAAAovB,MAAApvB,KAAAwvC,SAAA3f,QAAAT,MAAAz4B,KAAAqJ,KAAAwvC,SAAA3f,SAuEA,MAvDAsf,GAAAM,kBAAA,SAAAL,EAAAC,EAAAK,EAAAn8C,EAAAg8C,GACA,GAAAI,GAAA1kD,KAAAunB,MAAAk9B,EACAE,EAAA,GAAAT,GAAAC,EAAAC,EAAAM,EAAAp8C,EAAAg8C,EAEA,OADAK,GAAAr3C,MAAAm3C,GACAE,GAMAT,EAAAliD,UAAAsL,MAAA,SAAAm3C,GACA,GAAAhvC,GAAAV,IACAA,MAAA6vC,YAAAxmB,WAAA,WAAmD,MAAA3oB,GAAAovC,sBAAqCJ,IAMxFP,EAAAliD,UAAA8iD,UAAA,WACA,MAAA/vC,MAAA8vC,sBASAX,EAAAliD,UAAA+iD,OAAA,SAAA1I,GACA,OAAAtnC,KAAA6vC,cACA7vC,KAAAiwC,eACAjwC,KAAAwvC,SAAAt1C,OAAA,GAAApN,IAAAC,GAAAqH,UAAA,uBAAAkzC,EAAA,KAAAA,EAAA,QAGA6H,EAAAliD,UAAA6iD,mBAAA,WACA,GAAApvC,GAAAV,IACAA,MAAAovC,WAAAc,QAAA,WACA,cAAAxvC,EAAAmvC,aACAnvC,EAAAuvC,eACAvvC,EAAAnN,KAAAo6B,KAAA,SAAAx/B,GACA,MAAAuS,GAAA8uC,SAAAv1C,QAAA9L,MAIA44B,QAAA9sB,aAIAk1C,EAAAliD,UAAAgjD,aAAA,WACA,OAAAjwC,KAAA6vC,cACA7vC,KAAAuvC,gBAAAvvC,MACAiwC,aAAAjwC,KAAA6vC,aACA7vC,KAAA6vC,YAAA,OAGAV,KAEAgB,GAAA,WACA,QAAAC,KAEApwC,KAAAqwC,KAAAtpB,QAAA9sB,UAGA+F,KAAAswC,qBAGAtwC,KAAAuwC,qBAAA,EAkHA,MA5GAH,GAAAnjD,UAAAijD,QAAA,SAAA38C,GACA,GAAAmN,GAAAV,IACAA,MAAAwwC,iBACA,IAAAC,GAAAzwC,KAAAqwC,KAAA1iB,KAAA,WAEA,MADAjtB,GAAA6vC,qBAAA,EACAh9C,IACA67B,MAAA,SAAAvjC,GACA6U,EAAAtU,QAAAP,EACA6U,EAAA6vC,qBAAA,CACA,IAAAlkD,GAAAR,EAAA6kD,OAAA7kD,EAAAQ,SAAA,EAaA,MAZAV,GAAA,6BAAAU,GAIAA,EAAAkF,QAAA,qCACA83B,WAAA,WACA,KAAAx9B,IACqB,GAKrBA,IAEA8hC,KAAA,SAAAx/B,GAEA,MADAuS,GAAA6vC,qBAAA,EACApiD,KAIA,OADA6R,MAAAqwC,KAAAI,EACAA,GAOAL,EAAAnjD,UAAA0jD,kBAAA,SAAAtB,EAAAK,EAAAn8C,GACA,GAAAmN,GAAAV,IACAA,MAAAwwC,kBAGAjkD,GAAAyT,KAAA4wC,yBAAAvB,GAAA,2DAAArc,GAAAqc,GAAA,IACA,IAAAO,GAAAV,GAAAO,kBAAAzvC,KAAAqvC,EAAAK,EAAAn8C,EAAA,SAAAA,GAAsG,MAAAmN,GAAAmwC,uBAAAt9C,IAEtG,OADAyM,MAAAswC,kBAAArgD,KAAA2/C,GACAA,GAEAQ,EAAAnjD,UAAAujD,gBAAA,WACAxwC,KAAA5T,SACAD,EAAA,kCACA6T,KAAA5T,QAAAskD,OAAA1wC,KAAA5T,QAAAC,WASA+jD,EAAAnjD,UAAA6jD,0BAAA,WACAvkD,EAAAyT,KAAAuwC,oBAAA,sEAMAH,EAAAnjD,UAAA8jD,MAAA,WACA,MAAA/wC,MAAAkwC,QAAA,WAAyC,MAAAnpB,SAAA9sB,aAMzCm2C,EAAAnjD,UAAA2jD,yBAAA,SAAAvB,GACA,MAAArvC,MAAAswC,kBAAAU,UAAA,SAAAz9C,GAA+D,MAAAA,GAAA87C,eAAiC,GAUhGe,EAAAnjD,UAAAgkD,0BAAA,SAAAC,GACA,GAAAxwC,GAAAV,IAEA,OAAAA,MAAA+wC,QAAApjB,KAAA,WACAphC,MAAAoB,KAAAujD,GAAAxwC,EAAAkwC,yBAAAM,GAAA,2CAAAA,GAEAxwC,EAAA4vC,kBAAAtb,KAAA,SAAAmc,EAAA9wC,GAA0D,MAAA8wC,GAAA7B,aAAAjvC,EAAAivC,cAC1D,QAAA3kD,GAAA,EAAAokB,EAAArO,EAAA4vC,kBAA0D3lD,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAC1E,GAAA4I,GAAAwb,EAAApkB,EAEA,IADA4I,EAAAw8C,gBACApiD,KAAAujD,GAAA39C,EAAA87C,UAAA6B,EACA,MAGA,MAAAxwC,GAAAqwC,WAIAX,EAAAnjD,UAAA4jD,uBAAA,SAAAt9C,GAEA,GAAAiR,GAAAxE,KAAAswC,kBAAA/+C,QAAAgC,EACAhH,GAAAiY,GAAA,kCACAxE,KAAAswC,kBAAAhkB,OAAA9nB,EAAA,IAEA4rC,KczNAgB,GAAA,WACA,QAAAC,GAIAzC,EAIAS,EAMAiC,EAKAC,EAMAC,GACAxxC,KAAA4uC,QACA5uC,KAAAqvC,UACArvC,KAAAsxC,iBACAtxC,KAAAuxC,gBACAvxC,KAAAwxC,aACAxxC,KAAAyxC,aAAA,KACAzxC,KAAA0xC,QAkDA,MAzCAL,GAAApkD,UAAAykD,MAAA,WACA1xC,KAAA2xC,cAAA,GAMAN,EAAApkD,UAAA2kD,WAAA,WACA5xC,KAAA2xC,cAAA3xC,KAAAwxC,YAOAH,EAAApkD,UAAA4kD,cAAA,SAAAt+C,GACA,OAAAyM,KAAAyxC,cACAzxC,KAAAyxC,aAAAzB,QAIA,IAAA8B,GAAA9xC,KAAA2xC,cAAA3xC,KAAA+xC,eACA/xC,MAAA2xC,cAAA,GACApnD,EA3EA,qBA2EA,mBAAAunD,EAAA,oBACA9xC,KAAA2xC,cAAA,QAEA3xC,KAAAyxC,aAAAzxC,KAAA4uC,MAAA+B,kBAAA3wC,KAAAqvC,QAAAyC,EAAAv+C,GAGAyM,KAAA2xC,eAAA3xC,KAAAuxC,cACAvxC,KAAA2xC,cAAA3xC,KAAAsxC,iBACAtxC,KAAA2xC,cAAA3xC,KAAAsxC,gBAEAtxC,KAAA2xC,cAAA3xC,KAAAwxC,aACAxxC,KAAA2xC,cAAA3xC,KAAAwxC,aAIAH,EAAApkD,UAAA8kD,cAAA,WACA,OAAA9wC,KAAAE,SAAA,IAAAnB,KAAA2xC,eAEAN,KD9FAW,GAAAhyC,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,SAWA,SAAA0uC,GAMAA,IAAA,qBAMAA,IAAA,eAKAA,IAAA,eAMAA,IAAA,iBAOAA,IAAA,qBAIAA,IAAA,sBACCA,YAKD,I9CMAzyC,I8CNAy1C,GAAA,IAEAC,GAAA,IACAC,GAAA,IAkCAC,GAAA,WACA,QAAAC,GAAAzD,EAAA0D,EAAAC,EAAAC,EAAAC,GACAzyC,KAAA4uC,QACA5uC,KAAAuyC,cACAvyC,KAAAwyC,aACAxyC,KAAAyyC,sBACAzyC,KAAA0yC,uBAAA,KACA1yC,KAAA2yC,OAAA,KACA3yC,KAAAqtB,SAAA,KACArtB,KAAA4yC,QAAA,GAAAxB,IAAAxC,EAAA0D,EAAAL,GAAAE,GAAAD,IACAlyC,KAAAoa,MAAA60B,GAAA4D,QA2PA,MAlPAR,GAAAplD,UAAA6lD,UAAA,WACA,MAAA9yC,MAAAoa,QAAA60B,GAAA8D,SACA/yC,KAAAoa,QAAA60B,GAAA+D,MACAhzC,KAAAoa,QAAA60B,GAAAgE,MAMAZ,EAAAplD,UAAAimD,OAAA,WACA,MAAAlzC,MAAAoa,QAAA60B,GAAAgE,MASAZ,EAAAplD,UAAAsL,MAAA,SAAA80B,GACA,GAAArtB,KAAAoa,QAAA60B,GAAA3iD,MAEA,WADA0T,MAAAmzC,eAAA9lB,EAGA9gC,GAAAyT,KAAAoa,QAAA60B,GAAA4D,QAAA,mBACA7yC,KAAAqtB,WACArtB,KAAAozC,QAQAf,EAAAplD,UAAAomD,KAAA,WACArzC,KAAA8yC,aACA9yC,KAAAulB,MAAA0pB,GAAAqE,UAWAjB,EAAAplD,UAAAsmD,eAAA,WACAhnD,GAAAyT,KAAA8yC,YAAA,+CACA9yC,KAAAoa,MAAA60B,GAAA4D,QACA7yC,KAAA4yC,QAAAlB,SAYAW,EAAAplD,UAAAumD,SAAA,WACA,GAAA9yC,GAAAV,IAGAA,MAAAkzC,UAAA,OAAAlzC,KAAA0yC,yBACA1yC,KAAA0yC,uBAAA1yC,KAAA4uC,MAAA+B,kBAAA3wC,KAAAuyC,YAtHA,IAsHA,WAAuH,MAAA7xC,GAAA+yC,yBACvHzzC,KAAA0yC,uBAAAtjB,MAAA,SAAAzJ,GAKAp5B,EAAAo5B,EAAAzxB,OAAAnH,GAAAqH,UAAA,mFAAAuxB,OAKA0sB,EAAAplD,UAAAymD,YAAA,SAAAjpD,GACAuV,KAAA2zC,kBACA3zC,KAAA2yC,OAAAntB,KAAA/6B,IAGA4nD,EAAAplD,UAAAwmD,qBAAA,WACA,MAAAzzC,MAAAkzC,SAGAlzC,KAAAulB,MAAA0pB,GAAA4D,SAEA9rB,QAAA9sB,WAGAo4C,EAAAplD,UAAA0mD,gBAAA,WACA3zC,KAAA0yC,yBACA1yC,KAAA0yC,uBAAA1C,SACAhwC,KAAA0yC,uBAAA,OAiBAL,EAAAplD,UAAAs4B,MAAA,SAAAquB,EAAA/nD,GACAU,EAAAqnD,IAAA3E,GAAA3iD,OAAA0G,EAAAnH,GAAA,sDACAmU,KAAA2zC,kBACAC,IAAA3E,GAAA3iD,MAEA0T,KAAA4yC,QAAAlB,QAEA7lD,KAAAqI,OAAAnH,GAAAwH,qBAEA5I,EAAAE,MACAF,EAAA,mEACAqU,KAAA4yC,QAAAhB,cAGA,OAAA5xC,KAAA2yC,SACA3yC,KAAA6zC,WACA7zC,KAAA2yC,OAAAptB,QACAvlB,KAAA2yC,OAAA,MAIA3yC,KAAAoa,MAAAw5B,CACA,IAAAvmB,GAAArtB,KAAAqtB,QAKA,OAHArtB,MAAAqtB,SAAA,KAGAumB,IAAA3E,GAAAqE,QACAjmB,EAAAlI,QAAAt5B,GAGAk7B,QAAA9sB,WAOAo4C,EAAAplD,UAAA4mD,SAAA,aACAxB,EAAAplD,UAAAmmD,KAAA,WACA,GAAA1yC,GAAAV,IACAzT,GAAAyT,KAAAoa,QAAA60B,GAAA4D,QAAA,oCACA7yC,KAAAoa,MAAA60B,GAAA+D,KACAhzC,KAAAyyC,oBAAAqB,UAAA,GAAAnmB,KAAA,SAAAnzB,GAIAkG,EAAAqzC,YAAAv5C,IACS,SAAA3O,GACT6U,EAAAkuC,MAAAsB,QAAA,WACA,GAAAxvC,EAAA0Z,QAAA60B,GAAAqE,QAAA,CAEA,GAAAU,GAAA,GAAAlnD,IAAAC,GAAAsH,QAAA,+BAAAxI,EAAAQ,QACA,OAAAqU,GAAAuzC,kBAAAD,GAGA,MAAAjtB,SAAA9sB,eAKAo4C,EAAAplD,UAAA8mD,YAAA,SAAAv5C,GACA,GAAAkG,GAAAV,IACA,IAAAA,KAAAoa,QAAA60B,GAAAqE,QAAA,CAIA/mD,EAAAyT,KAAAoa,QAAA60B,GAAA+D,KAAA,6CAIA,IAAAkB,GAAA,SAAAvB,EAAA9kD,GACA6S,EAAAkuC,MAAAsB,QAAA,WAEA,MAAAxvC,GAAAiyC,WACA9kD,IAGAk5B,QAAA9sB,YAKA,WAAA+F,KAAAqtB,SAAA,CACA,GAAA8mB,GAAAn0C,KAAAo0C,SAAA55C,EACAwF,MAAA2yC,OAAAwB,EACAn0C,KAAA2yC,OAAA3tB,OAAA,WACAkvB,EAAAC,EAAA,WAGA,MAFA5nD,GAAAmU,EAAA0Z,QAAA60B,GAAA+D,KAAA,gDAAAtyC,EAAA0Z,OACA1Z,EAAA0Z,MAAA60B,GAAAgE,KACAvyC,EAAA2sB,SAAArI,aAGAhlB,KAAA2yC,OAAAxtB,QAAA,SAAAt5B,GACAqoD,EAAAC,EAAA,WACA,MAAAzzC,GAAAuzC,kBAAApoD,OAGAmU,KAAA2yC,OAAAttB,UAAA,SAAA56B,GACAypD,EAAAC,EAAA,WACA,MAAAzzC,GAAA2kB,UAAA56B,UAKA4nD,EAAAplD,UAAAkmD,eAAA,SAAA9lB,GACA,GAAA3sB,GAAAV,IACAzT,GAAAyT,KAAAoa,QAAA60B,GAAA3iD,MAAA,gDACA0T,KAAAoa,MAAA60B,GAAA8D,QACA/yC,KAAA4yC,QAAAf,cAAA,WACA,MAAAnxC,GAAA0Z,QAAA60B,GAAAqE,QAEAvsB,QAAA9sB,WAEAyG,EAAA0Z,MAAA60B,GAAA4D,QACAnyC,EAAAnI,MAAA80B,GACA9gC,EAAAmU,EAAAoyC,YAAA,wCACA/rB,QAAA9sB,cAGAo4C,EAAAplD,UAAAgnD,kBAAA,SAAApoD,GAQA,MAPAU,GAAAyT,KAAA8yC,YAAA,mDACAvoD,EA5UA,mBA4UA,qBAAAsB,GACAmU,KAAA2yC,OAAA,KAKA3yC,KAAAulB,MAAA0pB,GAAA3iD,MAAAT,IAEAwmD,KAUAgC,GAAA,SAAA5zC,GAEA,QAAA6zC,GAAA1F,EAAA4D,EAAA72C,EAAAgkC,GACA,GAAAj/B,GAAAD,EAAAlT,KAAAyS,KAAA4uC,EAAA5b,GAAAuhB,uBAAAvhB,GAAAwhB,iBAAAhC,EAAA72C,IAAAqE,IAEA,OADAU,GAAAi/B,aACAj/B,EAsCA,MA1CAsxC,IAAAsC,EAAA7zC,GAMA6zC,EAAArnD,UAAAmnD,SAAA,SAAA55C,GACA,MAAAwF,MAAAwyC,WAAArqB,WAAA,SAAA3tB,IAEA85C,EAAArnD,UAAAo4B,UAAA,SAAAovB,GAEAz0C,KAAA4yC,QAAAlB,OACA,IAAA72B,GAAA7a,KAAA2/B,WAAA1f,gBAAAw0B,GACAt2C,EAAA6B,KAAA2/B,WAAApf,0BAAAk0B,EACA,OAAAz0C,MAAAqtB,SAAAqnB,cAAA75B,EAAA1c,IAQAm2C,EAAArnD,UAAA0nD,MAAA,SAAAhyB,GACA,GAAA5oB,KACAA,GAAAsJ,SAAArD,KAAA2/B,WAAAhiB,kBACA5jB,EAAA66C,UAAA50C,KAAA2/B,WAAA1c,SAAAN,EACA,IAAAkyB,GAAA70C,KAAA2/B,WAAAjd,sBAAAC,EACAkyB,KACA96C,EAAA86C,UAEA70C,KAAA0zC,YAAA35C,IAMAu6C,EAAArnD,UAAA6nD,QAAA,SAAA9gC,GACA,GAAAja,KACAA,GAAAsJ,SAAArD,KAAA2/B,WAAAhiB,kBACA5jB,EAAAg7C,aAAA/gC,EACAhU,KAAA0zC,YAAA35C,IAEAu6C,GACClC,IAmBD4C,GAAA,SAAAv0C,GAEA,QAAAw0C,GAAArG,EAAA4D,EAAA72C,EAAAgkC,GACA,GAAAj/B,GAAAD,EAAAlT,KAAAyS,KAAA4uC,EAAA5b,GAAAkiB,sBAAAliB,GAAAmiB,gBAAA3C,EAAA72C,IAAAqE,IAGA,OAFAU,GAAAi/B,aACAj/B,EAAA00C,GAAA,EACA10C,EA0EA,MA/EAsxC,IAAAiD,EAAAx0C,GAOAnT,OAAAqS,eAAAs1C,EAAAhoD,UAAA,qBAKAwK,IAAA,WACA,MAAAuI,MAAAo1C,GAEA1yC,YAAA,EACAC,cAAA,IAGAsyC,EAAAhoD,UAAAsL,MAAA,SAAA80B,GACArtB,KAAAo1C,GAAA,EACA30C,EAAAxT,UAAAsL,MAAAhL,KAAAyS,KAAAqtB,IAEA4nB,EAAAhoD,UAAA4mD,SAAA,WACA7zC,KAAAo1C,GACAp1C,KAAAq1C,oBAGAJ,EAAAhoD,UAAAmnD,SAAA,SAAA55C,GACA,MAAAwF,MAAAwyC,WAAArqB,WAAA,QAAA3tB,IAEAy6C,EAAAhoD,UAAAo4B,UAAA,SAAAiwB,GAIA,GAFA/oD,IAAA+oD,EAAAva,YAAA,+CACA/6B,KAAAu7B,gBAAA+Z,EAAAva,YACA/6B,KAAAo1C,EAMA,CAIAp1C,KAAA4yC,QAAAlB,OACA,IAAA1gD,GAAAgP,KAAA2/B,WAAAte,iBAAAi0B,EAAAC,cACAza,EAAA96B,KAAA2/B,WAAA1iB,YAAAq4B,EAAAE,WACA,OAAAx1C,MAAAqtB,SAAAooB,iBAAA3a,EAAA9pC,GATA,MAFAzE,IAAA+oD,EAAAC,cAAA,IAAAD,EAAAC,aAAA1qD,OAAA,sCACAmV,KAAAo1C,GAAA,EACAp1C,KAAAqtB,SAAAqoB,uBAiBAT,EAAAhoD,UAAA0oD,eAAA,WACAppD,EAAAyT,KAAAkzC,SAAA,+CACA3mD,GAAAyT,KAAAo1C,EAAA,8BAGA,IAAAr7C,KACAA,GAAAsJ,SAAArD,KAAA2/B,WAAAhiB,kBACA3d,KAAA0zC,YAAA35C,IAGAk7C,EAAAhoD,UAAAooD,eAAA,SAAA/a,GACA,GAAA55B,GAAAV,IACAzT,GAAAyT,KAAAkzC,SAAA,+CACA3mD,EAAAyT,KAAAo1C,EAAA,uDACA7oD,EAAAyT,KAAAu7B,gBAAA1wC,OAAA,6CACA,IAAAkP,IAGAghC,YAAA/6B,KAAAu7B,gBACAqa,OAAAtb,EAAAlvC,IAAA,SAAAq1B,GAAuD,MAAA/f,GAAAi/B,WAAAnf,WAAAC,KAEvDzgB,MAAA0zC,YAAA35C,IAEAk7C,GACC7C,IEtfDyD,GAAA,WACA,QAAAC,GAAAlH,EAAA4D,EAAA72C,EAAAgkC,GACA3/B,KAAA4uC,QACA5uC,KAAAwyC,aACAxyC,KAAArE,cACAqE,KAAA2/B,aAuDA,MArDAmW,GAAA7oD,UAAA8oD,yBAAA,WACA,UAAAf,IAAAh1C,KAAA4uC,MAAA5uC,KAAAwyC,WAAAxyC,KAAArE,YAAAqE,KAAA2/B,aAEAmW,EAAA7oD,UAAA+oD,yBAAA,WACA,UAAA3B,IAAAr0C,KAAA4uC,MAAA5uC,KAAAwyC,WAAAxyC,KAAArE,YAAAqE,KAAA2/B,aAEAmW,EAAA7oD,UAAAmrC,OAAA,SAAAkC,GACA,GAAA55B,GAAAV,KACAi2C,GACA5yC,SAAArD,KAAA2/B,WAAAhiB,kBACAi4B,OAAAtb,EAAAlvC,IAAA,SAAA65C,GAAgD,MAAAvkC,GAAAi/B,WAAAnf,WAAAykB,KAEhD,OAAAjlC,MAAA2mB,UAAA,SAAAsvB,GAAAtoB,KAAA,SAAAuoB,GACA,MAAAx1C,GAAAi/B,WAAAte,iBAAA60B,EAAAX,iBAGAO,EAAA7oD,UAAAkpD,OAAA,SAAAx+B,GACA,GAAAjX,GAAAV,KACAi2C,GACA5yC,SAAArD,KAAA2/B,WAAAhiB,kBACAliB,UAAAkc,EAAAvsB,IAAA,SAAA8c,GAA8C,MAAAxH,GAAAi/B,WAAApiB,OAAArV,KAE9C,OAAAlI,MAAAkoB,mBAAA,oBAAA+tB,GAAAtoB,KAAA,SAAAuoB,GACA,GAAA38B,GAAA/jB,IACA0gD,GAAAloD,QAAA,SAAAgzB,GACA,GAAAxiB,GAAAkC,EAAAi/B,WAAAjgB,kBAAAsB,EACAzH,KAAAhS,OAAA/I,EAAAnR,IAAAmR,IAEA,IAAArQ,KAMA,OALAwpB,GAAA3pB,QAAA,SAAAX,GACA,GAAAmR,GAAA+a,EAAA9hB,IAAApK,EACAd,KAAAiS,EAAA,wCAAAnR,GACAc,EAAA8B,KAAAuO,KAEArQ,KAIA2nD,EAAA7oD,UAAA05B,UAAA,SAAAC,EAAA7sB,GACA,GAAA2G,GAAAV,IAEA,OAAAA,MAAArE,YAAAm4C,UAAA,GAAAnmB,KAAA,SAAAnzB,GACA,MAAAkG,GAAA8xC,WAAA7rB,UAAAC,EAAA7sB,EAAAS,MAIAs7C,EAAA7oD,UAAAi7B,mBAAA,SAAAtB,EAAA7sB,GACA,GAAA2G,GAAAV,IAEA,OAAAA,MAAArE,YAAAm4C,UAAA,GAAAnmB,KAAA,SAAAnzB,GACA,MAAAkG,GAAA8xC,WAAAtqB,mBAAAtB,EAAA7sB,EAAAS,MAGAs7C,KC3DAM,GAAA,WACA,QAAAC,GAAAC,GACAt2C,KAAAs2C,YAEAt2C,KAAAu2C,aAAA3gD,KACAoK,KAAAs6B,aACAt6B,KAAAw2C,WAAA,EAgGA,MA9FAH,GAAAppD,UAAAwpD,cAAA,SAAAj4C,GACA,GAAAk4C,GAAAl4C,EAAAgI,OACAhI,aAAA0I,MAEAwvC,EAAAtjC,GAAAK,gBAEA,IAAAkjC,GAAA32C,KAAAu2C,aAAA9+C,IAAA+G,EAAAnR,IACA,WAAAspD,GACA,IAAAD,EAAA5kD,QAAA6kD,GAEA,SAAA7pD,IAAAC,GAAAgI,QAAA,mDAIAiL,MAAAu2C,aAAAv2C,KAAAu2C,aAAAhvC,OAAA/I,EAAAnR,IAAAqpD,IAGAL,EAAAppD,UAAAkpD,OAAA,SAAAx+B,GACA,GAAAjX,GAAAV,IACA,OAAAA,MAAAw2C,UACAzvB,QAAA7sB,OAAA,sCAEA8F,KAAAs6B,UAAAzvC,OAAA,EACAk8B,QAAA7sB,OAAA,kDAEA8F,KAAAs2C,UAAAH,OAAAx+B,GAAAgW,KAAA,SAAApU,GAEA,MADAA,GAAAvrB,QAAA,SAAAwQ,GAAyC,MAAAkC,GAAA+1C,cAAAj4C,KACzC+a,KAGA88B,EAAAppD,UAAAoqC,MAAA,SAAAiD,GACA,GAAAt6B,KAAAw2C,UACA,SAAA1pD,IAAAC,GAAA+H,oBAAA,qCAEAkL,MAAAs6B,UAAAt6B,KAAAs6B,UAAA5uC,OAAA4uC,IAMA+b,EAAAppD,UAAA2oB,aAAA,SAAAvoB,GACA,GAAAmZ,GAAAxG,KAAAu2C,aAAA9+C,IAAApK,EACA,OAAAmZ,GACAsO,GAAAE,WAAAxO,GAGAsO,GAAAO,MAMAghC,EAAAppD,UAAA2pD,sBAAA,SAAAvpD,GACA,GAAAmZ,GAAAxG,KAAAu2C,aAAA9+C,IAAApK,EACA,IAAAmZ,KAAA1U,QAAAshB,GAAAK,iBAEA,SAAA3mB,IAAAC,GAAA+H,oBAAA,8CAEA,OAAA0R,GAEAsO,GAAAE,WAAAxO,GAKAsO,GAAAG,QAAA,IAGAohC,EAAAppD,UAAAkgB,IAAA,SAAA9f,EAAAoZ,GACAzG,KAAAq3B,MAAA5wB,EAAAowC,YAAAxpD,EAAA2S,KAAA4V,aAAAvoB,MAEAgpD,EAAAppD,UAAAknB,OAAA,SAAA9mB,EAAAoZ,GACAzG,KAAAq3B,MAAA5wB,EAAAowC,YAAAxpD,EAAA2S,KAAA42C,sBAAAvpD,MAEAgpD,EAAAppD,UAAA+R,OAAA,SAAA3R,GACA2S,KAAAq3B,OAAA,GAAAngB,IAAA7pB,EAAA2S,KAAA4V,aAAAvoB,MAGA2S,KAAAu2C,aAAAv2C,KAAAu2C,aAAAhvC,OAAAla,EAAA+lB,GAAAK,kBAEA4iC,EAAAppD,UAAAmrC,OAAA,WACA,GAAA13B,GAAAV,KACA82C,EAAA92C,KAAAu2C,YAKA,OAHAv2C,MAAAs6B,UAAAtsC,QAAA,SAAAyyB,GACAq2B,IAAApvC,OAAA+Y,EAAApzB,OAEAypD,EAAA7oD,UAGA+R,KAAAs2C,UAAAle,OAAAp4B,KAAAs6B,WAAA3M,KAAA,WACAjtB,EAAA81C,WAAA,IAHAzvB,QAAA7sB,OAAA5N,MAAA,gEAMA+pD,KCpEAU,GAAA,WACA,QAAAC,GAKAlhB,EAEAwgB,EAAAW,GACAj3C,KAAA81B,aACA91B,KAAAs2C,YACAt2C,KAAAi3C,qBACAj3C,KAAAk3C,iBACAl3C,KAAAm3C,cAAAhd,GAUAn6B,KAAAya,iBAeAza,KAAA0a,0BACA1a,KAAAo3C,2BACAp3C,KAAAq3C,YAAA,KACAr3C,KAAAs3C,YAAA,KAKAt3C,KAAAu3C,uBAAAntB,GAAA6C,QAEAjtB,KAAAw3C,oBAAA,EAEAx3C,KAAAy3C,mBAAA,EAgjBA,MA1iBAT,GAAA/pD,UAAAsL,MAAA,WACA,MAAAyH,MAAA03C,iBAMAV,EAAA/pD,UAAA0qD,kBAAA,SAAAC,GACAA,IAAA53C,KAAAu3C,yBACAK,IAAAxtB,GAAAytB,QAGA73C,KAAAy3C,mBAAA,EAEAG,IAAAxtB,GAAA6C,UAOAjtB,KAAAw3C,oBAAA,GAEAx3C,KAAAu3C,uBAAAK,EACA53C,KAAAi3C,mBAAAW,KASAZ,EAAA/pD,UAAA6qD,8BAAA,WACA93C,KAAAu3C,yBAAAntB,GAAAytB,QACA73C,KAAA23C,kBAAAvtB,GAAA6C,WAGAjtB,KAAAw3C,qBAlHA,IAoHAx3C,KAAAy3C,oBACA9rD,EAAA,sCACAqU,KAAAy3C,mBAAA,GAEAz3C,KAAA23C,kBAAAvtB,GAAAsE,UAIAsoB,EAAA/pD,UAAA8qD,iBAAA,WAEA,MADAxrD,GAAA,MAAAyT,KAAAq3C,cAAA,MAAAr3C,KAAAs3C,aAAA,+DACA,MAAAt3C,KAAAq3C,aAGAL,EAAA/pD,UAAAyqD,cAAA,WACA,GAAAh3C,GAAAV,IACA,OAAAA,MAAA+3C,mBACAhxB,QAAA9sB,WAGA+F,KAAAq3C,YAAAr3C,KAAAs2C,UAAAN,2BACAh2C,KAAAs3C,YAAAt3C,KAAAs2C,UAAAP,2BAEA/1C,KAAA81B,WAAA4K,qBAAA/S,KAAA,SAAAnzB,GAMA,MALAkG,GAAA42C,YAAA/b,gBAAA/gC,EACAkG,EAAAs3C,0BACAt3C,EAAAu3C,mBAEAv3C,EAAAi3C,kBAAAvtB,GAAA6C,SACAvsB,EAAAk3B,wBAOAof,EAAA/pD,UAAAirD,eAAA,WAIA,MAHAl4C,MAAAm4C,yBAEAn4C,KAAA23C,kBAAAvtB,GAAAsE,QACA3H,QAAA9sB,WAKA+8C,EAAA/pD,UAAAkrD,uBAAA,WACAn4C,KAAA+3C,qBAGA/3C,KAAAq3C,YAAAhE,OACArzC,KAAAs3C,YAAAjE,OACArzC,KAAAo4C,0BACAp4C,KAAAq4C,0BACAr4C,KAAAs3C,YAAA,KACAt3C,KAAAq3C,YAAA,OAGAL,EAAA/pD,UAAAk5C,SAAA,WAMA,MALA57C,GArLA,cAqLA,8BACAyV,KAAAm4C,yBAGAn4C,KAAA23C,kBAAAvtB,GAAA6C,SACAlG,QAAA9sB,WAGA+8C,EAAA/pD,UAAAk8B,OAAA,SAAAxG,GACAp2B,GAAAa,EAAA4S,KAAAya,cAAAkI,EAAA3O,UAAA,0CAEAhU,KAAAya,cAAAkI,EAAA3O,UAAA2O,EACA3iB,KAAAg4C,yBAEAh4C,KAAAi4C,mBAEAj4C,KAAA+3C,oBAAA/3C,KAAAq3C,YAAAnE,UACAlzC,KAAAs4C,iBAAA31B,IAIAq0B,EAAA/pD,UAAA2gC,SAAA,SAAA5Z,GACAznB,EAAAa,EAAA4S,KAAAya,cAAAzG,GAAA,qDACAhU,MAAAya,cAAAzG,GACAhU,KAAA+3C,oBAAA/3C,KAAAq3C,YAAAnE,WACAlzC,KAAAu4C,mBAAAvkC,GACA/lB,EAAA+R,KAAAya,gBACAza,KAAAq3C,YAAA7D,aAQAwD,EAAA/pD,UAAAqrD,iBAAA,SAAA31B,GACA3iB,KAAAw4C,2BAAA71B,EAAA3O,UACAhU,KAAAq3C,YAAA1C,MAAAhyB,IAOAq0B,EAAA/pD,UAAAsrD,mBAAA,SAAAvkC,GACAhU,KAAAw4C,2BAAAxkC,GACAhU,KAAAq3C,YAAAvC,QAAA9gC,IAMAgjC,EAAA/pD,UAAAurD,2BAAA,SAAAxkC,GAEAhU,KAAA0a,uBAAA1G,IACAhU,KAAA0a,uBAAA1G,IAAA,MAEAgjC,EAAA/pD,UAAAgrD,iBAAA,WACA1rD,EAAAyT,KAAAg4C,yBAAA,qEACAh4C,KAAAq3C,YAAA9+C,OACAysB,OAAAhlB,KAAAy4C,kBAAA9hD,KAAAqJ,MACAmlB,QAAAnlB,KAAA04C,mBAAA/hD,KAAAqJ,MACA00C,cAAA10C,KAAA24C,oBAAAhiD,KAAAqJ,SAOAg3C,EAAA/pD,UAAA+qD,uBAAA,WACA,MAAAh4C,MAAA+3C,qBACA/3C,KAAAq3C,YAAAvE,cACA7kD,EAAA+R,KAAAya,gBAEAu8B,EAAA/pD,UAAAmrD,wBAAA,WAKAp4C,KAAAo3C,2BACAp3C,KAAA0a,2BAEAs8B,EAAA/pD,UAAAwrD,kBAAA,WACA,GAAA/3C,GAAAV,IAMA,OAHApS,GAAAoS,KAAAya,cAAA,SAAAzG,EAAA2O,GACAjiB,EAAA43C,iBAAA31B,KAEAoE,QAAA9sB,WAEA+8C,EAAA/pD,UAAAyrD,mBAAA,SAAA7sD,GAcA,MAbAU,GAAAyT,KAAA+3C,mBAAA,0EACA/3C,KAAAo4C,0BAEAp4C,KAAAg4C,0BACAh4C,KAAA83C,gCACA93C,KAAAi4C,oBAMAj4C,KAAA23C,kBAAAvtB,GAAA6C,SAEAlG,QAAA9sB,WAEA+8C,EAAA/pD,UAAA0rD,oBAAA,SAAA99B,EAAA3G,GAGA,GADAlU,KAAA23C,kBAAAvtB,GAAAytB,SACAh9B,YAAAX,KACAW,EAAAT,QAAAf,GAAAhiB,SACAwjB,EAAAP,MAGA,MAAAta,MAAA44C,kBAAA/9B,EAMA,IADA7a,KAAAo3C,wBAAAnnD,KAAA4qB,IACA3G,EAAApiB,QAAAshB,GAAAM,MACAQ,EAAA5Q,UAAAtD,KAAA81B,WAAAuN,iCAAA,GACA,GAAArY,GAAAhrB,KAAAo3C,uBAEA,OADAp3C,MAAAo3C,2BACAp3C,KAAA64C,uBAAA3kC,EAAA8W,GAGA,MAAAjE,SAAA9sB,WAQA+8C,EAAA/pD,UAAA4rD,uBAAA,SAAA3kC,EAAA8W,GACA,GAAAtqB,GAAAV,KACA84C,EAAA,GAAAv+B,IAAArG,EAAAlU,KAAAya,cAAAza,KAAA0a,uBACAo+B,GAAA79B,WAAA+P,EACA,IAAAsN,GAAAwgB,EAAA39B,mBAEAnb,MAAA0a,uBAAAo+B,EAAAp+B,sBACA,IAAAkW,KAoEA,OAlEAhjC,GAAAkrD,EAAAn+B,iBAAA,SAAA3G,EAAAhP,GACA,GAAA2d,GAAAjiB,EAAA+Z,cAAAzG,EACA,IAAA2O,EAAA,CAIA,GAAAhkB,GAAAgkB,EAAAhkB,KACA,IAAAA,EAAApD,kBACA,OAAAyJ,EAAAsS,MAAA,CAOA,GAAAjqB,GAAA,GAAAyY,IAAAnH,EAAApI,MACAwiD,EAAA,GAAA7xC,IAAA7Z,EAAA6mB,EACAokB,GAAAvf,kBAAAggC,OAGAxsD,GAAA,IAAAyY,EAAAsS,MAAA,gDAAAtS,EAAAsS,WAGA,CAEA,GAAAuY,GAAAnvB,EAAAo1B,WACAgB,mBAAA9iB,GACA2Z,KAAA,SAAAqrB,GACA,GAAA1gB,EAAAzf,cAAA7E,GAAA,CACA,GAAAiF,GAAAqf,EAAAzf,cAAA7E,GAAAiF,OACA,QAAAA,IACAA,YAAAO,IACAw/B,EAAA//B,EAAAU,cAAAq/B,IAGAzsD,EAAA0sB,YAAAC,IAAA,mEACAD,GACA+/B,EAAA//B,EAAAxd,YAIA,GAAAu9C,EAAA50C,OAAAY,EAAAsS,MAAA,CAGAghB,EAAAtf,8BAAAhF,EAGA,IAAAilC,GAAA,GAAAnlC,IAAAnV,EAAAqV,EAAA2O,EAAA1O,QACAvT,GAAA+Z,cAAAzG,GAAAilC,EAKAv4C,EAAA63C,mBAAAvkC,EAMA,IAAAklC,GAAA,GAAAplC,IAAAnV,EAAAqV,EAAAvJ,GAAAsY,wBACAriB,GAAA43C,iBAAAY,KAGAtoB,GAAA3gC,KAAA4/B,OAGA9I,QAAA6I,IAAAgB,GAAAjD,KAAA,WAgBA,MAbA//B,GAAA0qC,EAAAzf,cAAA,SAAA7E,EAAA/d,GACA,GAAAA,EAAAC,YAAArL,OAAA,GACA,GAAA83B,GAAAjiB,EAAA+Z,cAAAzG,EAEA2O,KACAjiB,EAAA+Z,cAAAzG,GAAA2O,EAAAxO,QACAje,YAAAD,EAAAC,YACAge,gBAAAje,EAAAie,sBAMAxT,EAAAmsB,WAAAwL,iBAAAC,MAIA0e,EAAA/pD,UAAA2rD,kBAAA,SAAA/9B,GACA,GAAAna,GAAAV,IACAzT,KAAAsuB,EAAAP,MAAA,wCACA,IAAAzuB,GAAAgvB,EAAAP,MACAiyB,EAAAxlB,QAAA9sB,SAaA,OAZA4gB,GAAAR,UAAArsB,QAAA,SAAAgmB,GACAu4B,IAAA5e,KAAA,WACA,MAAAvgC,GAAAsT,EAAA+Z,cAAAzG,UACAtT,GAAA+Z,cAAAzG,GACAtT,EAAAmsB,WAAA4L,aAAAzkB,EAAAnoB,IAIAk7B,QAAA9sB,cAIAsyC,GAEAyK,EAAA/pD,UAAAorD,wBAAA,WACAr4C,KAAAm3C,cAAAhd,GACA5vC,EAjbA,cAibA,8BACAyV,KAAAk3C,cAAArsD,OACA,mBACAmV,KAAAk3C,kBAMAF,EAAA/pD,UAAA2qC,kBAAA,WACA,GAAAl3B,GAAAV,IACA,OAAAA,MAAAm5C,oBAIAn5C,KAAA81B,WACAgW,kBAAA9rC,KAAAm3C,eACAxpB,KAAA,SAAA2J,GACA,cAAAA,GACA,IAAA52B,EAAAw2C,cAAArsD,QACA6V,EAAA42C,YAAA9D,WAEAzsB,QAAA9sB,YAGAyG,EAAA03B,OAAAd,GACA52B,EAAAk3B,uBAdA7Q,QAAA9sB,WA6BA+8C,EAAA/pD,UAAAksD,kBAAA,WACA,MAAAn5C,MAAA+3C,oBAAA/3C,KAAAk3C,cAAArsD,OAzdA,IA4dAmsD,EAAA/pD,UAAAmsD,kBAAA,WACA,MAAAp5C,MAAAk3C,cAAArsD,QAOAmsD,EAAA/pD,UAAAmrC,OAAA,SAAAd,GACA/qC,EAAAyT,KAAAm5C,oBAAA,+CACAn5C,KAAAm3C,cAAA7f,EAAAI,QACA13B,KAAAk3C,cAAAjnD,KAAAqnC,GACAt3B,KAAAq5C,yBACAr5C,KAAAs5C,mBAEAt5C,KAAA+3C,oBAAA/3C,KAAAs3C,YAAAiC,mBACAv5C,KAAAs3C,YAAAjC,eAAA/d,EAAAgD,YAGA0c,EAAA/pD,UAAAosD,uBAAA,WACA,MAAAr5C,MAAA+3C,qBACA/3C,KAAAs3C,YAAAxE,aACA9yC,KAAAk3C,cAAArsD,OAAA,GAEAmsD,EAAA/pD,UAAAqsD,iBAAA,WACA/sD,EAAAyT,KAAAq5C,yBAAA,qEACAr5C,KAAAs3C,YAAA/+C,OACAysB,OAAAhlB,KAAAw5C,kBAAA7iD,KAAAqJ,MACAmlB,QAAAnlB,KAAAy5C,mBAAA9iD,KAAAqJ,MACA01C,oBAAA11C,KAAA05C,yBAAA/iD,KAAAqJ,MACAy1C,iBAAAz1C,KAAAy1C,iBAAA9+C,KAAAqJ,SAGAg3C,EAAA/pD,UAAAusD,kBAAA,WAEA,MADAx5C,MAAAs3C,YAAA3B,iBACA5uB,QAAA9sB,WAEA+8C,EAAA/pD,UAAAysD,yBAAA,WACA,GAAAh5C,GAAAV,IAEA,OAAAA,MAAA81B,WACA6K,mBAAA3gC,KAAAs3C,YAAA/b,iBACA5N,KAAA,WAcA,OAAAhjC,GAAA,EAAAokB,EAAArO,EAAAw2C,cAAsDvsD,EAAAokB,EAAAlkB,OAAgBF,IAAA,CACtE,GAAA2sC,GAAAvoB,EAAApkB,EACA+V,GAAA42C,YAAAjC,eAAA/d,EAAAgD,eAIA0c,EAAA/pD,UAAAwoD,iBAAA,SAAA3a,EAAA9pC,GACA,GAAA0P,GAAAV,IAGAzT,GAAAyT,KAAAk3C,cAAArsD,OAAA,wCACA,IAAAysC,GAAAt3B,KAAAk3C,cAAAyC,QACAC,EAAAhf,GAAA9Y,KAAAwV,EAAAwD,EAAA9pC,EAAAgP,KAAAs3C,YAAA/b,gBACA,OAAAv7B,MAAA6sB,WAAAgM,qBAAA+gB,GAAAjsB,KAAA,WAGA,MAAAjtB,GAAAk3B,uBAGAof,EAAA/pD,UAAAwsD,mBAAA,SAAA5tD,GACA,GAAA6U,GAAAV,IAIA,IAHAzT,EAAAyT,KAAA+3C,mBAAA,0EAGAlsD,GAAAmU,KAAAk3C,cAAArsD,OAAA,GACA0B,IAAAV,EAAA,uEAEA,IAAAguD,OAAA,EAWA,OARAA,GAFA75C,KAAAs3C,YAAAiC,kBAEAv5C,KAAA85C,iBAAAjuD,GAMAmU,KAAA+5C,qBAAAluD,GAEAguD,EAAAlsB,KAAA,WAGAjtB,EAAA24C,0BACA34C,EAAA44C,qBAMA,MAAAvyB,SAAA9sB,WAGA+8C,EAAA/pD,UAAA8sD,qBAAA,SAAAluD,GAGA,MAAAoI,GAAApI,EAAAqI,OAAArI,EAAAqI,OAAAnH,GAAAgI,SACAxK,EA7kBA,cA6kBA,yEAA6EyV,KAAAs3C,YAAA/b,iBAC7Ev7B,KAAAs3C,YAAA/b,gBAAA9uC,IACAuT,KAAA81B,WAAA6K,mBAAAl0C,MAKAs6B,QAAA9sB,WAGA+8C,EAAA/pD,UAAA6sD,iBAAA,SAAAjuD,GACA,GAAA6U,GAAAV,IACA,IAAA/L,EAAApI,EAAAqI,MAAA,CAGA,GAAAojC,GAAAt3B,KAAAk3C,cAAAyC,OAKA,OADA35C,MAAAs3C,YAAA/D,iBACAvzC,KAAA6sB,WACAoM,kBAAA3B,EAAAI,QAAA7rC,GACA8hC,KAAA,WAGA,MAAAjtB,GAAAk3B,sBAKA,MAAA7Q,SAAA9sB,WAGA+8C,EAAA/pD,UAAAirC,kBAAA,WACA,UAAAke,IAAAp2C,KAAAs2C,YAEAU,EAAA/pD,UAAAgtC,iBAAA,SAAAC,GAIA,GAHA3vC,EAlnBA,cAknBA,mCAAA2vC,EAAA2F,KAGA7/B,KAAA+3C,mBAMA,MAFA/3C,MAAAm4C,yBACAn4C,KAAA23C,kBAAAvtB,GAAA6C,SACAjtB,KAAA03C,iBAGAV,KC1nBAgD,GAAA,WACA,QAAAC,GAAAnuD,EAAAk+B,EAAAruB,EASAyzC,GACApvC,KAAAlU,WACAkU,KAAAgqB,eACAhqB,KAAArE,cACAqE,KAAAovC,aAwPA,MApNA6K,GAAAhtD,UAAAsL,MAAA,SAAA2hD,GACA,GAAAx5C,GAAAV,KAQAm6C,EAAA,GAAAnL,IAOAoL,EAAA,GAAApL,IACAqL,GAAA,CAqBA,OApBAr6C,MAAArE,YAAA2+C,sBAAA,SAAApgB,GACAmgB,EAOA35C,EAAA0uC,WAAAc,QAAA,WACA,MAAAxvC,GAAAu5B,iBAAAC,MAPAmgB,GAAA,EACA35C,EAAA65C,sBAAAL,EAAAE,GACAzsB,KAAA,WAAuC,MAAAjtB,GAAA85C,eAAAtgB,KACvCvM,KAAAwsB,EAAAlgD,QAAAkgD,EAAAjgD,WASA8F,KAAAovC,WAAAc,QAAA,WACA,MAAAiK,GAAAtqB,UAKAuqB,EAAAvqB,SAGAoqB,EAAAhtD,UAAAyqD,cAAA,WACA,GAAAh3C,GAAAV,IACA,OAAAA,MAAAovC,WAAAc,QAAA,WACA,MAAAxvC,GAAAq1B,YAAA2hB,mBAoBAuC,EAAAhtD,UAAAstD,sBAAA,SAAAL,EAAAE,GACA,GAAA15C,GAAAV,IACA,OAAAk6C,GACAl6C,KAAAy6C,4BACA9sB,KAAAysB,EAAAngD,SACAm1B,MAAA,SAAAvjC,GAKA,MAFAuuD,GAAAlgD,OAAArO,GAEA6U,EAAAg6C,YAAA7uD,IAGAP,QAAAqvD,KAAA,qEAEA9uD,GACA6U,EAAAk6C,0BALA7zB,QAAA7sB,OAAArO,MAaAuuD,EAAAngD,UACA+F,KAAA46C,2BAGAX,EAAAhtD,UAAAytD,YAAA,SAAA7uD,GACA,MAAAA,GAAAqI,OAAAnH,GAAA+H,qBACAjJ,EAAAqI,OAAAnH,GAAA4F,eAOAsnD,EAAAhtD,UAAAwtD,0BAAA,WAGAz6C,KAAA+xB,iBAAA,GAAA+c,GACA,IAAA+L,GAAAvV,GAAAsB,mBAAA5mC,KAAAgqB,cAEA2V,EAAA,GAAAvjB,IAAApc,KAAAgqB,aAAAnnB,YACAyZ,eAAA,GAGA,OADAtc,MAAAwpC,YAAA,GAAAlE,IAAAuV,EAAAlb,GACA3/B,KAAAwpC,YAAAjxC,SAOA0hD,EAAAhtD,UAAA2tD,uBAAA,WAGA,MAFA56C,MAAA+xB,iBAAA,GAAA9B,IACAjwB,KAAAwpC,YAAA,GAAAiF,IACAzuC,KAAAwpC,YAAAjxC,SAOA0hD,EAAAhtD,UAAAutD,eAAA,SAAAtgB,GACA,GAAAx5B,GAAAV,IACA,OAAAA,MAAAlU,SACAi+B,eAAA/pB,KAAAgqB,cACA2D,KAAA,SAAA6kB,GACA9xC,EAAAo1B,WAAA,GAAAyT,IAAA7oC,EAAA8oC,YAAAtP,EAAAx5B,EAAAqxB,iBACA,IAAA4N,GAAAj/B,EAAA5U,SAAAm+B,cAAAvpB,EAAAspB,aAAAnnB,YACAyzC,EAAA,GAAAT,IAAAn1C,EAAA0uC,WAAAoD,EAAA9xC,EAAA/E,YAAAgkC,GACAmb,EAAA,SAAA9tB,GACAtsB,EAAAmsB,WAAAW,uBAAAR,GACAtsB,EAAAq6C,SAAAvtB,uBAAAR,GAUA,OARAtsB,GAAAq1B,YAAA,GAAAghB,IAAAr2C,EAAAo1B,WAAAwgB,EAAAwE,GACAp6C,EAAAmsB,WAAA,GAAAgJ,IAAAn1B,EAAAo1B,WAAAp1B,EAAAq1B,YAAAmE,GAEAx5B,EAAAq1B,YAAAlJ,WAAAnsB,EAAAmsB,WACAnsB,EAAAq6C,SAAA,GAAApuB,IAAAjsB,EAAAmsB,YAIAnsB,EAAAo1B,WAAAv9B,UAEAo1B,KAAA,WACA,MAAAjtB,GAAAq1B,YAAAx9B,WAGA0hD,EAAAhtD,UAAAgtC,iBAAA,SAAAC,GAGA,MAFAl6B,MAAAovC,WAAA0B,4BACAvmD,EApNA,kBAoNA,iBAAA2vC,EAAA2F,KACA7/B,KAAA6sB,WAAAoN,iBAAAC,IAGA+f,EAAAhtD,UAAAirD,eAAA,WACA,GAAAx3C,GAAAV,IACA,OAAAA,MAAAovC,WAAAc,QAAA,WACA,MAAAxvC,GAAAq1B,YAAAmiB,oBAGA+B,EAAAhtD,UAAAk5C,SAAA,WACA,GAAAzlC,GAAAV,IACA,OAAAA,MAAAovC,WACAc,QAAA,WAEA,MADAxvC,GAAA/E,YAAAq/C,2BACAt6C,EAAAq1B,YAAAoQ,aAEAxY,KAAA,WAEA,MAAAjtB,GAAA8oC,YAAArD,cAGA8T,EAAAhtD,UAAAk8B,OAAA,SAAAxqB,EAAAs8C,EAAA7pD,GACA,GAAAsP,GAAAV,KACAqtB,EAAA,GAAAW,IAAArvB,EAAAs8C,EAAA7pD,EAIA,OAHA4O,MAAAovC,WAAAc,QAAA,WACA,MAAAxvC,GAAAq6C,SAAA5xB,OAAAkE,KAEAA,GAEA4sB,EAAAhtD,UAAA2gC,SAAA,SAAAP,GACA,GAAA3sB,GAAAV,IACAA,MAAAovC,WAAAc,QAAA,WACA,MAAAxvC,GAAAq6C,SAAAntB,SAAAP,MAGA4sB,EAAAhtD,UAAAoqC,MAAA,SAAAiD,GACA,GAAA55B,GAAAV,KACAwvC,EAAA,GAAAR,GAEA,OADAhvC,MAAAovC,WAAAc,QAAA,WAA6C,MAAAxvC,GAAAmsB,WAAAwK,MAAAiD,EAAAkV,KAC7CA,EAAA3f,SAEAoqB,EAAAhtD,UAAA4V,WAAA,WACA,MAAA7C,MAAAgqB,aAAAnnB,YAEAo3C,EAAAhtD,UAAAgrC,YAAA,SAAAF,GACA,GAAAr3B,GAAAV,IAEA,OAAAA,MAAAovC,WACAc,QAAA,WACA,MAAAnpB,SAAA9sB,YAEA0zB,KAAA,WACA,MAAAjtB,GAAAmsB,WAAAiL,eAAAC,MAGAkiB,KCpRAiB,GAAA,WACA,QAAAA,GAAAD,GACAj7C,KAAAi7C,WAKAj7C,KAAAm7C,OAAA,EAqBA,MAnBAD,GAAAjuD,UAAA4Y,KAAA,SAAApY,GACAuS,KAAAo7C,cAAAp7C,KAAAi7C,SAAAp1C,KAAApY,IAEAytD,EAAAjuD,UAAApB,MAAA,SAAAA,GACAmU,KAAAo7C,cAAAp7C,KAAAi7C,SAAApvD,UAEAqvD,EAAAjuD,UAAAouD,KAAA,WACAr7C,KAAAm7C,OAAA,GAEAD,EAAAjuD,UAAAmuD,cAAA,SAAAE,EAAAlhD,GACA,GAAAsG,GAAAV,IACAA,MAAAm7C,OACA9xB,WAAA,WACA3oB,EAAAy6C,OACAG,EAAAlhD,IAEa,IAGb8gD,KC7BAK,GAAA,WACA,QAAAA,GAAA1b,GACA7/B,KAAA6/B,MA0BA,MAxBA0b,GAAAtuD,UAAA6yC,gBAAA,WACA,aAAA9/B,KAAA6/B,KAMA0b,EAAAtuD,UAAAmsC,MAAA,WACA,MAAAp5B,MAAA8/B,kBACA,OAAA9/B,KAAA6/B,IAGA,kBAGA0b,EAAAtuD,UAAA6E,QAAA,SAAA0pD,GACA,MAAAA,GAAA3b,MAAA7/B,KAAA6/B,KAGA0b,EAAA7mD,gBAAA,GAAA6mD,GAAA,MAGAA,EAAAE,mBAAA,GAAAF,GAAA,0BACAA,EAAAG,YAAA,GAAAH,GAAA,mBACAA,KvD7BAI,GAAA,WACA,QAAAA,GAAAluD,EAAAysC,GACAl6B,KAAAk6B,OACAl6B,KAAA/Q,KAAA,QACA+Q,KAAA0mB,aAA4Bk1B,cAAA,UAAAnuD,GAE5B,MAAAkuD,MAIA//C,GAAA,WACA,QAAAigD,KAMA77C,KAAA87C,aAAA,KAeA,MAbAD,GAAA5uD,UAAA6mD,SAAA,SAAAiI,GACA,MAAAh1B,SAAA9sB,QAAA,OAEA4hD,EAAA5uD,UAAAqtD,sBAAA,SAAAjtB,GACA9gC,GAAAyT,KAAA87C,aAAA,+CACA97C,KAAA87C,aAAAzuB,EAEAA,EAAAkuB,GAAA7mD,kBAEAmnD,EAAA5uD,UAAA+tD,yBAAA,WACAzuD,EAAA,OAAAyT,KAAA87C,aAAA,0DACA97C,KAAA87C,aAAA,MAEAD,KAGAG,GAAA,WACA,QAAAC,GAAA38C,GACA,GAAAoB,GAAAV,IACAA,MAAAV,MAKAU,KAAAk8C,cAAA,KAKAl8C,KAAAm8C,YAAA,EAEAn8C,KAAA87C,aAAA,KAGA97C,KAAAk8C,cAAA,WACA,GAAAE,GAAA17C,EAAA27C,SACA37C,GAAAs1B,aAAAomB,EAAAtqD,QAAA4O,EAAAs1B,eACAt1B,EAAAs1B,YAAAomB,EACA17C,EAAAy7C,cACAz7C,EAAAo7C,cACAp7C,EAAAo7C,aAAAp7C,EAAAs1B,eAIAh2B,KAAAm8C,YAAA,EAEAn8C,KAAAV,IAAA9K,SAAA8nD,qBAAAt8C,KAAAk8C,eAoDA,MAlDAD,GAAAhvD,UAAA6mD,SAAA,SAAAiI,GACA,GAAAr7C,GAAAV,IACAzT,GAAA,MAAAyT,KAAAk8C,cAAA,oDAIA,IAAAK,GAAAv8C,KAAAm8C,WACA,OAAAn8C,MAAAV,IAAA9K,SAAAs/C,SAAAiI,GAAApuB,KAAA,SAAA6uB,GAIA,GAAA97C,EAAAy7C,cAAAI,EACA,SAAAzvD,IAAAC,GAAAgI,QAAA,sCAGA,OAAAynD,IACAjwD,EAAA,gBAAAiwD,GAAAC,YAAA,8CAAAD,GACA,GAAAb,IAAAa,EAAAC,YAAA/7C,EAAAs1B,cAGA,QAKAimB,EAAAhvD,UAAAqtD,sBAAA,SAAAjtB,GACA9gC,GAAAyT,KAAA87C,aAAA,+CACA97C,KAAA87C,aAAAzuB,EAEArtB,KAAAg2B,aACA3I,EAAArtB,KAAAg2B,cAGAimB,EAAAhvD,UAAA+tD,yBAAA,WACAzuD,EAAA,MAAAyT,KAAAk8C,cAAA,2CACA3vD,EAAA,OAAAyT,KAAA87C,aAAA,iEACA97C,KAAAV,IAAA9K,SAAAkoD,wBAAA18C,KAAAk8C,eACAl8C,KAAAk8C,cAAA,KACAl8C,KAAA87C,aAAA,MAEAG,EAAAhvD,UAAAovD,QAAA,WAEA,kBAAAr8C,MAAAV,IAAA9K,SAAAmoD,QACAxwD,EAAA,oFAGA,IAAAywD,GAAA58C,KAAAV,IAAA9K,SAAAmoD,QAEA,OADApwD,GAAA,OAAAqwD,GAAA,gBAAAA,GAAA,yBAAAA,GACA,GAAArB,IAAAqB,IAEAX,KAUAY,GAAA,WACA,QAAAC,GAAAC,EAAAhhD,GACAiE,KAAA+8C,OACA/8C,KAAAjE,eACAiE,KAAA/Q,KAAA,aACA+Q,KAAAk6B,KAAAqhB,GAAAG,YACAnvD,EAAAyT,KAAA+8C,MACA/8C,KAAA+8C,KAAA,MACA/8C,KAAA+8C,KAAA,kEAYA,MAVAzvD,QAAAqS,eAAAm9C,EAAA7vD,UAAA,eACAwK,IAAA,WACA,OACAmkD,cAAA57C,KAAA+8C,KAAA,yCACAC,kBAAAh9C,KAAAjE,eAGA2G,YAAA,EACAC,cAAA,IAEAm6C,KAQAjhD,GAAA,WACA,QAAAohD,GAAAF,EAAAhhD,GACAiE,KAAA+8C,OACA/8C,KAAAjE,eACAxP,EAAAyT,KAAA+8C,MACA/8C,KAAA+8C,KAAA,MACA/8C,KAAA+8C,KAAA,kEAYA,MAVAE,GAAAhwD,UAAA6mD,SAAA,SAAAiI,GACA,MAAAh1B,SAAA9sB,QAAA,GAAA4iD,IAAA78C,KAAA+8C,KAAA/8C,KAAAjE,gBAIAkhD,EAAAhwD,UAAAqtD,sBAAA,SAAAjtB,GAEAA,EAAAkuB,GAAAG,cAEAuB,EAAAhwD,UAAA+tD,yBAAA,aACAiC,KwDhLAC,GAAAl9C,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,QASAtD,GAAA,WACA,QAAAA,MAWA,MATAA,GAAA+B,OAAA,WACA,MAAAm+C,IAAAz9C,UAEAzC,EAAAmgD,gBAAA,WACA,MAAAC,IAAA39C,UAEAzC,EAAAhQ,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,QAAAiC,GAEAhF,KAGAkgD,GAAA,SAAA18C,GAEA,QAAA08C,KACA,MAAA18C,GAAAlT,KAAAyS,YAIA,MANAk9C,IAAAC,EAAA18C,GAKA08C,EAAAz9C,SAAA,GAAAy9C,GACAA,GACClgD,IAEDogD,GAAA,SAAA58C,GAEA,QAAA48C,KACA,MAAA58C,GAAAlT,KAAAyS,YAIA,MANAk9C,IAAAG,EAAA58C,GAKA48C,EAAA39C,SAAA,GAAA29C,GACAA,GACCpgD,IAUDqgD,GAAA5wD,EAAAuQ,GAAA,qCtD3CAsgD,GAAA,WAEAC,GAAA,WACA,QAAAC,GAAAh3C,EAAA0P,EAAAS,GACA5W,KAAAyG,OACAzG,KAAAmW,YACAnW,KAAA4W,kBAeA,MAbA6mC,GAAAxwD,UAAA4pD,YAAA,SAAAxpD,EAAAuoB,GACA,GAAA0kB,KAUA,OATA,QAAAt6B,KAAAmW,UACAmkB,EAAArqC,KAAA,GAAAgmB,IAAA5oB,EAAA2S,KAAAyG,KAAAzG,KAAAmW,UAAAP,IAGA0kB,EAAArqC,KAAA,GAAAylB,IAAAroB,EAAA2S,KAAAyG,KAAAmP,IAEA5V,KAAA4W,gBAAA/rB,OAAA,GACAyvC,EAAArqC,KAAA,GAAAymB,IAAArpB,EAAA2S,KAAA4W,kBAEA0jB,GAEAmjB,KAIAC,GAAA,WACA,QAAAC,GAAAl3C,EAAA0P,EAAAS,GACA5W,KAAAyG,OACAzG,KAAAmW,YACAnW,KAAA4W,kBAWA,MATA+mC,GAAA1wD,UAAA4pD,YAAA,SAAAxpD,EAAAuoB,GACA,GAAA0kB,IACA,GAAArkB,IAAA5oB,EAAA2S,KAAAyG,KAAAzG,KAAAmW,UAAAP,GAKA,OAHA5V,MAAA4W,gBAAA/rB,OAAA,GACAyvC,EAAArqC,KAAA,GAAAymB,IAAArpB,EAAA2S,KAAA4W,kBAEA0jB,GAEAqjB,MASA,SAAAnhD,GACAA,IAAA,aACAA,IAAA,mBACAA,IAAA,uBACAA,IAAA,4BACCA,YAcD,IAAAohD,IAAA,WAuBA,QAAAC,GAAAthD,EAAAe,EAAA/G,EAAAunD,EAAAlnC,EAAAT,GACAnW,KAAAzD,aACAyD,KAAA1C,aACA0C,KAAAzJ,OACAyJ,KAAA89C,mBAGAnwD,KAAAipB,GACA5W,KAAA+9C,eAEA/9C,KAAA89C,iBAAAnwD,KAAAmwD,KACA99C,KAAA4W,sBACA5W,KAAAmW,gBA8CA,MA5CA0nC,GAAA5wD,UAAA+wD,qBAAA,SAAA1qD,GACA,GAAA2qD,GAAA,MAAAj+C,KAAAzJ,KAAA,KAAAyJ,KAAAzJ,KAAAwN,MAAAzQ,GACA6J,EAAA,GAAA0gD,GAAA79C,KAAAzD,WAAAyD,KAAA1C,WAAA2gD,GACA,EAAAj+C,KAAA4W,gBAAA5W,KAAAmW,UAEA,OADAhZ,GAAA+gD,oBAAA5qD,GACA6J,GAEA0gD,EAAA5wD,UAAAkxD,yBAAA,SAAA7qD,GACA,GAAA2qD,GAAA,MAAAj+C,KAAAzJ,KAAA,KAAAyJ,KAAAzJ,KAAAwN,MAAAzQ,GACA6J,EAAA,GAAA0gD,GAAA79C,KAAAzD,WAAAyD,KAAA1C,WAAA2gD,GACA,EAAAj+C,KAAA4W,gBAAA5W,KAAAmW,UAEA,OADAhZ,GAAA4gD,eACA5gD,GAEA0gD,EAAA5wD,UAAAmxD,qBAAA,SAAA55C,GAGA,UAAAq5C,GAAA79C,KAAAzD,WAAAyD,KAAA1C,WACA,MACA,EAAA0C,KAAA4W,gBAAA5W,KAAAmW,YAEA0nC,EAAA5wD,UAAAmQ,YAAA,SAAAkqC,GACA,GAAA+W,GAAA,OAAAr+C,KAAAzJ,MAAAyJ,KAAAzJ,KAAAtI,UACA,GACA,oBAAA+R,KAAAzJ,KAAA,GACA,WAAAzJ,IAAAC,GAAAC,iBAAA,YAAAgT,KAAA1C,WAAA,gCACAgqC,EACA+W,IAEAR,EAAA5wD,UAAA8wD,aAAA,WAGA,UAAA/9C,KAAAzJ,KAGA,OAAAvE,GAAA,EAAuBA,EAAAgO,KAAAzJ,KAAA1L,OAAsBmH,IAC7CgO,KAAAk+C,oBAAAl+C,KAAAzJ,KAAAkB,IAAAzF,KAGA6rD,EAAA5wD,UAAAixD,oBAAA,SAAAxmD,GACA,GAAA4E,GAAA0D,KAAAzD,aAAAghD,GAAAl4C,KAAA3N,GACA,KAAAsI,MAAA5C,YAAA,iDAGAygD,KAOA7gD,GAAA,WACA,QAAAA,GAAA6F,EAAAxV,GACA2S,KAAA6C,aACA7C,KAAA3S,MAEA,MAAA2P,MAOAshD,GAAA,WACA,QAAAC,GAAAC,GACAx+C,KAAAw+C,eA4OA,MAzOAD,GAAAtxD,UAAAwxD,aAAA,SAAAnhD,EAAA1N,GACA,GAAAuN,GAAA,GAAAygD,IAAAphD,GAAAC,IAAAa,EAAA4H,GAAA/M,WACA+E,IAAA,sCAAAC,EAAAvN,EACA,IAAA8uD,GAAA1+C,KAAA2+C,UAAA/uD,EAAAuN,EACA,WAAAqgD,IAAAkB,EACA,KAAAvhD,EAAAyZ,kBAGA2nC,EAAAtxD,UAAA2xD,eAAA,SAAAthD,EAAA1N,GACA,GAAAuN,GAAA,GAAAygD,IAAAphD,GAAAE,SAAAY,EAAA4H,GAAA/M,WACA+E,IAAA,sCAAAC,EAAAvN,EACA,IAAA8uD,GAAA1+C,KAAA2+C,UAAA/uD,EAAAuN,GACAgZ,EAAA,GAAA7B,IAAAnX,EAAAgZ,UACA,WAAAqnC,IAAAkB,EAAAvoC,EAAAhZ,EAAAyZ,kBAGA2nC,EAAAtxD,UAAA4xD,gBAAA,SAAAvhD,EAAA1N,GACA,GAAA8Q,GAAAV,KACA7C,EAAA,GAAAygD,IAAAphD,GAAAG,OAAAW,EAAA4H,GAAA/M,WACA+E,IAAA,sCAAAC,EAAAvN,EACA,IAAAkvD,MACAJ,EAAA7xC,GAAAxG,KACArY,GAAA4B,EAAA,SAAAvC,EAAAI,GACA,GAAA8I,GAAAiH,GAAAF,EAAAjQ,GACA0xD,EAAA5hD,EAAAghD,yBAAA5nD,EAEA,KADA9I,EAAAiT,EAAAs+C,gBAAAvxD,EAAAsxD,aACA5B,IAEA2B,EAAA7uD,KAAAsG,OAEA,CACA,GAAA0oD,GAAAv+C,EAAAi+C,UAAAlxD,EAAAsxD,EACA,OAAAE,IACAH,EAAA7uD,KAAAsG,GACAmoD,IAAAvxC,IAAA5W,EAAA0oD,MAIA,IAAAC,GAAA,GAAA5qC,IAAAwqC,EACA,WAAApB,IAAAgB,EAAAQ,EAAA/hD,EAAAyZ,kBAGA2nC,EAAAtxD,UAAAkyD,mBAAA,SAAA7hD,EAAAhK,EAAA7F,EAAA2xD,GACA,GAAAjiD,GAAA,GAAAygD,IAAAphD,GAAAG,OAAAW,EAAA4H,GAAA/M,YACAwf,GAAAta,GAAAC,EAAAhK,IACAwrB,GAAArxB,EACA,IAAA2xD,EAAAv0D,OAAA,KACA,SAAAiC,IAAAC,GAAAC,iBAAA,YAAAsQ,EAAA,wGAGA,QAAAtL,GAAA,EAAuBA,EAAAotD,EAAAv0D,OAAgCmH,GAAA,EACvD2lB,EAAA1nB,KAAAoN,GAAAC,EAAA8hD,EAAAptD,KACA8sB,EAAA7uB,KAAAmvD,EAAAptD,EAAA,GAIA,QAFA8sD,MACAJ,EAAA7xC,GAAAxG,MACArU,EAAA,EAAuBA,EAAA2lB,EAAA9sB,SAAiBmH,EAAA,CACxC,GAAAuE,GAAAohB,EAAA3lB,GACA+sD,EAAA5hD,EAAAghD,yBAAA5nD,GACA8oD,EAAAr/C,KAAAg/C,gBAAAlgC,EAAA9sB,GAAA+sD,EACA,IAAAM,YAAAlC,IAEA2B,EAAA7uD,KAAAsG,OAEA,CACA,GAAA0oD,GAAAj/C,KAAA2+C,UAAAU,EAAAN,EACA,OAAAE,IACAH,EAAA7uD,KAAAsG,GACAmoD,IAAAvxC,IAAA5W,EAAA0oD,KAIA,GAAAC,GAAA,GAAA5qC,IAAAwqC,EACA,WAAApB,IAAAgB,EAAAQ,EAAA/hD,EAAAyZ,kBAMA2nC,EAAAtxD,UAAAqyD,gBAAA,SAAAhiD,EAAA1N,GACA,GAAAuN,GAAA,GAAAygD,IAAAphD,GAAAI,WAAAU,EAAA4H,GAAA/M,YACAonD,EAAAv/C,KAAA2+C,UAAA/uD,EAAAuN,EAGA,OAFA5Q,GAAA,MAAAgzD,EAAA,mCACAhzD,EAAA,IAAA4Q,EAAAyZ,gBAAA/rB,OAAA,iDACA00D,GAGAhB,EAAAtxD,UAAA+xD,gBAAA,SAAApvD,EAAAuN,GACA,IACA,MAAA6C,MAAAw+C,aAAA5uD,GAEA,MAAA1D,GACA,GAAAG,GAAAoR,GAAAvR,EACA,MAAAiR,GAAAC,YAAA/Q,KAYAkyD,EAAAtxD,UAAA0xD,UAAA,SAAA/uD,EAAAuN,GAEA,IADAvN,EAAAoQ,KAAAg/C,gBAAApvD,EAAAuN,aACApO,OAAA,CAGA,GAAAoO,EAAA2gD,aACA,KAAA3gD,GAAAC,YAAA,kCAOA,OAHAD,GAAA5G,MACA4G,EAAAgZ,UAAAlmB,KAAAkN,EAAA5G,MAEAyJ,KAAAw/C,WAAA5vD,EAAAuN,GAEA,MAAAN,IAAAjN,IACAsN,GAAA,2BAAAC,EAAAvN,GACAoQ,KAAAy/C,YAAA7vD,EAAAuN,KAKAA,EAAA5G,MACA4G,EAAAgZ,UAAAlmB,KAAAkN,EAAA5G,MAEAyJ,KAAA0/C,iBAAA9vD,EAAAuN,KAGAohD,EAAAtxD,UAAAuyD,WAAA,SAAA79C,EAAAxE,GAGA,OAFAhP,MACAwxD,EAAA,EACAh1D,EAAA,EAAAi1D,EAAAj+C,EAAyChX,EAAAi1D,EAAA/0D,OAAqBF,IAAA,CAC9D,GAAAk1D,GAAAD,EAAAj1D,GACAm1D,EAAA9/C,KAAA2+C,UAAAkB,EAAA1iD,EAAAihD,qBAAAuB,GACA,OAAAG,IAGAA,EAAAtsD,GAAAC,UAEAtF,EAAA8B,KAAA6vD,GACAH,IAEA,UAAAlyC,IAAAtf,IAEAowD,EAAAtxD,UAAAwyD,YAAA,SAAA/0D,EAAAyS,GACA,GAAAuD,GAAAV,KACA7R,EAAA,GAAAiZ,IAAA1V,EAOA,OANA1D,GAAAtD,EAAA,SAAA2C,EAAA2C,GACA,GAAAivD,GAAAv+C,EAAAi+C,UAAA3uD,EAAAmN,EAAA6gD,qBAAA3wD,GACA,OAAA4xD,IACA9wD,IAAAoZ,OAAAla,EAAA4xD,MAGA,GAAApyC,IAAA1e,IAQAowD,EAAAtxD,UAAAyyD,iBAAA,SAAAjyD,EAAA0P,GACA,UAAA1P,EACA,MAAA+F,IAAAC,QAEA,oBAAAhG,GACA,MAAAwF,GAAAxF,GACA,GAAAoe,IAAApe,GAGA,GAAAoG,IAAApG,EAGA,qBAAAA,GACA,MAAA8d,IAAAE,GAAAhe,EAEA,oBAAAA,GACA,UAAAye,IAAAze,EAEA,IAAAA,YAAAxC,MACA,UAAAmhB,IAAAgG,GAAAM,SAAAjlB,GAEA,IAAAA,YAAAqP,IACA,UAAA8P,IAAAnf,EAEA,IAAAA,YAAAsP,IACA,UAAA0P,IAAAhf,EAEA,IAAAA,YAAAuP,IACA,UAAA0P,IAAAjf,EAAAoV,WAAApV,EAAAJ,IAEA,IAAAI,YAAAwP,IAAA,CACA,GAAAxP,YAAA0vD,IAAA,CACA,GAAAhgD,EAAAZ,aAAAC,GAAAE,SACA,WAEA,MAAAS,GAAAZ,aAAAC,GAAAG,QACApQ,EAAA,MAAA4Q,EAAA5G,MAAA4G,EAAA5G,KAAA1L,OAAA,4EAEAsS,EAAAC,YAAA,6EAKAD,EAAAC,YAAA,kFAGA,GAAA3P,YAAA4vD,IAAA,CACA,IAAA/gD,GAAAa,EAAAZ,YACA,KAAAY,GAAAC,YAAA,wEAGA,WAAAD,EAAA5G,KACA,KAAA4G,GAAAC,YAAA,wEAKA,OAFAD,GAAAyZ,gBAAA3mB,KAAA,GAAAykB,IAAAvX,EAAA5G,KAAAke,GAAA/U,WAEA,KAGA,MAAAvT,GAAA,4BAAAsB,GAIA,KAAA0P,GAAAC,YAAA,4BAAAlN,EAAAzC,KAGA8wD,KCtaAwB,GAAA//C,WAAAD,WAAA,WACA,GAAAE,GAAA3S,OAAA4S,iBACUC,uBAAgBpR,QAAA,SAAAqR,EAAAC,GAAsCD,EAAAD,UAAAE,IAChE,SAAAD,EAAAC,GAAyB,OAAAC,KAAAD,KAAAlT,eAAAmT,KAAAF,EAAAE,GAAAD,EAAAC,IACzB,iBAAAF,EAAAC,GAEA,QAAAE,KAAuBP,KAAAlP,YAAAsP,EADvBH,EAAAG,EAAAC,GAEAD,EAAAnT,UAAA,OAAAoT,EAAA/S,OAAAkT,OAAAH,IAAAE,EAAAtT,UAAAoT,EAAApT,UAAA,GAAAsT,QA+BAy/C,GAAA,2BACAC,IAAA,EAMAC,GAAA,WACA,QAAAC,GAAAC,GACA,OAAAzyD,KAAAyyD,EAAAr9C,KAAA,CACA,OAAApV,KAAAyyD,EAAAp9C,IACA,SAAAlW,IAAAC,GAAAC,iBAAA,qDAEAgT,MAAA+C,KAAAi9C,GACAhgD,KAAAgD,IAAAi9C,OAGA1wD,GAAA,2BAAA6wD,EAAAr9C,MACA/C,KAAA+C,KAAAq9C,EAAAr9C,KACAtT,EAAA,2BAAA2wD,EAAAp9C,KACAhD,KAAAgD,IAAAxV,EAAA4yD,EAAAp9C,IAAAi9C,GAEA9uD,GAAA,WAAAivD,GAAA,6BACA3wD,EAAA,kCAAA2wD,EAAAzkD,aACAqE,KAAArE,YAAAykD,EAAAzkD,YAOA,MALAwkD,GAAAlzD,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAA+C,OAAAd,EAAAc,MACA/C,KAAAgD,MAAAf,EAAAe,KACAhD,KAAArE,cAAAsG,EAAAtG,aAEAwkD,KAEAE,GAAA,WACA,QAAAA,MAEA,MAAAA,MAKA9gD,GAAA,WACA,QAAA+gD,GAAAC,GACA,GAAA7/C,GAAAV,IAGAA,MAAAwgD,EAAA,GAAArQ,IACAnwC,KAAAxL,UACAwK,OAAA,WACA,MAAA0B,GAAA+/C,EACA//C,EAAA+/C,EAAAta,WAGApf,QAAA9sB,WAIA,IAAAymD,GAAA,GAAAL,GACA,oBAAAE,GAAAnvD,QAAA,CAGA,GAAAkO,GAAAihD,CACAG,GAAAC,YAAArhD,EACAohD,EAAA79C,WAAAy9C,EAAAM,kBAAAthD,GACAohD,EAAA59C,eAAA49C,EAAAC,YAAA9xD,KACA6xD,EAAA/kD,YAAA,GAAAqgD,IAAA18C,OAEA,CACA,GAAAuhD,GAAAN,CACA,KAAAM,EAAAz9C,UACA,SAAAtW,IAAAC,GAAAC,iBAAA,yBAEA0zD,GAAA79C,WAAA,GAAAK,IAAA29C,EAAAz9C,UAAAy9C,EAAAx9C,UAEAq9C,EAAA59C,eAAA,YACA49C,EAAA/kD,YAAA,GAAAC,IAEA8kD,EAAAN,SAAA,GAAAF,QACAlgD,KAAA8gD,EAAAJ,EACA1gD,KAAA+gD,YAAAL,EAAA79C,WAmKA,MAjKAy9C,GAAArzD,UAAAmzD,SAAA,SAAAY,GAGA,GAFA5yD,EAAA,qBAAAxD,UAAA,GACAoE,EAAA,gCAAAgyD,GACA5zD,EAAA4zD,EAAA,eACA,SAAAl0D,IAAAC,GAAAC,iBAAA,wFAGA,IAAAi0D,GAAA,GAAAf,IAAAc,EACA,IAAAhhD,KAAAygD,IAAAzgD,KAAA8gD,EAAAV,SAAAtuD,QAAAmvD,GACA,SAAAn0D,IAAAC,GAAA+H,oBAAA,qKAIAkL,MAAA8gD,EAAAV,SAAAa,MACAtzD,KAAAszD,EAAAtlD,cACAqE,KAAA8gD,EAAAnlD,YAAAD,GAAAulD,EAAAtlD,eAGA2kD,EAAArzD,UAAAyqD,cAAA,WAEA,MADA13C,MAAAkhD,yBACAlhD,KAAAygD,EAAA/I,iBAEA4I,EAAArzD,UAAAirD,eAAA,WAEA,MADAl4C,MAAAkhD,yBACAlhD,KAAAygD,EAAAvI,kBAEAoI,EAAArzD,UAAAk0D,kBAAA,WACA,GAAAnhD,KAAAygD,EACA,SAAA3zD,IAAAC,GAAA+H,oBAAA,6KAIA,OAAAkL,MAAAohD,iBAAA,IAEAd,EAAArzD,UAAAi0D,uBAAA,WAIA,MAHAlhD,MAAAygD,GACAzgD,KAAAohD,iBAAA,GAEAphD,KAAAygD,GAEAH,EAAArzD,UAAAm0D,gBAAA,SAAA5X,GACA,GAAA9oC,GAAAV,IACAzT,KAAAyT,KAAA8gD,EAAAV,SAAAr9C,KAAA,2CACAxW,GAAAyT,KAAAygD,EAAA,0CACA,IAAAz2B,GAAA,GAAApnB,IAAA5C,KAAA8gD,EAAAj+C,WAAA7C,KAAA8gD,EAAAh+C,eAAA9C,KAAA8gD,EAAAV,SAAAr9C,KAAA/C,KAAA8gD,EAAAV,SAAAp9C,KACAw7C,EAAA,SAAA/wD,GACA,GAAAA,YAAAwQ,IAAA,CACA,GAAAojD,GAAA3gD,EAAAogD,EAAAj+C,WACAy+C,EAAA7zD,EAAAuQ,UAAA8iD,EAAAj+C,UACA,KAAAy+C,EAAAxvD,QAAAuvD,GACA,SAAAv0D,IAAAC,GAAAC,iBAAA,sCACAs0D,EAAAl+C,UAAA,IAAAk+C,EAAAj+C,SAAA,+BACAg+C,EAAAj+C,UAAA,IAAAi+C,EAAAh+C,SAEA,WAAArG,IAAA0D,EAAAogD,EAAAj+C,WAAApV,EAAA8zD,GAGA,MAAA9zD,GAKA,OAFAuS,MAAAwhD,eAAA,GAAAlD,IAAAE,GACAx+C,KAAAygD,EAAA,GAAAzG,IAAAjuD,GAAAC,cAAAg+B,EAAAhqB,KAAA8gD,EAAAnlD,YAAAqE,KAAAwgD,GACAxgD,KAAAygD,EAAAloD,MAAAixC,IAEA8W,EAAAM,kBAAA,SAAAthD,GACA,GAAAlO,GAAAkO,EAAAlO,OACA,KAAAhE,EAAAgE,EAAA,cAGA,GAAAhE,EAAAgE,EAAA,eACA,SAAAtE,IAAAC,GAAAC,iBAAA,2EAGA,UAAAF,IAAAC,GAAAC,iBAAA,uDAEA,GAAAI,EAAAgE,EAAA,oBAGA,SAAAtE,IAAAC,GAAAC,iBAAA,wEAGA,IAAAoW,GAAAhS,EAAA,SACA,KAAAgS,GAAA,gBAAAA,GACA,SAAAtW,IAAAC,GAAAC,iBAAA,oDAEA,WAAAkW,IAAAE,IAEA9V,OAAAqS,eAAA2gD,EAAArzD,UAAA,OACAwK,IAAA,WACA,IAAAuI,KAAA8gD,EAAAH,YACA,SAAA7zD,IAAAC,GAAA+H,oBAAA,+EAGA,OAAAkL,MAAA8gD,EAAAH,aAEAj+C,YAAA,EACAC,cAAA,IAEA29C,EAAArzD,UAAAw0D,WAAA,SAAAC,GAGA,GAFAtzD,EAAA,uBAAAxD,UAAA,GACAoE,EAAA,kCAAA0yD,IACAA,EACA,SAAA50D,IAAAC,GAAAC,iBAAA,2DAGA,OADAgT,MAAAkhD,yBACA,GAAAS,IAAAzpD,GAAA6M,WAAA28C,GAAA1hD,OAEAsgD,EAAArzD,UAAAuR,IAAA,SAAAkjD,GAGA,GAFAtzD,EAAA,gBAAAxD,UAAA,GACAoE,EAAA,2BAAA0yD,IACAA,EACA,SAAA50D,IAAAC,GAAAC,iBAAA,kDAGA,OADAgT,MAAAkhD,yBACAjjD,GAAA2jD,QAAA1pD,GAAA6M,WAAA28C,GAAA1hD,OAEAsgD,EAAArzD,UAAA6qC,eAAA,SAAAC,GACA,GAAAr3B,GAAAV,IAGA,OAFA5R,GAAA,2BAAAxD,UAAA,GACAoE,EAAA,wCAAA+oC,GACA/3B,KAAAkhD,yBAAAjpB,YAAA,SAAAA,GACA,MAAAF,GAAA,GAAA8pB,IAAAnhD,EAAAu3B,OAGAqoB,EAAArzD,UAAAqqC,MAAA,WAEA,MADAt3B,MAAAkhD,yBACA,GAAAY,IAAA9hD,OAEA1S,OAAAqS,eAAA2gD,EAAA,YACA7oD,IAAA,WACA,OAAAtN,KACA,IAAAW,IAAAC,MACA,aACA,KAAAD,IAAAc,MACA,aACA,KAAAd,IAAAi3D,OACA,cACA,SACA,MAAA51D,GAAA,sBAAAhC,OAGAuY,YAAA,EACAC,cAAA,IAEA29C,EAAAj2D,YAAA,SAAA23D,GAGA,OAFA5zD,EAAA,wBAAAxD,UAAA,GACAoE,EAAA,mCAAAgzD,GACAA,GACA,YACA33D,EAAAS,GAAAC,MACA,MACA,aACAV,EAAAS,GAAAc,MACA,MACA,cACAvB,EAAAS,GAAAi3D,OACA,MACA,SACA,SAAAj1D,IAAAC,GAAAC,iBAAA,sBAAAg1D,KAGA1B,KAMAuB,GAAA,WACA,QAAAxL,GAAA4L,EAAAC,GACAliD,KAAAiiD,IACAjiD,KAAAkiD,IAwDA,MAtDA7L,GAAAppD,UAAAwK,IAAA,SAAAsG,GACA,GAAA2C,GAAAV,IACA5R,GAAA,kBAAAxD,UAAA,EACA,IAAAqnC,GAAAn0B,GAAA,kBAAAC,EAAAiC,KAAAiiD,EACA,OAAAjiD,MAAAkiD,EACA/L,QAAAlkB,EAAAsvB,IACA5zB,KAAA,SAAApU,GACA,IAAAA,GAAA,IAAAA,EAAA1uB,OACA,MAAAsB,GAAA,kDAEA,IAAAqS,GAAA+a,EAAA,EACA,OAAA/a,aAAA0I,IACA,GAAAi7C,IAAAzhD,EAAAuhD,EAAAhwB,EAAAsvB,EAAA,SAEA,GAAAY,IAAAzhD,EAAAuhD,EAAAhwB,EAAAsvB,EAAA/iD,GAAA,MAGA63C,EAAAppD,UAAAkgB,IAAA,SAAApP,EAAAtQ,EAAA2D,GACA1C,EAAA,kBAAA9D,UAAA,IACA,IAAAqnC,GAAAn0B,GAAA,kBAAAC,EAAAiC,KAAAiiD,EACA7wD,GAAAsM,GAAA,kBAAAtM,EACA,IAAAmuD,GAAAnuD,EAAAuM,MACAqC,KAAAiiD,EAAAT,eAAA5C,eAAA,kBAAAnxD,GACAuS,KAAAiiD,EAAAT,eAAA/C,aAAA,kBAAAhxD,EAEA,OADAuS,MAAAkiD,EAAA/0C,IAAA8kB,EAAAsvB,EAAAhC,GACAv/C,MAEAq2C,EAAAppD,UAAAknB,OAAA,SAAApW,EAAAqkD,EAAA30D,GAEA,OADA2xD,MACAz0D,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/Cy0D,EAAAz0D,EAAA,GAAAC,UAAAD,EAEA,IAAAsnC,GACAstB,CAaA,OAZA,gBAAA6C,IACAA,YAAA1rD,KACAlI,EAAA,qBAAA5D,UAAA,GACAqnC,EAAAn0B,GAAA,qBAAAC,EAAAiC,KAAAiiD,GACA1C,EAAAv/C,KAAAiiD,EAAAT,eAAArC,mBAAA,qBAAAiD,EAAA30D,EAAA2xD,KAGAhxD,EAAA,qBAAAxD,UAAA,GACAqnC,EAAAn0B,GAAA,qBAAAC,EAAAiC,KAAAiiD,GACA1C,EAAAv/C,KAAAiiD,EAAAT,eAAA3C,gBAAA,qBAAAuD,IAEApiD,KAAAkiD,EAAA/tC,OAAA8d,EAAAsvB,EAAAhC,GACAv/C,MAEAq2C,EAAAppD,UAAA+R,OAAA,SAAAjB,GACA3P,EAAA,qBAAAxD,UAAA,EACA,IAAAqnC,GAAAn0B,GAAA,qBAAAC,EAAAiC,KAAAiiD,EAEA,OADAjiD,MAAAkiD,EAAAljD,OAAAizB,EAAAsvB,GACAvhD,MAEAq2C,KAGAyL,GAAA,WACA,QAAAO,GAAAJ,GACAjiD,KAAAiiD,IACAjiD,KAAAsiD,KACAtiD,KAAAuiD,IAAA,EA0DA,MAxDAF,GAAAp1D,UAAAkgB,IAAA,SAAApP,EAAAtQ,EAAA2D,GACA1C,EAAA,iBAAA9D,UAAA,KACAoV,KAAAwiD,oBACA,IAAAvwB,GAAAn0B,GAAA,iBAAAC,EAAAiC,KAAAiiD,EACA7wD,GAAAsM,GAAA,iBAAAtM,EACA,IAAAmuD,GAAAnuD,EAAAuM,MACAqC,KAAAiiD,EAAAT,eAAA5C,eAAA,iBAAAnxD,GACAuS,KAAAiiD,EAAAT,eAAA/C,aAAA,iBAAAhxD,EAEA,OADAuS,MAAAsiD,EAAAtiD,KAAAsiD,EAAA52D,OAAA6zD,EAAA1I,YAAA5kB,EAAAsvB,EAAAzsC,GAAAO,OACArV,MAEAqiD,EAAAp1D,UAAAknB,OAAA,SAAApW,EAAAqkD,EAAA30D,GAEA,OADA2xD,MACAz0D,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/Cy0D,EAAAz0D,EAAA,GAAAC,UAAAD,EAEAqV,MAAAwiD,oBACA,IAAAvwB,GACAstB,CAaA,OAZA,gBAAA6C,IACAA,YAAA1rD,KACAlI,EAAA,oBAAA5D,UAAA,GACAqnC,EAAAn0B,GAAA,oBAAAC,EAAAiC,KAAAiiD,GACA1C,EAAAv/C,KAAAiiD,EAAAT,eAAArC,mBAAA,oBAAAiD,EAAA30D,EAAA2xD,KAGAhxD,EAAA,oBAAAxD,UAAA,GACAqnC,EAAAn0B,GAAA,oBAAAC,EAAAiC,KAAAiiD,GACA1C,EAAAv/C,KAAAiiD,EAAAT,eAAA3C,gBAAA,oBAAAuD,IAEApiD,KAAAsiD,EAAAtiD,KAAAsiD,EAAA52D,OAAA6zD,EAAA1I,YAAA5kB,EAAAsvB,EAAAzsC,GAAAG,QAAA,KACAjV,MAEAqiD,EAAAp1D,UAAA+R,OAAA,SAAAjB,GACA3P,EAAA,oBAAAxD,UAAA,GACAoV,KAAAwiD,oBACA,IAAAvwB,GAAAn0B,GAAA,oBAAAC,EAAAiC,KAAAiiD,EAEA,OADAjiD,MAAAsiD,EAAAtiD,KAAAsiD,EAAA52D,OAAA,GAAAwrB,IAAA+a,EAAAsvB,EAAAzsC,GAAAO,OACArV,MAEAqiD,EAAAp1D,UAAAmrC,OAAA,WAGA,MAFAp4B,MAAAwiD,qBACAxiD,KAAAuiD,IAAA,EACAviD,KAAAsiD,EAAAz3D,OAAA,EACAmV,KAAAiiD,EAAAf,yBAAA7pB,MAAAr3B,KAAAsiD,GAGAv7B,QAAA9sB,WAGAooD,EAAAp1D,UAAAu1D,mBAAA,WACA,GAAAxiD,KAAAuiD,GACA,SAAAz1D,IAAAC,GAAA+H,oBAAA,wEAIAutD,KAMApkD,GAAA,WACA,QAAAwkD,GAAAlB,EAAAvjD,GACAgC,KAAAuhD,IACAvhD,KAAAhC,YACAgC,KAAAygD,EAAAzgD,KAAAhC,UAAAkjD,yBA2KA,MAzKAuB,GAAAb,QAAA,SAAArrD,EAAAyH,GACA,GAAAzH,EAAA1L,OAAA,KACA,SAAAiC,IAAAC,GAAAC,iBAAA,6FAEAuJ,EAAAuO,kBAAA,QAAAvO,EAAA1L,OAEA,WAAA43D,GAAA,GAAA38C,IAAAvP,GAAAyH,IAEA1Q,OAAAqS,eAAA8iD,EAAAx1D,UAAA,MACAwK,IAAA,WACA,MAAAuI,MAAAuhD,EAAAhrD,KAAAgO,eAEA7B,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAA8iD,EAAAx1D,UAAA,UACAwK,IAAA,WACA,UAAAkqD,IAAA3hD,KAAAuhD,EAAAhrD,KAAA8N,UAAArE,KAAAhC,YAEA0E,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAA8iD,EAAAx1D,UAAA,QACAwK,IAAA,WACA,MAAAuI,MAAAuhD,EAAAhrD,KAAAuO,mBAEApC,YAAA,EACAC,cAAA,IAEA8/C,EAAAx1D,UAAAw0D,WAAA,SAAAC,GAGA,GAFAtzD,EAAA,+BAAAxD,UAAA,GACAoE,EAAA,0CAAA0yD,IACAA,EACA,SAAA50D,IAAAC,GAAAC,iBAAA,2DAEA,IAAAuJ,GAAA2B,GAAA6M,WAAA28C,EACA,WAAAC,IAAA3hD,KAAAuhD,EAAAhrD,KAAAwN,MAAAxN,GAAAyJ,KAAAhC,YAEAykD,EAAAx1D,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAAwgD,IACA,KAAAjxD,GAAA,gCAAAyQ,EAEA,OAAAjC,MAAAhC,YAAAiE,EAAAjE,WAAAgC,KAAAuhD,EAAAzvD,QAAAmQ,EAAAs/C,IAEAkB,EAAAx1D,UAAAkgB,IAAA,SAAA1f,EAAA2D,GACA1C,EAAA,wBAAA9D,UAAA,KACAwG,EAAAsM,GAAA,wBAAAtM,EACA,IAAAmuD,GAAAnuD,EAAAuM,MACAqC,KAAAhC,UAAAwjD,eAAA5C,eAAA,wBAAAnxD,GACAuS,KAAAhC,UAAAwjD,eAAA/C,aAAA,wBAAAhxD,EACA,OAAAuS,MAAAygD,EAAAppB,MAAAkoB,EAAA1I,YAAA72C,KAAAuhD,EAAAzsC,GAAAO,QAEAotC,EAAAx1D,UAAAknB,OAAA,SAAAiuC,EAAA30D,GAEA,OADA2xD,MACAz0D,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/Cy0D,EAAAz0D,EAAA,GAAAC,UAAAD,EAEA,IAAA40D,EAUA,OATA,gBAAA6C,IACAA,YAAA1rD,KACAlI,EAAA,2BAAA5D,UAAA,GACA20D,EAAAv/C,KAAAhC,UAAAwjD,eAAArC,mBAAA,2BAAAiD,EAAA30D,EAAA2xD,KAGAhxD,EAAA,2BAAAxD,UAAA,GACA20D,EAAAv/C,KAAAhC,UAAAwjD,eAAA3C,gBAAA,2BAAAuD,IAEApiD,KAAAygD,EAAAppB,MAAAkoB,EAAA1I,YAAA72C,KAAAuhD,EAAAzsC,GAAAG,QAAA,MAEAwtC,EAAAx1D,UAAA+R,OAAA,WAEA,MADA5Q,GAAA,2BAAAxD,UAAA,GACAoV,KAAAygD,EAAAppB,OACA,GAAAngB,IAAAlX,KAAAuhD,EAAAzsC,GAAAO,SAGAotC,EAAAx1D,UAAAy1D,WAAA,WAEA,OADAv3D,MACAR,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/CQ,EAAAR,GAAAC,UAAAD,EAEA+D,GAAA,+BAAA9D,UAAA,IACA,IAGAqwD,GAHA7pD,GACAuxD,wBAAA,GAGAC,EAAA,CACA,iBAAAz3D,GAAAy3D,IACA5mD,GAAA7Q,EAAAy3D,MACAxxD,EAAAjG,EAAAy3D,GACAzxD,EAAA,+BAAAC,GACA,2BAEA3B,EAAA,kEAAA2B,EAAAuxD,wBACAC,IAEA,IAAAC,IACAx0B,+BAAAj9B,EAAAuxD,uBACA9zB,4BAAAz9B,EAAAuxD,uBAeA,OAbA3mD,IAAA7Q,EAAAy3D,IACA3H,EAAA9vD,EAAAy3D,IAGA5zD,EAAA,0CAAA4zD,EAAAz3D,EAAAy3D,IACAtzD,EAAA,0CAAAszD,EAAA,EAAAz3D,EAAAy3D,EAAA,IACAtzD,EAAA,0CAAAszD,EAAA,EAAAz3D,EAAAy3D,EAAA,IACA3H,GACAp1C,KAAA1a,EAAAy3D,GACA/2D,MAAAV,EAAAy3D,EAAA,GACAE,SAAA33D,EAAAy3D,EAAA,KAGA5iD,KAAA+iD,mBAAAF,EAAA5H,IAEAwH,EAAAx1D,UAAA81D,mBAAA,SAAA3xD,EAAA6pD,GACA,GAAAv6C,GAAAV,KACAgjD,EAAA,SAAAr9B,GACAr6B,QAAAO,MAAA,gCAAA85B,GAEAs1B,GAAApvD,QACAm3D,EAAA/H,EAAApvD,MAAA8K,KAAAskD,GAEA,IAAAgI,GAAA,GAAA/H,KACAr1C,KAAA,SAAA1H,GACA,GAAA88C,EAAAp1C,KAAA,CACAtZ,EAAA4R,EAAAob,KAAAnV,MAAA,oDACA,IAAA5F,GAAAL,EAAAob,KAAA9hB,IAAAiJ,EAAA6gD,EACAtG,GAAAp1C,KAAA,GAAAs8C,IAAAzhD,EAAA1C,UAAA0C,EAAA6gD,EAAA/iD,EAAAL,EAAAO,cAGA7S,MAAAm3D,IAEAE,EAAAljD,KAAAygD,EAAAt3B,OAAArb,GAAAS,OAAAvO,KAAAuhD,EAAAhrD,MAAA0sD,EAAA7xD,EACA,mBACA6xD,EAAA5H,OACA36C,EAAA+/C,EAAA7yB,SAAAs1B,KAGAT,EAAAx1D,UAAAwK,IAAA,WACA,GAAAiJ,GAAAV,IAEA,OADA5R,GAAA,wBAAAxD,UAAA,GACA,GAAAm8B,SAAA,SAAA9sB,EAAAC,GACA,GAAA0zB,GAAAltB,EAAAqiD,oBACAl0B,6BAAA,EACAR,gCAAA,EACAM,uBAAA,IAEA9oB,KAAA,SAAAuoB,GAGAR,KACAQ,EAAAnZ,QAAAmZ,EAAA6R,SAAAvhC,UAQAxE,EAAA,GAAApN,IAAAC,GAAAgI,QAAA,0DAGAkF,EAAAm0B,IAGAviC,MAAAqO,OAIAuoD,KAGAU,GAAA,WACA,QAAAA,GAAAj4B,EAAAxsB,GACAsB,KAAAkrB,mBACAlrB,KAAAtB,YAMA,MAJAykD,GAAAl2D,UAAA6E,QAAA,SAAAmQ,GACA,MAAAjC,MAAAkrB,mBAAAjpB,EAAAipB,kBACAlrB,KAAAtB,YAAAuD,EAAAvD,WAEAykD,KAEAhB,GAAA,WACA,QAAAiB,GAAAnB,EAAAV,EAAA8B,EAAAC,GACAtjD,KAAAiiD,IACAjiD,KAAAuhD,IACAvhD,KAAAqjD,KACArjD,KAAAsjD,KAkGA,MAhGAF,GAAAn2D,UAAAwZ,KAAA,SAAArV,GAGA,MAFA1C,GAAA,wBAAA9D,UAAA,KACAwG,EAAAwM,GAAA,wBAAAxM,GACA4O,KAAAqjD,GAEArjD,KAAAujD,cAAAvjD,KAAAqjD,GAAA58C,KAAAiE,GAAAG,oBAAAzZ,QADAzD,IAGAy1D,EAAAn2D,UAAAwK,IAAA,SAAA+e,EAAAplB,GAGA,GAFA1C,EAAA,uBAAA9D,UAAA,KACAwG,EAAAwM,GAAA,uBAAAxM,GACA4O,KAAAqjD,GAAA,CACA,GAAA51D,GAAAuS,KAAAqjD,GAAA58C,KAAAnT,MAAA+J,GAAA,uBAAAmZ,GACA,QAAA7oB,KAAAF,EACA,MAAAuS,MAAAwjD,aAAA/1D,EAAAid,GAAAG,oBAAAzZ,MAKA9D,OAAAqS,eAAAyjD,EAAAn2D,UAAA,MACAwK,IAAA,WACA,MAAAuI,MAAAuhD,EAAAhrD,KAAAgO,eAEA7B,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAyjD,EAAAn2D,UAAA,OACAwK,IAAA,WACA,UAAAwG,IAAA+B,KAAAuhD,EAAAvhD,KAAAiiD,IAEAv/C,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAyjD,EAAAn2D,UAAA,UACAwK,IAAA,WACA,cAAAuI,KAAAqjD,IAEA3gD,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAyjD,EAAAn2D,UAAA,YACAwK,IAAA,WACA,UAAA0rD,IAAA,OAAAnjD,KAAAqjD,IAAArjD,KAAAqjD,GAAA38C,kBAAA1G,KAAAsjD,KAEA5gD,YAAA,EACAC,cAAA,IAEAygD,EAAAn2D,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAAmhD,IACA,KAAA5xD,GAAA,+BAAAyQ,EAEA,OAAAjC,MAAAiiD,IAAAhgD,EAAAggD,GACAjiD,KAAAsjD,KAAArhD,EAAAqhD,IACAtjD,KAAAuhD,EAAAzvD,QAAAmQ,EAAAs/C,KACA,OAAAvhD,KAAAqjD,GACA,OAAAphD,EAAAohD,GACArjD,KAAAqjD,GAAAvxD,QAAAmQ,EAAAohD,MAEAD,EAAAn2D,UAAAs2D,cAAA,SAAA98C,EAAArV,GACA,GAAAsP,GAAAV,KACA7R,IAIA,OAHAsY,GAAAzY,QAAA,SAAAX,EAAAI,GACAU,EAAAd,GAAAqT,EAAA8iD,aAAA/1D,EAAA2D,KAEAjD,GAEAi1D,EAAAn2D,UAAAu2D,aAAA,SAAA/1D,EAAA2D,GACA,GAAA3D,YAAAof,IACA,MAAA7M,MAAAujD,cAAA91D,EAAA2D,EAEA,IAAA3D,YAAAggB,IACA,MAAAzN,MAAAyjD,aAAAh2D,EAAA2D,EAEA,IAAA3D,YAAAif,IAAA,CACA,GAAArf,GAAAI,QAAA2D,GACAiS,EAAArD,KAAAiiD,EAAAf,yBAAAr+C,YAUA,OATApV,GAAAoV,WAAA/Q,QAAAuR,IAEA1X,EAAA,YAAAqU,KAAAuhD,EAAAhrD,KAAA,+DAEA9I,EAAAoV,WAAAO,UAAA,IAAA3V,EAAAoV,WAAAQ,SAAA,wFAEAA,EAAAD,UAAA,IAAAC,WAAA,cAGA,GAAApF,IAAA5Q,EAAA2S,KAAAiiD,GAGA,MAAAx0D,SAAA2D,IAGAgyD,EAAAn2D,UAAAw2D,aAAA,SAAAh9C,EAAArV,GACA,GAAAsP,GAAAV,IACA,OAAAyG,GAAA6E,cAAAlgB,IAAA,SAAAqC,GACA,MAAAiT,GAAA8iD,aAAA/1D,EAAA2D,MAGAgyD,KAGA3kD,GAAA,SAAAgC,GAEA,QAAAijD,GAAA1lD,EAAA3Q,EAAA8xB,EAAAzgB,GACA,MAAA+B,GAAAlT,KAAAyS,KAAAhC,EAAA3Q,EAAA8xB,EAAAzgB,IAAAsB,KAOA,MATA+/C,IAAA2D,EAAAjjD,GAIAijD,EAAAz2D,UAAAwZ,KAAA,SAAArV,GACA,GAAAqV,GAAAhG,EAAAxT,UAAAwZ,KAAAlZ,KAAAyS,KAAA5O,EAEA,OADA7E,GAAA,gBAAAka,GAAA,oDACAA,GAEAi9C,GACCvB,IAEDwB,GAAA,WACA,QAAA51C,GAAA61C,EAAA5lD,GACAgC,KAAA4jD,KACA5jD,KAAAhC,YAuUA,MArUA+P,GAAA9gB,UAAA+0B,MAAA,SAAA1uB,EAAAuwD,EAAAp2D,GACAW,EAAA,cAAAxD,UAAA,GACAoE,EAAA,yBAAA60D,GACA3yD,EAAA,gBAAAzD,EACA,IAAAkZ,GACA6P,EAAAnZ,GAAA,cAAA/J,EACA,IAAAkjB,EAAAjR,aACA,mBAAA9X,GAAA,CACA,QAAAA,EAAA8D,QAAA,KAEA,SAAAzE,IAAAC,GAAAC,iBAAA,2JAIA,SAAAS,EACA,SAAAX,IAAAC,GAAAC,iBAAA,8JAIA,IAAAuJ,GAAAyJ,KAAA4jD,GAAArtD,KAAAwN,MAAA,GAAA7L,KAAAzK,IACAlB,GAAAgK,EAAA1L,OAAA,sCACA8b,EAAA,GAAA+F,IAAA1M,KAAAhC,UAAA+iD,YAAA,GAAAj7C,IAAAvP,QAEA,MAAA9I,YAAAwQ,KAKA,SAAAnR,IAAAC,GAAAC,iBAAA,2JAGAkD,EAAAzC,GAAA,IAPA,IAAAwkC,GAAAxkC,CACAkZ,GAAA,GAAA+F,IAAA1M,KAAAhC,UAAA+iD,YAAA9uB,EAAAsvB,OAUA56C,GAAA3G,KAAAhC,UAAAwjD,eAAAlC,gBAAA,cAAA7xD,EAEA,IAAAuX,GAAA3R,EAAAmjB,EAAA9iB,GAAAqR,WAAA8+C,GAAAl9C,EAEA,OADA3G,MAAA8jD,kBAAA9+C,GACA,GAAA+I,GAAA/N,KAAA4jD,GAAAt0C,UAAAtK,GAAAhF,KAAAhC,YAEA+P,EAAA9gB,UAAA+hB,QAAA,SAAA1b,EAAAywD,GACAr1D,EAAA,gBAAA9D,UAAA,KACA0E,EAAA,2BAAAy0D,EACA,IAAAz/B,EACA,QAAA32B,KAAAo2D,GAAA,QAAAA,EACAz/B,EAAAnV,GAAAC,cAEA,aAAA20C,EAIA,SAAAj3D,IAAAC,GAAAC,iBAAA,mDAAA+2D,EAAA,+BAHAz/B,GAAAnV,GAAAoC,WAMA,UAAAvR,KAAA4jD,GAAA11C,QACA,SAAAphB,IAAAC,GAAAC,iBAAA,yGAGA,WAAAgT,KAAA4jD,GAAAz1C,MACA,SAAArhB,IAAAC,GAAAC,iBAAA,sGAGA,IAAAwpB,GAAAnZ,GAAA,gBAAA/J,GACA0b,EAAA,GAAAH,IAAA2H,EAAA8N,EAEA,OADAtkB,MAAAgkD,mBAAAh1C,GACA,GAAAjB,GAAA/N,KAAA4jD,GAAAn0C,WAAAT,GAAAhP,KAAAhC,YAEA+P,EAAA9gB,UAAAiX,MAAA,SAAAmF,GAGA,GAFAjb,EAAA,cAAAxD,UAAA,GACAoE,EAAA,yBAAAqa,GACAA,GAAA,EACA,SAAAvc,IAAAC,GAAAC,iBAAA,+BAAAqc,EAAA,wCAGA,WAAA0E,GAAA/N,KAAA4jD,GAAAj0C,UAAAtG,GAAArJ,KAAAhC,YAEA+P,EAAA9gB,UAAAihB,QAAA,SAAA+1C,GAEA,OADAzvC,MACA7pB,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/C6pB,EAAA7pB,EAAA,GAAAC,UAAAD,EAEA6D,GAAA,gBAAA5D,UAAA,EACA,IAAAilB,GAAA7P,KAAAkkD,qBAAA,gBAAAD,EAAAzvC,GACA,EACA,WAAAzG,GAAA/N,KAAA4jD,GAAAh0C,YAAAC,GAAA7P,KAAAhC,YAEA+P,EAAA9gB,UAAAk3D,WAAA,SAAAF,GAEA,OADAzvC,MACA7pB,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/C6pB,EAAA7pB,EAAA,GAAAC,UAAAD,EAEA6D,GAAA,mBAAA5D,UAAA,EACA,IAAAilB,GAAA7P,KAAAkkD,qBAAA,mBAAAD,EAAAzvC,GACA,EACA,WAAAzG,GAAA/N,KAAA4jD,GAAAh0C,YAAAC,GAAA7P,KAAAhC,YAEA+P,EAAA9gB,UAAAm3D,UAAA,SAAAH,GAEA,OADAzvC,MACA7pB,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/C6pB,EAAA7pB,EAAA,GAAAC,UAAAD,EAEA6D,GAAA,kBAAA5D,UAAA,EACA,IAAAilB,GAAA7P,KAAAkkD,qBAAA,kBAAAD,EAAAzvC,GACA,EACA,WAAAzG,GAAA/N,KAAA4jD,GAAA9zC,UAAAD,GAAA7P,KAAAhC,YAEA+P,EAAA9gB,UAAAkhB,MAAA,SAAA81C,GAEA,OADAzvC,MACA7pB,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/C6pB,EAAA7pB,EAAA,GAAAC,UAAAD,EAEA6D,GAAA,cAAA5D,UAAA,EACA,IAAAilB,GAAA7P,KAAAkkD,qBAAA,cAAAD,EAAAzvC,GACA,EACA,WAAAzG,GAAA/N,KAAA4jD,GAAA9zC,UAAAD,GAAA7P,KAAAhC,YAEA+P,EAAA9gB,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAA8L,IACA,KAAAvc,GAAA,oBAAAyQ,EAEA,OAAAjC,MAAAhC,YAAAiE,EAAAjE,WAAAgC,KAAA4jD,GAAA9xD,QAAAmQ,EAAA2hD,KAGA71C,EAAA9gB,UAAAi3D,qBAAA,SAAA5mD,EAAA2mD,EAAAzvC,EAAA9C,GAEA,GADAxgB,EAAAoM,EAAA,EAAA2mD,GACAA,YAAA9B,IAAA,CACA,GAAA3tC,EAAA3pB,OAAA,EACA,SAAAiC,IAAAC,GAAAC,iBAAA,kCAAAsQ,EAAA,MAEA,IAAA8wB,GAAA61B,CACA,KAAA71B,EAAAnZ,OACA,SAAAnoB,IAAAC,GAAA4H,UAAA,uDACA2I,EAAA,MAEA,OAAA0C,MAAAqkD,kBAAA/mD,EAAA8wB,EAAAi1B,GAAA3xC,GAGA,GAAA4yC,IAAAL,GAAAv4D,OAAA8oB,EACA,OAAAxU,MAAAukD,gBAAAjnD,EAAAgnD,EAAA5yC,IAaA3D,EAAA9gB,UAAAo3D,kBAAA,SAAA/mD,EAAAkB,EAAAkT,GASA,OARA8yC,MAQA75D,EAAA,EAAAokB,EAAA/O,KAAA4jD,GAAA50C,QAAkDrkB,EAAAokB,EAAAlkB,OAAgBF,IAAA,CAClE,GAAAqkB,GAAAD,EAAApkB,EACA,IAAAqkB,EAAA1b,MAAAiS,aACAi/C,EAAAv0D,KAAA,GAAAyc,IAAA1M,KAAAhC,UAAA+iD,YAAAviD,EAAAnR,UAEA,CACA,GAAAI,GAAA+Q,EAAAlL,MAAA0b,EAAA1b,MACA,QAAA3F,KAAAF,EAGA,CACA,GAAA6F,GAAA0b,EAAA1b,MAAAwR,iBACA,UAAAhY,IAAAC,GAAAC,iBAAA,+FACAsG,EAAA,2CALAkxD,EAAAv0D,KAAAxC,IAUA,UAAA+jB,IAAAgzC,EAAA9yC,IAKA3D,EAAA9gB,UAAAs3D,gBAAA,SAAAjnD,EAAAwhB,EAAApN,GAEA,GAAA1C,GAAAhP,KAAA4jD,GAAA51C,eACA,IAAA8Q,EAAAj0B,OAAAmkB,EAAAnkB,OACA,SAAAiC,IAAAC,GAAAC,iBAAA,kCAAAsQ,EAAA,kGAKA,QADAknD,MACAxyD,EAAA,EAAuBA,EAAA8sB,EAAAj0B,OAAmBmH,IAAA,CAC1C,GAAAyyD,GAAA3lC,EAAA9sB,EAEA,IADAgd,EAAAhd,GACAsB,MAAAiS,aAAA,CACA,mBAAAk/C,GACA,SAAA33D,IAAAC,GAAAC,iBAAA,uDACAsQ,EAAA,uBAAAmnD,GAEA,SAAAA,EAAAlzD,QAAA,KACA,SAAAzE,IAAAC,GAAAC,iBAAA,+BAAAy3D,EAAA,yBACAnnD,EAAA,KAEA,IAAAjQ,GAAA,GAAAyY,IAAA9F,KAAA4jD,GAAArtD,KAAAwN,MAAA0gD,GACAD,GAAAv0D,KAAA,GAAAyc,IAAA1M,KAAAhC,UAAA+iD,YAAA1zD,QAEA,CACA,GAAAq3D,GAAA1kD,KAAAhC,UAAAwjD,eAAAlC,gBAAAhiD,EAAAmnD,EACAD,GAAAv0D,KAAAy0D,IAGA,UAAAlzC,IAAAgzC,EAAA9yC,IAEA3D,EAAA9gB,UAAAy1D,WAAA,WAEA,OADAv3D,MACAR,EAAA,EAAwBA,EAAAC,UAAAC,OAAuBF,IAC/CQ,EAAAR,GAAAC,UAAAD,EAEA+D,GAAA,mBAAA9D,UAAA,IACA,IACAqwD,GADA7pD,KAEAwxD,EAAA,CAyBA,OAxBA,gBAAAz3D,GAAAy3D,IACA5mD,GAAA7Q,EAAAy3D,MACAxxD,EAAAjG,EAAAy3D,GACAzxD,EAAA,mBAAAC,GACA,8BACA,mCAEA3B,EAAA,8DAAA2B,EAAAi9B,gCACA5+B,EAAA,2DAAA2B,EAAAy9B,6BACA+zB,KAEA5mD,GAAA7Q,EAAAy3D,IACA3H,EAAA9vD,EAAAy3D,IAGA5zD,EAAA,8BAAA4zD,EAAAz3D,EAAAy3D,IACAtzD,EAAA,8BAAAszD,EAAA,EAAAz3D,EAAAy3D,EAAA,IACAtzD,EAAA,8BAAAszD,EAAA,EAAAz3D,EAAAy3D,EAAA,IACA3H,GACAp1C,KAAA1a,EAAAy3D,GACA/2D,MAAAV,EAAAy3D,EAAA,GACAE,SAAA33D,EAAAy3D,EAAA,KAGA5iD,KAAA+iD,mBAAA3xD,EAAA6pD,IAEAltC,EAAA9gB,UAAA81D,mBAAA,SAAA3xD,EAAA6pD,GACA,GAAAv6C,GAAAV,KACAgjD,EAAA,SAAAr9B,GACAr6B,QAAAO,MAAA,gCAAA85B,GAEAs1B,GAAApvD,QACAm3D,EAAA/H,EAAApvD,MAAA8K,KAAAskD,GAEA,IAAAgI,GAAA,GAAA/H,KACAr1C,KAAA,SAAA1X,GACA8sD,EAAAp1C,MACAo1C,EAAAp1C,KAAA,GAAA8+C,IAAAjkD,EAAA1C,UAAA0C,EAAAkjD,GAAAz1D,KAGAtC,MAAAm3D,IAEA4B,EAAA5kD,KAAAhC,UAAAkjD,yBACAgC,EAAA0B,EAAAz7B,OAAAnpB,KAAA4jD,GAAAX,EAAA7xD,EACA,mBACA6xD,EAAA5H,OACAuJ,EAAAh3B,SAAAs1B,KAGAn1C,EAAA9gB,UAAAwK,IAAA,WACA,GAAAiJ,GAAAV,IAEA,OADA5R,GAAA,YAAAxD,UAAA,GACA,GAAAm8B,SAAA,SAAA9sB,EAAAC,GACA,GAAA0zB,GAAAltB,EAAAqiD,oBACA10B,gCAAA,EACAQ,6BAAA,EACAF,uBAAA,IAEA9oB,KAAA,SAAA1X,GAGAy/B,IACA3zB,EAAA9L,IAEAtC,MAAAqO,OAIA6T,EAAA9gB,UAAA62D,kBAAA,SAAA9+C,GACA,GAAAA,YAAAhR,KAAAgR,EAAAuK,eAAA,CACA,GAAAs1C,GAAA7kD,KAAA4jD,GAAAn1C,0BACA,WAAAo2C,MAAA/yD,QAAAkT,EAAA1R,OACA,SAAAxG,IAAAC,GAAAC,iBAAA,wIAEA63D,EAAA,UACA7/C,EAAA1R,MAAA,IAEA,IAAAob,GAAA1O,KAAA4jD,GAAAj1C,sBACA,QAAAD,GACA1O,KAAA8kD,kCAAA9/C,EAAA1R,MAAAob,KAIAX,EAAA9gB,UAAA+2D,mBAAA,SAAAh1C,GACA,UAAAhP,KAAA4jD,GAAAj1C,uBAAA,CAEA,GAAAH,GAAAxO,KAAA4jD,GAAAn1C,0BACA,QAAAD,GACAxO,KAAA8kD,kCAAAt2C,EAAAQ,EAAA1b,SAIAya,EAAA9gB,UAAA63D,kCAAA,SAAAC,EAAA/1C,GACA,IAAAA,EAAAld,QAAAizD,GACA,SAAAj4D,IAAAC,GAAAC,iBAAA,yFACA+3D,EAAA,+BACAA,EAAA,gFAEA/1C,EAAA,eAGAjB,KAGA42C,GAAA,WACA,QAAAK,GAAA/C,EAAAgD,EAAAC,GACAllD,KAAAiiD,IACAjiD,KAAAilD,KACAjlD,KAAAklD,KACAllD,KAAAmlD,eAAA,KACAnlD,KAAAigC,SAAA,GAAAkjB,IAAA+B,EAAAh6B,iBAAAg6B,EAAAxmD,WA8DA,MA5DApR,QAAAqS,eAAAqlD,EAAA/3D,UAAA,QACAwK,IAAA,WACA,GAAAtJ,KAEA,OADA6R,MAAAhS,QAAA,SAAAwQ,GAAyC,MAAArQ,GAAA8B,KAAAuO,KACzCrQ,GAEAuU,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAqlD,EAAA/3D,UAAA,SACAwK,IAAA,WACA,MAAAuI,MAAAklD,GAAA3rC,KAAAtrB,WAEAyU,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAqlD,EAAA/3D,UAAA,QACAwK,IAAA,WACA,MAAAuI,MAAAklD,GAAA3rC,KAAAnV,MAEA1B,YAAA,EACAC,cAAA,IAEAqiD,EAAA/3D,UAAAe,QAAA,SAAAi3B,EAAAmgC,GACA,GAAA1kD,GAAAV,IACAtR,GAAA,wBAAA9D,UAAA,KACAoE,EAAA,qCAAAi2B,GACAjlB,KAAAklD,GAAA3rC,KAAAvrB,QAAA,SAAAwQ,GACAymB,EAAA13B,KAAA63D,EAAA1kD,EAAA2kD,sBAAA7mD,OAGAlR,OAAAqS,eAAAqlD,EAAA/3D,UAAA,SACAwK,IAAA,WACA,UAAAksD,IAAA3jD,KAAAilD,GAAAjlD,KAAAiiD,IAEAv/C,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAAqlD,EAAA/3D,UAAA,cACAwK,IAAA,WAIA,MAHAuI,MAAAmlD,iBACAnlD,KAAAmlD,eAAAjnD,GAAA8B,KAAAiiD,EAAAjiD,KAAAklD,KAEAllD,KAAAmlD,gBAEAziD,YAAA,EACAC,cAAA,IAGAqiD,EAAA/3D,UAAA6E,QAAA,SAAAmQ,GACA,KAAAA,YAAA+iD,IACA,KAAAxzD,GAAA,4BAAAyQ,EAEA,OAAAjC,MAAAiiD,IAAAhgD,EAAAggD,GACAjiD,KAAAilD,GAAAnzD,QAAAmQ,EAAAgjD,KACAjlD,KAAAklD,GAAApzD,QAAAmQ,EAAAijD,KAEAF,EAAA/3D,UAAAo4D,sBAAA,SAAA7mD,GACA,UAAAC,IAAAuB,KAAAiiD,EAAAzjD,EAAAnR,IAAAmR,EAAAwB,KAAAigC,SAAAvhC,YAEAsmD,KAGArD,GAAA,SAAAlhD,GAEA,QAAA6kD,GAAA/uD,EAAAyH,GACA,GAAA0C,GAAAD,EAAAlT,KAAAyS,KAAA8N,GAAAS,OAAAhY,GAAAyH,IAAAgC,IACA,IAAAzJ,EAAA1L,OAAA,KACA,SAAAiC,IAAAC,GAAAC,iBAAA,gGAEAuJ,EAAAuO,kBAAA,QAAAvO,EAAA1L,OAEA,OAAA6V,GAiDA,MAzDAq/C,IAAAuF,EAAA7kD,GAUAnT,OAAAqS,eAAA2lD,EAAAr4D,UAAA,MACAwK,IAAA,WACA,MAAAuI,MAAA4jD,GAAArtD,KAAAgO,eAEA7B,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAA2lD,EAAAr4D,UAAA,UACAwK,IAAA,WACA,GAAA8tD,GAAAvlD,KAAA4jD,GAAArtD,KAAA8N,SACA,OAAAkhD,GAAAt3D,UACA,KAGA,GAAAgQ,IAAA,GAAA6H,IAAAy/C,GAAAvlD,KAAAhC,YAGA0E,YAAA,EACAC,cAAA,IAEArV,OAAAqS,eAAA2lD,EAAAr4D,UAAA,QACAwK,IAAA,WACA,MAAAuI,MAAA4jD,GAAArtD,KAAAuO,mBAEApC,YAAA,EACAC,cAAA,IAEA2iD,EAAAr4D,UAAAuR,IAAA,SAAAkjD,GAQA,GAPAhzD,EAAA,0BAAA9D,UAAA,KAGA,IAAAA,UAAAC,SACA62D,EAAA9gD,GAAAE,SAEA9R,EAAA,qCAAA0yD,GACA,KAAAA,EACA,SAAA50D,IAAAC,GAAAC,iBAAA,2CAEA,IAAAuJ,GAAA2B,GAAA6M,WAAA28C,EACA,OAAAzjD,IAAA2jD,QAAA5hD,KAAA4jD,GAAArtD,KAAAwN,MAAAxN,GAAAyJ,KAAAhC,YAEAsnD,EAAAr4D,UAAAgS,IAAA,SAAAxR,GACAW,EAAA,0BAAAxD,UAAA,GACAoE,EAAA,qCAAAvB,EACA,IAAA+3D,GAAAxlD,KAAAxB,KACA,OAAAgnD,GAAAr4C,IAAA1f,GAAAkgC,KAAA,WAAmD,MAAA63B,MAEnDF,GACC3B,IA8FD8B,GAAA/4D,EAAA6S,GAAA,qCACAmmD,GAAAh5D,EAAAm1D,GAAA,sDACA8D,GAAAj5D,EAAAo1D,GAAA,6CACA8D,GAAAl5D,EAAAuR,GAAA,2CACA4nD,GAAAn5D,EAAAy1D,IACA2D,GAAAp5D,EAAA+R,IACAsnD,GAAAr5D,EAAAi3D,IACAqC,GAAAt5D,EAAAi4D,IACAsB,GAAAv5D,EAAAi1D,GAAA,kDCnwCAniD,IACA8gD,UAAAmF,GACArjD,SAAAtF,GACAsE,KAAAe,GACAk0C,YAAAqP,GACArD,WAAAsD,GACAlD,kBAAAmD,GACAxC,iBAAAyC,GACA93C,MAAAg4C,GACArC,sBAAAoC,GACAd,cAAAgB,GACAV,oBAAAW,GACA9gD,UAAAzO,GACAyU,WAAAmyC,GACAjzD,YAAAkV,GAAAlV,YCnCAH,GAAA,kBAAAuV,GAqBAA,GAAAG,GAAA,U/B2khBMsmD,IACA,SAAUp8D,OAAQC,QAASC,sBmFjmhBjC,SAAAm8D,SAAA,WAAwC,QAAAC,GAAAjV,GAAc,sBAAAA,GAAyB,QAAAkV,OAC/E,QAAAC,IAAAnV,GAAe,GAAA9wC,SAAA8wC,EAAe,cAAA9wC,EAAA,KAAA8wC,EAAye,YAApd,IAAAA,YAAApiD,OAAA,aAAoC,IAAAoiD,YAAA7jD,QAAA,MAAA+S,EAAgC,IAAAzI,GAAAtK,OAAAL,UAAA0T,SAAApT,KAAA4jD,EAAwC,uBAAAv5C,EAAA,cAAuC,sBAAAA,GAAA,gBAAAu5C,GAAAtmD,YAAA,KAAAsmD,EAAA7kB,YAAA,KAAA6kB,EAAAoV,uBAAApV,EAAAoV,qBAAA,uBAA6K,yBAAA3uD,OAAA,KAAAu5C,EAAA5jD,UAAA,KAAA4jD,EAAAoV,uBAAApV,EAAAoV,qBAAA,6BACnX,gBAAAlmD,OAAA,KAAA8wC,EAAA5jD,KAAA,cAAiE,OAAA8S,GAAS,QAAAgJ,GAAA8nC,GAAc,eAAAmV,GAAAnV,GAAqB,QAAAqV,IAAArV,GAAe,GAAA9wC,GAAAimD,GAAAnV,EAAY,gBAAA9wC,GAAA,UAAAA,GAAA,gBAAA8wC,GAAAtmD,OAAyD,QAAA47D,IAAAtV,GAAe,kBAAAmV,GAAAnV,GAAwB,QAAAuV,IAAAvV,GAAe,GAAA9wC,SAAA8wC,EAAe,iBAAA9wC,GAAA,MAAA8wC,GAAA,YAAA9wC,EAA4F,QAAAsmD,IAAAxV,EAAA9wC,EAAAzI,GAAmB,MAAAu5C,GAAA5jD,KAAA/B,MAAA2lD,EAAAx6C,KAAA/L,WACrX,QAAAg8D,IAAAzV,EAAA9wC,EAAAzI,GAAmB,IAAAu5C,EAAA,KAAA7kD,QAAoB,MAAA1B,UAAAC,OAAA,CAAuB,GAAAuV,GAAArR,MAAA9B,UAAAgX,MAAA1W,KAAA3C,UAAA,EAA8C,mBAAkB,GAAAgN,GAAA7I,MAAA9B,UAAAgX,MAAA1W,KAAA3C,UAA+E,OAAnCmE,OAAA9B,UAAA45D,QAAAr7D,MAAAoM,EAAAwI,GAAmC+wC,EAAA3lD,MAAA6U,EAAAzI,IAAqB,kBAAkB,MAAAu5C,GAAA3lD,MAAA6U,EAAAzV,YAA6B,QAAAmiC,GAAAokB,EAAA9wC,EAAAzI,GAAmH,MAAjGm1B,GAAA+5B,SAAA75D,UAAA0J,OAAA,IAAAmwD,YAAA75D,UAAA0J,MAAApF,QAAA,eAAAo1D,GAAAC,GAAiG75B,EAAAvhC,MAAA,KAAAZ,WACpY,QAAAm8D,IAAA5V,EAAA9wC,GAAiB,GAAAzI,GAAA7I,MAAA9B,UAAAgX,MAAA1W,KAAA3C,UAAA,EAA8C,mBAAkB,GAAAyV,GAAAzI,EAAAqM,OAA0C,OAA1B5D,GAAApQ,KAAAzE,MAAA6U,EAAAzV,WAA0BumD,EAAA3lD,MAAAwU,KAAAK,IAAoE,QAAA2mD,GAAA7V,EAAA9wC,GAAgB,QAAAzI,MAAcA,EAAA3K,UAAAoT,EAAApT,UAAwBkkD,EAAA8V,EAAA5mD,EAAApT,UAAgBkkD,EAAAlkD,UAAA,GAAA2K,GAAkBu5C,EAAAlkD,UAAA6D,YAAAqgD,EAA0BA,EAAA+V,GAAA,SAAA/V,EAAAv5C,EAAA4rB,GAAqB,OAAApjB,GAAArR,MAAAnE,UAAAC,OAAA,GAAAqB,EAAA,EAAwCA,EAAAtB,UAAAC,OAAmBqB,IAAAkU,EAAAlU,EAAA,GAAAtB,UAAAsB,EAAwB,OAAAmU,GAAApT,UAAA2K,GAAApM,MAAA2lD,EAAA/wC,IAAmC,QAAA+mD,IAAAhW,GAAe,GAAA7kD,MAAA86D,kBAAA96D,MAAA86D,kBAAApnD,KAAAmnD,QAA4D,CAAK,GAAA9mD,GAAA/T,QAAAokD,KAAoBrwC,KAAAL,KAAA0wC,MAAArwC,GAAkB8wC,IAAAnxC,KAAA3T,QAAA8kD,EAAA9+C,IAAwE,QAAAg1D,IAAAlW,EAAA9wC,GAAiB8wC,IAAAv6C,MAAA,KAAgB,QAAAgB,GAAA,GAAAwI,EAAA+wC,EAAAtmD,OAAA,EAAAqB,EAAA,EAA8BA,EAAAkU,EAAIlU,IAAA0L,GAAAu5C,EAAAjlD,MAAAmU,EAAAxV,OAAAwV,EAAAnU,GAAA,KAAmCi7D,IAAA55D,KAAAyS,KAAApI,EAAAu5C,EAAA/wC,IAAiE,QAAAknD,IAAAnW,EAAA9wC,GAAiB,SAAAgnD,IAAA,WAAAlW,EAAA,KAAAA,EAAA,IAAApiD,MAAA9B,UAAAgX,MAAA1W,KAAA3C,UAAA,IAAgF,QAAA28D,KAAa,GAAAC,KAAAC,GAAAznD,KAAAM,KAAAN,KAAAM,KAAAonD,KAAA1nD,MAA0CA,KAAAhO,EAAAgO,KAAAhO,EAAcgO,KAAAilC,EAAAjlC,KAAAilC,EACv8B,QAAA0iB,IAAAxW,GAAeA,EAAA,CAAY,OAAT9wC,GAAAunD,GAAShwD,EAAAu5C,EAAAtmD,OAAAuV,EAAAgmD,EAAAjV,KAAAv6C,MAAA,IAAAu6C,EAAAjlD,EAAA,EAA4CA,EAAA0L,EAAI1L,IAAA,GAAAA,IAAAkU,IAAAC,EAAA9S,SAAA,GAAA6S,EAAAlU,KAAAilD,GAAA,CAAwC9wC,EAAAnU,CAAI,MAAAilD,GAAQ9wC,GAAA,EAAK,SAAAA,EAAA,KAAA+lD,EAAAjV,KAAA/+C,OAAAiO,GAAA8wC,EAAA9wC,GAAsC,QAAAw8B,IAAAsU,GAAe,IAAA9nC,EAAA8nC,GAAA,OAAA9wC,GAAA8wC,EAAAtmD,OAAA,EAA8B,GAAAwV,EAAKA,UAAA8wC,GAAA9wC,EAAgB8wC,GAAAtmD,OAAA,EAAW,QAAAg9D,IAAA1W,GAAe,MAAApiD,OAAA9B,UAAAvB,OAAAF,SAAAZ,WAAkD,QAAAk9D,IAAA3W,GAAe,GAAA9wC,GAAA8wC,EAAAtmD,MAAe,MAAAwV,EAAA,CAAQ,OAAAzI,GAAA7I,MAAAsR,GAAAD,EAAA,EAAuBA,EAAAC,EAAID,IAAAxI,EAAAwI,GAAA+wC,EAAA/wC,EAAc,OAAAxI,GAAS,SAAU,QAAAmwD,IAAA5W,GAAe,oBAAA9rC,KAAA8rC,GAAqJ,QAAA6W,IAAA7W,EAAA9wC,GAAiB,MAAA8wC,GAAA9wC,GAAA,EAAA8wC,EAAA9wC,EAAA,IAAwG,QAAA4nD,GAAA9W,GAAc,UAAA+W,EAAA32D,QAAA4/C,GAAwB,QAAAgX,IAAAhX,EAAA9wC,EAAAzI,GAAmB,OAAAwI,KAAA+wC,GAAA9wC,EAAA9S,KAAAqK,EAAAu5C,EAAA/wC,KAAA+wC,GAAkC,QAAAiX,IAAAjX,GAAe,GAAA/wC,GAAAC,KAAAzI,EAAA,CAAe,KAAAwI,IAAA+wC,GAAA9wC,EAAAzI,KAAAu5C,EAAA/wC,EAAuB,OAAAC,GAAS,QAAAgoD,IAAAlX,GAAe,GAAA/wC,GAAAC,KAAAzI,EAAA,CAAe,KAAAwI,IAAA+wC,GAAA9wC,EAAAzI,KAAAwI,CAAoB,OAAAC,GAAS,QAAAioD,IAAAnX,GAAe,GAAQv5C,GAARyI,IAAW,KAAAzI,IAAAu5C,GAAA9wC,EAAAzI,GAAAu5C,EAAAv5C,EAAqB,OAAAyI,GAC17B,QAAAkoD,IAAApX,EAAA9wC,GAAiB,OAAAzI,GAAAwI,EAAAlU,EAAA,EAAgBA,EAAAtB,UAAAC,OAAmBqB,IAAA,CAAKkU,EAAAxV,UAAAsB,EAAe,KAAA0L,IAAAwI,GAAA+wC,EAAAv5C,GAAAwI,EAAAxI,EAAqB,QAAA4rB,GAAA,EAAYA,EAAAglC,GAAA39D,OAAY24B,IAAA5rB,EAAA4wD,GAAAhlC,GAAAl2B,OAAAL,UAAAE,eAAAI,KAAA6S,EAAAxI,KAAAu5C,EAAAv5C,GAAAwI,EAAAxI,KAAqE,QAAA6wD,IAAAtX,GAA0B,MAAXsX,IAAA,KAAAtX,GAAWA,EAAoB,QAAAuX,IAAAvX,EAAA9wC,GAAiB,GAAAzI,GAAA+wD,EAAS,OAAAr7D,QAAAL,UAAAE,eAAAI,KAAAqK,EAAAu5C,GAAAv5C,EAAAu5C,GAAAv5C,EAAAu5C,GAAA9wC,EAAA8wC,GAAoS,QAAAyX,MAAc,GAAAzX,GAAAjpC,EAAAiX,QAAiB,OAAAgyB,KAAA0X,iBAAA,GAErkB,QAAAC,IAAA3X,GAAe,MAAAuX,IAAAvX,EAAA,WAAuB,OAAA9wC,GAAA,EAAAzI,EAAAmxD,GAAAC,GAAA32D,IAAAuE,MAAA,KAAAwJ,EAAA2oD,GAAA5X,EAAA9+C,IAAAuE,MAAA,KAAA1K,EAAA+U,KAAAosC,IAAAz1C,EAAA/M,OAAAuV,EAAAvV,QAAA24B,EAAA,EAAqG,GAAAnjB,GAAAmjB,EAAAt3B,EAAUs3B,IAAA,CAAK,GAAAylC,GAAArxD,EAAA4rB,IAAA,GAAAyhB,EAAA7kC,EAAAojB,IAAA,EAA0B,IAAuF,GAApFylC,EAAA,iBAAAh4D,KAAAg4D,KAAA,aAA0ChkB,EAAA,iBAAAh0C,KAAAg0C,KAAA,aAA0C,GAAAgkB,EAAA,GAAAp+D,QAAA,GAAAo6C,EAAA,GAAAp6C,OAAA,KAAwCwV,GAAA2nD,GAAA,GAAAiB,EAAA,GAAAp+D,OAAA,EAAAq+D,SAAAD,EAAA,UAAAhkB,EAAA,GAAAp6C,OAAA,EAAAq+D,SAAAjkB,EAAA,SAAA+iB,GAAA,GAAAiB,EAAA,GAAAp+D,OAAA,GAAAo6C,EAAA,GAAAp6C,SAAAm9D,GAAAiB,EAAA,GAAAhkB,EAAA,IAA8HgkB,IAAA,GAAOhkB,IAAA,SAAO,GAAA5kC,GAAY,UAAAA,IACtF,QAAA8oD,GAAAhY,EAAA9wC,GAAgBL,KAAA/Q,KAAAkiD,EAAYnxC,KAAAmxC,EAAAnxC,KAAA3F,OAAAgG,EAAqBL,KAAA4oD,IAAA,EAAgD,QAAAQ,IAAAjY,EAAA9wC,GAA2Q,GAA1P8oD,EAAA57D,KAAAyS,KAAAmxC,IAAAliD,KAAA,IAAyB+Q,KAAAqpD,cAAArpD,KAAAmxC,EAAAnxC,KAAA3F,OAAA,KAA2C2F,KAAAspD,OAAAtpD,KAAAupD,QAAAvpD,KAAAwpD,QAAAxpD,KAAAypD,QAAAzpD,KAAA0pD,QAAA,EAAkE1pD,KAAA3S,IAAA,GAAY2S,KAAA2pD,QAAA3pD,KAAA4pD,SAAA5pD,KAAA6pD,OAAA7pD,KAAA8pD,SAAA,EAAuD9pD,KAAA+pD,UAAA,EAAiB/pD,KAAAgqD,YAAA,GAAoBhqD,KAAApI,EAAA,KAAYu5C,EAAA,CAAM,GAAAv5C,GAAAoI,KAAA/Q,KAAAkiD,EAAAliD,KAAAmR,EAAA+wC,EAAA8Y,eAAA9Y,EAAA8Y,eAAA,OAA+G,IAA5CjqD,KAAA3F,OAAA82C,EAAA92C,QAAA82C,EAAA+Y,WAAmClqD,KAAAmxC,EAAA9wC,EAASA,EAAA8wC,EAAAkY,eAAsB,GAAAc,GAAA,CAAOhZ,EAAA,CAAG,IAAIsX,GAAApoD,EAAA+pD,SAAe,IAAAl+D,IAAA,CAAS,MAAAilD,GAAQ,MAAA3tB,IAAUt3B,GAAA,EAAKA,IAAAmU,EAAA,WAAa,aAAAzI,EAAAyI,EACt7B8wC,EAAAkZ,YAAA,YAAAzyD,IAAAyI,EAAA8wC,EAAAmZ,UAA6CtqD,MAAAqpD,cAAAhpD,EAAqB,OAAAD,GAAAJ,KAAA0pD,YAAA,KAAAvY,EAAAuY,QAAAvY,EAAAuY,QAAAvY,EAAAoZ,MAAAvqD,KAAAypD,YAAA,KAAAtY,EAAAsY,QAAAtY,EAAAsY,QAAAtY,EAAAqZ,MAAAxqD,KAAAwpD,QAAArY,EAAAqY,SAAA,EAAAxpD,KAAAupD,QAAApY,EAAAoY,SAAA,IAAAvpD,KAAA0pD,YAAA,KAAAtpD,EAAAspD,QAAAtpD,EAAAspD,QAAAtpD,EAAAmqD,MAAAvqD,KAAAypD,YAAA,KAAArpD,EAAAqpD,QAAArpD,EAAAqpD,QAAArpD,EAAAoqD,MAAAxqD,KAAAwpD,QAAAppD,EAAAopD,SAAA,EAAAxpD,KAAAupD,QAAAnpD,EAAAmpD,SAAA,GAA6TvpD,KAAAspD,OAAAnY,EAAAmY,OAAqBtpD,KAAA3S,IAAA8jD,EAAA9jD,KAAA,GAAmB2S,KAAA8pD,QAAA3Y,EAAA2Y,QAAuB9pD,KAAA6pD,OAAA1Y,EAAA0Y,OAAqB7pD,KAAA4pD,SAAAzY,EAAAyY,SAAyB5pD,KAAA2pD,QAC5exY,EAAAwY,QAAU3pD,KAAA+pD,UAAA5Y,EAAA4Y,WAAA,EAA8B/pD,KAAAgqD,YAAA5D,EAAAjV,EAAA6Y,aAAA7Y,EAAA6Y,YAAAhyC,GAAAm5B,EAAA6Y,cAAA,GAAsEhqD,KAAApI,EAAAu5C,EAASA,EAAAsZ,kBAAAzqD,KAAAK,KAA6U,QAAAqqD,IAAAvZ,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAuB8T,KAAAqtB,SAAA8jB,EAAgBnxC,KAAA2qD,MAAA,KAAgB3qD,KAAA4qD,IAAAvqD,EAAWL,KAAA/Q,KAAA2I,EAAYoI,KAAA6qD,UAAAzqD,EAAiBJ,KAAA8qD,GAAA5+D,EAAU8T,KAAA3S,MAAA09D,GAAc/qD,KAAAgrD,EAAAhrD,KAAAsmD,IAAA,EAAkB,QAAA2E,IAAA9Z,GAAeA,EAAA6Z,GAAA,EAAO7Z,EAAA9jB,SAAA,KAAgB8jB,EAAAwZ,MAAA,KAAaxZ,EAAAyZ,IAAA,KAAWzZ,EAAA2Z,GAAA,KAAW,QAAAI,IAAA/Z,GAAenxC,KAAA4qD,IAAAzZ,EAAWnxC,KAAAmxC,KAAUnxC,KAAAK,EAAA,EAAiN,QAAA8qD,IAAAha,EAAA9wC,GAAiB,GAAAzI,GAAAyI,EAAApR,IAAa,IAAA2I,IAAAu5C,KAAA,CAAa,GAAA3tB,GAAApjB,EAAA+wC,IAAAv5C,GAAA1L,EAAAk/D,GAAAhrD,EAAAC,IAAyBmjB,EAAA,GAAAt3B,IAAA6C,MAAA9B,UAAAq/B,OAAA/+B,KAAA6S,EAAAlU,EAAA,GAA6Cs3B,IAAAynC,GAAA5qD,GAAA,GAAA8wC,IAAAv5C,GAAA/M,eAAAsmD,KAAAv5C,GAAAu5C,EAAA9wC,OAC5/B,QAAAgrD,IAAAla,EAAA9wC,EAAAzI,EAAAwI,GAAqB,OAAAlU,GAAA,EAAYA,EAAAilD,EAAAtmD,SAAWqB,EAAA,CAAK,GAAAs3B,GAAA2tB,EAAAjlD,EAAW,KAAAs3B,EAAAwnC,GAAAxnC,EAAA6J,UAAAhtB,GAAAmjB,EAAAqnC,WAAAjzD,GAAA4rB,EAAAsnC,IAAA1qD,EAAA,MAAAlU,GAAyD,SAAgE,QAAAo/D,IAAAna,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAuB,GAAAkU,KAAAmrD,KAAA,MAAAC,IAAAra,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,EAAkC,IAAAmd,EAAAhJ,GAAA,CAAS,OAAAmjB,GAAA,EAAYA,EAAAnjB,EAAAxV,OAAW24B,IAAA8nC,GAAAna,EAAA9wC,EAAAmjB,GAAA5rB,EAAAwI,EAAAlU,EAAqB,aAAoB,MAAR0L,GAAA6zD,GAAA7zD,GAAQu5C,KAAAx4C,IAAAw4C,EAAAoX,GAAAloD,EAAAzI,EAAA8uD,GAAAtmD,OAAAyqD,UAAAzqD,EAAAlU,GAAAw/D,GAAAva,EAAA9wC,EAAAzI,GAAA,EAAAwI,EAAAlU,GACvT,QAAAw/D,IAAAva,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,EAAAs3B,GAAyB,IAAAnjB,EAAA,KAAA/T,OAAA,qBAAwC,IAAA28D,GAAAvC,GAAAx6D,OAAA2+D,UAAA3+D,EAAA+4C,EAAA0mB,GAAAxa,EAA8E,IAA1ClM,IAAAkM,EAAAya,IAAA3mB,EAAA,GAAAimB,IAAA/Z,IAAuBv5C,EAAAqtC,EAAAhmC,IAAAoB,EAAAzI,EAAAwI,EAAA6oD,EAAAzlC,GAAmB5rB,EAAA+yD,MAAA,MAAA/yD,EAA0D,IAAtCwI,EAAAyrD,KAAOj0D,EAAA+yD,MAAAvqD,EAAUA,EAAAwqD,IAAAzZ,EAAQ/wC,EAAAitB,SAAAz1B,EAAau5C,EAAAzJ,iBAAAokB,KAAA5/D,EAAA+8D,OAAA,KAAA/8D,OAAA,GAAAilD,EAAAzJ,iBAAArnC,KAAAD,EAAAlU,OAAwF,IAAAilD,EAAA4a,YAAA5a,EAAA4a,YAAAC,GAAA3rD,MAAAD,OAAwD,KAAA+wC,EAAA8a,cAAA9a,EAAA+a,eAAyD,KAAA5/D,OAAA,oDAAzD6kD,GAAA8a,YAAA7rD,GAAoI,MAAL+rD,MAAKv0D,EAC7d,QAAAi0D,MAAc,GAAA1a,GAAAib,GAAA/rD,EAAAgsD,GAAA,SAAAz0D,GAA0B,MAAAu5C,GAAA5jD,KAAA8S,EAAAuqD,IAAAvqD,EAAAgtB,SAAAz1B,IAAkC,SAAAA,GAA0C,KAA7BA,EAAAu5C,EAAA5jD,KAAA8S,EAAAuqD,IAAAvqD,EAAAgtB,SAAAz1B,IAA6B,MAAAA,GAAgB,OAAAyI,GAAS,QAAAmrD,IAAAra,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAuB,GAAAmd,EAAAhJ,GAAA,CAAS,OAAAmjB,GAAA,EAAYA,EAAAnjB,EAAAxV,OAAW24B,IAAAgoC,GAAAra,EAAA9wC,EAAAmjB,GAAA5rB,EAAAwI,EAAAlU,EAAqB,aAAoB,MAAR0L,GAAA6zD,GAAA7zD,GAAQu5C,KAAAx4C,IAAAw4C,EAAAsX,GAAApoD,EAAAzI,EAAA8uD,GAAAtmD,OAAAyqD,UAAAzqD,EAAAlU,GAAAw/D,GAAAva,EAAA9wC,EAAAzI,GAAA,EAAAwI,EAAAlU,GAC7O,QAAAogE,IAAAnb,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAuB,GAAAmd,EAAAhJ,GAAA,OAAAmjB,GAAA,EAAoBA,EAAAnjB,EAAAxV,OAAW24B,IAAA8oC,GAAAnb,EAAA9wC,EAAAmjB,GAAA5rB,EAAAwI,EAAAlU,OAAqBkU,GAAAsmD,GAAAtmD,OAAAyqD,UAAAzqD,EAAAxI,EAAA6zD,GAAA7zD,GAAAu5C,KAAAx4C,KAAAw4C,IAAA3tB,GAAAnjB,GAAAhO,KAAA8+C,OAAA3tB,EAAA2tB,IAAA9wC,IAAA,GAAAzI,EAAAyzD,GAAA7nC,EAAA5rB,EAAAwI,EAAAlU,MAAA++D,GAAAznC,EAAA5rB,IAAA7I,MAAA9B,UAAAq/B,OAAA/+B,KAAAi2B,EAAA5rB,EAAA,MAAA4rB,EAAA34B,eAAAsmD,KAAA9wC,GAAA8wC,EAAA9wC,QAAA8wC,MAAAwa,GAAAxa,MAAA9wC,EAAA8wC,IAAA9wC,MAAA8wC,GAAA,EAAA9wC,IAAA8wC,EAAAka,GAAAhrD,EAAAzI,EAAAwI,EAAAlU,KAAA0L,GAAA,EAAAu5C,EAAA9wC,EAAA8wC,GAAA,OAAAob,GAAA30D,IAC3E,QAAA20D,IAAApb,GAAe,mBAAAA,UAAA6Z,EAAA,CAAgC,GAAA3qD,GAAA8wC,EAAAyZ,GAAY,IAAAvqD,KAAA1H,IAAAwyD,GAAA9qD,EAAAmjB,EAAA2tB,OAAsB,CAAK,GAAAv5C,GAAAu5C,EAAAliD,KAAAmR,EAAA+wC,EAAAwZ,KAAuBtqD,GAAAsnC,oBAAAtnC,EAAAsnC,oBAAA/vC,EAAAwI,EAAA+wC,EAAA0Z,SAAAxqD,EAAAmsD,YAAAnsD,EAAAmsD,YAAAR,GAAAp0D,GAAAwI,GAAAC,EAAA4rD,aAAA5rD,EAAA6rD,gBAAA7rD,EAAA6rD,eAAA9rD,GAAqJ+rD,MAAKv0D,EAAA+zD,GAAAtrD,KAAA8qD,GAAAvzD,EAAAu5C,GAAA,GAAAv5C,EAAAyI,IAAAzI,EAAAgzD,IAAA,KAAAvqD,EAAAurD,IAAA,OAAAX,GAAA9Z,KAA4D,QAAA6a,IAAA7a,GAAe,MAAAA,KAAAsb,OAAAtb,GAAAsb,GAAAtb,GAAA,KAAAA,EAClV,QAAAub,IAAAvb,EAAA9wC,EAAAzI,EAAAwI,GAAqB,GAAAlU,IAAA,CAAS,KAAAilD,EAAAwa,GAAAxa,MAAA9wC,EAAA8wC,IAAA9wC,OAAA,IAAAA,IAAA3U,SAAAylD,EAAA,EAAuDA,EAAA9wC,EAAAxV,OAAWsmD,IAAA,CAAK,GAAA3tB,GAAAnjB,EAAA8wC,EAAW3tB,MAAAqnC,SAAAjzD,IAAA4rB,EAAAwnC,IAAAxnC,EAAAmpC,GAAAnpC,EAAApjB,GAAAlU,MAAA,IAAAs3B,GAA+C,MAAAt3B,GAAS,QAAAygE,IAAAxb,EAAA9wC,GAAiB,GAAAzI,GAAAu5C,EAAA9jB,SAAAjtB,EAAA+wC,EAAA2Z,IAAA3Z,EAAAyZ,GAA2C,OAAZzZ,GAAAmV,IAAAiG,GAAApb,GAAYv5C,EAAArK,KAAA6S,EAAAC,GACpO,QAAA+rD,IAAAjb,EAAA9wC,GAAiB,GAAA8wC,EAAA6Z,EAAA,QAAgB,KAAAqB,GAAA,CAAQ,IAAAhsD,EAAA8wC,EAAA,CAAS9wC,GAAA,iBAAqB,QAAAzI,GAAAsQ,EAAA9H,EAAA,EAAgBA,EAAAC,EAAAxV,OAAWuV,IAAA,UAAAxI,IAAAyI,EAAAD,KAAA,CAA0BC,EAAA,IAAO,MAAA8wC,GAAQ9wC,EAAAzI,EAA8B,GAA1BwI,EAAAC,EAAIA,EAAA,GAAA+oD,IAAAhpD,EAAAJ,MAAiBpI,GAAA,IAAK,EAAAwI,EAAAwsD,aAAA,IAAAxsD,EAAAysD,aAAA,CAA0C1b,EAAA,CAAG,GAAAjlD,IAAA,CAAS,OAAAkU,EAAAwsD,QAAA,IAAoBxsD,EAAAwsD,SAAA,CAAa,MAAAzb,GAAQ,MAAA8X,GAAS/8D,GAAA,GAAKA,OAAA,IAAAkU,EAAAysD,eAAAzsD,EAAAysD,aAAA,GAAkD,IAALzsD,KAAKlU,EAAAmU,EAAA8wC,EAAUjlD,EAAEA,IAAA4gE,WAAA1sD,EAAAnQ,KAAA/D,EAAkC,KAATilD,IAAAliD,KAAS/C,EAAAkU,EAAAvV,OAAA,EAAiB,GAAAqB,EAAKA,IAAA,CAAKmU,EAAA8wC,EAAA/wC,EAAAlU,EAAS,IAAAs3B,GAAAkpC,GAAAtsD,EAAAlU,GAAAilD,GAAA,EAAA9wC,EAAsBzI,MAAA4rB,EAAO,IAAAt3B,EAAA,EAAQA,EAAAkU,EAAAvV,OAAWqB,IAAAmU,EAAA8wC,EAAA/wC,EAAAlU,GAAAs3B,EAAAkpC,GAAAtsD,EAAAlU,GAAAilD,GAAA,EAAA9wC,GAAAzI,KAAA4rB,EAAsC,MAAA5rB,GAAS,MAAA+0D,IAAAxb,EACzf,GAAAiY,IAAA/oD,EAAAL,OAAgB,QAAA2rD,IAAAxa,GAAuB,MAARA,KAAAya,IAAQza,YAAA+Z,IAAA/Z,EAAA,KAAoF,QAAAsa,IAAAta,GAAe,MAAAsV,IAAAtV,MAAkBA,EAAA4b,MAAA5b,EAAA4b,IAAA,SAAA1sD,GAA0B,MAAA8wC,GAAA6b,YAAA3sD,KAA0B8wC,EAAA4b,KAAc,QAAAE,KAAa1F,EAAAh6D,KAAAyS,MAAaA,KAAAwjB,EAAA,GAAA0nC,IAAAlrD,MAAoBA,KAAAktD,EAAAltD,KAAYA,KAAAmtD,EAAA,KAGxR,QAAAC,IAAAjc,EAAA9wC,EAAAzI,EAAAwI,GAAwC,KAAnBC,EAAA8wC,EAAA3tB,EAAA2tB,EAAA9wC,EAAAhO,KAAmB,QAAegO,KAAA3U,QAAa,QAAAQ,IAAA,EAAAs3B,EAAA,EAAiBA,EAAAnjB,EAAAxV,SAAW24B,EAAA,CAAK,GAAAylC,GAAA5oD,EAAAmjB,EAAW,IAAAylC,MAAA+B,GAAA/B,EAAA4B,SAAAjzD,EAAA,CAA0B,GAAAqtC,GAAAgkB,EAAA57B,SAAAllB,EAAA8gD,EAAA6B,IAAA7B,EAAA2B,GAA+B3B,GAAA3C,IAAA6E,GAAAha,EAAA3tB,EAAAylC,GAAgB/8D,GAAA,IAAA+4C,EAAA13C,KAAA4a,EAAA/H,IAAAlU,GAAuB,MAAAA,IAAA,GAAAkU,EAAAwoD,GAAmB,QAAAyE,IAAAlc,GAAe,eAAA9rC,KAAA8rC,IAAA,4BAAkC9rC,KAAA8rC,EAAA7rC,QAAA,wBAAAA,QAAA,mIAA+L,KAAAA,QAAA,0CAA6D,QAAAgoD,IAAAnc,GAA2B,GAAZA,GAAA9+C,GAAYg7D,GAAAlc,GAAA,IAAa,MAAAoc,MAAA,IAAApc,EAAA,KAAuB,MAAA9wC,IAAU,KAAA/T,OAAA,wBAAA6kD,GAAwC,QAAA+V,IAAA/V,GAAe,GAAA9wC,KAAwB,OAAfmtD,IAAA,GAAAC,IAAAtc,EAAA9wC,GAAeA,EAAAjQ,KAAA,IAAkB,QAAAq9D,OAC1rB,QAAAD,IAAArc,EAAA9wC,EAAAzI,GAAmB,SAAAyI,EAAAzI,EAAA3H,KAAA,YAA0B,CAAK,mBAAAoQ,GAAA,CAAuB,GAAAgJ,EAAAhJ,GAAA,CAAS,GAAAD,GAAAC,CAAQA,GAAAD,EAAAvV,OAAW+M,EAAA3H,KAAA,IAAY,QAAA/D,GAAA,GAAAs3B,EAAA,EAAiBA,EAAAnjB,EAAImjB,IAAA5rB,EAAA3H,KAAA/D,GAAAshE,GAAArc,EAAA/wC,EAAAojB,GAAA5rB,GAAA1L,EAAA,GAA6C,YAAZ0L,GAAA3H,KAAA,KAAmB,KAAAoQ,YAAAhO,SAAAgO,YAAAwN,SAAAxN,YAAAqtD,UAAgF,CAAK91D,EAAA3H,KAAA,KAAY/D,EAAA,EAAK,KAAAkU,IAAAC,GAAA/S,OAAAL,UAAAE,eAAAI,KAAA8S,EAAAD,IAAA,mBAAAojB,EAAAnjB,EAAAD,MAAAxI,EAAA3H,KAAA/D,GAAAyhE,GAAAvtD,EAAAxI,KAAA3H,KAAA,KAAAu9D,GAAArc,EAAA3tB,EAAA5rB,GAAA1L,EAAA,IAAiJ,YAAZ0L,GAAA3H,KAAA,KAA3OoQ,IAAAutD,UAA+P,aAAAvtD,IAAiB,aAAAstD,GAAAttD,EAAAzI,EAAsB,MAAM,cAAAA,EAAA3H,KAAAsS,SAAAlC,KACtetS,MAAAsS,KAAAhO,GAAA,OAA4B,MAAM,eAAAuF,EAAA3H,KAAAoQ,EAAAhO,GAAiC,MAAM,gBAAAuF,EAAA3H,KAAA,OAA+B,MAAM,cAAA3D,OAAA,uBAAA+T,MAC9G,QAAAstD,IAAAxc,EAAA9wC,GAAiBA,EAAApQ,KAAA,IAAAkhD,EAAA7rC,QAAAuoD,GAAA,SAAA1c,GAAoC,GAAA9wC,GAAAytD,GAAA3c,EAAgF,OAApE9wC,OAAA,aAAA8wC,EAAA5+C,WAAA,IAAAoO,SAAA,IAAAuS,OAAA,GAAA46C,GAAA3c,GAAA9wC,GAAoEA,IAAS,KAAQ,QAAA0tD,IAAA5c,EAAA9wC,GAAiBL,KAAApI,EAAAu5C,EAASnxC,KAAAwjB,EAAAnjB,EAASL,KAAAK,EAAA,EAASL,KAAAmxC,EAAA,KAA+H,QAAA6c,MAAchuD,KAAAK,EAAAL,KAAAmxC,EAAA,KAAoL,QAAA8c,MAAc,GAAA9c,GAAA+c,GAAA7tD,EAAA,IAAsE,OAAtD8wC,OAAA9wC,EAAA8wC,YAAAtrC,KAAAsrC,QAAA9wC,EAAA,MAAAA,EAAAwF,KAAA,MAAsDxF,EAAS,QAAA8tD,MAAcnuD,KAAA6F,KAAA7F,KAAAK,EAAAL,KAAAmxC,EAAA,KAA0J,QAAAid,IAAAjd,GAAejpC,EAAAmhB,WAAA,WAAwB,KAAA8nB,IAAS,GACxzB,QAAAkd,MAAc,GAAAld,GAAAjpC,EAAAomD,cAC6H,QADtG,KAAAnd,GAAA,mBAAA1U,gBAAA8xB,aAAA9xB,OAAAiL,mBAAAugB,EAAA,YAAA9W,EAAA,WAA8H,GAAAA,GAAAhyB,SAAAqvC,cAAA,SAAuCrd,GAAAsd,MAAAC,QAAA,OAAuBvd,EAAAyZ,IAAA,GAASzrC,SAAAwvC,gBAAAC,YAAAzd,EAAwC,IAAA9wC,GAAA8wC,EAAA0d,aAAsB1d,GAAA9wC,EAAA8e,SAAagyB,EAAAloB,OAASkoB,EAAA9Z,MAAA,IAAY8Z,EAAA5rB,OAAU,IAAA3tB,GAAA,gBAAAqJ,KAAAE,SAAAf,EAAA,SAAAC,EAAAyuD,SAAAC,SAAA,IAAA1uD,EAAAyuD,SAAAC,SAAA,KAAA1uD,EAAAyuD,SAAA/rD,IAAgHouC,GAAApkB,EAAA,SAAAokB,GAAgB,KAAA/wC,GAAA+wC,EAAA6d,QAAA5uD,GAAA+wC,EAAA1qC,MACpd7O,GAAAoI,KAAAivD,MAAAC,aAAyBlvD,MAAOK,EAAAqnC,iBAAA,UAAAyJ,GAAA,GAAmCnxC,KAAAivD,SAAcjvD,KAAAmvD,OAAYZ,YAAA,WAAuBluD,EAAAkuD,YAAA32D,EAAAwI,WAAuB,KAAA+wC,IAAA8W,EAAA,aAAAA,EAAA,SAAsD,GAAA5nD,GAAA,GAAA8wC,GAAAv5C,KAAgBwI,EAAAxI,CAA0F,OAArFyI,GAAA4uD,MAAAC,UAAA,WAA6B,YAAAt3D,EAAAiO,KAAA,CAAoBjO,IAAAiO,IAAS,IAAAsrC,GAAAv5C,EAAAmxD,EAAWnxD,GAAAmxD,GAAA,KAAU5X,MAAM,SAAAA,GAAmB/wC,EAAAyF,MAAQkjD,GAAA5X,GAAM/wC,IAAAyF,KAASxF,EAAA8uD,MAAAZ,YAAA,IAAwB,yBAAApvC,WAAA,sBAAAA,UAAAqvC,cAAA,mBAAArd,GAAyG,GAAA9wC,GAAA8e,SAAAqvC,cAAA,SACtdnuD,GAAA+uD,mBAAA,WAAgC/uD,EAAA+uD,mBAAA,KAA0B/uD,EAAAysD,WAAAuC,YAAAhvD,GAA4BA,EAAA,KAAO8wC,IAAIA,EAAA,MAAQhyB,SAAAwvC,gBAAAC,YAAAvuD,IAAwC,SAAA8wC,GAAajpC,EAAAmhB,WAAA8nB,EAAA,IAA2B,QAAAme,MAAc,QAAApnD,EAAA6e,QAAA10B,IAAAd,QAAA,kBAAmD,GAAA4/C,GAAAjpC,EAAA6e,QAAA9sB,YAAA,GAAgCs1D,IAAA,WAAcpe,EAAAxjB,KAAA6hC,SAAYD,IAAA,WAAmB,GAAApe,GAAAqe,IAAS/I,GAAAv+C,EAAAunD,eAAAvnD,EAAAwnD,QAAAxnD,EAAAwnD,OAAAziE,YAAAg7D,EAAA,SAAA//C,EAAAwnD,OAAAziE,UAAAwiE,cAAAvnD,EAAAunD,cAAAE,QAAAtB,MAAAsB,GAAAxe,IAAAjpC,EAAAunD,aAAAte,IAA4K,QAAAqe,MAAc,OAAAre,GAAUA,EAAA8c,MAAO,CAAE,IAAI9c,IAAA5jD,KAAA4jD,EAAA9wC,GAAc,MAAAzI,GAASw2D,GAAAx2D,GAAM,GAAAyI,GAAAuvD,EAASvvD,GAAAmjB,EAAA2tB,GAAO,IAAA9wC,YAAA8wC,EAAAtrC,KAAAxF,EAAA8wC,EAAA9wC,EAAA8wC,KAAkC0e,IAAA,EAAO,QAAAC,IAAA3e,EAAA9wC,GAAiB4sD,EAAA1/D,KAAAyS,MAAaA,KAAAK,EAAA8wC,GAAA,EAAYnxC,KAAAmxC,EAAA9wC,GAAA6H,EAAYlI,KAAApI,EAAAm1B,EAAA/sB,KAAAysD,GAAAzsD,MAAuBA,KAAA+vD,EAAAC,IACpsB,QAAAC,IAAA9e,GAAeA,EAAAuV,IAAA,EAAQvV,EAAA+e,IAAA/e,IAAAlB,aAAAkB,EAAA+e,GAAA/e,EAAA+e,EAAA,MAA+F,QAAAC,IAAAhf,EAAA9wC,EAAAzI,GAAmB,GAAA6uD,GAAAtV,GAAAv5C,IAAAu5C,EAAApkB,EAAAokB,EAAAv5C,QAAuB,KAAAu5C,GAAA,kBAAAA,GAAA6b,YAAiE,KAAA1gE,OAAA,4BAAjE6kD,GAAApkB,EAAAokB,EAAA6b,YAAA7b,GAA+G,mBAAA9wC,GAAA,EAAA6H,EAAAmhB,WAAA8nB,EAAA9wC,GAAA,GAAqD,QAAA+vD,IAAAjf,EAAA9wC,EAAAzI,GAAmB2vD,EAAAh6D,KAAAyS,MAAaA,KAAAwjB,EAAA,MAAA5rB,EAAAm1B,EAAAokB,EAAAv5C,GAAAu5C,EAAwBnxC,KAAApI,EAAAyI,EAASL,KAAAK,EAAA0sB,EAAA/sB,KAAA0qD,GAAA1qD,MAAuBA,KAAAmxC,KAAgR,QAAAkf,IAAAlf,GAAeA,EAAAmf,EAAAH,GAAAhf,EAAA9wC,EAAA8wC,EAAAv5C,GAAgBu5C,EAAA3tB,EAAAh4B,MAAA,KAAA2lD,KAAqB,QAAAof,IAAApf,GAAeoW,EAAAh6D,KAAAyS,MAAaA,KAAAK,EAAA8wC,EAASnxC,KAAAmxC,KAA4B,QAAAqf,IAAArf,EAAA9wC,EAAAzI,EAAAwI,GAAqBiJ,EAAAzR,SAAA64D,GAAA,GAAA74D,QAAA64D,GAAqC,QAAAvkE,GAAA,EAAYA,EAAA0L,EAAA/M,OAAWqB,IAAA,CAAK,GAAAs3B,GAAA8nC,GAAAjrD,EAAAzI,EAAA1L,GAAAkU,GAAA+wC,EAAA6b,aAAA,EAAA7b,EAAA9wC,GAAA8wC,EAA4C,KAAA3tB,EAAA,KAAY2tB,KAAA3tB,EAAAn2B,KAAAm2B,GAAc,QAAAktC,IAAAvf,GAAegX,GAAAhX,IAAA,SAAAA,EAAAv5C,GAAqBoI,KAAAmxC,EAAAhkD,eAAAyK,IAAA20D,GAAApb,IAAgCA,GAAIA,OAA2J,QAAAwf,IAAAxf,EAAA9wC,EAAAzI,GAAmBoI,KAAA0xC,MAAAP,EAAA9wC,EAAAzI,MAAA,WAAmJ,QAAAg5D,IAAAzf,GAAenxC,KAAAwjB,EAAA2tB,EAASnxC,KAAAK,EAAAL,KAAApI,EAAAoI,KAAAmxC,EAAA,KAA0B,QAAA0f,GAAA1f,EAAA9wC,GAAgBL,KAAAnR,KAAAsiD,EAAYnxC,KAAAvS,MAAA4S,EAAmL,QAAAywD,IAAA3f,GAAe,MAAAA,GAAAv5C,EAAAu5C,EAAAv5C,EAAkBu5C,IAAA2f,GAAA3f,MAAsBmW,GAAA,iCAAoC,MAChpD,QAAAyJ,IAAA5f,GAAe6f,QAAA,GAAAJ,IAAA,IAAAK,GAAA,IAAAD,MAAAp5D,EAAAs5D,GAAsC,IAAA7wD,EAAM,MAAAA,EAAA4wD,GAAA9f,IAAA,CAAe9wC,EAAA,GAAAuwD,IAAAzf,EAAY,IAAAv5C,GAAAu5C,EAAAggB,YAAA,KAAA/wD,EAAA+wC,EAAAj+B,OAAAtb,EAAA,EAAyCA,GAAAm5D,GAAA5f,EAAAj+B,OAAA,EAAAtb,IAAoBA,EAAAyI,IAAAzI,EAAAyI,MAAczI,EAAAyI,EAAAD,GAAAC,EAASA,EAAA8wC,EAAAv5C,EAAMq5D,GAAA9f,GAAA9wC,EAAQ,MAAAA,GAAU,QAAA+wD,GAAAjgB,EAAA9wC,GAAgB8wC,KAAA5lD,IAAA8lE,GAAAhxD,MAAA,IAAsB,QAAAixD,IAAAngB,EAAA9wC,GAAiB8wC,KAAA5lD,IAAAgmE,GAAAlxD,MAAA,IAAsB,QAAAmxD,GAAArgB,EAAA9wC,GAAgB8wC,KAAA5lD,IAAAkmE,GAAApxD,MAAA,IAAuB,QAAAqxD,MAAc1xD,KAAAmxC,EAAA4f,GAAA,4CAAsD/wD,KAAAK,GAAA,EAAgD,QAAAsxD,IAAAxgB,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,EAAAs3B,GAAyBouC,EAAAzgB,EAAA,WAAe,GAAAA,EAAA9wC,EAAA,GAAAmjB,EAAsB,OAATylC,GAAA,GAAShkB,EAAAzhB,EAAA5sB,MAAA,KAAAuR,EAAA,EAA2BA,EAAA88B,EAAAp6C,OAAWsd,IAAA,CAAK,GAAA0pD,GAAA5sB,EAAA98B,GAAAvR,MAAA,IAAsB,MAAAi7D,EAAAhnE,OAAA,CAAe,GAAAinE,GAAAD,EAAA,EAAWA,KAAA,EAAO,IAAAE,GAAAD,EAAAl7D,MAAA,IAAoBqyD,GAAA,GAAA8I,EAAAlnE,QAAA,QAAAknE,EAAA,GAAA9I,GAAA6I,EAAA,KAAAD,EAAA,IAAA5I,GAAA6I,EAAA,mBAAmE7I,GAAA,SAAYA,GAAAzlC,CAAS,uBAAApjB,EAAA,cAAAlU,EAAA,MAAAmU,EAAA,KAAAzI,EAAA,KAAAqxD,IACxsB,QAAA+I,IAAA7gB,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,EAAAs3B,EAAAylC,GAA2B2I,EAAAzgB,EAAA,WAAe,uBAAA/wC,EAAA,eAAAlU,EAAA,MAAAmU,EAAA,KAAAzI,EAAA,KAAA4rB,EAAA,IAAAylC,IAAwE,QAAAgJ,GAAA9gB,EAAA9wC,EAAAzI,EAAAwI,GAAoBwxD,EAAAzgB,EAAA,WAAe,uBAAA9wC,EAAA,MAAA6xD,GAAA/gB,EAAAv5C,IAAAwI,EAAA,IAAAA,EAAA,MAAsD,QAAA+xD,IAAAhhB,EAAA9wC,GAAiBuxD,EAAAzgB,EAAA,WAAe,kBAAA9wC,IAAsB,QAAA+xD,GAAAjhB,EAAA9wC,GAAgBmxD,EAAArgB,IAAA9wC,GAAS,QAAAgyD,IAAAlhB,EAAA9wC,EAAAzI,IAAmBu5C,UAAA5lD,IAAA+mE,GAAA16D,GAAA,YAAAyI,GAAoC,QAAAuxD,GAAAzgB,EAAA9wC,GAAgBixD,GAAAngB,IAAA9wC,GAAU,QAAA4mD,GAAA9V,EAAA9wC,IAAgB8wC,UAAA5lD,IAAA+mE,GAAAjyD,MAAA,IAC3X,QAAA6xD,IAAA/gB,EAAA9wC,GAAiB,IAAA8wC,EAAA9wC,EAAA,MAAAA,EAAiB,KAAAA,EAAA,WAAkB,KAAI,GAAAzI,GAAAlH,KAAA6hE,MAAAlyD,EAAoB,IAAAzI,EAAA,OAAAwI,GAAA,EAAiBA,EAAAxI,EAAA/M,OAAWuV,IAAA,GAAAiJ,EAAAzR,EAAAwI,IAAA,CAAgB,GAAAlU,GAAA0L,EAAAwI,EAAW,QAAAlU,EAAArB,QAAA,CAAkB,GAAA24B,GAAAt3B,EAAA,EAAW,IAAAmd,EAAAma,MAAA,EAAAA,EAAA34B,QAAA,CAAwB,GAAAo+D,GAAAzlC,EAAA,EAAW,YAAAylC,GAAA,QAAAA,GAAA,SAAAA,EAAA,OAAAhkB,GAAA,EAAgDA,EAAAzhB,EAAA34B,OAAWo6C,IAAAzhB,EAAAyhB,GAAA,KAAc,MAAAiiB,IAAAtvD,GAAa,MAAAuQ,GAAS,MAAAiqD,GAAAjhB,EAAA,6DAAA9wC,GAAwF,QAAAmyD,IAAArhB,GAAegY,EAAA57D,KAAAyS,KAAA,qBAAAmxC,GAA4C,QAAAshB,IAAAthB,GAAegc,EAAAuF,cAAA,GAAAF,IAAArF,EAAAhc,IAA6B,QAAAwhB,IAAAxhB,GAAegY,EAAA57D,KAAAyS,KAAA,YAAAmxC,GAAmC,QAAAyhB,GAAAzhB,GAAcgc,EAAAuF,cAAA,GAAAC,IAAAxF,EAAAhc,IAA6B,QAAA0hB,IAAA1hB,GAAegY,EAAA57D,KAAAyS,KAAA,cAAAmxC,GAAqC,QAAA2hB,IAAA3hB,EAAA9wC,EAAAzI,GAAmBu1D,EAAAuF,cAAA,GAAAG,IAAA1F,EAAAhc,EAAA9wC,EAAAzI,IAAiC,QAAAm7D,IAAA5hB,EAAA9wC,GAAiB,IAAAomD,GAAAtV,GAAA,KAAA7kD,OAAA,6CAAoE,OAAA4b,GAAAmhB,WAAA,WAA+B8nB,KAAI9wC,GAAqQ,QAAA2yD,OAAsD,QAAAC,MAAc9J,EAAA57D,KAAAyS,KAAA,KAAyB,QAAAkzD,MAAc/J,EAAA57D,KAAAyS,KAAA,KAAyB,QAAAmzD,OAAmC,QAAAC,IAAAjiB,GAAe,GAAA9wC,EAAuD,QAAjDA,EAAA8wC,OAAA9wC,KAAcgzD,GAAAliB,KAAA9wC,EAAA,MAAAA,EAAA,OAAAA,EAAA8wC,IAAA9wC,GAAmCA,EAAiB,QAAAizD,OAAwB,QAAAC,IAAApiB,GAAe,OAAAA,EAAAkiB,GAAAliB,IAAA,GAAAqiB,eAAAriB,GAAA,GAAAsiB,gBAAwD,QAAAJ,IAAAliB,GAAe,IAAAA,EAAA9wC,GAAA,mBAAAozD,iBAAA,mBAAAD,eAAA,CAAgF,OAAAnzD,IAAA,gFAAAzI,EAAA,EAA+FA,EAAAyI,EAAWzI,IAAA,CAAK,GAAAwI,GAAAC,EAAAzI,EAAW,KAAI,UAAA47D,eAAApzD,GAAA+wC,EAAA9wC,EAAAD,EAAkC,MAAAlU,KAAW,KAAAI,OAAA,8FAA2G,MAAA6kD,GAAA9wC,EAAqB,QAAAqzD,GAAAviB,EAAA9wC,EAAAzI,EAAAwI,GAAoBJ,KAAAhO,EAAAm/C,EAASnxC,KAAAK,IAASL,KAAApI,IAASoI,KAAA2zD,EAAAvzD,GAAA,EAAYJ,KAAA0zD,EAAA,GAAAnD,IAAAvwD,MAAoBA,KAAA4zD,EAAAC,GAAU1iB,EAAA2iB,GAAA,WAAgB9zD,KAAA+zD,EAAA,GAAAjE,IAAA3e,GAAiBnxC,KAAAg0D,EAAA,KAAYh0D,KAAAwjB,GAAA,EAAUxjB,KAAAomD,EAAApmD,KAAA+vD,EAAA/vD,KAAAipD,EAAAjpD,KAAAmtD,EAAAntD,KAAAwxD,EAAAxxD,KAAAi0D,EAAAj0D,KAAA9N,EAAA,KAAsD8N,KAAAunD,KAAUvnD,KAAAmxC,EAAA,KAAYnxC,KAAAoyD,EAAA,EAASpyD,KAAAilC,EAAAjlC,KAAAk0D,EAAA,KAAmBl0D,KAAAoxD,GAAA,EAAUpxD,KAAA6wD,GAAA,EAAU7wD,KAAAktD,EAAA,EAASltD,KAAA6xD,EAAA,KAAY7xD,KAAAmI,EAAAnI,KAAAm0D,EAAAn0D,KAAA4yD,GAAA,EAC3iE,QAAAwB,IAAAjjB,EAAA9wC,GAAiB,OAAA8wC,GAAU,qCAAA9wC,EAAA,GAA2C,yCAAyC,sCAAsC,gCAAgG,QAAAg0D,IAAAljB,EAAA9wC,EAAAzI,GAAmBu5C,EAAAgc,EAAA,EAAMhc,EAAA8X,EAAAqL,GAAAC,EAAAl0D,IAAa8wC,EAAAiV,EAAAxuD,EAAMu5C,EAAAyhB,GAAA,EAAO4B,GAAArjB,EAAA,MAAW,QAAAsjB,IAAAtjB,EAAA9wC,EAAAzI,EAAAwI,GAAqB+wC,EAAAgc,EAAA,EAAMhc,EAAA8X,EAAAqL,GAAAC,EAAAl0D,IAAa8wC,EAAAiV,EAAA,KAASjV,EAAAyhB,EAAAh7D,EAAM48D,GAAArjB,EAAA/wC,GAC1W,QAAAo0D,IAAArjB,EAAA9wC,GAAiB8wC,EAAAqgB,EAAAxB,IAAQ0E,GAAAvjB,GAAMA,EAAA4e,EAAAwE,EAAApjB,EAAA8X,GAAW0L,GAAAxjB,EAAA4e,EAAA,IAAA5e,EAAAwiB,GAAgBxiB,EAAAihB,EAAA,EAAMjhB,MAAAn/C,EAAAw0D,GAAArV,EAAAn/C,EAAA40D,KAAAvmD,EAAA,MAA4B,EAAA8wC,EAAA+b,IAAA/b,EAAA0gB,EAAA,GAAAzB,IAAArjC,EAAAokB,EAAA6X,GAAA7X,SAAA+b,IAAuCsD,GAAArf,EAAAuiB,EAAAviB,IAAA,mBAAAA,EAAAka,IAAoChrD,EAAA8wC,EAAA6iB,EAAA1L,GAAAnX,EAAA6iB,MAAiB7iB,EAAAiV,GAAAjV,EAAA+iB,IAAA/iB,EAAA+iB,EAAA,QAAA7zD,EAAA,oDAAA8wC,IAAAuW,GAAAvW,EAAA4e,EAAA5e,EAAA+iB,EAAA/iB,EAAAiV,EAAA/lD,KAAA8wC,EAAA+iB,EAAA,MAAA/iB,IAAAuW,GAAAvW,EAAA4e,EAAA5e,EAAA+iB,EAAA,KAAA7zD,IAAuIoyD,GAAA,GAAMd,GAAAxgB,EAAA9wC,EAAA8wC,EAAA+iB,EAAA/iB,EAAA4e,EAAA5e,EAAAv5C,EAAAu5C,EAAAwiB,EAAAxiB,EAAAiV,GAErU,QAAAwO,IAAAzjB,GAAe,GAAA9wC,GAAA6sD,EAAA/b,KAAAv5C,EAAAu5C,IAAAmX,KAAAloD,EAAA+wC,IAAA2gB,GAAkC,QAAAzxD,GAAA,GAAAA,IAAAyzD,KAAA3iB,IAAA0jB,KAAA,CAAgC1jB,EAAA0f,GAAA,GAAAxwD,GAAA,GAAAzI,GAAA66D,GAAA,GAAA76D,GAAA,GAAAwI,EAAA,KAA0C00D,GAAA3jB,EAAM,IAAAjlD,GAAAilD,IAAA2gB,GAAc3gB,GAAAigB,EAAAllE,GAAM0L,EAAAu5C,IAAA0jB,MAAAzC,EAAAjhB,EAAA9wC,EAAA,WAA8B,kCAAA8wC,EAAA4e,EAAA,WAAA7jE,IAAqDilD,EAAA3tB,EAAA,KAAAt3B,EAAW8lE,GAAA7gB,EAAA9wC,EAAA8wC,EAAA+iB,EAAA/iB,EAAA4e,EAAA5e,EAAAv5C,EAAAu5C,EAAAwiB,EAAAtzD,EAAAnU,GAA4BilD,EAAA3tB,IAAQpjB,EAAA20D,GAAA5jB,MAAA8gB,EAAA9gB,EAAA9wC,EAAA8wC,EAAAv5C,EAAAwI,EAAA,0DAAA+wC,EAAAhpC,GAAA,EAAA6sD,GAAA7jB,EAAA/wC,IAAgG+wC,EAAAyhB,GAAAqC,GAAA9jB,EAAA9wC,EAAAzI,GAAAk8D,IAAA3iB,EAAA3tB,GAAA,GAAAnjB,GAAA60D,GAAA/jB,KAAA8gB,EAAA9gB,EAAA9wC,EAAA8wC,EAAAv5C,IAAA,MAAAo9D,GAAA7jB,EAAAv5C,IAAiE,GAAAyI,GAAA80D,GAAAhkB,GAAYA,EAAA3tB,IAAA2tB,EAAA0f,IAAA,GAAAxwD,EAAA8wC,EAAAn/C,EAAA41D,GAAAzW,MAAA3tB,GAAA,EAAAkxC,GAAAvjB,OAA2C,KAC/ejlD,GAAA,EAAA0L,EAAArG,QAAA,gBAAA4/C,EAAAlM,EAAA,EAAA2tB,EAAA,IAAAxB,EAAAjgB,EAAA9wC,EAAA8wC,EAAA,wBAAAA,EAAAv5C,EAAA,OAAAu5C,EAAAlM,EAAA,EAAA2tB,EAAA,IAAAxB,EAAAjgB,EAAA9wC,EAAA8wC,EAAA,sBAAAjlD,EAAA,KAAAilD,EAAAv5C,EAAA,MAAAu9D,GAAAhkB,GAAAikB,GAAAjkB,KAA8J,QAAA4jB,IAAA5jB,GAAe,OAAAA,EAAAgjB,GAAAhjB,EAAAhpC,EAAA,KAAAgpC,QAAAkkB,GAAAlkB,IAAA,8BAAA4W,GAAA5W,KAAA,KAC7K,QAAA8jB,IAAA9jB,EAAA9wC,EAAAzI,GAAmB,OAAAwI,IAAA,GAAa+wC,EAAA0f,GAAA1f,EAAAihB,EAAAx6D,EAAA/M,QAAmB,CAAE,GAAAqB,GAAAigC,GAAAglB,EAAAv5C,EAAc,IAAA1L,GAAAopE,GAAA,CAAU,GAAAj1D,IAAA8wC,EAAAlM,EAAA,EAAA2tB,EAAA,IAAAxyD,GAAA,GAAyB6xD,EAAA9gB,EAAA9wC,EAAA8wC,EAAAv5C,EAAA,6BAAwC,OAAM,GAAA1L,GAAAqpE,GAAA,CAAepkB,EAAAlM,EAAA,EAAM2tB,EAAA,IAAMX,EAAA9gB,EAAA9wC,EAAA8wC,EAAAv5C,IAAA,mBAA+BwI,GAAA,CAAK,OAAM6xD,EAAA9gB,EAAA9wC,EAAA8wC,EAAAv5C,EAAA1L,EAAA,MAAA8oE,GAAA7jB,EAAAjlD,GAA+B,GAAAmU,GAAA,GAAAzI,EAAA/M,SAAAsmD,EAAAlM,EAAA,EAAA2tB,EAAA,IAAAxyD,GAAA,GAAsC+wC,EAAA3tB,EAAA2tB,EAAA3tB,GAAApjB,EAAWA,IAAA6xD,EAAA9gB,EAAA9wC,EAAA8wC,EAAAv5C,IAAA,8BAAAu9D,GAAAhkB,GAAAikB,GAAAjkB,IACzS,QAAA+jB,IAAA/jB,GAAeqf,GAAArf,EAAAuiB,EAAAviB,EAAA4iB,EAAA,OAAA5iB,EAAA+Z,IAAwB/Z,EAAA4iB,EAAAx7D,QAAY,QAAA4zB,IAAAglB,EAAA9wC,GAAiB,GAAAzI,GAAAu5C,EAAAihB,EAAAhyD,EAAAC,EAAA9O,QAAA,KAAAqG,EAA8B,WAAAwI,EAAAk1D,IAAmB19D,GAAAyI,EAAA5P,UAAAmH,EAAAwI,GAA2BrS,MAAA6J,GAAA29D,IAAsBn1D,GAAA,GAAKxI,EAAAyI,EAAAxV,OAAAyqE,IAA0Bj1D,IAAA6S,OAAA9S,EAAAxI,GAAgBu5C,EAAAihB,EAAAhyD,EAAAxI,EAAQyI,IAAiD,QAAAq0D,IAAAvjB,GAAeA,EAAA8iB,EAAAjE,IAAA7e,EAAAyiB,EAAY4B,GAAArkB,IAAAyiB,GAAU,QAAA4B,IAAArkB,EAAA9wC,GAAiB,SAAA8wC,EAAAj/C,EAAA,KAAA5F,OAAA,0BAAoD6kD,GAAAj/C,EAAA6gE,GAAAhmC,EAAAokB,EAAA8Z,GAAA9Z,GAAA9wC,GAAoB,QAAAy0D,IAAA3jB,GAAeA,EAAAj/C,IAAAgW,EAAA+nC,aAAAkB,EAAAj/C,GAAAi/C,EAAAj/C,EAAA,MACxI,QAAAkjE,IAAAjkB,GAAeA,EAAAn/C,EAAA22D,MAAAxX,EAAA0f,GAAA1f,EAAAn/C,EAAA41D,GAAAzW,GAAyB,QAAAgkB,IAAAhkB,GAAe2jB,GAAA3jB,EAAM,IAAA9wC,GAAA8wC,EAAA0gB,CAAUxxD,IAAA,kBAAAA,GAAAo1D,GAAAp1D,EAAAo1D,IAAiCtkB,EAAA0gB,EAAA,KAAS5B,GAAA9e,EAAA4iB,GAAQrD,GAAAvf,EAAAuiB,GAAQviB,MAAA9wC,EAAA8wC,QAAA,KAAA9wC,EAAA+8B,QAAA/8B,EAAAo1D,KACpZ,QAAAT,IAAA7jB,EAAA9wC,GAAiB,IAAI8wC,EAAAn/C,EAAA8hE,GAAA3iB,EAAA9wC,GAAAoyD,GAAA,GAAkB,MAAA76D,GAASy6D,GAAAlhB,EAAA9wC,EAAAzI,EAAA,kCAA4C,QAAA89D,IAAAvkB,GAAe,GAAAA,EAAA8b,GAAA,kBAAA9b,GAAA8b,EAAA,MAAA9b,GAAA8b,GAA4C,IAAA7G,EAAAjV,GAAA,MAAAA,GAAAv6C,MAAA,GAA2B,IAAA4vD,GAAArV,GAAA,CAAU,OAAA9wC,MAAAzI,EAAAu5C,EAAAtmD,OAAAuV,EAAA,EAA4BA,EAAAxI,EAAIwI,IAAAC,EAAApQ,KAAAkhD,EAAA/wC,GAAiB,OAAAC,GAAS,MAAA+nD,IAAAjX,GACtP,QAAAwkB,IAAAxkB,EAAA9wC,GAAiB,GAAA8wC,EAAAnjD,SAAA,kBAAAmjD,GAAAnjD,QAAAmjD,EAAAnjD,QAAAqS,MAAA,QAA+D,IAAAmmD,GAAArV,IAAAiV,EAAAjV,GAAAykB,GAAAzkB,EAAA9wC,MAAA,QAAmC,CAAK,GAAA8wC,EAAAojB,GAAA,kBAAApjB,GAAAojB,EAAA,GAAA38D,GAAAu5C,EAAAojB,QAA2C,IAAApjB,EAAA8b,GAAA,kBAAA9b,GAAA8b,EAAAr1D,MAAA,OAA6C,IAAA4uD,GAAArV,IAAAiV,EAAAjV,GAAA,CAAqBv5C,IAAK,QAAAwI,GAAA+wC,EAAAtmD,OAAAqB,EAAA,EAAuBA,EAAAkU,EAAIlU,IAAA0L,EAAA3H,KAAA/D,OAAc0L,GAAAywD,GAAAlX,EAAa/wC,GAAAs1D,GAAAvkB,GAAQjlD,EAAAkU,EAAAvV,MAAW,QAAA24B,GAAA,EAAYA,EAAAt3B,EAAIs3B,IAAAnjB,EAAA9S,SAAA,GAAA6S,EAAAojB,GAAA5rB,KAAA4rB,GAAA2tB,IAAoC,QAAA+e,GAAA/e,EAAA9wC,GAAgBL,KAAAK,KAAUL,KAAAmxC,KAAUnxC,KAAApI,EAAA,CAAS,IAAAA,GAAAhN,UAAAC,MAAuB,MAAA+M,EAAA,CAAQ,GAAAA,EAAA,OAAAtL,OAAA,6BAAiD,QAAA8T,GAAA,EAAYA,EAAAxI,EAAIwI,GAAA,EAAAJ,KAAAmN,IAAAviB,UAAAwV,GAAAxV,UAAAwV,EAAA,QAA2C,IAAA+wC,EAAA,GAAAA,YAAA+e,GAAA,IAAAt4D,EAAAu5C,EAAAojB,IAAAn0D,EAAA,EAA4CA,EAAAxI,EAAA/M,OAAWuV,IAAAJ,KAAAmN,IAAAvV,EAAAwI,GAAA+wC,EAAA15C,IAAAG,EAAAwI,SAA+B,KAAAA,IAAA+wC,GAAAnxC,KAAAmN,IAAA/M,EAAA+wC,EAAA/wC,IACrnB,QAAAy1D,IAAA1kB,GAAeA,EAAA9wC,KAAO8wC,IAAAtmD,OAAA,EAAasmD,EAAAv5C,EAAA,EAAM,QAAAk+D,IAAA3kB,EAAA9wC,GAAiB,QAAA01D,EAAA5kB,EAAA9wC,aAAA8wC,GAAA9wC,KAAA8wC,EAAAv5C,IAAAu5C,IAAAtmD,OAAA,EAAAsmD,EAAAv5C,GAAAo+D,GAAA7kB,IAAA,GAAoE,QAAA6kB,IAAA7kB,GAAe,GAAAA,EAAAv5C,GAAAu5C,IAAAtmD,OAAA,CAAoB,OAAAwV,GAAA,EAAAzI,EAAA,EAAgByI,EAAA8wC,IAAAtmD,QAAa,CAAE,GAAAuV,GAAA+wC,IAAA9wC,EAAa01D,GAAA5kB,EAAA9wC,EAAAD,KAAA+wC,IAAAv5C,KAAAwI,GAAuBC,IAAI8wC,IAAAtmD,OAAA+M,EAAa,GAAAu5C,EAAAv5C,GAAAu5C,IAAAtmD,OAAA,CAAoB,GAAAqB,KAAS,KAAA0L,EAAAyI,EAAA,EAAUA,EAAA8wC,IAAAtmD,QAAauV,EAAA+wC,IAAA9wC,GAAA01D,EAAA7pE,EAAAkU,KAAA+wC,IAAAv5C,KAAAwI,EAAAlU,EAAAkU,GAAA,GAAAC,GAA0C8wC,KAAAtmD,OAAA+M,GACtO,QAAAm+D,GAAA5kB,EAAA9wC,GAAgB,MAAA/S,QAAAL,UAAAE,eAAAI,KAAA4jD,EAAA9wC,GAAgL,QAAA41D,IAAA9kB,EAAA9wC,GAAiB,GAAA8wC,EAAA,CAAMA,IAAAv6C,MAAA,IAAe,QAAAgB,GAAA,EAAYA,EAAAu5C,EAAAtmD,OAAW+M,IAAA,CAAK,GAAAwI,GAAA+wC,EAAAv5C,GAAArG,QAAA,KAAArF,EAAA,IAA+B,OAAAkU,EAAA,CAAS,GAAAojB,GAAA2tB,EAAAv5C,GAAAnH,UAAA,EAAA2P,EAA0BlU,GAAAilD,EAAAv5C,GAAAnH,UAAA2P,EAAA,OAAsBojB,GAAA2tB,EAAAv5C,EAAYyI,GAAAmjB,EAAAt3B,EAAAgqE,mBAAAhqE,EAAAoZ,QAAA,kBAAsD,QAAA6wD,GAAAhlB,EAAA9wC,GAAgBL,KAAAK,EAAAL,KAAAg0D,EAAAh0D,KAAAwjB,EAAA,GAAwBxjB,KAAAhO,EAAA,KAAYgO,KAAA+vD,EAAA/vD,KAAAmxC,EAAA,GAAiBnxC,KAAAipD,GAAA,CAAU,IAAArxD,EAAMu5C,aAAAglB,IAAAn2D,KAAAipD,MAAA,KAAA5oD,IAAA8wC,EAAA8X,EAAAmN,GAAAp2D,KAAAmxC,EAAA3tB,GAAAxjB,KAAAg0D,EAAA7iB,EAAA6iB,EAAAqC,GAAAr2D,KAAAmxC,EAAA9wC,GAAAi2D,GAAAt2D,KAAAmxC,EAAAn/C,GAAAgO,KAAAmxC,MAAAolB,GAAAv2D,KAAAw2D,GAAArlB,EAAAv5C,IAAAoI,KAAA+vD,EAAA5e,EAAA4e,GAAA5e,IAAAv5C,GAAAu5C,EAAA9+C,IAAAokE,MAAAC,MAAA12D,KAAAipD,IAAA5oD,EAAA+1D,GAAAp2D,KAAApI,EAAA,WAAAoI,KAAAg0D,EAAA2C,GAAA/+D,EAAA,QAAAy+D,GAAAr2D,KAAApI,EAAA,WAAA0+D,GAAAt2D,KAAApI,EAAA,IAAAoI,KAAAmxC,EAAAwlB,GAAA/+D,EAAA,WAAA2+D,GAAAv2D,KAAApI,EAAA,WAAAoI,KAAA+vD,EAAA4G,GAAA/+D,EAAA,UAAAoI,KAAAipD,IAAA5oD,EAAAL,KAAApI,EAAA,GAAAg/D,IAAA,KAAA52D,KAAAipD,IAG9b,QAAAsL,GAAApjB,GAAc,UAAAglB,GAAAhlB,GAAgB,QAAAilB,IAAAjlB,EAAA9wC,EAAAzI,GAAmBu5C,EAAA3tB,EAAA5rB,EAAA++D,GAAAt2D,GAAA,GAAAA,EAAiB8wC,EAAA3tB,IAAA2tB,EAAA3tB,EAAA2tB,EAAA3tB,EAAAle,QAAA,UAAgC,QAAA+wD,IAAAllB,EAAA9wC,EAAAzI,GAAmBu5C,EAAA9wC,EAAAzI,EAAA++D,GAAAt2D,GAAA,GAAAA,EAAiB,QAAAi2D,IAAAnlB,EAAA9wC,GAAiB,GAAAA,EAAA,CAAkB,GAAZA,KAAYtS,MAAAsS,IAAA,EAAAA,EAAA,KAAA/T,OAAA,mBAAA+T,EAAmD8wC,GAAAn/C,EAAAqO,MAAM8wC,GAAAn/C,EAAA,KAAc,QAAAukE,IAAAplB,EAAA9wC,EAAAzI,GAAmByI,YAAAu2D,KAAAzlB,EAAAv5C,EAAAyI,EAAAw2D,GAAA1lB,EAAAv5C,EAAAu5C,EAAA8X,KAAArxD,IAAAyI,EAAAy2D,GAAAz2D,EAAA02D,KAAA5lB,EAAAv5C,EAAA,GAAAg/D,IAAAv2D,EAAA8wC,EAAA8X,IACna,QAAA2K,GAAAziB,EAAA9wC,EAAAzI,GAAkBu5C,EAAAv5C,EAAAuV,IAAA9M,EAAAzI,GAAa,QAAA+8D,IAAAxjB,EAAA9wC,EAAAzI,GAAmByR,EAAAzR,UAAAvF,KAAsB2kE,GAAA7lB,EAAAv5C,EAAAyI,EAAAzI,GAAY,QAAA08D,IAAAnjB,GAA2I,MAA5HyiB,GAAAziB,EAAA,KAAAlwC,KAAAC,MAAA,WAAAD,KAAAE,UAAAR,SAAA,IAAAM,KAAAg2D,IAAAh2D,KAAAC,MAAA,WAAAD,KAAAE,UAAA6uD,KAAArvD,SAAA,KAA4HwwC,EAAS,QAAA+lB,IAAA/lB,GAAe,MAAAA,aAAAglB,GAAA5B,EAAApjB,GAAA,GAAAglB,GAAAhlB,MAAA,IAA2C,QAAAgmB,IAAAhmB,EAAA9wC,EAAAzI,EAAAwI,GAAqB,GAAAlU,GAAA,GAAAiqE,GAAA,YAAqE,OAA5ChlB,IAAAilB,GAAAlqE,EAAAilD,GAAW9wC,GAAAg2D,GAAAnqE,EAAAmU,GAAWzI,GAAA0+D,GAAApqE,EAAA0L,GAAWwI,IAAAlU,EAAAilD,EAAA/wC,GAAWlU,EAAS,QAAAyqE,IAAAxlB,EAAA9wC,GAAiB,MAAA8wC,GAAA9wC,EAAA+2D,UAAAjmB,EAAA7rC,QAAA,iBAAA4wD,mBAAA/kB,GAAA,GACtZ,QAAA2lB,IAAA3lB,EAAA9wC,EAAAzI,GAAmB,MAAAwuD,GAAAjV,MAAAkmB,UAAAlmB,GAAA7rC,QAAAjF,EAAAi3D,IAAA1/D,IAAAu5C,IAAA7rC,QAAA,uBAA6E,QAAA6rC,GAAA,KAAoB,QAAAmmB,IAAAnmB,GAAiC,MAAlBA,KAAA5+C,WAAA,GAAkB,KAAA4+C,GAAA,MAAAxwC,SAAA,QAAAwwC,GAAAxwC,SAAA,IAAsH,QAAAi2D,IAAAzlB,EAAA9wC,GAAiBL,KAAAK,EAAAL,KAAAmxC,EAAA,KAAmBnxC,KAAApI,EAAAu5C,GAAA,KAAenxC,KAAAwjB,IAAAnjB,EAAW,QAAA0zD,GAAA5iB,GAAcA,UAAA,GAAA+e,GAAA/e,EAAA9wC,EAAA,EAAA8wC,EAAAv5C,GAAAq+D,GAAA9kB,EAAAv5C,EAAA,SAAAyI,EAAAzI,GAAgDu5C,EAAAlyC,IAAAi3D,mBAAA71D,EAAAiF,QAAA,YAAA1N,MACvQ,QAAA2/D,IAAApmB,EAAA9wC,GAAiB0zD,EAAA5iB,GAAK9wC,EAAAm3D,GAAArmB,EAAA9wC,GAAU01D,EAAA5kB,IAAA9wC,OAAA8wC,EAAAv5C,EAAA,KAAAu5C,EAAA9wC,GAAA8wC,IAAA15C,IAAA4I,GAAAxV,OAAAirE,GAAA3kB,IAAA9wC,IAAwD,QAAAo3D,IAAAtmB,EAAA9wC,GAAgC,MAAf0zD,GAAA5iB,GAAK9wC,EAAAm3D,GAAArmB,EAAA9wC,GAAU01D,EAAA5kB,IAAA9wC,KAExP,QAAA22D,IAAA7lB,EAAA9wC,EAAAzI,GAAmB2/D,GAAApmB,EAAA9wC,GAAQ,EAAAzI,EAAA/M,SAAAsmD,EAAAv5C,EAAA,KAAAu5C,IAAAhkC,IAAAqqD,GAAArmB,EAAA9wC,GAAAynD,GAAAlwD,IAAAu5C,EAAA9wC,GAAAzI,EAAA/M,QAAkW,QAAA2rE,IAAArlB,GAAe,GAAA9wC,GAAA,GAAAu2D,GAAmD,OAAtCv2D,GAAAzI,EAAAu5C,EAAAv5C,EAAQu5C,MAAA9wC,EAAA8wC,EAAA,GAAA+e,GAAA/e,KAAA9wC,IAAA8wC,EAAA9wC,GAA8BA,EAC/b,QAAAm3D,IAAArmB,EAAA9wC,GAAsD,MAArCA,IAAAhO,GAAY8+C,EAAA3tB,IAAAnjB,IAAAq3D,eAAyBr3D,EAAS,QAAAw2D,IAAA1lB,EAAA9wC,GAAiBA,IAAA8wC,EAAA3tB,IAAAuwC,EAAA5iB,KAAAv5C,EAAA,KAAAu5C,IAAAnjD,QAAA,SAAAmjD,EAAA9wC,GAAkD,GAAAzI,GAAAyI,EAAAq3D,aAAsBr3D,IAAAzI,IAAA2/D,GAAAv3D,KAAAK,GAAA22D,GAAAh3D,KAAApI,EAAAu5C,KAAgCA,IAAKA,EAAA3tB,EAAAnjB,EAAO,QAAAs3D,MAAc33D,KAAAmxC,EAAA6e,IAAsJ,QAAA4H,MAAcC,QAAA,GAAAF,KAAgB,QAAAG,MAAcD,QAAA,GAAAF,KAAyB,QAAAI,IAAA5mB,EAAA9wC,GAAiBL,KAAAmxC,IAASnxC,KAAAK,IAASL,KAAApI,EAAAoI,KAAAhO,EAAA,KAAmBgO,KAAAipD,GAAA,EAAUjpD,KAAAilC,EAAA,KAAYjlC,KAAAwjB,GAAA,EAAUxjB,KAAAomD,EAAApmD,KAAA+vD,EAAA,KACngB,QAAAiI,IAAA7mB,GAAeihB,EAAAjhB,EAAA9wC,EAAA,mCAA0C,IAAAA,GAAA8wC,IAAA0gB,EAAA1gB,CAAc,UAAA9wC,EAAA+xD,EAAAjhB,EAAA9wC,EAAA,WAA4B,mBAA2FuyD,EAAA,GAAAvyD,GAAAuyD,EAAA,IAAAqF,GAAA9mB,OAAA,KAAAyhB,EAAA,IAAAqF,GAAA9mB,OAAA,QAAmD,CAAKA,EAAAv5C,EAAA,GAAA87D,GAAAviB,IAAA9wC,MAAA,WAA+B8wC,EAAAv5C,EAAAo8D,EAAA7iB,EAAAn/C,CAAU,IAAA4F,GAAAsgE,GAAA/mB,MAAA4e,EAAA5e,EAAAlM,EAAsB2tB,GAAA,GAAK+B,GAAA/8D,EAAA,iBAAuB,IAAAwI,GAAA+wC,IAAA6iB,EAAA9nE,EAAAilD,IAAAyhB,CAAoBxyD,IAAAlU,GAAA0nE,EAAAh8D,EAAAwI,EAAAlU,GAAeuoE,GAAAtjB,EAAAv5C,KAAA,EAAAu5C,EAAA4e,IAK5S,QAAAoI,MAAcn4D,KAAAmxC,EAAAnxC,KAAAK,EAAA,KAAoB,QAAA+3D,MAAcp4D,KAAAmxC,EAAA,GAAA+e,GAAa,QAAAmI,IAAAlnB,GAAe,GAAA9wC,SAAA8wC,EAAe,iBAAA9wC,GAAA8wC,GAAA,YAAA9wC,EAAA,KAAA8wC,EAAA7wC,KAAA6wC,EAAA7wC,KAAAonD,KAAArnD,EAAAjO,OAAA,GAAA++C,EAAyK,QAAAmnB,IAAAnnB,EAAA9wC,GAAiBL,KAAAmxC,IAASnxC,KAAAK,IAAU,QAAAk4D,IAAApnB,GAAenxC,KAAA+vD,EAAA5e,GAAAqnB,GAAax4D,KAAAwjB,EAAAtb,EAAAuwD,IAAAvwD,EAAAuwD,GAAAC,IAAAxwD,EAAAuwD,GAAAC,MAAAxwD,EAAAuwD,GAAAC,KAAAjL,GAAAztD,KAAA+vD,EAAA,EAAuD/vD,KAAAmxC,EAAA,KAAY,EAAAnxC,KAAAwjB,IAAAxjB,KAAAmxC,EAAA,GAAAinB,KAA0Bp4D,KAAAK,EAAA,KAAYL,KAAApI,KAAoB,QAAA+gE,IAAAxnB,EAAA9wC,GAAiB8wC,MAAA,GAAA9wC,EAAA9O,QAAA,aAAA8O,EAAA9O,QAAA,aAAA8O,EAAA9O,QAAA,QAAA4/C,EAAA3tB,EAAA2tB,EAAA4e,EAAA5e,IAAA,GAAAinB,IAAAjnB,EAAA9wC,IAAAu4D,GAAAznB,IAAA9wC,GAAA8wC,EAAA9wC,EAAA,OAAuH,QAAAw4D,IAAA1nB,GAAe,QAAAA,EAAA9wC,KAAA8wC,WAAAv5C,GAAAu5C,EAAA3tB,EAAkC,QAAAs1C,IAAA3nB,EAAA9wC,GAAgE,MAA/C8wC,GAAA9wC,EAAA8wC,IAAA9wC,KAAA8wC,KAAA9wC,EAAAg4D,GAAAh4D,GAAA8wC,EAAA4kB,EAAA5kB,MAAA9wC,MAAA8wC,GAAA,EAA+CA,EAAS,QAAAynB,IAAAznB,EAAA9wC,GAAiB8wC,QAAAlyC,IAAAoB,GAAA8wC,EAAA9wC,IAC5xB,QAAA04D,IAAA5nB,EAAA9wC,GAAiB,GAAA8wC,EAAA9wC,GAAA8wC,EAAA9wC,KAAA8wC,EAAA9wC,EAAA,SAAwB,CAAK,GAAAzI,IAAMA,EAAAu5C,OAAAv5C,EAAAygE,GAAAh4D,GAAAzI,EAAAm+D,EAAA5kB,MAAA9wC,EAAAzI,IAAgCA,GAAAk+D,GAAA3kB,MAAAknB,GAAAh4D,KAAsL,QAAA24D,IAAA7nB,GAAe,SAAAA,EAAA9wC,EAAA,MAAA8wC,GAAAv5C,EAAAlM,OAAAylD,EAAA9wC,EAAAknD,EAAsC,UAAApW,KAAA,GAAAA,MAAAv5C,EAAA,CAA0B,GAAAyI,GAAA8wC,EAAAv5C,CAAmD,OAAzCg+D,IAAAzkB,IAAA8b,IAAA,SAAA9b,GAAuB9wC,IAAA3U,OAAAylD,EAAAoW,KAAkBlnD,EAAS,MAAAynD,IAAA3W,EAAAv5C,GAAe,QAAAqhE,IAAA9nB,EAAA9wC,GAAiB8wC,EAAAv5C,EAAAu5C,EAAAv5C,EAAAlM,OAAA2U,GAAmB,QAAA64D,OAAmJ,QAAAC,MAAcn5D,KAAAmxC,EAAA,GAAA+nB,IAAc,QAAAE,IAAAjoB,EAAA9wC,EAAAzI,GAAmB,GAAAwI,GAAAxI,GAAA,EAAY,KAAI+9D,GAAAxkB,EAAA,SAAAA,EAAAv5C,GAAmB,GAAA1L,GAAAilD,CAAQuV,IAAAvV,KAAAjlD,EAAAg7D,GAAA/V,IAAiB9wC,EAAApQ,KAAAmQ,EAAAxI,EAAA,IAAAyhE,mBAAAntE,MAAwC,MAAAA,GAAS,KAAAmU,GAAApQ,KAAAmQ,EAAA,QAAAi5D,mBAAA,YAAAntE,GAA2D,QAAAotE,IAAAnoB,EAAA9wC,GAAiB,GAAAzI,GAAA,GAAA85D,GAAaU,GAAAx6D,EAAA,0BAAAu5C,EAAiC,IAAA/wC,GAAA,GAAAm5D,MAAgBn5D,GAAAo5D,OAAAzS,GAAA0S,GAAA7hE,EAAAwI,EAAA,2BAAAC,GAAiDD,EAAA9F,QAAAysD,GAAA0S,GAAA7hE,EAAAwI,EAAA,0BAAAC,GAAiDD,EAAA29B,QAAAgpB,GAAA0S,GAAA7hE,EAAAwI,EAAA,0BAAAC,GAAiDD,EAAAs5D,UAAA3S,GAAA0S,GAAA7hE,EAAAwI,EAAA,4BAAAC,GAAqD6H,EAAAmhB,WAAA,WAAwBjpB,EAAAs5D,WAAAt5D,EAAAs5D,aAA6B,KAAMt5D,EAAAwqD,IAAAzZ,EAAQ,QAAAsoB,IAAAtoB,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAuB,IAAIkmE,EAAAjhB,EAAAv5C,GAAAyI,EAAAm5D,OAAA,KAAAn5D,EAAA/F,QAAA,KAAA+F,EAAA09B,QAAA,KAAA19B,EAAAq5D,UAAA,KAAAxtE,EAAAkU,GAAyE,MAAAojB,GAAS6uC,GAAAlhB,EAAA3tB,IAAU,QAAAmwC,GAAAxiB,GAAc8b,EAAA1/D,KAAAyS,MAAaA,KAAAwmB,QAAA,GAAA0pC,GAAmBlwD,KAAAwxD,EAAArgB,GAAA,KAAenxC,KAAApI,GAAA,EAAUoI,KAAAmI,EAAAnI,KAAAmxC,EAAA,KAAmBnxC,KAAA4yD,EAAA5yD,KAAAunD,EAAA,GAAiBvnD,KAAAg0D,EAAA,EAASh0D,KAAA+vD,EAAA,GAAU/vD,KAAAipD,EAAAjpD,KAAA6xD,EAAA7xD,KAAA9N,EAAA8N,KAAAoyD,GAAA,EAA+BpyD,KAAAomD,EAAA,EAASpmD,KAAA6wD,EAAA,KAAY7wD,KAAA0zD,EAAAiG,GAAU35D,KAAAoxD,EAAApxD,KAAAk0D,GAAA,EAG9uC,QAAA0F,IAAAzoB,GAAe,MAAA0oB,IAAA/Q,GAAA,oBAAA3X,GAAA2oB,aAAA,KAAA3oB,EAAAuoB,UAAkE,QAAA9R,IAAAzW,GAAe,sBAAAA,EAAAumB,cAC9H,QAAAqC,IAAA5oB,EAAA9wC,GAAiB8wC,EAAAv5C,GAAA,EAAOu5C,QAAA8X,GAAA,EAAA9X,IAAA/T,QAAA+T,EAAA8X,GAAA,GAAiC9X,EAAA4e,EAAA1vD,EAAM8wC,EAAA6iB,EAAA,EAAMgG,GAAA7oB,GAAM8oB,GAAA9oB,GAAM,QAAA6oB,IAAA7oB,GAAeA,EAAAihB,IAAAjhB,EAAAihB,GAAA,EAAAjhB,EAAAuhB,cAAA,YAAAvhB,EAAAuhB,cAAA,UAEnR,QAAAwH,IAAA/oB,GAAe,GAAAA,EAAAv5C,OAAA,KAAAuiE,KAAA,GAAAhpB,EAAAhpC,EAAA,OAAA+kD,EAAA/b,IAAA,GAAAA,EAAA2gB,IAAAN,EAAArgB,EAAA9wC,EAAA4zD,EAAA9iB,EAAA,iDAAqH,IAAAA,EAAAj/C,GAAA,GAAAg7D,EAAA/b,GAAAgf,GAAAhf,EAAAipB,GAAA,EAAAjpB,OAAkC,IAAAA,EAAAuhB,cAAA,uBAAAxF,EAAA/b,GAAA,CAAqDqgB,EAAArgB,EAAA9wC,EAAA4zD,EAAA9iB,EAAA,qBAA+BA,EAAAv5C,GAAA,CAAO,KAAI,GAAAyI,GAAA8wC,EAAA2gB,GAAY3gB,GAAA,OAAA9wC,GAAY,mEAAAzI,IAAA,CAAyE,MAAAu5C,EAAQ,SAAAv5C,GAAA,EAAa,GAAAwI,EAAM,MAAAA,EAAAxI,GAAA,CAAW,GAAA1L,EAAM,IAAAA,EAAA,IAAAmU,EAAA,CAAY,GAAAmjB,IAAA2tB,EAAAoW,EAAAl1D,IAAAokE,MAAAC,IAAA,QAAqC,KAAAlzC,GAAAtb,EAAAmyD,MAAAnyD,EAAAmyD,KAAAvL,SAAA,CAAgC,GAAA7F,GAAA/gD,EAAAmyD,KAAAvL,SAAAC,QACnevrC,GAAAylC,EAAA/1C,OAAA,EAAA+1C,EAAAp+D,OAAA,GAAyBqB,GAAAouE,GAAAj1D,KAAAme,IAAAk0C,cAAA,IAAiCt3D,EAAAlU,EAAIkU,GAAA+wC,EAAAuhB,cAAA,YAAAvhB,EAAAuhB,cAAA,aAAAvhB,EAAA6iB,EAAA,EAAA7iB,EAAA4e,EAAA5e,EAAAqX,KAAA,KAAArX,EAAA2gB,IAAA,IAAAkI,GAAA7oB,IAAmG,QAAQ8oB,GAAA9oB,KAAQ,QAAA8oB,IAAA9oB,EAAA9wC,GAAiB,GAAA8wC,IAAA,CAAQopB,GAAAppB,EAAM,IAAAv5C,GAAAu5C,IAAA/wC,EAAA+wC,EAAAhpC,EAAA,GAAAk+C,GAAA,IAA2BlV,KAAA,KAASA,EAAAhpC,EAAA,KAAS9H,GAAA8wC,EAAAuhB,cAAA,QAA4B,KAAI96D,EAAAw3D,mBAAAhvD,EAAuB,MAAAlU,IAASilD,IAAA9wC,IAAA8wC,EAAA5lD,IAAA+mE,GAAA,qDAAApmE,EAAAG,YAAA,MAA2F,QAAAkuE,IAAAppB,GAAeA,OAAAigB,IAAAjgB,IAAAuoB,UAAA,MAA+BvoB,EAAA0f,IAAA3oD,EAAA+nC,aAAAkB,EAAA0f,GAAA1f,EAAA0f,EAAA,MACtc,QAAA3D,GAAA/b,GAAc,MAAAA,SAAAqpB,WAAA,EACsK,QAAAnF,IAAAlkB,EAAA9wC,GAAiB,MAAA8wC,SAAAspB,kBAAAp6D,GAAA,KAAgI,QAAA4zD,GAAA9iB,EAAA9wC,GAAgB,MAAAA,GAAA,KAAA8wC,EAAAyhB,EAAA,IAAAzhB,EAAAoW,EAAA,IAAApW,EAAA2gB,IAAA,IAAyC,QAAA4I,IAAAvpB,GAAe,GAAA9wC,GAAA,EAAyD,OAAhD8nD,IAAAhX,EAAA,SAAAA,EAAA/wC,GAAmBC,GAAAD,EAAKC,GAAA,IAAOA,GAAA8wC,EAAK9wC,GAAA,SAAYA,EAAS,QAAAs6D,IAAAxpB,EAAA9wC,EAAAzI,GAAmBu5C,EAAA,CAAG,IAAA/wC,IAAAxI,GAAA,CAAY,GAAAwI,IAAA,CAAS,MAAA+wC,GAAQ/wC,GAAA,EAAK,GAAAA,EAAA,MAAA+wC,EAAsB,IAARv5C,EAAA8iE,GAAA9iE,GAAQwuD,EAAAjV,GAAA,CAAwF,GAA/E9wC,EAAAg5D,mBAAAh5D,EAAAhO,IAAgCuF,EAAA,MAAAA,EAAA,IAAAyhE,mBAAAzhE,EAAAvF,IAAA,GAA+CgO,GAAAzI,EAAA,CAA6D,GAApDA,EAAAu5C,EAAA5/C,QAAA,KAAiB,EAAAqG,MAAAu5C,EAAAtmD,QAAmC,GAAjBuV,EAAA+wC,EAAA5/C,QAAA,OAAiB6O,EAAAxI,EAAA,CAAawI,EAAAxI,CAAI,IAAA1L,GAAA,OAASA,GAAAilD,EAAA1gD,UAAA2P,EAAA,EAAAxI,EAA0Bu5C,MAAAj+B,OAAA,EAAA9S,GAAAlU,EAAAilD,EAAAj+B,OAAAtb,IAAgCA,EAAAu5C,EAAA,GAAOA,EAAA,GAAA9wC,EAAAzI,IAAA,IAAAyI,IAAAzI,EAAqBu5C,IAAA,IAAAA,EAAA,OAAAA,EAAA,OAAAA,EAAA,GAA+B,MAAAA,GAAkB,MAATyiB,GAAAziB,EAAA9wC,EAAAzI,GAASu5C,EAAU,QAAAypB,IAAAzpB,GAAenxC,KAAA+nD,GAAA,EAAU/nD,KAAA+vD,KAAU/vD,KAAAmxC,EAAA,GAAAugB,IAAc1xD,KAAA6xD,EAAA,GAAAsG,IAAcn4D,KAAAm0D,EAAAn0D,KAAA68B,GAAA78B,KAAAwxD,EAAAxxD,KAAA+mD,GAAA/mD,KAAAK,EAAAL,KAAA4yD,EAAA5yD,KAAAg0D,EAAAh0D,KAAAi0D,EAAAj0D,KAAAipD,EAAAjpD,KAAA0zD,EAAA1zD,KAAAhO,EAAA,KAAoFgO,KAAA8oD,GAAA9oD,KAAA4zD,EAAA,EAAiB5zD,KAAA66D,GAAA1pB,KAAAqc,KAAA,EAAoBxtD,KAAAmnD,GAAAnnD,KAAAoxD,EAAApxD,KAAA9N,EAAA8N,KAAAomD,EAAApmD,KAAAilC,EAAAjlC,KAAAwjB,EAAA,KAAgDxjB,KAAAunD,EAAAvnD,KAAA8nD,GAAA9nD,KAAAktD,GAAA,EAAyBltD,KAAA2zD,EAAA3zD,KAAA6wD,EAAA7wD,KAAAmI,EAAA,EAAuBnI,KAAAoyD,MAAA,GAAcpyD,KAAA+zD,EAAA5iB,KAAAxoB,yBAAA,EAAuC3oB,KAAAmtD,EAAA,GAAUntD,KAAApI,EAAA,GAAA2gE,IAAApnB,KAAA2pB,wBAA2C96D,KAAAqnD,GAAA,GAAA8R,IAAen5D,KAAAk0D,GAAA/iB,OAAA,KAAAA,EAAA7oB,uBAAA6oB,EAAA7oB,uBAAsEtoB,KAAA6nD,GAAA1W,KAAA4pB,gBAAA,KACpzC/6D,KAAAk0D,IAAA9C,EAAApxD,KAAAmxC,IAAA,8DAAAnxC,KAAAk0D,GAAA,GAA8F/iB,KAAAkX,IAAAroD,KAAAmxC,EAAAkX,KAC9F,QAAA2S,IAAA7pB,GAA2C,GAA5BihB,EAAAjhB,IAAA,gBAAsB8pB,GAAA9pB,GAAM,GAAAA,EAAA8gB,EAAA,CAAW,GAAA5xD,GAAA8wC,EAAAyiB,IAAAh8D,EAAA28D,EAAApjB,EAAAqgB,EAAqBoC,GAAAh8D,EAAA,MAAAu5C,EAAAgc,GAAeyG,EAAAh8D,EAAA,MAAAyI,GAAauzD,EAAAh8D,EAAA,oBAAwBsjE,GAAA/pB,EAAAv5C,GAAQyI,EAAA,GAAAqzD,GAAAviB,MAAA9wC,MAAA,IAAwBA,EAAA8sD,EAAA,EAAM9sD,EAAA4oD,EAAAqL,GAAAC,EAAA38D,IAAaA,GAAA,EAAKsQ,EAAA40B,WAAA50B,EAAA40B,UAAAq+B,aAAAvjE,EAAAsQ,EAAA40B,UAAAq+B,WAAA96D,KAAA4oD,EAAA,MAAmFrxD,GAAAsQ,EAAAqxD,SAAA,GAAAA,QAAA3O,IAAAvqD,EAAA4oD,EAAArxD,GAAA,GAAwCA,IAAAyI,EAAA8wC,EAAA9wC,EAAArO,EAAAw0D,GAAA,MAAAnmD,EAAA8wC,EAAAuW,GAAArnD,EAAA4oD,IAAkC5oD,EAAAmxD,EAAAxB,IAAQ0E,GAAAr0D,GAAM+6D,GAAAjqB,GAClW,QAAA8pB,IAAA9pB,GAAeA,EAAAigB,IAAAjgB,EAAAigB,EAAAh0B,QAAA+T,EAAAigB,EAAA,MAA4BjgB,EAAA9wC,IAAA8wC,EAAA9wC,EAAA2vC,SAAAmB,EAAA9wC,EAAA,MAA6B8wC,EAAAiV,IAAAl+C,EAAA+nC,aAAAkB,EAAAiV,GAAAjV,EAAAiV,EAAA,MAAoCiV,GAAAlqB,GAAMA,EAAAv5C,EAAAo4C,SAAamB,EAAAlM,IAAA/8B,EAAA+nC,aAAAkB,EAAAlM,GAAAkM,EAAAlM,EAAA,MAAoC,QAAAq2B,IAAAnqB,EAAA9wC,GAAiB,KAAA8wC,EAAA4e,EAAAllE,QAAAo8D,EAAA9V,IAAA,WAAkC,qDAAA+V,GAAA7mD,KAA6D8wC,EAAA4e,EAAA9/D,KAAA,GAAAqoE,IAAAnnB,EAAA2X,KAAAzoD,IAA2B,GAAA8wC,EAAA8gB,GAAAsJ,GAAApqB,GAAgD,QAAAoqB,IAAApqB,GAAe0nB,GAAA1nB,EAAAv5C,IAAAu5C,EAAAlM,IAAAkM,EAAAlM,EAAA8tB,GAAAhmC,EAAAokB,EAAAqqB,GAAArqB,GAAA,GAAAA,EAAAhpC,EAAA,GAC7W,QAAAszD,IAAAtqB,EAAA9wC,GAAiB,GAAAzI,GAAAu5C,EAAAv5C,CAAU,QAAAA,EAAAyI,EAAA,EAAAzI,EAAAu5C,EAAAv5C,EAAAu5C,IAAAv5C,EAAA,IAAAu5C,EAAAv5C,EAAA4rB,GAAA2tB,EAAAlM,EAAA,MAAAgiB,EAAA9V,IAAA,8CAAoGA,EAAAlM,GAAAmtB,EAAAjhB,IAAA,oDAAAA,EAAA4e,EAAA1vD,EAAAknD,EAAA77D,OAAAylD,EAAA4e,IAAA,KAA+F,GAAA5e,EAAA8gB,GAAA,GAAA9gB,EAAA8gB,GAAA9gB,EAAAhpC,IAAAgpC,EAAA0pB,GAAA,OAA4CzI,EAAAjhB,IAAA,uBAA6BA,EAAAlM,EAAA8tB,GAAAhmC,EAAAokB,EAAAqqB,GAAArqB,EAAA9wC,GAAAq7D,GAAAvqB,IAAAhpC,IAA8BgpC,EAAAhpC,IAAM,IAG3U,QAAAwzD,IAAAxqB,EAAA9wC,GAAiB,GAAAzI,EAAMA,GAAAyI,IAAAzI,EAAAu5C,EAAAyiB,GAAgB,IAAAxzD,GAAAm0D,EAAApjB,EAAAqgB,EAAaoC,GAAAxzD,EAAA,MAAA+wC,EAAAgc,GAAeyG,EAAAxzD,EAAA,MAAAxI,GAAag8D,EAAAxzD,EAAA,MAAA+wC,EAAA+b,GAAegO,GAAA/pB,EAAA/wC,GAAQ+wC,EAAA8X,GAAA9X,EAAAn/C,GAAA2oE,GAAAv6D,EAAA+wC,EAAA8X,EAAA9X,EAAAn/C,GAAwB4F,EAAA,GAAA87D,GAAAviB,MAAAv5C,EAAAu5C,EAAAhpC,EAAA,GAAuB,OAAAgpC,EAAA8X,IAAArxD,EAAAo8D,EAAA7iB,EAAAn/C,GAAsBqO,IAAA8wC,EAAA4e,EAAA1vD,EAAAknD,EAAA77D,OAAAylD,EAAA4e,IAAyB1vD,EAAAu7D,GAAAzqB,EAAAv5C,GAAUA,EAAAyxB,WAAA,IAAApoB,KAAA46D,MAAA,IAAA56D,KAAAE,WAAgDy3D,GAAAznB,EAAAv5C,KAAUy8D,GAAAz8D,EAAAwI,EAAAC,GAAU,QAAA66D,IAAA/pB,EAAA9wC,GAAiB8wC,EAAA3tB,GAAAmyC,MAAU,SAAAxkB,EAAA/wC,GAAewzD,EAAAvzD,EAAAD,EAAA+wC,KAC7T,QAAAyqB,IAAAzqB,EAAA9wC,GAAiB,GAAAzI,GAAAqJ,KAAA2D,IAAAusC,EAAA4e,EAAAllE,OAAA,KAAAuV,EAAA+wC,EAAA3tB,EAAAuJ,EAAAokB,EAAA3tB,EAAAs4C,GAAA3qB,EAAA3tB,EAAA2tB,GAAA,IAA0DA,GAAA,OAAAjlD,GAAAilD,EAAA4e,EAAAvsC,GAAA,IAAsB,CAAE,GAAAylC,IAAA,SAAArxD,IAAmB,GAAA4rB,EAAA,EAAA5rB,GAAA4rB,EAAAt3B,EAAA,GAAAilD,EAAA8X,EAAAh5D,KAAA,OAAAuzB,MAAA,EAAAylC,EAAAh5D,KAAA,OAAAuzB,EAA2D,QAAAyhB,IAAA,EAAA98B,EAAA,EAAiBA,EAAAvQ,EAAIuQ,IAAA,CAAK,GAAA0pD,GAAA3lE,EAAAic,GAAAgpC,EAAA2gB,EAAA5lE,EAAAic,GAAA9H,CAA2B,OAALwxD,GAAAruC,GAAKA,EAAAviB,KAAAosC,IAAA,EAAAnhD,EAAAic,GAAAgpC,EAAA,KAAAlM,GAAA,MAAqC,KAASm0B,GAAAtH,EAAA7I,EAAA,MAAA4I,EAAA,KAAoB,MAAAE,GAAU3xD,KAAA0xD,IAAS,GAAA7sB,EAAA,CAAM7kC,EAAA6oD,EAAA74D,KAAA,IAAc,MAAA+gD,IAAiC,MAAxBA,KAAA4e,EAAAzjC,OAAA,EAAA10B,GAAkByI,EAAAknD,EAAApW,EAAM/wC,EAAS,QAAA27D,IAAA5qB,GAAe,IAAAA,EAAA9wC,IAAA8wC,EAAAiV,EAAA,CAAejV,EAAAwiB,EAAA,CAAM,IAAAtzD,GAAA8wC,EAAAgZ,EAAWoF,KAAAD,KAASO,KAAAN,KAAAM,IAAA,GAAiB3B,GAAAjvD,IAAAoB,EAAA8wC,GAAYA,EAAA0f,EAAA,GAC9c,QAAAmL,IAAA7qB,GAAe,MAAAA,GAAA9wC,GAAA8wC,EAAAiV,GAAAa,EAAA9V,IAAA,qCAA2D,GAAAA,EAAA0f,IAAmBuB,EAAAjhB,IAAA,sBAA4BA,EAAAwiB,IAAMxiB,EAAAiV,EAAA2M,GAAAhmC,EAAAokB,EAAAgZ,GAAAhZ,GAAAuqB,GAAAvqB,IAAA0f,IAA4B1f,EAAA0f,IAAM,IAEjK,QAAAoH,IAAA9mB,EAAA9wC,EAAAzI,GAAmBw6D,EAAAjhB,IAAA,2BAAkC,IAAA/wC,GAAAC,EAAA+lD,CAAUhmD,IAAAu4D,GAAAxnB,EAAAv5C,EAAAwI,GAAa+wC,EAAAgW,GAAAvvD,EAAOu5C,EAAAoW,EAAAlnD,EAAAmjB,EAAQ4uC,EAAAjhB,IAAA,qBAA2BA,EAAAqgB,EAAAyK,GAAA9qB,IAAA4V,IAAewU,GAAApqB,GAAM,QAAA+qB,IAAA/qB,EAAA9wC,GAAiB+xD,EAAAjhB,IAAA,0BAAgCA,EAAAoW,EAAAlnD,EAAAmjB,EAAQqxC,EAAA1jB,EAAA,GAIoE,QAAAkqB,IAAAlqB,GAAe,MAAAA,EAAAj/C,IAAAgW,EAAA+nC,aAAAkB,EAAAj/C,GAAAi/C,EAAAj/C,EAAA,MAElH,QAAAwpE,IAAAvqB,EAAA9wC,GAAiB,GAAAzI,GAAA,IAAAqJ,KAAAC,MAAA,IAAAD,KAAAE,SAAiF,OAAzCgwC,GAAAia,OAAAgH,EAAAjhB,IAAA,oBAAAv5C,GAAA,GAAyCA,EAAAyI,EACvQ,QAAAw0D,GAAA1jB,EAAA9wC,GAAuC,GAAvBuxD,EAAAzgB,IAAA,cAAA9wC,GAAuB,GAAAA,EAAA,CAAS,GAAAzI,GAAA,IAAWu5C,GAAA3tB,IAAA5rB,EAAA,KAAc,IAAAwI,GAAA2sB,EAAAokB,EAAAya,GAAAza,EAAgBv5C,OAAA,GAAAu+D,GAAA,wCAAAjuD,EAAA4mD,UAAA,QAAA5mD,EAAA4mD,SAAAC,UAAAqH,GAAAx+D,EAAA,SAAA08D,GAAA18D,IAAkH0hE,GAAA1hE,KAAAwI,OAAmBwyD,GAAA,EAAUR,GAAAjhB,IAAA,wBAAA9wC,GAAiC8wC,EAAA8gB,EAAA,EAAM9gB,EAAA3tB,GAAA2tB,EAAA3tB,EAAA24C,GAAA97D,GAAe+6D,GAAAjqB,GAAM8pB,GAAA9pB,GACpS,QAAAiqB,IAAAjqB,GAA4B,GAAbA,EAAA8gB,EAAA,EAAM9gB,EAAAoW,GAAA,EAAOpW,EAAA3tB,EAAA,CAAQ,GAAAnjB,GAAA24D,GAAA7nB,EAAAv5C,EAAc,IAAAyI,EAAAxV,QAAA,GAAAsmD,EAAA4e,EAAAllE,SAAAunE,EAAAjhB,IAAA,WAA+C,8CAAA9wC,EAAAxV,OAAA,eAAAsmD,EAAA4e,EAAAllE,SAAiFsmD,EAAAv5C,IAAA/M,OAAA,EAAAi9D,GAAA3W,EAAA4e,GAAA5e,EAAA4e,EAAAllE,OAAA,GAAsCsmD,EAAA3tB,EAAAwkC,MAAU,QAAAiU,IAAA9qB,EAAA9wC,GAAkE,MAAjDA,GAAA+7D,GAAAjrB,EAAA,KAAA9wC,GAAe+xD,EAAAjhB,IAAA,yBAAA9wC,GAAkCA,EAAS,QAAA63D,IAAA/mB,EAAA9wC,EAAAzI,GAA0E,MAAvDyI,GAAA+7D,GAAAjrB,IAAAyV,KAAAvmD,EAAA,KAAAzI,GAAwBw6D,EAAAjhB,IAAA,sBAAA9wC,GAA+BA,EACvX,QAAA+7D,IAAAjrB,EAAA9wC,EAAAzI,GAAmB,GAAAwI,GAAA82D,GAAAt/D,EAAY,QAAAwI,EAAAC,KAAAg2D,GAAAj2D,EAAAC,EAAA,IAAAD,EAAAC,GAAAi2D,GAAAl2D,IAAApO,OAAwC,CAAK,GAAAwxB,GAAAt3B,EAAAgc,EAAA4mD,QAAmBtrC,GAAAnjB,IAAA,IAAAnU,EAAAmwE,SAAAnwE,EAAAmwE,SAAkCj8D,EAAA+2D,GAAAjrE,EAAA6iE,SAAAvrC,EAAAt3B,EAAAowE,KAAA1kE,GAAoH,MAAxFu5C,GAAA8iB,GAAA9L,GAAAhX,EAAA8iB,EAAA,SAAA9iB,EAAA9wC,GAA0BuzD,EAAAxzD,EAAAC,EAAA8wC,KAAW9wC,EAAA8wC,EAAA6iB,EAAMp8D,EAAAu5C,EAAAyhB,EAAMvyD,GAAAzI,GAAAg8D,EAAAxzD,EAAAC,EAAAzI,GAAeg8D,EAAAxzD,EAAA,MAAA+wC,EAAAqW,IAAgB0T,GAAA/pB,EAAA/wC,GAAQA,EAAkN,QAAAm8D,OAC/X,QAAAC,IAAArrB,GAAe,OAAA9wC,GAAAzV,UAAA,GAAAgN,EAAA,EAA2BA,EAAAhN,UAAAC,OAAmB+M,IAAA,CAAK,GAAAwI,GAAAxV,UAAAgN,EAAmB,OAAAwI,EAAA+wD,YAAA,OAAA9wD,EAAAD,MAA+B,CAAK,GAAAlU,IAAMA,EAAA,IAAAmU,KAAAnU,EAAAmU,EAAAxV,OAAA,EAAAqB,EAAA,GAAAA,GAAAmU,EAAA9O,QAAA,IAAArF,OAAsDmU,GAAAnU,EAAAkU,EAAA,IAAAA,GAAiB,MAAAC,GAAU,QAAAo8D,MAAc,GAAA5C,KAAA,KAAAiC,IAAA,KAAAxvE,OAAA,gDACtS,QAAA6nE,GAAAhjB,EAAA9wC,GAAgB4sD,EAAA1/D,KAAAyS,MAAaA,KAAAmxC,EAAA,GAAAypB,IAAAv6D,GAAiBL,KAAAK,EAAA8wC,EAASnxC,KAAAk0D,EAAA7zD,KAAAq8D,QAAAr8D,EAAAq8D,QAAAF,GAAAx8D,KAAAK,EAAA,QAAgDL,KAAApI,EAAAm5D,GAAA,oDAA8D/wD,KAAA+vD,EAAA1vD,KAAAs8D,kBAAA,KAAmCxrB,EAAA9wC,KAAAu8D,gBAAA,KAA4Bv8D,KAAAw8D,+BAAA1rB,IAAA,kCAAAA,GAA6E2rB,oBAAA,eAAmC98D,KAAAmxC,EAAAn/C,EAAAm/C,EAAWA,EAAA9wC,KAAAmoB,oBAAA,KAAgCnoB,KAAA08D,qBAAA5rB,IAAA,6BAAA9wC,EAAA08D,mBAAA5rB,GAAmF6rB,4BAAA38D,EAAA08D,qBACld18D,KAAA+nD,KAAAjX,IAAA,+BAAA9wC,EAAA+nD,GAAAjX,GAAqD8rB,8BAAA58D,EAAA+nD,KAAqCpoD,KAAAmxC,EAAAuiB,EAAAviB,GAAWA,EAAA9wC,KAAAooB,6BAAAs/B,GAAA5W,KAAAnxC,KAAAmxC,EAAA8X,EAAA9X,GAAyDnxC,KAAAomD,EAAA/lD,KAAAsoB,yBAAA,EAAuC3oB,KAAAg0D,EAAA3zD,KAAAqoB,cAAA,GAA4BroB,OAAAkoB,sBAAAw/B,GAAA1nD,KAAAL,KAAAmxC,EAAA6iB,EAAA3zD,EAAA,QAAA8wC,EAAAnxC,KAAA+vD,IAAA1vD,IAAA8wC,OAAAnxC,KAAA+vD,EAAA1vD,IAAA8wC,aAAA9wC,GAAA+wD,EAAApxD,KAAApI,EAAA,mEAAAyI,KAA2LL,KAAAipD,EAAA,GAAAiU,IAAAl9D,MAG7J,QAAAm9D,IAAAhsB,GAAe8hB,GAAA1lE,KAAAyS,KAAc,IAAAK,GAAA8wC,EAAAisB,MAAe,IAAA/8D,EAAA,CAAM8wC,EAAA,CAAG,OAAAv5C,KAAAyI,GAAA,CAAgB8wC,EAAAv5C,CAAI,MAAAu5C,GAAQA,MAAA,IAASnxC,KAAApI,EAAAu5C,MAAAnxC,KAAApI,EAAAoI,KAAAyG,KAAA,OAAApG,GAAA8wC,IAAA9wC,KAAA8wC,OAAA,IAAAnxC,KAAAyG,KAAApG,MAAyEL,MAAAyG,KAAA0qC,EAA0B,QAAAksB,MAAcnK,GAAA3lE,KAAAyS,MAAcA,KAAA7K,OAAA,EACxd,QAAA+nE,IAAA/rB,GAAenxC,KAAAmxC,IAA0iB,QAAAmsB,MAAct9D,KAAAK,KAAUL,KAAAmxC,KAAU,QAAAosB,IAAApsB,GAA6D,MAA9C,IAAAA,EAAA9wC,EAAAxV,SAAAsmD,EAAA9wC,EAAA8wC,MAAA9wC,EAAAi/B,UAAA6R,QAA8CA,EAAA9wC,EAAA0I,MAAiB,QAAAy0D,IAAArsB,GAAe,MAAAA,GAAA9wC,EAAAxV,OAAAsmD,IAAAtmD,OAAiL,QAAA4yE,IAAAtsB,EAAA9wC,GAAuD,GAAtCknD,EAAAh6D,KAAAyS,MAAaA,KAAAipD,EAAA9X,GAAA,EAAYnxC,KAAApI,EAAAyI,GAAA,GAAaL,KAAAipD,EAAAjpD,KAAApI,EAAA,KAAAtL,OAAAoxE,GAAiC19D,MAAAmxC,EAAA,GAAAmsB,IAAct9D,KAAAK,EAAA,GAAA+3D,IAAcp4D,KAAA+vD,EAAA,KAAY/vD,KAAAqmD,KACzvB,QAAAsX,IAAAxsB,GAAe,qBAAAA,GAAAskB,EAAAtkB,EAAAskB,QAAgC,QAAAp1D,KAAA8wC,KAAA9wC,GAAA,KAAwF,QAAAu9D,IAAAzsB,GAAe,MAAAqsB,IAAArsB,OAAA9wC,EAAA8wC,EAAAv5C,EACvM,QAAAimE,IAAA1sB,EAAA9wC,GAAiBL,KAAAmxC,IAASnxC,KAAAK,IAAU,QAAAy9D,IAAA3sB,GAAyB,GAAVnxC,KAAAmxC,KAAUA,IAAA,CAAQ,GAAAA,YAAA2sB,IAAA,CAAoB,GAAAz9D,GAAA8wC,EAAAojB,GAAoB,IAARpjB,IAAA8b,IAAQ,GAAAjtD,KAAAmxC,EAAAtmD,OAAA,CAAqB,OAAA+M,GAAAoI,KAAAmxC,EAAA/wC,EAAA,EAAqBA,EAAAC,EAAAxV,OAAWuV,IAAAxI,EAAA3H,KAAA,GAAA4tE,IAAAx9D,EAAAD,GAAA+wC,EAAA/wC,IAA8B,MAAA+wC,QAAS9wC,GAAAgoD,GAAAlX,KAAAiX,GAAAjX,EAAqB,KAAA/wC,EAAA,EAAQA,EAAAC,EAAAxV,OAAWuV,IAAA29D,GAAA/9D,KAAAK,EAAAD,GAAA+wC,EAAA/wC,KAAwB,QAAA29D,IAAA5sB,EAAA9wC,EAAAzI,GAAmB,GAAAwI,GAAA+wC,GAAiD,KAAvC/wC,EAAAnQ,KAAA,GAAA4tE,IAAAx9D,EAAAzI,IAAoByI,EAAAD,EAAAvV,OAAA,EAAasmD,MAAMv5C,EAAAu5C,EAAA9wC,GAAW,EAAAA,IAAID,EAAAC,EAAA,KAAA8wC,EAAA/wC,GAAA+wC,EAAAv5C,EAAAu5C,MAAA9wC,GAAA8wC,EAAA/wC,GAAAC,EAAAD,CAAiD+wC,GAAA9wC,GAAAzI,EAC5e,QAAAomE,MAAcF,GAAAvwE,KAAAyS,MAAuB,QAAAswD,GAAAnf,EAAA9wC,GAAgBL,KAAAwjB,EAAA,GAAAw6C,IAAcP,GAAAlwE,KAAAyS,KAAAmxC,EAAA9wC,GACW,QAAA2qD,GAAA7Z,EAAA9wC,EAAAzI,EAAAwI,GAAoBJ,KAAAomD,EAAAjV,EAASnxC,KAAAg0D,IAAA5zD,EAAWkwD,EAAA/iE,KAAAyS,KAAAK,EAAAzI,GApGzM,GAAAm4D,GAAAoK,cAAmBjyD,EAAAlI,KAEgRM,EAAA,oBAAAW,KAAAE,WAAA,GAAAumD,GAAA,EAE7JsI,EAAA/kE,KAAAunB,KAAA,WAA2B,UAAAvnB,MAAga+7D,GAAAG,GAAA76D,OAAY66D,GAAAl6D,UAAA4B,KAAA,cAA2Jm4D,EAAAK,GAAAF,IAASE,GAAAp6D,UAAA4B,KAAA,gBAAuN,IAAA24D,IAAA,EAAAC,KAAeF,GAAAt6D,UAAA+E,GAAA,EAAiBu1D,EAAAt6D,UAAAwoE,EAAA,WAAyB,IAAAz1D,KAAAhO,IAAAgO,KAAAhO,GAAA,EAAAgO,KAAAkoD,IAAA,GAAAV,IAAA,CAAwC,GAAArW,GAAAnxC,KAAAM,KAAAN,KAAAM,KAAAonD,GAA8B,OAAAF,IAAAxnD,KAAAilC,GAAA,EAAAjlC,KAAAilC,EAAAp6C,OAAA,KAAAyB,OAAA0T,KAAA,6JAA0MynD,IAAAtW,KAAeoW,EAAAt6D,UAAAi7D,EAAA,WAAyB,GAAAloD,KAAAilC,EAAA,KAAejlC,KAAAilC,EAAAp6C,QAAcmV,KAAAilC,EAAA0U,UAAmB,IAAAyR,IAAAr8D,MAAA9B,UAAAsE,QAAA,SAAA4/C,EAAA9wC,GAA6C,MAAAtR,OAAA9B,UAAAsE,QAAAhE,KAAA4jD,EAAA9wC,MAAA,KAAgD,SAAA8wC,EAAA9wC,GAAe,GAAA+lD,EAAAjV,GAAA,MAAAiV,GAAA/lD,IAAA,GAAAA,EAAAxV,OAAAsmD,EAAA5/C,QAAA8O,EAAA,KAAmD,QAAAzI,GAAA,EAAYA,EAAAu5C,EAAAtmD,OAAW+M,IAAA,GAAAA,IAAAu5C,MAAAv5C,KAAAyI,EAAA,MAAAzI,EAAiC,WAASg+D,GAAA7mE,MAAA9B,UAAAe,QAAA,SAAAmjD,EAAA9wC,EAAAzI,GAA4C7I,MAAA9B,UAAAe,QAAAT,KAAA4jD,EAAA9wC,EAAAzI,IAAoC,SAAAu5C,EAAA9wC,EAAAzI,GAAiB,OAAAwI,GAAA+wC,EAAAtmD,OAAAqB,EAAAk6D,EAAAjV,KAAAv6C,MAAA,IAAAu6C,EAAA3tB,EAAA,EAA4CA,EAAApjB,EAAIojB,QAAAt3B,IAAAmU,EAAA9S,KAAAqK,EAAA1L,EAAAs3B,KAAA2tB,IAClyC4X,GAAA12D,OAAApF,UAAAgxE,KAAA,SAAA9sB,GAAyC,MAAAA,GAAA8sB,QAAgB,SAAA9sB,GAAa,uCAAAlgD,KAAAkgD,GAAA,IAA2F+W,CAAM/W,GAAA,CAAG,GAAAgrB,IAAAj0D,EAAA40B,SAAmB,IAAAq/B,GAAA,CAAO,GAAA+B,IAAA/B,GAAAp/B,SAAoB,IAAAmhC,GAAA,CAAOhW,EAAAgW,EAAK,MAAA/sB,IAAS+W,EAAA,GAAiR,GAAAM,IAAA,gGAAA5xD,MAAA,IACtuB6xD,IAAA,KAAApC,EAAsG,IAAAqS,IAAAzQ,EAAA,SAAA4R,EAAA5R,EAAA,YAAAA,EAAA,QAAAmS,GAAAnS,EAAA,QAAA6L,GAAAsG,IAAAP,EAAA1P,GAAAlC,EAAA,gBAAAC,EAAAwP,cAAAnmE,QAAA,YAAA02D,EAAA,YAAAA,EAAA,YAAAA,EAAA,WAAAA,EAAA,QAAAuT,IAAA,GAAAtT,EAAAwP,cAAAnmE,QAAA,YAAA02D,EAAA,QAAiSe,EACpmB7X,GAAA,CAAG,GAAAgtB,IAAA,GAAAC,GAAA,WAAwB,GAAAjtB,GAAA+W,CAAQ,OAAAiC,IAAA,qBAA8Bl5D,KAAAkgD,GAAWipB,GAAA,kBAAAnpE,KAAAkgD,GAAsC0oB,EAAA,mCAA2C5oE,KAAAkgD,GAAWqqB,GAAA,gBAAAvqE,KAAAkgD,GAAoCunB,GAAA,yBAAAznE,KAAAkgD,OAAA,KAAqE,IAArBitB,KAAAD,GAAAC,MAAA,OAAqBvE,EAAA,CAAM,GAAAgB,IAAAjS,IAAY,UAAAiS,OAAAwD,WAAAF,IAAA,CAAgCnV,GAAA6R,GAAAxoE,EAAc,MAAA8+C,IAAS6X,GAAAmV,GAAM,GAAAxV,OACyHmT,GAAOwC,GAAAp2D,EAAAiX,QAChe28C,IAAAwC,IAAAzE,EAAAjR,OAAA,cAAA0V,GAAAC,WAAArV,SAAAF,GAAA,aAAsE,IAAAwV,IAAAlxE,OAAAmxE,QAAA,SAAAttB,GAAkC,MAAAA,IAAUkb,IAAAwN,GAAA,IAAAiC,GAAA4C,GAAA7E,IAAA/Q,GAAA,KAAAgD,GAAA,WAAsD,IAAA5jD,EAAAw/B,mBAAAp6C,OAAAqS,eAAA,QAAwD,IAAAwxC,IAAA,EAAA9wC,EAAA/S,OAAAqS,kBAAmC,WAAYlI,IAAA,WAAe05C,GAAA,IAA2E,OAAnEjpC,GAAAw/B,iBAAA,OAAA2e,GAAAhmD,GAAgC6H,EAAAy/B,oBAAA,OAAA0e,GAAAhmD,GAAmC8wC,IAAwEgY,GAAAl8D,UAAAoT,EAAA,WAAyBL,KAAA4oD,IAAA,GAErT5B,EAAAoC,GAAAD,EAAQ,IAAAnxC,IAAAwmD,IAAWG,EAAA,QAAAC,EAAA,MAAAC,EAAA,SAA8BzV,IAAAn8D,UAAAoT,EAAA,WAA0B+oD,GAAAnC,EAAA5mD,EAAA9S,KAAAyS,KAAkB,IAAAmxC,GAAAnxC,KAAApI,CAAa,IAAAu5C,EAAA2tB,eAAA3tB,EAAA2tB,qBAAuC,IAAA3tB,EAAA0b,aAAA,EAAA6R,GAAA,KAAgCvtB,EAAA2Y,SAAA,KAAA3Y,EAAAyb,SAAA,KAAAzb,EAAAyb,WAAAzb,EAAAyb,SAAA,GAA0D,MAAAvsD,KAAY,IAAA1H,IAAA,2BAAAsI,KAAAE,SAAA,GAAA4pD,GAAA,CAAuTG,IAAAj+D,UAAAgS,IAAA,SAAAkyC,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAqC,GAAAs3B,GAAA2tB,MAAmBA,EAAAnxC,KAAAmxC,EAAA3tB,MAAY2tB,EAAAnxC,KAAAmxC,EAAA3tB,MAAAxjB,KAAAK,IAA6B,IAAA4oD,GAAAoC,GAAAla,EAAA9wC,EAAAD,EAAAlU,EAA6F,QAA3E,EAAA+8D,GAAA5oD,EAAA8wC,EAAA8X,GAAArxD,IAAAyI,EAAAimD,IAAA,KAAAjmD,EAAA,GAAAqqD,IAAArqD,EAAAL,KAAA4qD,IAAApnC,IAAApjB,EAAAlU,GAAAmU,EAAAimD,GAAA1uD,EAAAu5C,EAAAlhD,KAAAoQ,IAA2EA,EAClwB,IAAAurD,IAAA,mBAAA3qD,KAAAE,SAAA,GAAAsrD,MAAgDN,GAAA,EAO1GY,GAAA,4BAAA9rD,KAAAE,WAAA,EAA+N6lD,GAAAiG,EAAA1F,GAAO0F,EAAAhgE,UAAA0L,KAAA,EAAmBo3D,EAAA9C,EAAAhgE,UAAc8iE,EAAAroB,iBAAA,SAAAyJ,EAAA9wC,EAAAzI,EAAAwI,GAAqCkrD,GAAAtrD,KAAAmxC,EAAA9wC,EAAAzI,EAAAwI,IAAkB2vD,EAAApoB,oBAAA,SAAAwJ,EAAA9wC,EAAAzI,EAAAwI,GAAwCksD,GAAAtsD,KAAAmxC,EAAA9wC,EAAAzI,EAAAwI,IAC3a2vD,EAAA2C,cAAA,SAAAvhB,GAA4B,GAAA9wC,GAAAzI,EAAAoI,KAAAmtD,CAAe,IAAAv1D,EAAA,IAAAyI,KAAczI,EAAEA,IAAAu1D,EAAA9sD,EAAApQ,KAAA2H,EAAgBA,GAAAoI,KAAAktD,CAAS,IAAA9sD,GAAA+wC,EAAAliD,MAAAkiD,CAAgB,IAAAiV,EAAAjV,KAAA,GAAAgY,GAAAhY,EAAAv5C,OAAqB,IAAAu5C,YAAAgY,GAAAhY,EAAA92C,OAAA82C,EAAA92C,QAAAzC,MAA4C,CAAK,GAAA1L,GAAAilD,CAAQA,GAAA,GAAAgY,GAAA/oD,EAAAxI,GAAa2wD,GAAApX,EAAAjlD,GAAa,GAALA,GAAA,EAAKmU,EAAA,OAAAmjB,GAAAnjB,EAAAxV,OAAA,EAA0B,GAAA24B,EAAKA,IAAA,CAAK,GAAAylC,GAAA9X,IAAA9wC,EAAAmjB,EAAet3B,GAAAkhE,GAAAnE,EAAA7oD,GAAA,EAAA+wC,IAAAjlD,EAA8D,GAA5C+8D,EAAA9X,IAAAv5C,EAAQ1L,EAAAkhE,GAAAnE,EAAA7oD,GAAA,EAAA+wC,IAAAjlD,EAAkBA,EAAAkhE,GAAAnE,EAAA7oD,GAAA,EAAA+wC,IAAAjlD,EAAkBmU,EAAA,IAAAmjB,EAAA,EAAaA,EAAAnjB,EAAAxV,OAAW24B,IAAAylC,EAAA9X,IAAA9wC,EAAAmjB,GAAAt3B,EAAAkhE,GAAAnE,EAAA7oD,GAAA,EAAA+wC,IAAAjlD,CAAiC,OAAAA,IACtX6jE,EAAA7H,EAAA,WAAgC,GAAjB+E,EAAAhG,EAAAiB,EAAA36D,KAAAyS,MAAiBA,KAAAwjB,EAAA,CAAW,GAAA5rB,GAAAu5C,EAAAnxC,KAAAwjB,EAAAnjB,EAAA,CAAmB,KAAAzI,IAAAu5C,KAAA,CAAc,OAAA/wC,GAAA+wC,IAAAv5C,GAAA1L,EAAA,EAAqBA,EAAAkU,EAAAvV,OAAWqB,MAAAmU,EAAA4qD,GAAA7qD,EAAAlU,UAAiBilD,KAAAv5C,GAAcu5C,EAAA9wC,KAAOL,KAAAmtD,EAAA,MAAa4C,EAAAxH,GAAA,SAAApX,EAAA9wC,EAAAzI,EAAAwI,GAAuB,MAAAJ,MAAAwjB,EAAAvkB,IAAAkyC,EAAA9+C,GAAAgO,GAAA,EAAAzI,EAAAwI,IAAuC2vD,EAAAtH,GAAA,SAAAtX,EAAA9wC,EAAAzI,EAAAwI,GAAuB,MAAAJ,MAAAwjB,EAAAvkB,IAAAkyC,EAAA9+C,GAAAgO,GAAA,EAAAzI,EAAAwI,GAGpF,IAAA0tD,KAAQiR,IAAA,MAAAC,KAAA,OAAAC,IAAA,MAAAC,KAAA,MAAAC,KAAA,MAAAC,KAAA,MAAAC,KAAA,MAAAC,KAAA,MAAAC,KAAA,WAAwG1R,GAAA,SAAAxoD,KAAA,4DAClE0oD,IAAA9gE,UAAAwK,IAAA,WAA4B,KAAAuI,KAAAK,EAAA,CAAaL,KAAAK,GAAS,IAAA8wC,GAAAnxC,KAAAmxC,CAAanxC,MAAAmxC,IAAAtrC,KAAcsrC,EAAAtrC,KAAA,SAAYsrC,GAAAnxC,KAAApI,GAAgB,OAAAu5C,GAA2C,IAAAye,IAAA,GAAA7B,IAAA,WAAyB,UAAAI,KAAc,SAAAhd,GAAaA,EAAAO,SAAYsc,IAAA/gE,UAAAgS,IAAA,SAAAkyC,EAAA9wC,GAA+B,GAAAzI,GAAAg4D,GAAAn4D,KAAeG,GAAAuV,IAAAgkC,EAAA9wC,GAAWL,KAAAK,EAAAL,KAAAK,EAAAwF,KAAAjO,EAAAoI,KAAAmxC,EAAAv5C,EAA8BoI,KAAAK,EAAAzI,GAAkJu2D,GAAAlhE,UAAAkgB,IAAA,SAAAgkC,EAAA9wC,GAA+BL,KAAAmxC,IAASnxC,KAAAK,IAASL,KAAA6F,KAAA,MAAgBsoD,GAAAlhE,UAAAykD,MAAA,WAA8B1xC,KAAA6F,KAAA7F,KAAAK,EAAAL,KAAAmxC,EAAA,KAAkF,IAAAwe,IAG1oBJ,GAAsTM,IAAA,EAAA3B,GAAA,GAAAF,GAAuOhH,GAAA8I,GAAA7C,GAAQ8C,EAAAD,GAAA7iE,UAAe8iE,EAAArJ,IAAA,EAAQqJ,EAAAG,EAAA,KAASH,EAAAtD,GAAA,WAAgB,GAAAzsD,KAAA0mD,GAAA,CAAY,GAAAvV,GAAA6e,IAAAhwD,KAAA+vD,CAAiB,GAAA5e,KAAA,GAAAnxC,KAAAK,EAAAL,KAAAkwD,EAAAlwD,KAAAmxC,EAAA9nB,WAAArpB,KAAApI,EAAAoI,KAAAK,EAAA8wC,IAAAnxC,KAAAkwD,IAAAlwD,KAAAmxC,EAAAlB,aAAAjwC,KAAAkwD,GAAAlwD,KAAAkwD,EAAA,MAAAlwD,KAAA0yD,cAAA,QAAA1yD,KAAA0mD,KAAA1mD,KAAAkwD,EAAAlwD,KAAAmxC,EAAA9nB,WAAArpB,KAAApI,EAAAoI,KAAAK,GAAAL,KAAA+vD,EAAAC,QAA0MD,EAAAx3D,MAAA,WAAmByH,KAAA0mD,IAAA,EAAW1mD,KAAAkwD,IAAAlwD,KAAAkwD,EAAAlwD,KAAAmxC,EAAA9nB,WAAArpB,KAAApI,EAAAoI,KAAAK,GAAAL,KAAA+vD,EAAAC,MAC/8BD,EAAA7H,EAAA,WAAe4H,GAAA7I,EAAAiB,EAAA36D,KAAAyS,MAAkBiwD,GAAAjwD,YAASA,MAAAmxC,GAA+T6V,EAAAoJ,GAAA7I,GAAQwI,EAAAK,GAAAnjE,UAAe8iE,EAAApJ,IAAA,EAAQoJ,EAAAO,EAAA,KAASP,EAAAyO,GAAA,SAAArtB,GAAiBnxC,KAAAmxC,EAAAvmD,UAAiBoV,KAAAswD,EAAAtwD,KAAA2mD,IAAA,EAAA0J,GAAArwD,OAA4B+vD,EAAA7H,EAAA,WAAekI,GAAAnJ,EAAAiB,EAAA36D,KAAAyS,MAAkBA,KAAAswD,IAAApoD,EAAA+nC,aAAAjwC,KAAAswD,GAAAtwD,KAAAswD,EAAA,KAAAtwD,KAAA2mD,IAAA,EAAA3mD,KAAAmxC,OAAmE4e,EAAArF,GAAA,WAAgB1qD,KAAAswD,EAAA,KAAYtwD,KAAA2mD,KAAA3mD,KAAA2mD,IAAA,EAAA0J,GAAArwD,QAAmIgnD,EAAAuJ,GAAAhJ,EAAQ,IAAAkJ,MAAqPF,IAAAtjE,UAAAi7D,EAAA,WAA0BqI,GAAAtJ,EAAAiB,EAAA36D,KAAAyS,MAAkB0wD,GAAA1wD,OAAUuwD,GAAAtjE,UAAA+/D,YAAA,WAAoC,KAAA1gE,OAAA,6CAA6GqkE,GAAA1jE,UAAAkkD,EAAA,IAAoB,IAAAnO,IAAA,CAAS2tB,IAAA1jE,UAAAykD,MAAA,SAAAP,EAAA9wC,EAAAzI,EAAAwI,EAAAlU,GAAuC,gBAAAA,IAAA82C,KAAyB5iC,GAAA4vD,UAAOhwD,MAAAmxC,GAA0G0f,EAAA5jE,UAAA0T,SAAA,WAAgC,MAAAX,MAAAnR,KAAkB,IAAAyjE,IAAA,GAAAzB,GAAA,cAAAQ,GAAA,GAAAR,GAAA,eAAAU,GAAA,GAAAV,GAAA,YAAAK,GAAA,GAAAL,GAAA,cAAAY,GAAA,GAAAZ,GAAA,WAA2ND,IAAA3jE,UAAA1B,IAAA,SAAA4lD,EAAA9wC,EAAAzI,GAAiC,GAAAu5C,EAAA1jD,OAAAqjE,GAAA9wD,MAAAvS,MAAA,IAAAg5D,GAAApmD,YAAA8wC,EAAA,GAAAwf,IAAAxf,EAAA9wC,EAAAhO,GAAA2N,KAAAwjB,GAAA5rB,IAAAu5C,IAAAv5C,KAAAoI,KAA6FpI,GAAEA,IAAAu5C,EAC9yD,IAAA8f,OAASD,GAAA,IAA6YU,IAAAzkE,UAAAo7D,GAAA,WAA2BroD,KAAAK,GAAA,EAEnE,IAAA8sD,GAAA,GAAAF,EAA+DjG,GAAAwL,GAAArJ,GAA8FnC,EAAA2L,GAAAxJ,GAA+FnC,EAAA6L,GAAA1J,EAAyL,IAAAqW,KAAQn4C,SAAA,EAAA8kC,GAAA,EAAAH,GAAA,EAAAH,GAAA,EAAAJ,GAAA,EAAAE,GAAA,EAAAS,GAAA,EAAA+R,GAAA,EAAA32C,QAAA,EAAAklC,GAAA,GAA8D+S,IAAQjU,GAAA,WAAA6B,GAAA,UAAA+Q,GAAA,QAAAD,GAAA,QAAApR,GAAA,QAAAK,GAAA,mBAAA5lC,QAAA,UAAA8kC,GAAA,kBAAAK,GAAA,WAAAjB,GAAA,mBAAA4B,GAAA,kBAAiMoS,IAAQn2C,KAAA,IAAA+hC,GAAA,IAAA8S,GAAA,IAAA7R,GAAA,IAA8DvF,GAAAiM,GAAA9J,GAAuCnC,EAAAkM,GAAA/J,GAAuBgK,GAAAlmE,UAAAkkD,EAAA,IAAoG,IAAAwuB,GAAsB3Y,GAAAsM,GAAAH,IAAgdwM,GAAA,GAAArM,GAAmU,IAAAO,IAAA,KAC/4D0B,MAASD,KAAOvF,GAAA2D,EAAAzmE,UAAc8iE,EAAA1mC,WAAA,SAAA8nB,GAAyBnxC,KAAA4zD,EAAAziB,GACsH4e,EAAA1E,GAAA,SAAAla,GAAiBA,IAAA92C,MAAW,IAAAgG,GAAAL,KAAA6xD,CAAaxxD,IAAA,GAAA6sD,EAAA/b,IAAAihB,EAAApyD,KAAAK,EAAA,gCAAAA,EAAAm+D,MAAAx+D,KAAAgpD,GAAA7X,IAC1Y4e,EAAA/G,GAAA,SAAA7X,GAAiB,IAAIA,GAAAnxC,KAAAmxC,EAAAyjB,GAAA50D,MAAAoxD,EAAApxD,KAAAK,EAAA8wC,EAAA,0CAAwE,MAAAv5C,GAAS,GAAAw6D,EAAApyD,KAAAK,EAAA,8CAAAL,KAAAmxC,GAAAnxC,KAAAmxC,EAAA0jB,IAAA,CAA8E,GAAAx0D,GAAAL,IAAWqyD,IAAAryD,KAAAK,EAAAzI,EAAA,WAAuB,uBAAAyI,EAAA8wC,EAAA0jB,UAAiCxC,IAAAryD,KAAAK,EAAAzI,EAAA,sBAG6Gm4D,EAAA7E,GAAA,WAAgB,GAAAlrD,KAAAmxC,EAAA,CAAW,GAAAA,GAAA+b,EAAAltD,KAAAmxC,GAAA9wC,EAAAL,KAAAmxC,EAAA0jB,GAA6B70D,MAAAoyD,EAAA/xD,EAAAxV,SAAAiqE,GAAA90D,MAAAi1D,GAAAj1D,KAAAmxC,EAAA9wC,GAAAL,KAAAwjB,GAAA,GAAA2tB,GAAAujB,GAAA10D,SACtL+vD,EAAA/f,OAAA,WAAoBhwC,KAAA6wD,GAAA,EAAUsE,GAAAn1D,OACpQ+vD,EAAA9E,GAAA,WAAgBjrD,KAAA9N,EAAA,IAAY,IAAAi/C,GAAA6e,GAAU,IAAA7e,EAAAnxC,KAAAi0D,GAAAj0D,KAAAwjB,GAAAyjC,EAAAjnD,KAAAK,EAAA,qEAAA8xD,GAAAnyD,KAAAK,EAAAL,KAAA+vD,GAAA,GAAA/vD,KAAAmtD,IAAAsF,GAAA,GAAAG,EAAA,KAAAuC,GAAAn1D,WAAAilC,EAAA,EAAAmwB,GAAAp1D,QAAAoxD,EAAApxD,KAAAK,EAAA8wC,EAAA,mCAAAqkB,GAAAx1D,UAAAi0D,EAAA9iB,KAEgnB4e,EAAAG,EAAAjjE,UAAc8iE,EAAA9C,EAAA,WAAe+I,GAAAh2D,KAAS,QAAAmxC,MAAA9wC,EAAA,EAAiBA,EAAAL,KAAAmxC,EAAAtmD,OAAgBwV,IAAA8wC,EAAAlhD,KAAA+P,KAAAK,EAAAL,KAAAmxC,EAAA9wC,IAA8B,OAAA8wC,IAAU4e,EAAAwE,EAAA,WAAwB,MAATyB,IAAAh2D,MAASA,KAAAmxC,EAAAzlD,UAC5bqkE,EAAAt4D,IAAA,SAAA05C,EAAA9wC,GAAoB,MAAA01D,GAAA/1D,KAAAK,EAAA8wC,GAAAnxC,KAAAK,EAAA8wC,GAAA9wC,GAAgC0vD,EAAA5iD,IAAA,SAAAgkC,EAAA9wC,GAAoB01D,EAAA/1D,KAAAK,EAAA8wC,KAAAnxC,KAAApI,IAAAoI,KAAAmxC,EAAAlhD,KAAAkhD,IAAuCnxC,KAAAK,EAAA8wC,GAAA9wC,GAChd0vD,EAAA/hE,QAAA,SAAAmjD,EAAA9wC,GAAwB,OAAAzI,GAAAoI,KAAAu0D,IAAAn0D,EAAA,EAAuBA,EAAAxI,EAAA/M,OAAWuV,IAAA,CAAK,GAAAlU,GAAA0L,EAAAwI,GAAAojB,EAAAxjB,KAAAvI,IAAAvL,EAAyBilD,GAAA5jD,KAAA8S,EAAAmjB,EAAAt3B,EAAA8T,OAAuF,IAAA02D,IAAA,0HAC/KP,GAAAlpE,UAAA0T,SAAA,WAAgC,GAAAwwC,MAAA9wC,EAAAL,KAAAwjB,CAAkBnjB,IAAA8wC,EAAAlhD,KAAA6mE,GAAAz2D,EAAAu/D,IAAA,OAA2B,IAAAhoE,GAAAoI,KAAAK,CAAkW,QAArVzI,GAAA,QAAAyI,KAAA8wC,EAAAlhD,KAAA,OAAAoQ,EAAAL,KAAAg0D,IAAA7iB,EAAAlhD,KAAA6mE,GAAAz2D,EAAAu/D,IAAA,QAAAzuB,EAAAlhD,KAAAopE,mBAAAzhE,EAAAvF,IAAAiT,QAAA,uBAAiI,eAAA1N,EAAAoI,KAAAhO,IAAAm/C,EAAAlhD,KAAA,IAAA2H,EAAAvF,MAAoDuF,EAAAoI,KAAAmxC,KAAAnxC,KAAAK,GAAA,KAAAzI,EAAAxF,OAAA,IAAA++C,EAAAlhD,KAAA,KAAAkhD,EAAAlhD,KAAA6mE,GAAAl/D,EAAA,KAAAA,EAAAxF,OAAA,GAAAytE,GAAAC,IAAA,MAA0FloE,EAAAoI,QAAApI,IAAAu5C,EAAAlhD,KAAA,IAAA2H,IAAqCA,EAAAoI,KAAA+vD,IAAA5e,EAAAlhD,KAAA,IAAA6mE,GAAAl/D,EAAAmoE,KAAiC5uB,EAAA/gD,KAAA,KAC/a+lE,EAAAlpE,UAAAgN,QAAA,SAAAk3C,GAAgC,GAAA9wC,GAAAk0D,EAAAv0D,MAAApI,IAAAu5C,EAAA3tB,CAAsB5rB,GAAAw+D,GAAA/1D,EAAA8wC,EAAA3tB,GAAA5rB,IAAAu5C,EAAA6iB,EAAoBp8D,EAAAyI,EAAA2zD,EAAA7iB,EAAA6iB,EAAAp8D,IAAAu5C,EAAA9wC,EAAkBzI,EAAAy+D,GAAAh2D,EAAA8wC,EAAA9wC,GAAAzI,EAAA,MAAAu5C,EAAAn/C,CAAwB,IAAAoO,GAAA+wC,GAAU,IAAAv5C,EAAA0+D,GAAAj2D,EAAA8wC,EAAAn/C,OAAe,IAAA4F,IAAAu5C,IAAA,CAAiB,QAAA/wC,EAAAhO,OAAA,MAAA4N,KAAAK,IAAAL,KAAAmxC,EAAA/wC,EAAA,IAAAA,MAA+C,CAAK,GAAAlU,GAAAmU,EAAA8wC,EAAAggB,YAAA,MAA2B,GAAAjlE,IAAAkU,EAAAC,EAAA8wC,EAAAj+B,OAAA,EAAAhnB,EAAA,GAAAkU,GAAmC,UAAJlU,EAAAkU,IAAI,KAAAlU,EAAAkU,EAAA,OAAwB,QAAAlU,EAAAqF,QAAA,WAAArF,EAAAqF,QAAA,OAAkD6O,EAAA,GAAAlU,EAAAilE,YAAA,OAA0BjlE,IAAA0K,MAAA,IAAe,QAAA4sB,MAAAylC,EAAA,EAAiBA,EAAA/8D,EAAArB,QAAW,CAAE,GAAAo6C,GAAA/4C,EAAA+8D,IAAa,MAAAhkB,EAAA7kC,GAAA6oD,GAAA/8D,EAAArB,QAAA24B,EAAAvzB,KAAA,UAAAg1C,IAAA,EAAAzhB,EAAA34B,QAAA,GAAA24B,EAAA34B,QAAA,IAC9a24B,EAAA,KAAAA,EAAAza,MAAA3I,GAAA6oD,GAAA/8D,EAAArB,QAAA24B,EAAAvzB,KAAA,MAAAuzB,EAAAvzB,KAAAg1C,GAAA7kC,GAAA,GAA4DA,EAAAojB,EAAApzB,KAAA,SAAcgQ,GAAAlU,EAA4E,MAAnE0L,GAAAyI,EAAA8wC,EAAA/wC,EAAAxI,EAAA,IAAAu5C,KAAAv5C,EAA8BA,EAAA2+D,GAAAl2D,EAAAm2D,GAAArlB,EAAAv5C,QAAAu5C,EAAA4e,EAAwBn4D,IAAAyI,EAAA0vD,EAAA5e,EAAA4e,GAAa1vD,EAEoD,IAAAu/D,IAAA,YAAAE,GAAA,UAAAD,GAAA,SAAA9I,GAAA,UAAAgJ,GAAA,IAAkPhQ,GAAA6G,GAAA3pE,UAC5b8iE,EAAA9wD,IAAA,SAAAkyC,EAAA9wC,GAAoB0zD,EAAA/zD,MAAQA,KAAApI,EAAA,KAAYu5C,EAAAqmB,GAAAx3D,KAAAmxC,EAAa,IAAAv5C,GAAAoI,KAAAmxC,EAAA15C,IAAA05C,EAA8D,OAA1Cv5C,IAAAoI,KAAAmxC,EAAAhkC,IAAAgkC,EAAAv5C,MAAsBA,EAAA3H,KAAAoQ,GAAUL,KAAAK,GAAA,EAAUL,MAAuJ+vD,EAAA/hE,QAAA,SAAAmjD,EAAA9wC,GAAwB0zD,EAAA/zD,MAAQA,KAAAmxC,EAAAnjD,QAAA,SAAA4J,EAAAwI,GAA6Bw1D,GAAAh+D,EAAA,SAAAA,GAAiBu5C,EAAA5jD,KAAA8S,EAAAzI,EAAAwI,EAAAJ,OAAmBA,OAAOA,OAClX+vD,EAAAwE,EAAA,WAAeR,EAAA/zD,KAAQ,QAAAmxC,GAAAnxC,KAAAmxC,EAAA8b,IAAA5sD,EAAAL,KAAAmxC,EAAAojB,IAAA38D,KAAAwI,EAAA,EAA2CA,EAAAC,EAAAxV,OAAWuV,IAAA,OAAAlU,GAAAilD,EAAA/wC,GAAAojB,EAAA,EAAuBA,EAAAt3B,EAAArB,OAAW24B,IAAA5rB,EAAA3H,KAAAoQ,EAAAD,GAAiB,OAAAxI,IAAUm4D,EAAA9C,EAAA,SAAA9b,GAAgB4iB,EAAA/zD,KAAQ,IAAAK,KAAS,IAAA+lD,EAAAjV,GAAAsmB,GAAAz3D,KAAAmxC,KAAA9wC,EAAAwnD,GAAAxnD,EAAAL,KAAAmxC,EAAA15C,IAAA+/D,GAAAx3D,KAAAmxC,UAAqD,CAAKA,EAAAnxC,KAAAmxC,EAAA8b,GAAa,QAAAr1D,GAAA,EAAYA,EAAAu5C,EAAAtmD,OAAW+M,IAAAyI,EAAAwnD,GAAAxnD,EAAA8wC,EAAAv5C,IAAiB,MAAAyI,IAAU0vD,EAAA5iD,IAAA,SAAAgkC,EAAA9wC,GAA4H,MAAxG0zD,GAAA/zD,MAAQA,KAAApI,EAAA,KAAYu5C,EAAAqmB,GAAAx3D,KAAAmxC,GAAasmB,GAAAz3D,KAAAmxC,KAAAnxC,KAAAK,GAAAL,KAAAmxC,EAAA15C,IAAA05C,GAAAtmD,QAA2CmV,KAAAmxC,EAAAhkC,IAAAgkC,GAAA9wC,IAAkBL,KAAAK,GAAA,EAAUL,MAAa+vD,EAAAt4D,IAAA,SAAA05C,EAAA9wC,GAAqC,MAAjB8wC,KAAAnxC,KAAAitD,EAAA9b,MAAiB,EAAAA,EAAAtmD,OAAAsmD,EAAA,GAAA9+C,GAAAgO,GAC3X0vD,EAAApvD,SAAA,WAAsB,GAAAX,KAAApI,EAAA,MAAAoI,MAAApI,CAAwB,KAAAoI,KAAAmxC,EAAA,QAAoB,QAAAA,MAAA9wC,EAAAL,KAAAmxC,EAAAojB,IAAA38D,EAAA,EAA8BA,EAAAyI,EAAAxV,OAAW+M,IAAA,CAAK,GAAAwI,GAAAC,EAAAzI,GAAA1L,EAAAmtE,mBAAAj5D,EAAA/N,GAA2C+N,GAAAJ,KAAAitD,EAAA7sD,EAAY,QAAAojB,GAAA,EAAYA,EAAApjB,EAAAvV,OAAW24B,IAAA,CAAK,GAAAylC,GAAA/8D,CAAQ,MAAAkU,EAAAojB,KAAAylC,GAAA,IAAAoQ,mBAAAj5D,EAAAojB,GAAAnxB,KAAqD8+C,EAAAlhD,KAAAg5D,IAAW,MAAAjpD,MAAApI,EAAAu5C,EAAA/gD,KAAA,KACrI,IAAAynE,IAAA,IAAYF,IAAA1qE,UAAAkgB,IAAA,SAAAgkC,GAA6BnxC,KAAAmxC,KAAUwmB,GAAA1qE,UAAAykD,MAAA,WAA8B1xC,KAAAmN,IAAA6iD,MAAe2H,GAAA1qE,UAAAwK,IAAA,WAA4B,MAAAuI,MAAAmxC,GAA2E6V,EAAA8Q,GAAAF,IAAkH7H,EAAAgI,GAAA9qE,UAAe8iE,EAAAgG,EAAA,KAC/JhG,EAAAvJ,GAAA,SAAArV,GAAiB,MAAAnxC,MAAAmxC,EAAAqV,GAAArV,IAAqB4e,EAAA3yB,MAAA,WAAmBp9B,KAAApI,IAAAoI,KAAApI,EAAAo4C,SAAAhwC,KAAApI,EAAA,MAAsCoI,KAAAwjB,GAAA,GACreusC,EAAApH,GAAA,WAAgB,UAChBoH,EAAA+D,GAAA,SAAA3iB,EAAA9wC,GAA8B,GAAXL,KAAAwjB,EAAA2tB,EAAAigB,EAAW,GAAApxD,KAAA+1D,EAAA,CAA+D,GAAjD3D,EAAApyD,KAAAK,EAAA,yCAAiDL,KAAAmxC,EAAA+iB,IAAA/iB,OAAA,CAAuB,GAAAv5C,GAAAy9D,GAAAlkB,EAAA,yBAAqCnxC,MAAAomD,EAAAxuD,GAAA,KAAgBoI,KAAAmxC,EAAA6iB,KAAA7iB,EAAAkkB,GAAAlkB,EAAA,sBAAAnxC,KAAAmxC,EAAAyhB,EAAAzhB,EAAAigB,EAAApxD,KAAAK,EAAA8wC,EAAA,wDAAuH,GAAA9wC,EAAA,CAAM,IAAI,GAAAD,GAAAJ,KAAAmxC,EAAAkW,GAAAlW,EAAAohB,MAAAlyD,GAA2B,MAAAnU,GAAsC,MAA7BmmE,IAAAryD,KAAAK,EAAAnU,OAAagwE,IAAAl8D,KAAAmxC,EAAAnxC,MAAuBA,KAAA+vD,EAAA3vD,EAAA,OAAYgyD,GAAApyD,KAAAK,EAAA,qCAAA67D,GAAAl8D,KAAAmxC,EAAAnxC,UAAmE,IAAAA,KAAA+1D,IAAA/1D,KAAAipD,EAAA2J,EAAA,GAAiC,SAAAvyD,GAAoBuyD,EAAA,GACtf5yD,KAAAipD,GAAA,IAAA4Q,GAAA,KAAAiC,MAAA97D,KAAAwjB,EAAA,IAAAxjB,KAAApI,EAAAo4C,SAAAoiB,EAAApyD,KAAAK,EAAA,yDAA4FuyD,EAAA,IAAAqF,GAAAj4D,KAAAmxC,EAAAnxC,MAAA,MAAuD4yD,EAAA,GAAA5yD,KAAAipD,GAAA,KACnJ8G,EAAAnI,GAAA,WAAgB5nD,KAAAwjB,EAAAxjB,KAAApI,EAAAw5D,EAAgBpxD,KAAApI,EAAA4rB,EAAA,GAAAxjB,KAAA+1D,GAAA/1D,KAAA+1D,EAAA,EAAA3D,EAAApyD,KAAAK,EAAA,sDAAA23D,GAAAh4D,OAAA,GAAAA,KAAA+1D,IAAA3D,EAAApyD,KAAAK,EAAA,gDAAAL,KAAAipD,GAAAmJ,EAAApyD,KAAAK,EAAA,yDAAuNuyD,EAAA,IAAAqF,GAAAj4D,KAAAmxC,EAAAnxC,MAAA,KAAAoyD,EAAApyD,KAAAK,EAAA,+CAA0FuyD,EAAA,IAAAqF,GAAAj4D,KAAAmxC,EAAAnxC,MAAA,MAAAoyD,EAAApyD,KAAAK,EAAA,4CAAAL,KAAA+1D,GAAA,GAAA/1D,KAAA+1D,EAAAnD,EAAA,MAAA5yD,KAAA+1D,GAAAnD,EAAA,GAAAsJ,GAAAl8D,KAAAmxC,EAAAnxC,QACjV+vD,EAAAnJ,GAAA,WAAgB,MAAA5mD,MAAAmxC,EAAAyV,MAAoBmJ,EAAA3E,GAAA,WAAgB,MAAAprD,MAAAmxC,EAAAia,MAAyLgN,GAAAnrE,UAAAgS,IAAA,SAAAkyC,GAA6BnxC,KAAAmxC,EAAAhkC,IAAAkrD,GAAAlnB,OAAqBinB,GAAAnrE,UAAAggE,EAAA,WAA0B,MAAAjtD,MAAAmxC,EAAA8b,IAAsM,IAAAuL,IAAA,EACvZD,IAAAtrE,UAAA+iD,OAAA,WAA+BhwC,KAAApI,EAAAohE,GAAAh5D,MAAgBA,KAAAK,GAAAL,KAAAK,EAAA2vC,SAAAhwC,KAAAK,EAAA,MAAAL,KAAAmxC,GAAA,GAAAnxC,KAAAmxC,IAAAv5C,IAAAg+D,GAAA51D,KAAAmxC,EAAA8b,IAAA,SAAA9b,GAAuFA,EAAAnB,WAAW6lB,GAAA71D,KAAAmxC,OAA8N+nB,GAAAjsE,UAAA0D,UAAA,SAAAwgD,GAAmC,MAAAjpC,GAAAxX,KAAAC,UAAAwgD,MAAA,KAAmC+nB,GAAAjsE,UAAAslE,MAAA,SAAAphB,GAA+B,MAAAjpC,GAAAxX,KAAA6hE,MAAAphB,MAAA,KAAo5B6V,EAAA2M,EAAA1G,EAAO,IAAA0M,IAAA,EAAUhG,GAAA1mE,UAAAoT,EAAA0wD,GAAA,iBAAmC,IAAAuJ,IAAA,YAAA0F,IAAA,aAAqCjQ,GAAA4D,EAAA1mE,UACziD8iE,EAAArI,GAAA,SAAAvW,EAAA9wC,EAAAzI,EAAAwI,GAAuB,GAAAJ,KAAAmxC,EAAA,KAAA7kD,OAAA,0DAAA0T,KAAAunD,EAAA,YAAyFpW,EAAa9wC,OAAA4/D,cAAA,MAA0BjgE,KAAAunD,EAAApW,EAASnxC,KAAA+vD,EAAA,GAAU/vD,KAAAg0D,EAAA,EAASh0D,KAAA4yD,EAAAvyD,EAASL,KAAAoyD,GAAA,EAAUpyD,KAAApI,GAAA,EAAUoI,KAAAmxC,EAAAoiB,GAAAvzD,KAAAwxD,EAAAxxD,KAAAwxD,EAAAmO,IAAgC3/D,KAAAmI,EAAAirD,GAAApzD,KAAAwxD,EAAAxxD,KAAAwxD,EAAAmO,IAAgC3/D,KAAAmxC,EAAAie,mBAAAriC,EAAA/sB,KAAAo6D,GAAAp6D,KAA0C,KAAIwxD,EAAAxxD,KAAAK,EAAA4zD,EAAAj0D,KAAA,gBAAAA,KAAA6xD,GAAA,EAAA7xD,KAAAmxC,EAAAloB,KAAA5oB,EAAA8wC,EAAA9+C,IAAA,GAAA2N,KAAA6xD,GAAA,EAAgF,MAAAruC,GAAsE,MAA7DguC,GAAAxxD,KAAAK,EAAA4zD,EAAAj0D,KAAA,sBAAAwjB,EAAAn3B,cAAkD0tE,IAAA/5D,KAAAwjB,GAAkB2tB,EAAAv5C,GAAA,EAAQ,IAAA1L,GAAA,GAAAgkE,GAAAlwD,KAAAwmB,QACnepmB,IAAAu1D,GAAAv1D,EAAA,SAAA+wC,EAAA9wC,GAAsBnU,EAAAihB,IAAA9M,EAAA8wC,KAAa/wC,EAAAunD,GAAAz7D,EAAAqoE,KAAY38D,EAAAsQ,EAAAg4D,UAAA/uB,YAAAjpC,GAAAg4D,WAAsC,GAAA9U,GAAA4U,GAAA3/D,KAAAD,GAAAxI,GAAA1L,EAAAihB,IAAA,kEAA8FjhB,EAAA8B,QAAA,SAAAmjD,EAAA9wC,GAAwBL,KAAAmxC,EAAAgvB,iBAAA9/D,EAAA8wC,IAA6BnxC,MAAOA,KAAA0zD,IAAA1zD,KAAAmxC,EAAAivB,aAAApgE,KAAA0zD,GAAqC,mBAAA1zD,MAAAmxC,GAAAnxC,KAAAmxC,EAAAkvB,kBAAArgE,KAAAk0D,IAAAl0D,KAAAmxC,EAAAkvB,gBAAArgE,KAAAk0D,EAA6F,KAAIqG,GAAAv6D,MAAA,EAAAA,KAAAomD,IAAApmD,KAAAoxD,EAAAwI,GAAA55D,KAAAmxC,GAAAqgB,EAAAxxD,KAAAK,EAAA4zD,EAAAj0D,KAAA,oBAAAA,KAAAomD,EAAA,0BAAApmD,KAAAoxD,IAAApxD,KAAAoxD,GAAApxD,KAAAmxC,EAAA2oB,QACrX95D,KAAAomD,EAAApmD,KAAAmxC,EAAAuoB,UAAA3sC,EAAA/sB,KAAA0oD,GAAA1oD,YAAA6wD,EAAAV,GAAAnwD,KAAA0oD,GAAA1oD,KAAAomD,EAAApmD,OAAAwxD,EAAAxxD,KAAAK,EAAA4zD,EAAAj0D,KAAA,oBAAAA,KAAA9N,GAAA,EAAA8N,KAAAmxC,EAAA3rB,KAAA2rB,GAAAnxC,KAAA9N,GAAA,EAAgJ,MAAAsxB,GAASguC,EAAAxxD,KAAAK,EAAA4zD,EAAAj0D,KAAA,eAAAwjB,EAAAn3B,UAAA0tE,GAAA/5D,KAAAwjB,KACzJusC,EAAArH,GAAA,eAAgB,KAAAyR,MAAAn6D,KAAAmxC,IAAAnxC,KAAA+vD,EAAA,mBAAA/vD,KAAAomD,EAAA,eAAApmD,KAAAg0D,EAAA,EAAAxC,EAAAxxD,KAAAK,EAAA4zD,EAAAj0D,UAAA+vD,IAAA/vD,KAAA0yD,cAAA,WAAA1yD,KAAAo9B,MAAA,KAChB2yB,EAAA3yB,MAAA,SAAA+T,GAAoBnxC,KAAAmxC,GAAAnxC,KAAApI,IAAA45D,EAAAxxD,KAAAK,EAAA4zD,EAAAj0D,KAAA,aAAAA,KAAApI,GAAA,EAAAoI,KAAAipD,GAAA,EAAAjpD,KAAAmxC,EAAA/T,QAAAp9B,KAAAipD,GAAA,EAAAjpD,KAAAg0D,EAAA7iB,GAAA,EAAAnxC,KAAA0yD,cAAA,YAAA1yD,KAAA0yD,cAAA,SAAAuH,GAAAj6D,QAA6K+vD,EAAA7H,EAAA,WAAeloD,KAAAmxC,IAAAnxC,KAAApI,IAAAoI,KAAApI,GAAA,EAAAoI,KAAAipD,GAAA,EAAAjpD,KAAAmxC,EAAA/T,QAAAp9B,KAAAipD,GAAA,GAAAgR,GAAAj6D,MAAA,IAA6E2zD,EAAA1M,EAAAiB,EAAA36D,KAAAyS,OAAkB+vD,EAAAqK,GAAA,WAAgBp6D,KAAAhO,IAAAgO,KAAA6xD,GAAA7xD,KAAA9N,GAAA8N,KAAAipD,EAAAiR,GAAAl6D,WAAA+qD,OAAqDgF,EAAAhF,GAAA,WAAgBmP,GAAAl6D,OAG1V+vD,EAAA+B,EAAA,WAAe,IAAI,SAAA5E,EAAAltD,WAAAmxC,EAAAh8C,QAAA,EAAkC,MAAAg8C,GAAS,WAAW4e,EAAAvH,GAAA,WAAgB,IAAI,SAAA0E,EAAAltD,WAAAmxC,EAAAmvB,WAAA,GAAsC,MAAAnvB,GAAS,MAAAqgB,GAAAxxD,KAAAK,EAAA,uBAAA8wC,EAAA9kD,SAAA,KAAuD0jE,EAAA8E,EAAA,WAAe,IAAI,MAAA70D,MAAAmxC,EAAAnxC,KAAAmxC,EAAAovB,aAAA,GAAqC,MAAApvB,GAAS,MAAAqgB,GAAAxxD,KAAAK,EAAA,6BAAA8wC,EAAA9kD,SAAA,KAC9S0jE,EAAA1D,GAAA,SAAAlb,GAAiB,GAAAnxC,KAAAmxC,EAAA,CAAW,GAAA9wC,GAAAL,KAAAmxC,EAAAovB,YAA0BpvB,IAAA,GAAA9wC,EAAA9O,QAAA4/C,KAAA9wC,IAAA5P,UAAA0gD,EAAAtmD,QAA8CsmD,GAAA,CAAO,GAAJA,EAAA9wC,EAAI6H,EAAAxX,KAAA,IAAc,GAAAkH,GAAAsQ,EAAAxX,KAAA6hE,MAAAphB,EAAsB,MAAAA,GAAQ,MAAA/wC,IAAUxI,EAAA01D,GAAAnc,GAAQ,MAAAv5C,KAAqEm4D,EAAAzH,GAAA,WAAgB,MAAAtoD,MAAAg0D,GAAejE,EAAA3G,GAAA,WAAgB,MAAAhD,GAAApmD,KAAA+vD,GAAA/vD,KAAA+vD,EAAA/vD,KAAA+vD,EAAA19D,IAC1K09D,EAAA6K,GAAA3tE,UAAe8iE,EAAAvI,GAAA,EAAOuI,EAAAkC,EAAA,EAEmLlC,EAAApH,GAAA,WAAgB,UAAA3oD,KAAAiyD,GAE5UlC,EAAAyL,GAAA,SAAArqB,GAA8D,GAA7CnxC,KAAAilC,EAAA,KAAYmtB,EAAApyD,KAAAmxC,EAAA,wBAAiC,GAAAnxC,KAAAiyD,EAAA,GAAA9gB,EAAA8V,EAAAjnD,KAAAmxC,EAAA,sCAA6D,CAAKihB,EAAApyD,KAAAmxC,EAAA,WAAoBnxC,KAAA4zD,EAAA3yD,KAAAC,MAAA,IAAAD,KAAAE,UAAqCgwC,EAAAnxC,KAAA4zD,GAAW,IAAAvzD,GAAA,GAAAqzD,GAAA1zD,UAAAmxC,QAAA,IAAAv5C,EAAAoI,KAAAhO,CAA2CgO,MAAA0zD,IAAA97D,KAAA0wD,GAAA1wD,GAAA2wD,GAAA3wD,EAAAoI,KAAA0zD,IAAA97D,EAAAoI,KAAA0zD,GAA4C,OAAA1zD,KAAAipD,IAAA5oD,EAAA2zD,EAAAp8D,EAAuB,IAAAwI,GAAAw7D,GAAA57D,KAAAK,GAAAnU,EAAAqoE,EAAAv0D,KAAAwxD,EAA6BoC,GAAA1nE,EAAA,MAAAilD,GAAayiB,EAAA1nE,EAAA,WAAe8T,KAAAk0D,GAAAl0D,KAAAg0D,GAAAJ,EAAA1nE,EAAA,oBAAA8T,KAAAg0D,GAAgDkH,GAAAl7D,KAAA9T,GAAW8T,KAAAipD,GAAArxD,GAAA+iE,GAAAzuE,EAAA8T,KAAAipD,EAAArxD,GAA0BghE,GAAA54D,KAAApI,EAAAyI,GAAaL,KAAA6nD,IAAA+L,EAAA1nE,EAAA,OAAAkU,GAAAwzD,EAAA1nE,EAAA,cAC7cmU,EAAA8zD,GAAA,EAAAE,GAAAh0D,EAAAnU,EAAA,OAAAmoE,GAAAh0D,EAAAnU,EAAAkU,GAA+BJ,KAAAiyD,EAAA,MAAS,IAAAjyD,KAAAiyD,IAAA9gB,EAAAwqB,GAAA37D,KAAAmxC,GAAA,GAAAnxC,KAAA+vD,EAAAllE,OAAAunE,EAAApyD,KAAAmxC,EAAA,kDAAA0nB,GAAA74D,KAAApI,GAAAqvD,EAAAjnD,KAAAmxC,EAAA,kEAAAwqB,GAAA37D,MAAAoyD,EAAApyD,KAAAmxC,EAAA,kDAIxC4e,EAAA5F,GAAA,WAAgBnqD,KAAAomD,EAAA,KAAYgM,EAAApyD,KAAAmxC,EAAA,4BAAqCnxC,KAAAK,EAAA,GAAAqzD,GAAA1zD,UAAAmxC,EAAA,MAAAnxC,KAAA2zD,GAAuC,OAAA3zD,KAAAipD,IAAAjpD,KAAAK,EAAA2zD,EAAAh0D,KAAAhO,GAAiCgO,KAAAK,EAAA6sD,EAAA,CAAW,IAAA/b,GAAAojB,EAAAv0D,KAAA68B,GAAiB+2B,GAAAziB,EAAA,aAAiByiB,EAAAziB,EAAA,MAAAnxC,KAAAmtD,GAAkByG,EAAAziB,EAAA,KAAAnxC,KAAAmnD,GAAA,SAA0ByM,EAAAziB,EAAA,MAAAnxC,KAAAktD,GAAkBgO,GAAAl7D,KAAAmxC,GAAWyiB,EAAAziB,EAAA,kBAAsBnxC,KAAAipD,GAAAjpD,KAAAhO,GAAA2oE,GAAAxpB,EAAAnxC,KAAAipD,EAAAjpD,KAAAhO,GAAoCgO,KAAAoyD,GAAApyD,KAAAK,EAAAgpB,WAAArpB,KAAAoyD,GAAkCqC,GAAAz0D,KAAAK,EAAA8wC,GAAA,EAAAnxC,KAAAm0D,GAAuB/B,EAAApyD,KAAAmxC,EAAA,wBAElX4e,EAAA+D,GAAA,SAAA3iB,EAAA9wC,GAAmB,MAAAL,KAAAiyD,IAAAjyD,KAAAK,GAAA8wC,GAAA2nB,GAAA94D,KAAApI,EAAAu5C,IAAA,GAAAnxC,KAAAunD,EAAApW,EAAAigB,GAAAjgB,EAAAhpC,GAAA2wD,GAAA94D,KAAApI,EAAAu5C,IAAA,GAAAnxC,KAAAiyD,EAAA,CAAqF,IAAI,GAAAr6D,GAAAoI,KAAAqnD,GAAAlW,EAAAohB,MAAAlyD,GAAyB,MAAAmjB,GAAS5rB,EAAA,KAAO,GAAAyR,EAAAzR,IAAA,GAAAA,EAAA/M,OAAA,GAAAwV,EAAAzI,EAAA,GAAAyI,EAAA,GAAA8wC,EAAA,GAAAihB,EAAApyD,KAAAmxC,EAAA,6CAAAnxC,KAAAomD,EAAAgM,EAAApyD,KAAAmxC,EAAA,kDAA6J,CAAK,GAAAnxC,KAAAK,EAAA,MAAAL,KAAAK,EAAAmxD,EAAA,IAAArgB,EAAAqgB,GAAmE,KAAArgB,EAAnEkqB,IAAAr7D,WAAAK,EAAA2vC,SAAAhwC,KAAAK,EAAA,SAAgF+wD,GAAApxD,KAAAmxC,IAAA,2CAA4D6qB,IAAAh8D,MAAS4yD,EAAA,QAAM5yD,MAAA8nD,GAAAznD,EAAA,GACld,GADkd8wC,EAAAnxC,KAAA8nD,GAAA9nD,KAAAktD,KACld7sD,IAAA,GAAA+xD,EAAApyD,KAAAmxC,EAAA9wC,EAAA,cAAA8wC,EAAA,qDAAA9wC,GAAAL,KAAAmnD,IAAA,GAAAnnD,KAAA6wD,IAAA7wD,KAAA9N,IAAA8N,KAAA9N,EAAA6gE,GAAAhmC,EAAA/sB,KAAAgY,GAAAhY,MAAA,WAA+JoyD,GAAApyD,KAAAmxC,EAAA,mCAAA0jB,EAAA70D,KAAA,QAA4D,KAAAmxC,EAAAhpC,GAAAnI,KAAAK,GAAA8wC,IAAAkqB,GAAAr7D,OAAA+nD,GAAA1nD,GAAA,IAAAA,EAAAzI,EAAAoI,KAAAqnD,GAAAlW,EAAAohB,MAAAlyD,GAAAzI,EAAA,EAAyEA,EAAAyI,EAAAxV,OAAW+M,IAAA,CAAK,GAAAwI,GAAAC,EAAAzI,EAA8B,IAAnBoI,KAAAktD,EAAA9sD,EAAA,GAAYA,IAAA,GAAO,GAAAJ,KAAAiyD,EAAA,QAAA7xD,EAAA,IAA2BJ,KAAAmtD,EAAA/sD,EAAA,GAAYJ,KAAAm0D,EAAA/zD,EAAA,EAAY,IAAAlU,GAAAkU,EAAA,EAAW,OAAAlU,IAAA8T,KAAAwnD,GAAAt7D,EAAA0lE,EAAA5xD,KAAAmxC,EAAA,OAAAnxC,KAAAwnD,KAA8Ct7D,EAAAkU,EAAA,GAAO,MAAAlU,IAAA8T,KAAA+nD,GAAA77D,EAAA0lE,EAAA5xD,KAAAmxC,EAAA,QAAAnxC,KAAA+nD,KAA+C3nD,EACpfA,EAAA,GAAK,MAAAA,GAAA,gBAAAA,IAAA,EAAAA,IAAAJ,KAAAoyD,EAAAhyD,GAAA,IAAAwxD,EAAA5xD,KAAAmxC,EAAA,gCAAA/wC,IAA8FJ,KAAAk0D,IAAA9zD,EAAA+wC,QAAAjlD,EAAAmpE,GAAAj1D,EAAA,4BAAAu4D,GAAA34D,KAAApI,EAAA1L,GAAA8T,KAAAg0D,KAAA5zD,EAAAi1D,GAAAj1D,EAAA,uBAAAJ,KAAA4yD,EAAAxyD,EAAAwzD,EAAA5zD,KAAAwxD,EAAAxxD,KAAAg0D,EAAA5zD,IAAAgxD,EAAApxD,KAAAmxC,IAAA,yDAA4MnxC,KAAAiyD,EAAA,EAASjyD,KAAAwjB,GAAAxjB,KAAAwjB,EAAA2kC,KAAoB/nD,EAAA+wC,EAAInxC,KAAA68B,GAAAq7B,GAAAl4D,UAAAm0D,EAAAn0D,KAAA+mD,IAAgC3mD,EAAA+H,GAAAiqD,EAAApyD,KAAAmxC,EAAA,mDAAA4nB,GAAA/4D,KAAApI,EAAAwI,IAAAlU,EAAA8T,KAAAoyD,IAAAhyD,EAAAipB,WAAAn9B,GAAAkU,EAAAlO,IAAA4iE,GAAA10D,GAAAs0D,GAAAt0D,IAAAJ,KAAAK,EAAAD,GAChX27D,GAAA/7D,UAAS,QAAAI,EAAA,aAAAA,EAAA,IAAAy0D,EAAA70D,KAAA,OAA2C,IAAAA,KAAAiyD,IAAA,QAAA7xD,EAAA,aAAAA,EAAA,WAAAA,EAAA,GAAAy0D,EAAA70D,KAAA,GAAAg7D,GAAAh7D,MAAA,QAAAI,EAAA,IAAAJ,KAAAwjB,GAAAxjB,KAAAwjB,EAAA06C,GAAA99D,GAAAJ,KAAA6wD,EAAA,KAA4Hd,EAAA/3C,GAAA,WAAgB,MAAAhY,KAAA9N,IAAA8N,KAAA9N,EAAA,KAAA8N,KAAAK,EAAA2vC,SAAAhwC,KAAAK,EAAA,KAAA27D,GAAAh8D,MAAA4yD,EAAA,MAChM7C,EAAAnI,GAAA,SAAAzW,GAAiBihB,EAAApyD,KAAAmxC,EAAA,mBAA6B,IAAA9wC,GAAA,IAAW,IAAAL,KAAAK,GAAA8wC,EAAA,CAAckqB,GAAAr7D,MAASA,KAAAK,EAAA,IAAY,IAAAzI,GAAA,MAAQ,KAAAkhE,GAAA94D,KAAApI,EAAAu5C,GAA4C,MAA5C9wC,GAAA8wC,EAAAoW,EAAAwR,GAAA/4D,KAAApI,EAAAu5C,GAAAv5C,EAAA,EAAmE,GAAXoI,KAAAunD,EAAApW,EAAAigB,EAAW,GAAApxD,KAAAiyD,EAAA,GAAA9gB,EAAA3tB,EAAA,GAAA5rB,GAAAk7D,GAAA3hB,EAAAiV,EAAAjV,EAAAiV,EAAAv7D,OAAA,EAAAmlE,IAAA7e,EAAAqgB,EAAAxxD,KAAAmI,GAAAozD,GAAAv7D,OAAA+7D,GAAA/7D,UAAiF,CAAK,GAAAI,GAAA+wC,EAAAlM,CAAU,OAAA7kC,GAAA,GAAAA,GAAA,EAAAJ,KAAAunD,EAAA6K,EAAApyD,KAAAmxC,EAAA,sCAAmE,CAAK,GAAAjlD,GAAA8T,IAAgF,IAArEoyD,EAAApyD,KAAAmxC,EAAA,WAAoB,qCAAAijB,GAAAh0D,EAAAlU,EAAAq7D,KAAiD,GAAA3vD,GAAA6jE,GAAAz7D,KAAAmxC,IAAA,GAAAv5C,GAAAokE,GAAAh8D,MAAA,MAA2CoyD,GAAApyD,KAAAmxC,EAAA,kCAC1Y,OADqb9wC,GACrf,EAAAA,EAAAxV,QAAAouE,GAAAj5D,KAAApI,EAAAyI,GAAyB+xD,EAAApyD,KAAAmxC,EAAA,8BAAuC/wC,GAAU,OAAAy0D,EAAA70D,KAAA,EAAiB,MAAM,QAAA60D,EAAA70D,KAAA,GAAkB,MAAM,QAAA60D,EAAA70D,KAAA,EAAiB,MAAM,SAAA60D,EAAA70D,KAAA,MAC0J+vD,EAAAnE,GAAA,SAAAza,GAAiBA,GAAAygB,EAAA5xD,KAAAmxC,EAAA,kCAAAyhB,EAAA,KAAAhB,EAAA5xD,KAAAmxC,EAAA,6BAAAyhB,EAAA,KAE7D7C,EAAAvJ,GAAA,SAAArV,GAAiB,GAAAA,IAAAnxC,KAAA+zD,EAAA,KAAAznE,OAAA,sDAAoG,OAAnB6kD,GAAA,GAAAwiB,GAAQxiB,EAAA+iB,EAAAl0D,KAAA+zD,EAAW5iB,GAAU4e,EAAA3E,GAAA,WAAgB,QAAAprD,KAAAwjB,IAAA,GAAoBusC,EAAAnJ,GAAA,WAAgB,MAAA5mD,MAAA+zD,GAAe,GAAA+D,IAAsB/H,EAAAwM,GAAAtvE,UAAe8iE,EAAA5H,GAAA,aACre4H,EAAAmO,GAAA,aAAkBnO,EAAAoM,GAAA,aAAkBpM,EAAA/H,GAAA,aAAkB+H,EAAA+L,GAAA,aAAqUW,GAAAxvE,UAAAkkD,EAAA,SAAAA,EAAA9wC,GAA6B,UAAA8zD,GAAAhjB,EAAA9wC,IAEwB2mD,EAAAmN,EAAAlH,GAAO8C,EAAAoE,EAAAlnE,UACvb8iE,EAAAroB,iBAAA,SAAAyJ,EAAA9wC,EAAAzI,EAAAwI,GAAqC+zD,EAAAlN,EAAAvf,iBAAAn6C,KAAAyS,KAAAmxC,EAAA9wC,EAAAzI,EAAAwI,IAAyC2vD,EAAApoB,oBAAA,SAAAwJ,EAAA9wC,EAAAzI,EAAAwI,GAAwC+zD,EAAAlN,EAAAtf,oBAAAp6C,KAAAyS,KAAAmxC,EAAA9wC,EAAAzI,EAAAwI,IACtH2vD,EAAA2O,GAAA,WAAgB1+D,KAAAmxC,EAAA3tB,EAAAxjB,KAAAipD,EAAgBjpD,KAAAomD,IAAApmD,KAAAmxC,EAAA4iB,GAAA,EAAsB,IAAA5iB,GAAAnxC,KAAAmxC,EAAA9wC,EAAAL,KAAAk0D,EAAAt8D,EAAAoI,KAAAK,EAAAD,EAAAJ,KAAA+vD,OAAA,EAAgDqC,GAAAjhB,IAAA,aAAmByhB,EAAA,GAAKzhB,EAAA4V,GAAAnvD,EAAOu5C,EAAA8iB,EAAA7zD,MAAU+wC,EAAA+iB,IAAA9B,EAAAjhB,IAAA,oCAAAA,EAAA0gB,EAAAxxD,KAAA8wC,EAAA0gB,EAAA1gB,GAAA,GAAmEihB,EAAAjhB,IAAA,kBAAwBA,EAAAigB,EAAA,GAAA2G,IAAA5mB,OAAkB,OAAAA,EAAA8X,IAAA9X,EAAAigB,EAAAp/D,EAAAm/C,EAAAn/C,GAAwB4F,EAAAyI,EAAI8wC,EAAA8X,GAAA9X,EAAAn/C,IAAA4F,EAAA+iE,GAAAt6D,EAAA8wC,EAAA8X,EAAA9X,EAAAn/C,IAA4Bm/C,IAAAigB,EAAMjgB,EAAAlM,EAAArtC,EAAMyI,EAAA47D,GAAA9qB,MAAAlM,GAAc2tB,EAAA,GAAKh7D,EAAAu5C,IAAA0gB,EAAAxxD,EAAU,MAAAzI,GAAAu5C,EAAA4e,EAAAn4D,EAAA,GAAAu5C,EAAA4kB,EAAA,EAAAiC,GAAA7mB,KAAAwjB,GAAAt0D,EAAA,gBAAA8wC,IAAA+iB,GAAA/iB,IAAA6iB,GAAAW,GAAAt0D,EAAA,oBAAA8wC,IAAA6iB,GAAA7iB,EAAAv5C,EAAA,GAAA87D,GAAAviB,IAAA9wC,MAAA,WAAA8wC,EAAAv5C,EAAAo8D,EAAA7iB,EAAAn/C,EAAAyiE,GAAAtjB,EAAAv5C,EAAAyI,GAAA,EAC7V,MAAA8wC,EAAA4kB,EAAA,IAAchG,EAAAxqC,MAAA,WAAmBy1C,GAAAh7D,KAAAmxC,IAAY4e,EAAAjE,GAAA,SAAA3a,GAAiB,GAAAiV,EAAAjV,GAAA,CAAS,GAAA9wC,KAASA,GAAAmgE,SAAArvB,EAAamqB,GAAAt7D,KAAAmxC,EAAA9wC,OAAaL,MAAAg0D,GAAA3zD,KAAiBA,EAAAmgE,SAAAtZ,GAAA/V,GAAAmqB,GAAAt7D,KAAAmxC,EAAA9wC,IAAAi7D,GAAAt7D,KAAAmxC,MAA8C4e,EAAA7H,EAAA,WAAeloD,KAAAmxC,EAAA3tB,EAAA,WAAcxjB,MAAAipD,EAAc+R,GAAAh7D,KAAAmxC,SAAWnxC,MAAAmxC,EAAcgjB,EAAAlN,EAAAiB,EAAA36D,KAAAyS,OAAsMgnD,EAAAmW,GAAAlK,IAAmDjM,EAAAqW,GAAAnK,IAC9clM,EAAAkW,GAAAX,IAASW,GAAAjwE,UAAAk7D,GAAA,WAA2BmJ,GAAAtxD,KAAAmxC,EAAAv5C,EAAA,wBAAAoI,KAAAmxC,EAAA9wC,GAA8CL,KAAAmxC,EAAAuhB,cAAA,MAA2BwK,GAAAjwE,UAAAixE,GAAA,SAAA/sB,GAA4BnxC,KAAAmxC,EAAAuhB,cAAA,GAAAyK,IAAAhsB,KAAiC+rB,GAAAjwE,UAAAkvE,GAAA,SAAAhrB,GAA4BmgB,GAAAtxD,KAAAmxC,EAAAv5C,EAAA,yBAAAoI,KAAAmxC,EAAA9wC,EAAA,0BAAA8wC,GAA2EnxC,KAAAmxC,EAAAuhB,cAAA,GAAA2K,IAAAlsB,KAAiC+rB,GAAAjwE,UAAA+6D,GAAA,WAA2BsJ,GAAAtxD,KAAAmxC,EAAAv5C,EAAA,wBAAAoI,KAAAmxC,EAAA9wC,GAA8CL,KAAAmxC,EAAAuhB,cAAA,KAA2B,IAAA+N,IAAA1Z,GAAA,SAAA5V,EAAA9wC,GAAwB,QAAAzI,MAAcA,EAAA3K,UAAAkkD,EAAAlkD,SAAwB,IAAAmT,GAAA,GAAAxI,EAA+D,OAAnDu5C,GAAA3lD,MAAA4U,EAAArR,MAAA9B,UAAAgX,MAAA1W,KAAA3C,UAAA,IAAmDwV,GAASq8D,GAAiKa,IAAArwE,UAAAggE,EAAA,WAA0B,OAAA9b,MAAA9wC,EAAAL,KAAAK,EAAAxV,OAAA,EAA+B,GAAAwV,IAAKA,EAAA8wC,EAAAlhD,KAAA+P,KAAAK,KAAsB,IAAAzI,GAAAoI,KAAAmxC,EAAAtmD,MAAoB,KAAAwV,EAAA,EAAQA,EAAAzI,IAAIyI,EAAA8wC,EAAAlhD,KAAA+P,KAAAmxC,EAAA9wC,GAAsB,OAAA8wC,IAAoJ6V,EAAAyW,GAAAlW,EAAQ,IAAAmW,IAAA,qDAA6D3N,GAAA0N,GAAAxwE,UAAe8iE,EAAAtJ,GAAA,WAAgB,GAAAtV,GAAA6e,GAAU,YAAAhwD,KAAA+vD,GAAA,EAAA5e,EAAAnxC,KAAA+vD,GAAA,CAAgC,OAAA1vD,GAAU,EAAAm9D,GAAAx9D,KAAAmxC,KAAA9wC,EAAAk9D,GAAAv9D,KAAAmxC,IAAAnxC,KAAA2nD,GAAAtnD,KAAyCL,KAAAqmD,IAA0E,QAA/DhmD,GAAAu9D,GAAA59D,WAAApI,IAAAyI,EAAAL,KAAAynD,MAAmCpnD,IAAAL,KAAA+vD,EAAA5e,EAAAnxC,KAAAK,EAAApB,IAAAoB,IAA4BA,IAAW0vD,EAAA5E,GAAA,SAAAha,GAAiB,QAAA2kB,GAAA91D,KAAAK,EAAA8wC,EAAAknB,GAAAlnB,MAAAnxC,KAAAsnD,GAAAnW,IAAA,IAC1xC4e,EAAAzI,GAAA,SAAAnW,GAAiB2kB,GAAA91D,KAAAK,EAAA8wC,EAAAknB,GAAAlnB,IAAmBnxC,KAAA2nD,GAAAxW,IAAAysB,GAAA59D,WAAApI,EAAAoI,KAAAmxC,IAAAlhD,KAAAkhD,GAAAwsB,GAAAxsB,IAAoD4e,EAAA1J,GAAA,WAAgB,OAAAlV,GAAAnxC,KAAAmxC,EAAiBysB,GAAA59D,WAAAipD,GAAgB,CAAE,GAAA5oD,GAAAL,KAAAynD,IAAgBtW,KAAAlhD,KAAAoQ,GAAY,KAAKu9D,GAAA59D,WAAApI,GAAA,EAAA4lE,GAAAx9D,KAAAmxC,IAA8BwsB,GAAAJ,GAAApsB,KAAY4e,EAAAtI,GAAA,WAAgB,UAAuFsI,EAAApI,GAAA,SAAAxW,GAAiB,wBAAAA,GAAAmtB,IAAAntB,EAAAmtB,MAC9UvO,EAAA7H,EAAA,WAAiC,GAAlBuV,GAAAxW,EAAAiB,EAAA36D,KAAAyS,MAAkB,EAAAA,KAAAK,EAAA8wC,EAAAv5C,EAAA,KAAAtL,OAAA,kDAAwE0T,MAAAK,CAAc,QAAA8wC,GAAAnxC,KAAAmxC,EAAiB,GAAAA,EAAA9wC,EAAAxV,QAAA,GAAAsmD,IAAAtmD,QAA6B8yE,GAAAJ,GAAApsB,UAAWnxC,MAAAmxC,GAAma2sB,GAAA7wE,UAAAggE,EAAA,WAA0B,OAAA9b,GAAAnxC,KAAAmxC,EAAA9wC,KAAAzI,EAAAu5C,EAAAtmD,OAAAuV,EAAA,EAAqCA,EAAAxI,EAAIwI,IAAAC,EAAApQ,KAAAkhD,EAAA/wC,GAAAC,EAAmB,OAAAA,IACzqBy9D,GAAA7wE,UAAAsnE,EAAA,WAA0B,OAAApjB,GAAAnxC,KAAAmxC,EAAA9wC,KAAAzI,EAAAu5C,EAAAtmD,OAAAuV,EAAA,EAAqCA,EAAAxI,EAAIwI,IAAAC,EAAApQ,KAAAkhD,EAAA/wC,GAAA+wC,EAAmB,OAAA9wC,IAAsC2mD,EAAAgX,GAAAF,IAAyD9W,EAAAsJ,EAAAmN,IAAQ1N,EAAAO,EAAArjE,UAAc8iE,EAAAtJ,GAAA,SAAAtV,EAAA9wC,GAAmB,IAAA8wC,EAAA,MAAAmf,GAAArJ,EAAAR,GAAAl5D,KAAAyS,KAA+B+9D,IAAA/9D,KAAAwjB,MAAA,KAAAnjB,IAAA,IAAA8wC,GAA8BnxC,KAAA41D,MAAW7F,EAAA6F,GAAA,WAAgB,OAAAzkB,GAAAnxC,KAAAwjB,EAAiB,EAAA2tB,IAAAtmD,QAAa,CAAE,GAAAwV,GAAAL,KAAAymD,IAAgB,KAAApmD,EAA2P,KAArP,IAAAzI,GAAAu5C,EAAA/wC,EAAAxI,EAAAu5C,EAAAjlD,EAAAkU,EAAAvV,OAAyB24B,EAAApjB,EAAA,EAAW,OAAAlU,EAAAs3B,MAAA,OAAiB,CAAK,MAAAt3B,EAAA2wC,GAAAz8B,OAAc,CAAKA,EAAA,GAAAA,EAAA2I,MAAa3I,EAAA,EAAIxI,IAAAu5C,EAAMjlD,EAAA0L,EAAA/M,MAAW,QAAAo+D,GAAArxD,EAAAwI,GAAeA,EAAAlU,GAAA,GAAO,CAAE,GAAA+4C,GAAA,EAAA7kC,EAAA,EAAA+H,EAAA,EAAA/H,EAAA,CAA6C,IAAzB6kC,EAAA98B,EAAAjc,GAAA0L,EAAAuQ,GAAAgpC,EAAAv5C,EAAAqtC,GAAAkM,EAAAhpC,EAAA88B,EAAyBrtC,EAAAqtC,GAAAkM,EAAA8X,EAAA9X,EAAA,KAAoBv5C,GAAAwI,GAAAxI,EAAAqtC,GAAU7kC,EAAA6kC,EAAIrtC,EAAAwI,GAAA6oD,EAAOzlC,IAAAnjB,EAAMmjB,EAAAh4B,MAAAwU,MAAAK,MAC/kB0vD,EAAAzI,GAAA,SAAAnW,GAAiBmf,EAAArJ,EAAAK,GAAA/5D,KAAAyS,KAAAmxC,GAAoBnxC,KAAA41D,MAAW7F,EAAA1J,GAAA,WAAgBiK,EAAArJ,EAAAZ,GAAA94D,KAAAyS,MAAkBA,KAAA41D,MAAW7F,EAAA7H,EAAA,WAAeoI,EAAArJ,EAAAiB,EAAA36D,KAAAyS,MAAiBkI,EAAA+nC,iBAAA,IAAuBpT,GAAA78B,KAAAwjB,EAAA2tB,GAAanxC,KAAAwjB,EAAA,MAAsEwjC,EAAAgE,EAAAsF,GAAOtF,EAAA/9D,UAAAw6D,GAAA,WAA0B,GAAAtW,GAAA,GAAAwiB,GAAAtzD,EAAAL,KAAAomD,CAAsF,OAAjE/lD,MAAArS,QAAA,SAAAqS,EAAAD,GAA2B+wC,EAAA3qB,QAAArZ,IAAA/M,EAAAC,KAAqBL,KAAAg0D,IAAA7iB,EAAA+iB,GAAA,GAAiB/iB,GAAU6Z,EAAA/9D,UAAA06D,GAAA,SAAAxW,GAA2B,OAAAA,EAAAn/C,IAAAm/C,KAAkBsrB,GAAAxvE,UAAA47B,iBAAA4zC,GAAAxvE,UAAAkkD,EAA6CgjB,EAAAlnE,UAAAu4B,KAAA2uC,EAAAlnE,UAAA6+D,GAAgCqI,EAAAlnE,UAAAg8B,KAAAkrC,EAAAlnE,UAAAyxE,GAAgCvK,EAAAlnE,UAAAs4B,MAAA4uC,EAAAlnE,UAAAs4B,MAAoCi6C,GAAAn4C,SAAA,EAAcm4C,GAAAh4C,QAAA,EAAag4C,GAAA/3C,WAAA,EAAgBg4C,GAAAt4C,SAAA,WAAuB6rC,GAAA1pC,UAAAo2C,GAAgBA,GAAAn2C,KAAA,IAAYm2C,GAAAl2C,MAAA,IAAak2C,GAAA9zE,MAAA,IAAa8zE,GAAAj2C,QAAA,IAAewjC,EAAAhgE,UAAAk8B,OAAA8jC,EAAAhgE,UAAAs7D,GAAkCyC,EAAA/9D,UAAA+5B,UAAAgkC,EAAA/9D,UAAAw5D,GAAqCuE,EAAA/9D,UAAA86B,cAAAijC,EAAA/9D,UAAAk+D,GAAyCwI,EAAA1mE,UAAAi6B,WAAAysC,EAAA1mE,UAAAw7D,GAAsCkL,EAAA1mE,UAAA66B,aAAA6rC,EAAA1mE,UAAAm8D,GAAwCuK,EAAA1mE,UAAAm6B,iBAAAusC,EAAA1mE,UAAAq7D,GAC32BqL,EAAA1mE,UAAA06B,UAAAgsC,EAAA1mE,UAAA6kE,EAAoC6B,EAAA1mE,UAAA46B,cAAA8rC,EAAA1mE,UAAAu7D,GAAyCmL,EAAA1mE,UAAAs6B,gBAAAosC,EAAA1mE,UAAAo/D,GAA2CsH,EAAA1mE,UAAA26B,gBAAA+rC,EAAA1mE,UAAA4nE,EAA0ClB,EAAA1mE,UAAA26B,gBAAA+rC,EAAA1mE,UAAA4nE,EAA0ClB,EAAA1mE,UAAAu4B,KAAAmuC,EAAA1mE,UAAAy6D,GAAgC59D,OAAAC,SAAgB22E,0BAAAD,GAAAE,UAAAnB,GAAAl2C,UAAAm2C,GAAAmB,WAAA5N,GAAA6N,UAAA7V,KAAmFz9D,SAAA,KAAA44D,cAAA,mBAAAkU,WAAA,mBAAA59B,qBnFqmhBlTlvC,KAAKxD,QAASC,oBAAoB,QAI5D,MACO,MAAM6B,GACN,KAAUS,OACR","file":"firebase-firestore.js","sourcesContent":["/*!\n * @license Firebase v4.10.0\n * Build: rev-fc81427\n * Terms: https://firebase.google.com/terms/\n */\ntry {\n        webpackJsonpFirebase([1],{\n\n/***/ 113:\n/***/ (function(module, exports, __webpack_require__) {\n\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n__webpack_require__(114);\n\n\n/***/ }),\n\n/***/ 114:\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\nObject.defineProperty(__webpack_exports__, \"__esModule\", { value: true });\n\n// EXTERNAL MODULE: ../app/dist/esm/index.js + 1 modules\nvar esm = __webpack_require__(6);\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/version.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** The semver (www.semver.org) version of the SDK. */\nvar SDK_VERSION = esm[\"default\"].SDK_VERSION;\n\n//# sourceMappingURL=version.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/log.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* tslint:disable:no-console */\n\n\nvar LogLevel;\n(function (LogLevel) {\n    LogLevel[LogLevel[\"DEBUG\"] = 0] = \"DEBUG\";\n    LogLevel[LogLevel[\"ERROR\"] = 1] = \"ERROR\";\n    LogLevel[LogLevel[\"SILENT\"] = 2] = \"SILENT\";\n})(LogLevel || (LogLevel = {}));\nvar logLevel = LogLevel.ERROR;\n// Helper methods are needed because variables can't be exported as read/write\nfunction getLogLevel() {\n    return logLevel;\n}\nfunction setLogLevel(newLevel) {\n    logLevel = newLevel;\n}\nfunction debug(tag, msg) {\n    var obj = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        obj[_i - 2] = arguments[_i];\n    }\n    if (logLevel <= LogLevel.DEBUG) {\n        var time = new Date().toISOString();\n        var args = obj.map(argToString);\n        console.log.apply(console, [\"Firestore (\" + SDK_VERSION + \") \" + time + \" [\" + tag + \"]: \" + msg].concat(args));\n    }\n}\nfunction log_error(msg) {\n    var obj = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        obj[_i - 1] = arguments[_i];\n    }\n    if (logLevel <= LogLevel.ERROR) {\n        var time = new Date().toISOString();\n        var args = obj.map(argToString);\n        console.error.apply(console, [\"Firestore (\" + SDK_VERSION + \") \" + time + \": \" + msg].concat(args));\n    }\n}\n/**\n * Converts an additional log parameter to a string representation.\n */\nfunction argToString(obj) {\n    if (typeof obj === 'string') {\n        return obj;\n    }\n    else {\n        var platform = platform_PlatformSupport.getPlatform();\n        try {\n            return platform.formatJSON(obj);\n        }\n        catch (e) {\n            // Converting to JSON failed, just log the object directly\n            return obj;\n        }\n    }\n}\n\n//# sourceMappingURL=log.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/assert.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * Unconditionally fails, throwing an Error with the given message.\n *\n * Returns any so it can be used in expressions:\n * @example\n * let futureVar = fail('not implemented yet');\n */\nfunction fail(failure) {\n    // Log the failure in addition to throw an exception, just in case the\n    // exception is swallowed.\n    var message = \"FIRESTORE (\" + SDK_VERSION + \") INTERNAL ASSERTION FAILED: \" + failure;\n    log_error(message);\n    // NOTE: We don't use FirestoreError here because these are internal failures\n    // that cannot be handled by the user. (Also it would create a circular\n    // dependency between the error and assert modules which doesn't work.)\n    throw new Error(message);\n}\n/**\n * Fails if the given assertion condition is false, throwing an Error with the\n * given message if it did.\n */\nfunction assert(assertion, message) {\n    if (!assertion) {\n        fail(message);\n    }\n}\n\n//# sourceMappingURL=assert.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/platform/platform.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Provides singleton helpers where setup code can inject a platform at runtime.\n * setPlatform needs to be set before Firestore is used and must be set exactly\n * once.\n */\nvar platform_PlatformSupport = /** @class */ (function () {\n    function PlatformSupport() {\n    }\n    PlatformSupport.setPlatform = function (platform) {\n        if (PlatformSupport.platform) {\n            fail('Platform already defined');\n        }\n        PlatformSupport.platform = platform;\n    };\n    PlatformSupport.getPlatform = function () {\n        if (!PlatformSupport.platform) {\n            fail('Platform not set');\n        }\n        return PlatformSupport.platform;\n    };\n    return PlatformSupport;\n}());\n\n/**\n * Returns the representation of an empty \"proto\" byte string for the\n * platform.\n */\nfunction emptyByteString() {\n    return platform_PlatformSupport.getPlatform().emptyByteString;\n}\n\n//# sourceMappingURL=platform.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/error.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n// TODO(mcg): Change to a string enum once we've upgraded to typescript 2.4.\n//  tslint:disable-next-line:variable-name Intended to look like a TS 2.4 enum\nvar Code = {\n    // Causes are copied from:\n    // https://github.com/grpc/grpc/blob/bceec94ea4fc5f0085d81235d8e1c06798dc341a/include/grpc%2B%2B/impl/codegen/status_code_enum.h\n    /** Not an error; returned on success. */\n    OK: 'ok',\n    /** The operation was cancelled (typically by the caller). */\n    CANCELLED: 'cancelled',\n    /** Unknown error or an error from a different error domain. */\n    UNKNOWN: 'unknown',\n    /**\n     * Client specified an invalid argument. Note that this differs from\n     * FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are\n     * problematic regardless of the state of the system (e.g., a malformed file\n     * name).\n     */\n    INVALID_ARGUMENT: 'invalid-argument',\n    /**\n     * Deadline expired before operation could complete. For operations that\n     * change the state of the system, this error may be returned even if the\n     * operation has completed successfully. For example, a successful response\n     * from a server could have been delayed long enough for the deadline to\n     * expire.\n     */\n    DEADLINE_EXCEEDED: 'deadline-exceeded',\n    /** Some requested entity (e.g., file or directory) was not found. */\n    NOT_FOUND: 'not-found',\n    /**\n     * Some entity that we attempted to create (e.g., file or directory) already\n     * exists.\n     */\n    ALREADY_EXISTS: 'already-exists',\n    /**\n     * The caller does not have permission to execute the specified operation.\n     * PERMISSION_DENIED must not be used for rejections caused by exhausting\n     * some resource (use RESOURCE_EXHAUSTED instead for those errors).\n     * PERMISSION_DENIED must not be used if the caller can not be identified\n     * (use UNAUTHENTICATED instead for those errors).\n     */\n    PERMISSION_DENIED: 'permission-denied',\n    /**\n     * The request does not have valid authentication credentials for the\n     * operation.\n     */\n    UNAUTHENTICATED: 'unauthenticated',\n    /**\n     * Some resource has been exhausted, perhaps a per-user quota, or perhaps the\n     * entire file system is out of space.\n     */\n    RESOURCE_EXHAUSTED: 'resource-exhausted',\n    /**\n     * Operation was rejected because the system is not in a state required for\n     * the operation's execution. For example, directory to be deleted may be\n     * non-empty, an rmdir operation is applied to a non-directory, etc.\n     *\n     * A litmus test that may help a service implementor in deciding\n     * between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:\n     *  (a) Use UNAVAILABLE if the client can retry just the failing call.\n     *  (b) Use ABORTED if the client should retry at a higher-level\n     *      (e.g., restarting a read-modify-write sequence).\n     *  (c) Use FAILED_PRECONDITION if the client should not retry until\n     *      the system state has been explicitly fixed. E.g., if an \"rmdir\"\n     *      fails because the directory is non-empty, FAILED_PRECONDITION\n     *      should be returned since the client should not retry unless\n     *      they have first fixed up the directory by deleting files from it.\n     *  (d) Use FAILED_PRECONDITION if the client performs conditional\n     *      REST Get/Update/Delete on a resource and the resource on the\n     *      server does not match the condition. E.g., conflicting\n     *      read-modify-write on the same resource.\n     */\n    FAILED_PRECONDITION: 'failed-precondition',\n    /**\n     * The operation was aborted, typically due to a concurrency issue like\n     * sequencer check failures, transaction aborts, etc.\n     *\n     * See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,\n     * and UNAVAILABLE.\n     */\n    ABORTED: 'aborted',\n    /**\n     * Operation was attempted past the valid range. E.g., seeking or reading\n     * past end of file.\n     *\n     * Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed\n     * if the system state changes. For example, a 32-bit file system will\n     * generate INVALID_ARGUMENT if asked to read at an offset that is not in the\n     * range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from\n     * an offset past the current file size.\n     *\n     * There is a fair bit of overlap between FAILED_PRECONDITION and\n     * OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)\n     * when it applies so that callers who are iterating through a space can\n     * easily look for an OUT_OF_RANGE error to detect when they are done.\n     */\n    OUT_OF_RANGE: 'out-of-range',\n    /** Operation is not implemented or not supported/enabled in this service. */\n    UNIMPLEMENTED: 'unimplemented',\n    /**\n     * Internal errors. Means some invariants expected by underlying System has\n     * been broken. If you see one of these errors, Something is very broken.\n     */\n    INTERNAL: 'internal',\n    /**\n     * The service is currently unavailable. This is a most likely a transient\n     * condition and may be corrected by retrying with a backoff.\n     *\n     * See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,\n     * and UNAVAILABLE.\n     */\n    UNAVAILABLE: 'unavailable',\n    /** Unrecoverable data loss or corruption. */\n    DATA_LOSS: 'data-loss'\n};\n/**\n * An error class used for Firestore-generated errors. Ideally we should be\n * using FirebaseError, but integrating with it is overly arduous at the moment,\n * so we define our own compatible error class (with a `name` of 'FirebaseError'\n * and compatible `code` and `message` fields.)\n */\nvar FirestoreError = /** @class */ (function (_super) {\n    __extends(FirestoreError, _super);\n    function FirestoreError(code, message) {\n        var _this = _super.call(this, message) || this;\n        _this.code = code;\n        _this.message = message;\n        _this.name = 'FirebaseError';\n        // HACK: We write a toString property directly because Error is not a real\n        // class and so inheritance does not work correctly. We could alternatively\n        // do the same \"back-door inheritance\" trick that FirebaseError does.\n        _this.toString = function () { return _this.name + \": [code=\" + _this.code + \"]: \" + _this.message; };\n        return _this;\n    }\n    return FirestoreError;\n}(Error));\n\n\n//# sourceMappingURL=error.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/api.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// We are doing some heavy reflective stuff, lots of any casting necessary\n/* tslint:disable:no-any */\n\n/**\n * Helper function to prevent instantiation through the constructor.\n *\n * This method creates a new constructor that throws when it's invoked.\n * The prototype of that constructor is then set to the prototype of the hidden\n * \"class\" to expose all the prototype methods and allow for instanceof\n * checks.\n *\n * To also make all the static methods available, all properties of the\n * original constructor are copied to the new constructor.\n */\nfunction makeConstructorPrivate(cls, optionalMessage) {\n    function PublicConstructor() {\n        var error = 'This constructor is private.';\n        if (optionalMessage) {\n            error += ' ';\n            error += optionalMessage;\n        }\n        throw new FirestoreError(Code.INVALID_ARGUMENT, error);\n    }\n    // Make sure instanceof checks work and all methods are exposed on the public\n    // constructor\n    PublicConstructor.prototype = cls.prototype;\n    // Copy any static methods/members\n    for (var staticProperty in cls) {\n        if (cls.hasOwnProperty(staticProperty)) {\n            PublicConstructor[staticProperty] = cls[staticProperty];\n        }\n    }\n    return PublicConstructor;\n}\n\n//# sourceMappingURL=api.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/obj.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nfunction contains(obj, key) {\n    return Object.prototype.hasOwnProperty.call(obj, key);\n}\nfunction get(obj, key) {\n    return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : null;\n}\nfunction obj_size(obj) {\n    var count = 0;\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            count++;\n        }\n    }\n    return count;\n}\n/** Returns the given value if it's defined or the defaultValue otherwise. */\nfunction defaulted(value, defaultValue) {\n    return value !== undefined ? value : defaultValue;\n}\nfunction forEachNumber(obj, fn) {\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            var num = Number(key);\n            if (!isNaN(num)) {\n                fn(num, obj[key]);\n            }\n        }\n    }\n}\nfunction forEach(obj, fn) {\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            fn(key, obj[key]);\n        }\n    }\n}\nfunction lookupOrInsert(obj, key, valFn) {\n    if (!contains(obj, key)) {\n        obj[key] = valFn();\n    }\n    return obj[key];\n}\nfunction isEmpty(obj) {\n    assert(obj != null && typeof obj === 'object', 'isEmpty() expects object parameter.');\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            return false;\n        }\n    }\n    return true;\n}\nfunction shallowCopy(obj) {\n    assert(obj && typeof obj === 'object', 'shallowCopy() expects object parameter.');\n    var result = {};\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n//# sourceMappingURL=obj.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/input_validation.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * Validates the invocation of functionName has the exact number of arguments.\n *\n * Forward the magic \"arguments\" variable as second parameter on which the\n * parameter validation is performed:\n * validateExactNumberOfArgs('myFunction', arguments, 2);\n */\nfunction validateExactNumberOfArgs(functionName, args, numberOfArgs) {\n    if (args.length !== numberOfArgs) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires \" +\n            formatPlural(numberOfArgs, 'argument') +\n            ', but was called with ' +\n            formatPlural(args.length, 'argument') +\n            '.');\n    }\n}\n/**\n * Validates the invocation of functionName has at least the provided number of\n * arguments (but can have many more).\n *\n * Forward the magic \"arguments\" variable as second parameter on which the\n * parameter validation is performed:\n * validateAtLeastNumberOfArgs('myFunction', arguments, 2);\n */\nfunction validateAtLeastNumberOfArgs(functionName, args, minNumberOfArgs) {\n    if (args.length < minNumberOfArgs) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires at least \" +\n            formatPlural(minNumberOfArgs, 'argument') +\n            ', but was called with ' +\n            formatPlural(args.length, 'argument') +\n            '.');\n    }\n}\n/**\n * Validates the invocation of functionName has number of arguments between\n * the values provided.\n *\n * Forward the magic \"arguments\" variable as second parameter on which the\n * parameter validation is performed:\n * validateBetweenNumberOfArgs('myFunction', arguments, 2, 3);\n */\nfunction validateBetweenNumberOfArgs(functionName, args, minNumberOfArgs, maxNumberOfArgs) {\n    if (args.length < minNumberOfArgs || args.length > maxNumberOfArgs) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires between \" + minNumberOfArgs + \" and \" +\n            (maxNumberOfArgs + \" arguments, but was called with \") +\n            formatPlural(args.length, 'argument') +\n            '.');\n    }\n}\n/**\n * Validates the provided argument is an array and has as least the expected\n * number of elements.\n */\nfunction validateNamedArrayAtLeastNumberOfElements(functionName, value, name, minNumberOfElements) {\n    if (!(value instanceof Array) || value.length < minNumberOfElements) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires its \" + name + \" argument to be an \" +\n            'array with at least ' +\n            (formatPlural(minNumberOfElements, 'element') + \".\"));\n    }\n}\n/**\n * Validates the provided positional argument has the native JavaScript type\n * using typeof checks.\n */\nfunction validateArgType(functionName, type, position, argument) {\n    validateType(functionName, type, ordinal(position) + \" argument\", argument);\n}\n/**\n * Validates the provided argument has the native JavaScript type using\n * typeof checks or is undefined.\n */\nfunction validateOptionalArgType(functionName, type, position, argument) {\n    if (argument !== undefined) {\n        validateArgType(functionName, type, position, argument);\n    }\n}\n/**\n * Validates the provided named option has the native JavaScript type using\n * typeof checks.\n */\nfunction validateNamedType(functionName, type, optionName, argument) {\n    validateType(functionName, type, optionName + \" option\", argument);\n}\n/**\n * Validates the provided named option has the native JavaScript type using\n * typeof checks or is undefined.\n */\nfunction validateNamedOptionalType(functionName, type, optionName, argument) {\n    if (argument !== undefined) {\n        validateNamedType(functionName, type, optionName, argument);\n    }\n}\n/**\n * Validates that the provided named option equals one of the expected values.\n */\nfunction validateNamedPropertyEquals(functionName, inputName, optionName, input, expected) {\n    var expectedDescription = [];\n    for (var _i = 0, expected_1 = expected; _i < expected_1.length; _i++) {\n        var val = expected_1[_i];\n        if (val === input) {\n            return;\n        }\n        expectedDescription.push(valueDescription(val));\n    }\n    var actualDescription = valueDescription(input);\n    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid value \" + actualDescription + \" provided to function \" + functionName + \"() for option \\\"\" + optionName + \"\\\". Acceptable values: \" + expectedDescription.join(', '));\n}\n/**\n * Validates that the provided named option equals one of the expected values or\n * is undefined.\n */\nfunction validateNamedOptionalPropertyEquals(functionName, inputName, optionName, input, expected) {\n    if (input !== undefined) {\n        validateNamedPropertyEquals(functionName, inputName, optionName, input, expected);\n    }\n}\n/** Helper to validate the type of a provided input. */\nfunction validateType(functionName, type, inputName, input) {\n    if (typeof input !== type || (type === 'object' && !isPlainObject(input))) {\n        var description = valueDescription(input);\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires its \" + inputName + \" \" +\n            (\"to be of type \" + type + \", but it was: \" + description));\n    }\n}\n/**\n * Returns true iff it's a non-null object without a custom prototype\n * (i.e. excludes Array, Date, etc.).\n */\nfunction isPlainObject(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        Object.getPrototypeOf(input) === Object.prototype);\n}\n/** Returns a string describing the type / value of the provided input. */\nfunction valueDescription(input) {\n    if (input === undefined) {\n        return 'undefined';\n    }\n    else if (input === null) {\n        return 'null';\n    }\n    else if (typeof input === 'string') {\n        if (input.length > 20) {\n            input = input.substring(0, 20) + \"...\";\n        }\n        return JSON.stringify(input);\n    }\n    else if (typeof input === 'number' || typeof input === 'boolean') {\n        return '' + input;\n    }\n    else if (typeof input === 'object') {\n        if (input instanceof Array) {\n            return 'an array';\n        }\n        else {\n            var customObjectName = tryGetCustomObjectType(input);\n            if (customObjectName) {\n                return \"a custom \" + customObjectName + \" object\";\n            }\n            else {\n                return 'an object';\n            }\n        }\n    }\n    else if (typeof input === 'function') {\n        return 'a function';\n    }\n    else {\n        return fail('Unknown wrong type: ' + typeof input);\n    }\n}\n/** Hacky method to try to get the constructor name for an object. */\nfunction tryGetCustomObjectType(input) {\n    if (input.constructor) {\n        var funcNameRegex = /function\\s+([^\\s(]+)\\s*\\(/;\n        var results = funcNameRegex.exec(input.constructor.toString());\n        if (results && results.length > 1) {\n            return results[1];\n        }\n    }\n    return null;\n}\n/** Validates the provided argument is defined. */\nfunction validateDefined(functionName, position, argument) {\n    if (argument === undefined) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires a valid \" + ordinal(position) + \" \" +\n            \"argument, but it was undefined.\");\n    }\n}\n/**\n * Validates the provided positional argument is an object, and its keys and\n * values match the expected keys and types provided in optionTypes.\n */\nfunction validateOptionNames(functionName, options, optionNames) {\n    forEach(options, function (key, _) {\n        if (optionNames.indexOf(key) < 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Unknown option '\" + key + \"' passed to function \" + functionName + \"(). \" +\n                'Available options: ' +\n                optionNames.join(', '));\n        }\n    });\n}\n/**\n * Helper method to throw an error that the provided argument did not pass\n * an instanceof check.\n */\nfunction invalidClassError(functionName, type, position, argument) {\n    var description = valueDescription(argument);\n    return new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires its \" + ordinal(position) + \" \" +\n        (\"argument to be a \" + type + \", but it was: \" + description));\n}\n/** Converts a number to its english word representation */\nfunction ordinal(num) {\n    switch (num) {\n        case 1:\n            return 'first';\n        case 2:\n            return 'second';\n        case 3:\n            return 'third';\n        default:\n            return num + 'th';\n    }\n}\n/**\n * Formats the given word as plural conditionally given the preceding number.\n */\nfunction formatPlural(num, str) {\n    return num + \" \" + str + (num === 1 ? '' : 's');\n}\n\n//# sourceMappingURL=input_validation.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/misc.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// tslint:disable-next-line:class-as-namespace\nvar misc_AutoId = /** @class */ (function () {\n    function AutoId() {\n    }\n    AutoId.newId = function () {\n        // Alphanumeric characters\n        var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n        var autoId = '';\n        for (var i = 0; i < 20; i++) {\n            autoId += chars.charAt(Math.floor(Math.random() * chars.length));\n        }\n        assert(autoId.length === 20, 'Invalid auto ID: ' + autoId);\n        return autoId;\n    };\n    return AutoId;\n}());\n\nfunction primitiveComparator(left, right) {\n    if (left < right)\n        return -1;\n    if (left > right)\n        return 1;\n    return 0;\n}\n/** Helper to compare nullable (or undefined-able) objects using isEqual(). */\nfunction equals(left, right) {\n    if (left !== null && left !== undefined) {\n        return !!(right && left.isEqual(right));\n    }\n    else {\n        // HACK: Explicitly cast since TypeScript's type narrowing apparently isn't\n        // smart enough.\n        return left === right;\n    }\n}\n/** Helper to compare arrays using isEqual(). */\nfunction arrayEquals(left, right) {\n    if (left.length !== right.length) {\n        return false;\n    }\n    for (var i = 0; i < left.length; i++) {\n        if (!left[i].isEqual(right[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Returns the largest lexicographically smaller string of equal or smaller\n * length. Returns an empty string if there is no such predecessor (if the input\n * is empty).\n *\n * Strings returned from this method can be invalid UTF-16 but this is sufficent\n * in use for indexeddb because that depends on lexicographical ordering but\n * shouldn't be used elsewhere.\n */\nfunction immediatePredecessor(s) {\n    // We can decrement the last character in the string and be done\n    // unless that character is 0 (0x0000), in which case we have to erase the\n    // last character.\n    var lastIndex = s.length - 1;\n    if (s.length === 0) {\n        // Special case the empty string.\n        return '';\n    }\n    else if (s.charAt(lastIndex) === '\\0') {\n        return s.substring(0, lastIndex);\n    }\n    else {\n        return (s.substring(0, lastIndex) +\n            String.fromCharCode(s.charCodeAt(lastIndex) - 1));\n    }\n}\n/**\n * Returns the immediate lexicographically-following string. This is useful to\n * construct an inclusive range for indexeddb iterators.\n */\nfunction immediateSuccessor(s) {\n    // Return the input string, with an additional NUL byte appended.\n    return s + '\\0';\n}\n\n//# sourceMappingURL=misc.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/blob.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n/** Helper function to assert Uint8Array is available at runtime. */\nfunction assertUint8ArrayAvailable() {\n    if (typeof Uint8Array === 'undefined') {\n        throw new FirestoreError(Code.UNIMPLEMENTED, 'Uint8Arrays are not available in this environment.');\n    }\n}\n/** Helper function to assert Base64 functions are available at runtime. */\nfunction assertBase64Available() {\n    if (!platform_PlatformSupport.getPlatform().base64Available) {\n        throw new FirestoreError(Code.UNIMPLEMENTED, 'Blobs are unavailable in Firestore in this environment.');\n    }\n}\n/**\n * Immutable class holding a blob (binary data).\n * This class is directly exposed in the public API.\n *\n * Note that while you can't hide the constructor in JavaScript code, we are\n * using the hack above to make sure no-one outside this module can call it.\n */\nvar blob_Blob = /** @class */ (function () {\n    function Blob(binaryString) {\n        assertBase64Available();\n        this._binaryString = binaryString;\n    }\n    Blob.fromBase64String = function (base64) {\n        validateExactNumberOfArgs('Blob.fromBase64String', arguments, 1);\n        validateArgType('Blob.fromBase64String', 'string', 1, base64);\n        assertBase64Available();\n        try {\n            var binaryString = platform_PlatformSupport.getPlatform().atob(base64);\n            return new Blob(binaryString);\n        }\n        catch (e) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to construct Blob from Base64 string: ' + e);\n        }\n    };\n    Blob.fromUint8Array = function (array) {\n        validateExactNumberOfArgs('Blob.fromUint8Array', arguments, 1);\n        assertUint8ArrayAvailable();\n        if (!(array instanceof Uint8Array)) {\n            throw invalidClassError('Blob.fromUint8Array', 'Uint8Array', 1, array);\n        }\n        // We can't call array.map directly because it expects the return type to\n        // be a Uint8Array, whereas we can convert it to a regular array by invoking\n        // map on the Array prototype.\n        var binaryString = Array.prototype.map\n            .call(array, function (char) {\n            return String.fromCharCode(char);\n        })\n            .join('');\n        return new Blob(binaryString);\n    };\n    Blob.prototype.toBase64 = function () {\n        validateExactNumberOfArgs('Blob.toBase64', arguments, 0);\n        assertBase64Available();\n        return platform_PlatformSupport.getPlatform().btoa(this._binaryString);\n    };\n    Blob.prototype.toUint8Array = function () {\n        validateExactNumberOfArgs('Blob.toUint8Array', arguments, 0);\n        assertUint8ArrayAvailable();\n        var buffer = new Uint8Array(this._binaryString.length);\n        for (var i = 0; i < this._binaryString.length; i++) {\n            buffer[i] = this._binaryString.charCodeAt(i);\n        }\n        return buffer;\n    };\n    Blob.prototype.toString = function () {\n        return 'Blob(base64: ' + this.toBase64() + ')';\n    };\n    Blob.prototype.isEqual = function (other) {\n        return this._binaryString === other._binaryString;\n    };\n    /**\n     * Actually private to JS consumers of our API, so this function is prefixed\n     * with an underscore.\n     */\n    Blob.prototype._compareTo = function (other) {\n        return primitiveComparator(this._binaryString, other._binaryString);\n    };\n    return Blob;\n}());\n\n// Public instance that disallows construction at runtime. This constructor is\n// used when exporting Blob on firebase.firestore.Blob and will be called Blob\n// publicly. Internally we still use Blob which has a type checked private\n// constructor. Note that Blob and PublicBlob can be used interchangeably in\n// instanceof checks.\n// For our internal TypeScript code PublicBlob doesn't exist as a type, and so\n// we need to use Blob as type and export it too.\n// tslint:disable-next-line:variable-name We're treating this as a class name.\nvar PublicBlob = makeConstructorPrivate(blob_Blob, 'Use Blob.fromUint8Array() or Blob.fromBase64String() instead.');\n\n//# sourceMappingURL=blob.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/geo_point.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * Immutable class representing a geo point as latitude-longitude pair.\n * This class is directly exposed in the public API, including its constructor.\n */\nvar geo_point_GeoPoint = /** @class */ (function () {\n    function GeoPoint(latitude, longitude) {\n        validateExactNumberOfArgs('GeoPoint', arguments, 2);\n        validateArgType('GeoPoint', 'number', 1, latitude);\n        validateArgType('GeoPoint', 'number', 2, longitude);\n        if (!isFinite(latitude) || latitude < -90 || latitude > 90) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Latitude must be a number between -90 and 90, but was: ' + latitude);\n        }\n        if (!isFinite(longitude) || longitude < -180 || longitude > 180) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Longitude must be a number between -180 and 180, but was: ' + longitude);\n        }\n        this._lat = latitude;\n        this._long = longitude;\n    }\n    Object.defineProperty(GeoPoint.prototype, \"latitude\", {\n        /**\n         * Returns the latitude of this geo point, a number between -90 and 90.\n         */\n        get: function () {\n            return this._lat;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(GeoPoint.prototype, \"longitude\", {\n        /**\n         * Returns the longitude of this geo point, a number between -180 and 180.\n         */\n        get: function () {\n            return this._long;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    GeoPoint.prototype.isEqual = function (other) {\n        return this._lat === other._lat && this._long === other._long;\n    };\n    /**\n     * Actually private to JS consumers of our API, so this function is prefixed\n     * with an underscore.\n     */\n    GeoPoint.prototype._compareTo = function (other) {\n        return (primitiveComparator(this._lat, other._lat) ||\n            primitiveComparator(this._long, other._long));\n    };\n    return GeoPoint;\n}());\n\n\n//# sourceMappingURL=geo_point.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/database_info.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar DatabaseInfo = /** @class */ (function () {\n    /**\n     * Constructs a DatabaseInfo using the provided host, databaseId and\n     * persistenceKey.\n     *\n     * @param databaseId The database to use.\n     * @param persistenceKey A unique identifier for this Firestore's local\n     * storage (used in conjunction with the databaseId).\n     * @param host The Firestore backend host to connect to.\n     * @param ssl Whether to use SSL when connecting.\n     */\n    function DatabaseInfo(databaseId, persistenceKey, host, ssl) {\n        this.databaseId = databaseId;\n        this.persistenceKey = persistenceKey;\n        this.host = host;\n        this.ssl = ssl;\n    }\n    return DatabaseInfo;\n}());\n\n/** The default database name for a project. */\nvar DEFAULT_DATABASE_NAME = '(default)';\n/** Represents the database ID a Firestore client is associated with. */\nvar database_info_DatabaseId = /** @class */ (function () {\n    function DatabaseId(projectId, database) {\n        this.projectId = projectId;\n        this.database = database ? database : DEFAULT_DATABASE_NAME;\n    }\n    Object.defineProperty(DatabaseId.prototype, \"isDefaultDatabase\", {\n        get: function () {\n            return this.database === DEFAULT_DATABASE_NAME;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DatabaseId.prototype.isEqual = function (other) {\n        return (other instanceof DatabaseId &&\n            other.projectId === this.projectId &&\n            other.database === this.database);\n    };\n    DatabaseId.prototype.compareTo = function (other) {\n        return (primitiveComparator(this.projectId, other.projectId) ||\n            primitiveComparator(this.database, other.database));\n    };\n    return DatabaseId;\n}());\n\n\n//# sourceMappingURL=database_info.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/path.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar path___extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\nvar DOCUMENT_KEY_NAME = '__name__';\n/**\n * Path represents an ordered sequence of string segments.\n */\nvar path_Path = /** @class */ (function () {\n    function Path(segments, offset, length) {\n        this.init(segments, offset, length);\n    }\n    /**\n     * An initialization method that can be called from outside the constructor.\n     * We need this so that we can have a non-static construct method that returns\n     * the polymorphic `this` type.\n     */\n    Path.prototype.init = function (segments, offset, length) {\n        if (offset === undefined) {\n            offset = 0;\n        }\n        else if (offset > segments.length) {\n            fail('offset ' + offset + ' out of range ' + segments.length);\n        }\n        if (length === undefined) {\n            length = segments.length - offset;\n        }\n        else if (length > segments.length - offset) {\n            fail('length ' + length + ' out of range ' + (segments.length - offset));\n        }\n        this.segments = segments;\n        this.offset = offset;\n        this.len = length;\n    };\n    /**\n     * Constructs a new instance of Path using the same concrete type as `this`.\n     * We need this instead of using the normal constructor, because polymorphic\n     * `this` doesn't work on static methods.\n     */\n    Path.prototype.construct = function (segments, offset, length) {\n        var path = Object.create(Object.getPrototypeOf(this));\n        path.init(segments, offset, length);\n        return path;\n    };\n    Object.defineProperty(Path.prototype, \"length\", {\n        get: function () {\n            return this.len;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Path.prototype.isEqual = function (other) {\n        return Path.comparator(this, other) === 0;\n    };\n    Path.prototype.child = function (nameOrPath) {\n        var segments = this.segments.slice(this.offset, this.limit());\n        if (nameOrPath instanceof Path) {\n            nameOrPath.forEach(function (segment) {\n                segments.push(segment);\n            });\n        }\n        else if (typeof nameOrPath === 'string') {\n            segments.push(nameOrPath);\n        }\n        else {\n            fail('Unknown parameter type for Path.child(): ' + nameOrPath);\n        }\n        return this.construct(segments);\n    };\n    /** The index of one past the last segment of the path. */\n    Path.prototype.limit = function () {\n        return this.offset + this.length;\n    };\n    Path.prototype.popFirst = function (size) {\n        size = size === undefined ? 1 : size;\n        assert(this.length >= size, \"Can't call popFirst() with less segments\");\n        return this.construct(this.segments, this.offset + size, this.length - size);\n    };\n    Path.prototype.popLast = function () {\n        assert(!this.isEmpty(), \"Can't call popLast() on empty path\");\n        return this.construct(this.segments, this.offset, this.length - 1);\n    };\n    Path.prototype.firstSegment = function () {\n        assert(!this.isEmpty(), \"Can't call firstSegment() on empty path\");\n        return this.segments[this.offset];\n    };\n    Path.prototype.lastSegment = function () {\n        assert(!this.isEmpty(), \"Can't call lastSegment() on empty path\");\n        return this.segments[this.limit() - 1];\n    };\n    Path.prototype.get = function (index) {\n        assert(index < this.length, 'Index out of range');\n        return this.segments[this.offset + index];\n    };\n    Path.prototype.isEmpty = function () {\n        return this.length === 0;\n    };\n    Path.prototype.isPrefixOf = function (other) {\n        if (other.length < this.length) {\n            return false;\n        }\n        for (var i = 0; i < this.length; i++) {\n            if (this.get(i) !== other.get(i)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    Path.prototype.forEach = function (fn) {\n        for (var i = this.offset, end = this.limit(); i < end; i++) {\n            fn(this.segments[i]);\n        }\n    };\n    Path.prototype.toArray = function () {\n        return this.segments.slice(this.offset, this.limit());\n    };\n    Path.comparator = function (p1, p2) {\n        var len = Math.min(p1.length, p2.length);\n        for (var i = 0; i < len; i++) {\n            var left = p1.get(i);\n            var right = p2.get(i);\n            if (left < right)\n                return -1;\n            if (left > right)\n                return 1;\n        }\n        if (p1.length < p2.length)\n            return -1;\n        if (p1.length > p2.length)\n            return 1;\n        return 0;\n    };\n    return Path;\n}());\n\n/**\n * A slash-separated path for navigating resources (documents and collections)\n * within Firestore.\n */\nvar path_ResourcePath = /** @class */ (function (_super) {\n    path___extends(ResourcePath, _super);\n    function ResourcePath() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    ResourcePath.prototype.canonicalString = function () {\n        // NOTE: The client is ignorant of any path segments containing escape\n        // sequences (e.g. __id123__) and just passes them through raw (they exist\n        // for legacy reasons and should not be used frequently).\n        return this.toArray().join('/');\n    };\n    ResourcePath.prototype.toString = function () {\n        return this.canonicalString();\n    };\n    /**\n     * Creates a resource path from the given slash-delimited string.\n     */\n    ResourcePath.fromString = function (path) {\n        // NOTE: The client is ignorant of any path segments containing escape\n        // sequences (e.g. __id123__) and just passes them through raw (they exist\n        // for legacy reasons and should not be used frequently).\n        if (path.indexOf('//') >= 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid path (\" + path + \"). Paths must not contain // in them.\");\n        }\n        // We may still have an empty segment at the beginning or end if they had a\n        // leading or trailing slash (which we allow).\n        var segments = path.split('/').filter(function (segment) { return segment.length > 0; });\n        return new ResourcePath(segments);\n    };\n    ResourcePath.EMPTY_PATH = new ResourcePath([]);\n    return ResourcePath;\n}(path_Path));\n\nvar identifierRegExp = /^[_a-zA-Z][_a-zA-Z0-9]*$/;\n/** A dot-separated path for navigating sub-objects within a document. */\nvar path_FieldPath = /** @class */ (function (_super) {\n    path___extends(FieldPath, _super);\n    function FieldPath() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Returns true if the string could be used as a segment in a field path\n     * without escaping.\n     */\n    FieldPath.isValidIdentifier = function (segment) {\n        return identifierRegExp.test(segment);\n    };\n    FieldPath.prototype.canonicalString = function () {\n        return this.toArray()\n            .map(function (str) {\n            str = str.replace('\\\\', '\\\\\\\\').replace('`', '\\\\`');\n            if (!FieldPath.isValidIdentifier(str)) {\n                str = '`' + str + '`';\n            }\n            return str;\n        })\n            .join('.');\n    };\n    FieldPath.prototype.toString = function () {\n        return this.canonicalString();\n    };\n    /**\n     * Returns true if this field references the key of a document.\n     */\n    FieldPath.prototype.isKeyField = function () {\n        return this.length === 1 && this.get(0) === DOCUMENT_KEY_NAME;\n    };\n    /**\n     * The field designating the key of a document.\n     */\n    FieldPath.keyField = function () {\n        return new FieldPath([DOCUMENT_KEY_NAME]);\n    };\n    /**\n     * Parses a field string from the given server-formatted string.\n     *\n     * - Splitting the empty string is not allowed (for now at least).\n     * - Empty segments within the string (e.g. if there are two consecutive\n     *   separators) are not allowed.\n     *\n     * TODO(b/37244157): we should make this more strict. Right now, it allows\n     * non-identifier path components, even if they aren't escaped.\n     */\n    FieldPath.fromServerFormat = function (path) {\n        var segments = [];\n        var current = '';\n        var i = 0;\n        var addCurrentSegment = function () {\n            if (current.length === 0) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field path (\" + path + \"). Paths must not be empty, begin \" +\n                    \"with '.', end with '.', or contain '..'\");\n            }\n            segments.push(current);\n            current = '';\n        };\n        var inBackticks = false;\n        while (i < path.length) {\n            var c = path[i];\n            if (c === '\\\\') {\n                if (i + 1 === path.length) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Path has trailing escape character: ' + path);\n                }\n                var next = path[i + 1];\n                if (!(next === '\\\\' || next === '.' || next === '`')) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Path has invalid escape sequence: ' + path);\n                }\n                current += next;\n                i += 2;\n            }\n            else if (c === '`') {\n                inBackticks = !inBackticks;\n                i++;\n            }\n            else if (c === '.' && !inBackticks) {\n                addCurrentSegment();\n                i++;\n            }\n            else {\n                current += c;\n                i++;\n            }\n        }\n        addCurrentSegment();\n        if (inBackticks) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Unterminated ` in path: ' + path);\n        }\n        return new FieldPath(segments);\n    };\n    FieldPath.EMPTY_PATH = new FieldPath([]);\n    return FieldPath;\n}(path_Path));\n\n\n//# sourceMappingURL=path.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/document_key.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nvar document_key_DocumentKey = /** @class */ (function () {\n    function DocumentKey(path) {\n        this.path = path;\n        assert(DocumentKey.isDocumentKey(path), 'Invalid DocumentKey with an odd number of segments: ' +\n            path.toArray().join('/'));\n    }\n    DocumentKey.prototype.isEqual = function (other) {\n        return (other !== null && path_ResourcePath.comparator(this.path, other.path) === 0);\n    };\n    DocumentKey.prototype.toString = function () {\n        return this.path.toString();\n    };\n    DocumentKey.comparator = function (k1, k2) {\n        return path_ResourcePath.comparator(k1.path, k2.path);\n    };\n    DocumentKey.isDocumentKey = function (path) {\n        return path.length % 2 === 0;\n    };\n    /**\n     * Creates and returns a new document key with the given segments.\n     *\n     * @param path The segments of the path to the document\n     * @return A new instance of DocumentKey\n     */\n    DocumentKey.fromSegments = function (segments) {\n        return new DocumentKey(new path_ResourcePath(segments.slice()));\n    };\n    /**\n     * Creates and returns a new document key using '/' to split the string into\n     * segments.\n     *\n     * @param path The slash-separated path string to the document\n     * @return A new instance of DocumentKey\n     */\n    DocumentKey.fromPathString = function (path) {\n        return new DocumentKey(path_ResourcePath.fromString(path));\n    };\n    DocumentKey.EMPTY = new DocumentKey(new path_ResourcePath([]));\n    return DocumentKey;\n}());\n\n\n//# sourceMappingURL=document_key.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/document.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nvar document_Document = /** @class */ (function () {\n    function Document(key, version, data, options) {\n        this.key = key;\n        this.version = version;\n        this.data = data;\n        this.hasLocalMutations = options.hasLocalMutations;\n    }\n    Document.prototype.field = function (path) {\n        return this.data.field(path);\n    };\n    Document.prototype.fieldValue = function (path) {\n        var field = this.field(path);\n        return field ? field.value() : undefined;\n    };\n    Document.prototype.value = function () {\n        return this.data.value();\n    };\n    Document.prototype.isEqual = function (other) {\n        return (other instanceof Document &&\n            this.key.isEqual(other.key) &&\n            this.version.isEqual(other.version) &&\n            this.data.isEqual(other.data) &&\n            this.hasLocalMutations === other.hasLocalMutations);\n    };\n    Document.prototype.toString = function () {\n        return (\"Document(\" + this.key + \", \" + this.version + \", \" + this.data.toString() + \", \" +\n            (\"{hasLocalMutations: \" + this.hasLocalMutations + \"})\"));\n    };\n    Document.compareByKey = function (d1, d2) {\n        return document_key_DocumentKey.comparator(d1.key, d2.key);\n    };\n    Document.compareByField = function (field, d1, d2) {\n        var v1 = d1.field(field);\n        var v2 = d2.field(field);\n        if (v1 !== undefined && v2 !== undefined) {\n            return v1.compareTo(v2);\n        }\n        else {\n            return fail(\"Trying to compare documents on fields that don't exist\");\n        }\n    };\n    return Document;\n}());\n\n/**\n * A class representing a deleted document.\n * Version is set to 0 if we don't point to any specific time, otherwise it\n * denotes time we know it didn't exist at.\n */\nvar document_NoDocument = /** @class */ (function () {\n    function NoDocument(key, version) {\n        this.key = key;\n        this.version = version;\n    }\n    NoDocument.prototype.toString = function () {\n        return \"NoDocument(\" + this.key + \", \" + this.version + \")\";\n    };\n    NoDocument.prototype.isEqual = function (other) {\n        return (other &&\n            other.version.isEqual(this.version) &&\n            other.key.isEqual(this.key));\n    };\n    NoDocument.compareByKey = function (d1, d2) {\n        return document_key_DocumentKey.comparator(d1.key, d2.key);\n    };\n    return NoDocument;\n}());\n\n\n//# sourceMappingURL=document.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/sorted_map.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// An immutable sorted map implementation, based on a Left-leaning Red-Black\n// tree.\nvar SortedMap = /** @class */ (function () {\n    function SortedMap(comparator, root) {\n        this.comparator = comparator;\n        this.root = root ? root : sorted_map_LLRBNode.EMPTY;\n    }\n    // Returns a copy of the map, with the specified key/value added or replaced.\n    SortedMap.prototype.insert = function (key, value) {\n        return new SortedMap(this.comparator, this.root\n            .insert(key, value, this.comparator)\n            .copy(null, null, sorted_map_LLRBNode.BLACK, null, null));\n    };\n    // Returns a copy of the map, with the specified key removed.\n    SortedMap.prototype.remove = function (key) {\n        return new SortedMap(this.comparator, this.root\n            .remove(key, this.comparator)\n            .copy(null, null, sorted_map_LLRBNode.BLACK, null, null));\n    };\n    // Returns the value of the node with the given key, or null.\n    SortedMap.prototype.get = function (key) {\n        var node = this.root;\n        while (!node.isEmpty()) {\n            var cmp = this.comparator(key, node.key);\n            if (cmp === 0) {\n                return node.value;\n            }\n            else if (cmp < 0) {\n                node = node.left;\n            }\n            else if (cmp > 0) {\n                node = node.right;\n            }\n        }\n        return null;\n    };\n    // Returns the index of the element in this sorted map, or -1 if it doesn't\n    // exist.\n    SortedMap.prototype.indexOf = function (key) {\n        // Number of nodes that were pruned when descending right\n        var prunedNodes = 0;\n        var node = this.root;\n        while (!node.isEmpty()) {\n            var cmp = this.comparator(key, node.key);\n            if (cmp === 0) {\n                return prunedNodes + node.left.size;\n            }\n            else if (cmp < 0) {\n                node = node.left;\n            }\n            else {\n                // Count all nodes left of the node plus the node itself\n                prunedNodes += node.left.size + 1;\n                node = node.right;\n            }\n        }\n        // Node not found\n        return -1;\n    };\n    SortedMap.prototype.isEmpty = function () {\n        return this.root.isEmpty();\n    };\n    Object.defineProperty(SortedMap.prototype, \"size\", {\n        // Returns the total number of nodes in the map.\n        get: function () {\n            return this.root.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // Returns the minimum key in the map.\n    SortedMap.prototype.minKey = function () {\n        return this.root.minKey();\n    };\n    // Returns the maximum key in the map.\n    SortedMap.prototype.maxKey = function () {\n        return this.root.maxKey();\n    };\n    // Traverses the map in key order and calls the specified action function\n    // for each key/value pair. If action returns true, traversal is aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    SortedMap.prototype.inorderTraversal = function (action) {\n        return this.root.inorderTraversal(action);\n    };\n    SortedMap.prototype.forEach = function (fn) {\n        this.inorderTraversal(function (k, v) {\n            fn(k, v);\n            return false;\n        });\n    };\n    // Traverses the map in reverse key order and calls the specified action\n    // function for each key/value pair. If action returns true, traversal is\n    // aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    SortedMap.prototype.reverseTraversal = function (action) {\n        return this.root.reverseTraversal(action);\n    };\n    // Returns an iterator over the SortedMap.\n    SortedMap.prototype.getIterator = function () {\n        return new sorted_map_SortedMapIterator(this.root, null, this.comparator, false);\n    };\n    SortedMap.prototype.getIteratorFrom = function (key) {\n        return new sorted_map_SortedMapIterator(this.root, key, this.comparator, false);\n    };\n    SortedMap.prototype.getReverseIterator = function () {\n        return new sorted_map_SortedMapIterator(this.root, null, this.comparator, true);\n    };\n    SortedMap.prototype.getReverseIteratorFrom = function (key) {\n        return new sorted_map_SortedMapIterator(this.root, key, this.comparator, true);\n    };\n    return SortedMap;\n}()); // end SortedMap\n\n// An iterator over an LLRBNode.\nvar sorted_map_SortedMapIterator = /** @class */ (function () {\n    function SortedMapIterator(node, startKey, comparator, isReverse) {\n        this.isReverse = isReverse;\n        this.nodeStack = [];\n        var cmp = 1;\n        while (!node.isEmpty()) {\n            cmp = startKey ? comparator(node.key, startKey) : 1;\n            // flip the comparison if we're going in reverse\n            if (isReverse)\n                cmp *= -1;\n            if (cmp < 0) {\n                // This node is less than our start key. ignore it\n                if (this.isReverse) {\n                    node = node.left;\n                }\n                else {\n                    node = node.right;\n                }\n            }\n            else if (cmp === 0) {\n                // This node is exactly equal to our start key. Push it on the stack,\n                // but stop iterating;\n                this.nodeStack.push(node);\n                break;\n            }\n            else {\n                // This node is greater than our start key, add it to the stack and move\n                // to the next one\n                this.nodeStack.push(node);\n                if (this.isReverse) {\n                    node = node.right;\n                }\n                else {\n                    node = node.left;\n                }\n            }\n        }\n    }\n    SortedMapIterator.prototype.getNext = function () {\n        assert(this.nodeStack.length > 0, 'getNext() called on iterator when hasNext() is false.');\n        var node = this.nodeStack.pop();\n        var result = { key: node.key, value: node.value };\n        if (this.isReverse) {\n            node = node.left;\n            while (!node.isEmpty()) {\n                this.nodeStack.push(node);\n                node = node.right;\n            }\n        }\n        else {\n            node = node.right;\n            while (!node.isEmpty()) {\n                this.nodeStack.push(node);\n                node = node.left;\n            }\n        }\n        return result;\n    };\n    SortedMapIterator.prototype.hasNext = function () {\n        return this.nodeStack.length > 0;\n    };\n    SortedMapIterator.prototype.peek = function () {\n        if (this.nodeStack.length === 0)\n            return null;\n        var node = this.nodeStack[this.nodeStack.length - 1];\n        return { key: node.key, value: node.value };\n    };\n    return SortedMapIterator;\n}()); // end SortedMapIterator\n\n// Represents a node in a Left-leaning Red-Black tree.\nvar sorted_map_LLRBNode = /** @class */ (function () {\n    function LLRBNode(key, value, color, left, right) {\n        this.key = key;\n        this.value = value;\n        this.color = color != null ? color : LLRBNode.RED;\n        this.left = left != null ? left : LLRBNode.EMPTY;\n        this.right = right != null ? right : LLRBNode.EMPTY;\n        this.size = this.left.size + 1 + this.right.size;\n    }\n    // Returns a copy of the current node, optionally replacing pieces of it.\n    LLRBNode.prototype.copy = function (key, value, color, left, right) {\n        return new LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);\n    };\n    LLRBNode.prototype.isEmpty = function () {\n        return false;\n    };\n    // Traverses the tree in key order and calls the specified action function\n    // for each node. If action returns true, traversal is aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    LLRBNode.prototype.inorderTraversal = function (action) {\n        return (this.left.inorderTraversal(action) ||\n            action(this.key, this.value) ||\n            this.right.inorderTraversal(action));\n    };\n    // Traverses the tree in reverse key order and calls the specified action\n    // function for each node. If action returns true, traversal is aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    LLRBNode.prototype.reverseTraversal = function (action) {\n        return (this.right.reverseTraversal(action) ||\n            action(this.key, this.value) ||\n            this.left.reverseTraversal(action));\n    };\n    // Returns the minimum node in the tree.\n    LLRBNode.prototype.min = function () {\n        if (this.left.isEmpty()) {\n            return this;\n        }\n        else {\n            return this.left.min();\n        }\n    };\n    // Returns the maximum key in the tree.\n    LLRBNode.prototype.minKey = function () {\n        return this.min().key;\n    };\n    // Returns the maximum key in the tree.\n    LLRBNode.prototype.maxKey = function () {\n        if (this.right.isEmpty()) {\n            return this.key;\n        }\n        else {\n            return this.right.maxKey();\n        }\n    };\n    // Returns new tree, with the key/value added.\n    LLRBNode.prototype.insert = function (key, value, comparator) {\n        var n = this;\n        var cmp = comparator(key, n.key);\n        if (cmp < 0) {\n            n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);\n        }\n        else if (cmp === 0) {\n            n = n.copy(null, value, null, null, null);\n        }\n        else {\n            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));\n        }\n        return n.fixUp();\n    };\n    LLRBNode.prototype.removeMin = function () {\n        if (this.left.isEmpty()) {\n            return LLRBNode.EMPTY;\n        }\n        var n = this;\n        if (!n.left.isRed() && !n.left.left.isRed())\n            n = n.moveRedLeft();\n        n = n.copy(null, null, null, n.left.removeMin(), null);\n        return n.fixUp();\n    };\n    // Returns new tree, with the specified item removed.\n    LLRBNode.prototype.remove = function (key, comparator) {\n        var smallest;\n        var n = this;\n        if (comparator(key, n.key) < 0) {\n            if (!n.left.isEmpty() && !n.left.isRed() && !n.left.left.isRed()) {\n                n = n.moveRedLeft();\n            }\n            n = n.copy(null, null, null, n.left.remove(key, comparator), null);\n        }\n        else {\n            if (n.left.isRed())\n                n = n.rotateRight();\n            if (!n.right.isEmpty() && !n.right.isRed() && !n.right.left.isRed()) {\n                n = n.moveRedRight();\n            }\n            if (comparator(key, n.key) === 0) {\n                if (n.right.isEmpty()) {\n                    return LLRBNode.EMPTY;\n                }\n                else {\n                    smallest = n.right.min();\n                    n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin());\n                }\n            }\n            n = n.copy(null, null, null, null, n.right.remove(key, comparator));\n        }\n        return n.fixUp();\n    };\n    LLRBNode.prototype.isRed = function () {\n        return this.color;\n    };\n    // Returns new tree after performing any needed rotations.\n    LLRBNode.prototype.fixUp = function () {\n        var n = this;\n        if (n.right.isRed() && !n.left.isRed())\n            n = n.rotateLeft();\n        if (n.left.isRed() && n.left.left.isRed())\n            n = n.rotateRight();\n        if (n.left.isRed() && n.right.isRed())\n            n = n.colorFlip();\n        return n;\n    };\n    LLRBNode.prototype.moveRedLeft = function () {\n        var n = this.colorFlip();\n        if (n.right.left.isRed()) {\n            n = n.copy(null, null, null, null, n.right.rotateRight());\n            n = n.rotateLeft();\n            n = n.colorFlip();\n        }\n        return n;\n    };\n    LLRBNode.prototype.moveRedRight = function () {\n        var n = this.colorFlip();\n        if (n.left.left.isRed()) {\n            n = n.rotateRight();\n            n = n.colorFlip();\n        }\n        return n;\n    };\n    LLRBNode.prototype.rotateLeft = function () {\n        var nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);\n        return this.right.copy(null, null, this.color, nl, null);\n    };\n    LLRBNode.prototype.rotateRight = function () {\n        var nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);\n        return this.left.copy(null, null, this.color, null, nr);\n    };\n    LLRBNode.prototype.colorFlip = function () {\n        var left = this.left.copy(null, null, !this.left.color, null, null);\n        var right = this.right.copy(null, null, !this.right.color, null, null);\n        return this.copy(null, null, !this.color, left, right);\n    };\n    // For testing.\n    LLRBNode.prototype.checkMaxDepth = function () {\n        var blackDepth = this.check();\n        if (Math.pow(2.0, blackDepth) <= this.size + 1) {\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    // In a balanced RB tree, the black-depth (number of black nodes) from root to\n    // leaves is equal on both sides.  This function verifies that or asserts.\n    LLRBNode.prototype.check = function () {\n        if (this.isRed() && this.left.isRed()) {\n            throw fail('Red node has red child(' + this.key + ',' + this.value + ')');\n        }\n        if (this.right.isRed()) {\n            throw fail('Right child of (' + this.key + ',' + this.value + ') is red');\n        }\n        var blackDepth = this.left.check();\n        if (blackDepth !== this.right.check()) {\n            throw fail('Black depths differ');\n        }\n        else {\n            return blackDepth + (this.isRed() ? 0 : 1);\n        }\n    };\n    // tslint:disable-next-line:no-any Empty node is shared between all LLRB trees.\n    LLRBNode.EMPTY = null;\n    LLRBNode.RED = true;\n    LLRBNode.BLACK = false;\n    return LLRBNode;\n}()); // end LLRBNode\n\n// Represents an empty node (a leaf node in the Red-Black Tree).\nvar LLRBEmptyNode = /** @class */ (function () {\n    function LLRBEmptyNode() {\n        this.size = 0;\n    }\n    // Returns a copy of the current node.\n    LLRBEmptyNode.prototype.copy = function (key, value, color, left, right) {\n        return this;\n    };\n    // Returns a copy of the tree, with the specified key/value added.\n    LLRBEmptyNode.prototype.insert = function (key, value, comparator) {\n        return new sorted_map_LLRBNode(key, value);\n    };\n    // Returns a copy of the tree, with the specified key removed.\n    LLRBEmptyNode.prototype.remove = function (key, comparator) {\n        return this;\n    };\n    LLRBEmptyNode.prototype.isEmpty = function () {\n        return true;\n    };\n    LLRBEmptyNode.prototype.inorderTraversal = function (action) {\n        return false;\n    };\n    LLRBEmptyNode.prototype.reverseTraversal = function (action) {\n        return false;\n    };\n    LLRBEmptyNode.prototype.minKey = function () {\n        return null;\n    };\n    LLRBEmptyNode.prototype.maxKey = function () {\n        return null;\n    };\n    LLRBEmptyNode.prototype.isRed = function () {\n        return false;\n    };\n    // For testing.\n    LLRBEmptyNode.prototype.checkMaxDepth = function () {\n        return true;\n    };\n    LLRBEmptyNode.prototype.check = function () {\n        return 0;\n    };\n    return LLRBEmptyNode;\n}()); // end LLRBEmptyNode\n\nsorted_map_LLRBNode.EMPTY = new LLRBEmptyNode();\n\n//# sourceMappingURL=sorted_map.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/field_value.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar field_value___extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\nvar TypeOrder;\n(function (TypeOrder) {\n    // This order is defined by the backend.\n    TypeOrder[TypeOrder[\"NullValue\"] = 0] = \"NullValue\";\n    TypeOrder[TypeOrder[\"BooleanValue\"] = 1] = \"BooleanValue\";\n    TypeOrder[TypeOrder[\"NumberValue\"] = 2] = \"NumberValue\";\n    TypeOrder[TypeOrder[\"TimestampValue\"] = 3] = \"TimestampValue\";\n    TypeOrder[TypeOrder[\"StringValue\"] = 4] = \"StringValue\";\n    TypeOrder[TypeOrder[\"BlobValue\"] = 5] = \"BlobValue\";\n    TypeOrder[TypeOrder[\"RefValue\"] = 6] = \"RefValue\";\n    TypeOrder[TypeOrder[\"GeoPointValue\"] = 7] = \"GeoPointValue\";\n    TypeOrder[TypeOrder[\"ArrayValue\"] = 8] = \"ArrayValue\";\n    TypeOrder[TypeOrder[\"ObjectValue\"] = 9] = \"ObjectValue\";\n})(TypeOrder || (TypeOrder = {}));\n/** Defines the return value for pending server timestamps. */\nvar ServerTimestampBehavior;\n(function (ServerTimestampBehavior) {\n    ServerTimestampBehavior[ServerTimestampBehavior[\"Default\"] = 0] = \"Default\";\n    ServerTimestampBehavior[ServerTimestampBehavior[\"Estimate\"] = 1] = \"Estimate\";\n    ServerTimestampBehavior[ServerTimestampBehavior[\"Previous\"] = 2] = \"Previous\";\n})(ServerTimestampBehavior || (ServerTimestampBehavior = {}));\n/** Holds properties that define field value deserialization options. */\nvar field_value_FieldValueOptions = /** @class */ (function () {\n    function FieldValueOptions(serverTimestampBehavior) {\n        this.serverTimestampBehavior = serverTimestampBehavior;\n    }\n    FieldValueOptions.fromSnapshotOptions = function (options) {\n        switch (options.serverTimestamps) {\n            case 'estimate':\n                return new FieldValueOptions(ServerTimestampBehavior.Estimate);\n            case 'previous':\n                return new FieldValueOptions(ServerTimestampBehavior.Previous);\n            case 'none': // Fall-through intended.\n            case undefined:\n                return FieldValueOptions.defaultOptions;\n            default:\n                return fail('fromSnapshotOptions() called with invalid options.');\n        }\n    };\n    FieldValueOptions.defaultOptions = new FieldValueOptions(ServerTimestampBehavior.Default);\n    return FieldValueOptions;\n}());\n\n/**\n * A field value represents a datatype as stored by Firestore.\n */\nvar field_value_FieldValue = /** @class */ (function () {\n    function FieldValue() {\n    }\n    FieldValue.prototype.toString = function () {\n        var val = this.value();\n        return val === null ? 'null' : val.toString();\n    };\n    FieldValue.prototype.defaultCompareTo = function (other) {\n        assert(this.typeOrder !== other.typeOrder, 'Default compareTo should not be used for values of same type.');\n        var cmp = primitiveComparator(this.typeOrder, other.typeOrder);\n        return cmp;\n    };\n    return FieldValue;\n}());\n\nvar NullValue = /** @class */ (function (_super) {\n    field_value___extends(NullValue, _super);\n    function NullValue() {\n        var _this = _super.call(this) || this;\n        _this.typeOrder = TypeOrder.NullValue;\n        // internalValue is unused but we add it to work around\n        // https://github.com/Microsoft/TypeScript/issues/15585\n        _this.internalValue = null;\n        return _this;\n    }\n    NullValue.prototype.value = function (options) {\n        return null;\n    };\n    NullValue.prototype.isEqual = function (other) {\n        return other instanceof NullValue;\n    };\n    NullValue.prototype.compareTo = function (other) {\n        if (other instanceof NullValue) {\n            return 0;\n        }\n        return this.defaultCompareTo(other);\n    };\n    NullValue.INSTANCE = new NullValue();\n    return NullValue;\n}(field_value_FieldValue));\n\nvar field_value_BooleanValue = /** @class */ (function (_super) {\n    field_value___extends(BooleanValue, _super);\n    function BooleanValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.BooleanValue;\n        return _this;\n    }\n    BooleanValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    BooleanValue.prototype.isEqual = function (other) {\n        return (other instanceof BooleanValue &&\n            this.internalValue === other.internalValue);\n    };\n    BooleanValue.prototype.compareTo = function (other) {\n        if (other instanceof BooleanValue) {\n            return primitiveComparator(this, other);\n        }\n        return this.defaultCompareTo(other);\n    };\n    BooleanValue.of = function (value) {\n        return value ? BooleanValue.TRUE : BooleanValue.FALSE;\n    };\n    BooleanValue.TRUE = new BooleanValue(true);\n    BooleanValue.FALSE = new BooleanValue(false);\n    return BooleanValue;\n}(field_value_FieldValue));\n\n/** Base class for IntegerValue and DoubleValue. */\nvar NumberValue = /** @class */ (function (_super) {\n    field_value___extends(NumberValue, _super);\n    function NumberValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.NumberValue;\n        return _this;\n    }\n    NumberValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    NumberValue.prototype.compareTo = function (other) {\n        if (other instanceof NumberValue) {\n            return numericComparator(this.internalValue, other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return NumberValue;\n}(field_value_FieldValue));\n\n/** Utility function to compare doubles (using Firestore semantics for NaN). */\nfunction numericComparator(left, right) {\n    if (left < right) {\n        return -1;\n    }\n    else if (left > right) {\n        return 1;\n    }\n    else if (left === right) {\n        return 0;\n    }\n    else {\n        // one or both are NaN.\n        if (isNaN(left)) {\n            return isNaN(right) ? 0 : -1;\n        }\n        else {\n            return 1;\n        }\n    }\n}\n/**\n * Utility function to check numbers for equality using Firestore semantics\n * (NaN === NaN, -0.0 !== 0.0).\n */\nfunction numericEquals(left, right) {\n    // Implemented based on Object.is() polyfill from\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n    if (left === right) {\n        // +0 != -0\n        return left !== 0 || 1 / left === 1 / right;\n    }\n    else {\n        // NaN == NaN\n        return left !== left && right !== right;\n    }\n}\nvar IntegerValue = /** @class */ (function (_super) {\n    field_value___extends(IntegerValue, _super);\n    function IntegerValue(internalValue) {\n        return _super.call(this, internalValue) || this;\n    }\n    IntegerValue.prototype.isEqual = function (other) {\n        // NOTE: DoubleValue and IntegerValue instances may compareTo() the same,\n        // but that doesn't make them equal via isEqual().\n        if (other instanceof IntegerValue) {\n            return numericEquals(this.internalValue, other.internalValue);\n        }\n        else {\n            return false;\n        }\n    };\n    return IntegerValue;\n}(NumberValue));\n\nvar DoubleValue = /** @class */ (function (_super) {\n    field_value___extends(DoubleValue, _super);\n    function DoubleValue(internalValue) {\n        var _this = _super.call(this, internalValue) || this;\n        _this.internalValue = internalValue;\n        return _this;\n    }\n    DoubleValue.prototype.isEqual = function (other) {\n        // NOTE: DoubleValue and IntegerValue instances may compareTo() the same,\n        // but that doesn't make them equal via isEqual().\n        if (other instanceof DoubleValue) {\n            return numericEquals(this.internalValue, other.internalValue);\n        }\n        else {\n            return false;\n        }\n    };\n    DoubleValue.NAN = new DoubleValue(NaN);\n    DoubleValue.POSITIVE_INFINITY = new DoubleValue(Infinity);\n    DoubleValue.NEGATIVE_INFINITY = new DoubleValue(-Infinity);\n    return DoubleValue;\n}(NumberValue));\n\n// TODO(b/37267885): Add truncation support\nvar field_value_StringValue = /** @class */ (function (_super) {\n    field_value___extends(StringValue, _super);\n    function StringValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.StringValue;\n        return _this;\n    }\n    StringValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    StringValue.prototype.isEqual = function (other) {\n        return (other instanceof StringValue && this.internalValue === other.internalValue);\n    };\n    StringValue.prototype.compareTo = function (other) {\n        if (other instanceof StringValue) {\n            return primitiveComparator(this.internalValue, other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return StringValue;\n}(field_value_FieldValue));\n\nvar TimestampValue = /** @class */ (function (_super) {\n    field_value___extends(TimestampValue, _super);\n    function TimestampValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.TimestampValue;\n        return _this;\n    }\n    TimestampValue.prototype.value = function (options) {\n        return this.internalValue.toDate();\n    };\n    TimestampValue.prototype.isEqual = function (other) {\n        return (other instanceof TimestampValue &&\n            this.internalValue.isEqual(other.internalValue));\n    };\n    TimestampValue.prototype.compareTo = function (other) {\n        if (other instanceof TimestampValue) {\n            return this.internalValue.compareTo(other.internalValue);\n        }\n        else if (other instanceof ServerTimestampValue) {\n            // Concrete timestamps come before server timestamps.\n            return -1;\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    return TimestampValue;\n}(field_value_FieldValue));\n\n/**\n * Represents a locally-applied ServerTimestamp.\n *\n * Notes:\n * - ServerTimestampValue instances are created as the result of applying a\n *   TransformMutation (see TransformMutation.applyTo()). They can only exist in\n *   the local view of a document. Therefore they do not need to be parsed or\n *   serialized.\n * - When evaluated locally (e.g. for snapshot.data()), they by default\n *   evaluate to `null`. This behavior can be configured by passing custom\n *   FieldValueOptions to value().\n * - With respect to other ServerTimestampValues, they sort by their\n *   localWriteTime.\n */\nvar ServerTimestampValue = /** @class */ (function (_super) {\n    field_value___extends(ServerTimestampValue, _super);\n    function ServerTimestampValue(localWriteTime, previousValue) {\n        var _this = _super.call(this) || this;\n        _this.localWriteTime = localWriteTime;\n        _this.previousValue = previousValue;\n        _this.typeOrder = TypeOrder.TimestampValue;\n        return _this;\n    }\n    ServerTimestampValue.prototype.value = function (options) {\n        if (options &&\n            options.serverTimestampBehavior === ServerTimestampBehavior.Estimate) {\n            return this.localWriteTime.toDate();\n        }\n        else if (options &&\n            options.serverTimestampBehavior === ServerTimestampBehavior.Previous) {\n            return this.previousValue ? this.previousValue.value(options) : null;\n        }\n        else {\n            return null;\n        }\n    };\n    ServerTimestampValue.prototype.isEqual = function (other) {\n        return (other instanceof ServerTimestampValue &&\n            this.localWriteTime.isEqual(other.localWriteTime));\n    };\n    ServerTimestampValue.prototype.compareTo = function (other) {\n        if (other instanceof ServerTimestampValue) {\n            return this.localWriteTime.compareTo(other.localWriteTime);\n        }\n        else if (other instanceof TimestampValue) {\n            // Server timestamps come after all concrete timestamps.\n            return 1;\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    ServerTimestampValue.prototype.toString = function () {\n        return '<ServerTimestamp localTime=' + this.localWriteTime.toString() + '>';\n    };\n    return ServerTimestampValue;\n}(field_value_FieldValue));\n\nvar BlobValue = /** @class */ (function (_super) {\n    field_value___extends(BlobValue, _super);\n    function BlobValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.BlobValue;\n        return _this;\n    }\n    BlobValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    BlobValue.prototype.isEqual = function (other) {\n        return (other instanceof BlobValue &&\n            this.internalValue.isEqual(other.internalValue));\n    };\n    BlobValue.prototype.compareTo = function (other) {\n        if (other instanceof BlobValue) {\n            return this.internalValue._compareTo(other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return BlobValue;\n}(field_value_FieldValue));\n\nvar field_value_RefValue = /** @class */ (function (_super) {\n    field_value___extends(RefValue, _super);\n    function RefValue(databaseId, key) {\n        var _this = _super.call(this) || this;\n        _this.databaseId = databaseId;\n        _this.key = key;\n        _this.typeOrder = TypeOrder.RefValue;\n        return _this;\n    }\n    RefValue.prototype.value = function (options) {\n        return this.key;\n    };\n    RefValue.prototype.isEqual = function (other) {\n        if (other instanceof RefValue) {\n            return (this.key.isEqual(other.key) && this.databaseId.isEqual(other.databaseId));\n        }\n        else {\n            return false;\n        }\n    };\n    RefValue.prototype.compareTo = function (other) {\n        if (other instanceof RefValue) {\n            var cmp = this.databaseId.compareTo(other.databaseId);\n            return cmp !== 0 ? cmp : document_key_DocumentKey.comparator(this.key, other.key);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return RefValue;\n}(field_value_FieldValue));\n\nvar GeoPointValue = /** @class */ (function (_super) {\n    field_value___extends(GeoPointValue, _super);\n    function GeoPointValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.GeoPointValue;\n        return _this;\n    }\n    GeoPointValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    GeoPointValue.prototype.isEqual = function (other) {\n        return (other instanceof GeoPointValue &&\n            this.internalValue.isEqual(other.internalValue));\n    };\n    GeoPointValue.prototype.compareTo = function (other) {\n        if (other instanceof GeoPointValue) {\n            return this.internalValue._compareTo(other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return GeoPointValue;\n}(field_value_FieldValue));\n\nvar field_value_ObjectValue = /** @class */ (function (_super) {\n    field_value___extends(ObjectValue, _super);\n    function ObjectValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.ObjectValue;\n        return _this;\n    }\n    ObjectValue.prototype.value = function (options) {\n        var result = {};\n        this.internalValue.inorderTraversal(function (key, val) {\n            result[key] = val.value(options);\n        });\n        return result;\n    };\n    ObjectValue.prototype.forEach = function (action) {\n        this.internalValue.inorderTraversal(action);\n    };\n    ObjectValue.prototype.isEqual = function (other) {\n        if (other instanceof ObjectValue) {\n            var it1 = this.internalValue.getIterator();\n            var it2 = other.internalValue.getIterator();\n            while (it1.hasNext() && it2.hasNext()) {\n                var next1 = it1.getNext();\n                var next2 = it2.getNext();\n                if (next1.key !== next2.key || !next1.value.isEqual(next2.value)) {\n                    return false;\n                }\n            }\n            return !it1.hasNext() && !it2.hasNext();\n        }\n        return false;\n    };\n    ObjectValue.prototype.compareTo = function (other) {\n        if (other instanceof ObjectValue) {\n            var it1 = this.internalValue.getIterator();\n            var it2 = other.internalValue.getIterator();\n            while (it1.hasNext() && it2.hasNext()) {\n                var next1 = it1.getNext();\n                var next2 = it2.getNext();\n                var cmp = primitiveComparator(next1.key, next2.key) ||\n                    next1.value.compareTo(next2.value);\n                if (cmp) {\n                    return cmp;\n                }\n            }\n            // Only equal if both iterators are exhausted\n            return primitiveComparator(it1.hasNext(), it2.hasNext());\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    ObjectValue.prototype.set = function (path, to) {\n        assert(!path.isEmpty(), 'Cannot set field for empty path on ObjectValue');\n        if (path.length === 1) {\n            return this.setChild(path.firstSegment(), to);\n        }\n        else {\n            var child = this.child(path.firstSegment());\n            if (!(child instanceof ObjectValue)) {\n                child = ObjectValue.EMPTY;\n            }\n            var newChild = child.set(path.popFirst(), to);\n            return this.setChild(path.firstSegment(), newChild);\n        }\n    };\n    ObjectValue.prototype.delete = function (path) {\n        assert(!path.isEmpty(), 'Cannot delete field for empty path on ObjectValue');\n        if (path.length === 1) {\n            return new ObjectValue(this.internalValue.remove(path.firstSegment()));\n        }\n        else {\n            // nested field\n            var child = this.child(path.firstSegment());\n            if (child instanceof ObjectValue) {\n                var newChild = child.delete(path.popFirst());\n                return new ObjectValue(this.internalValue.insert(path.firstSegment(), newChild));\n            }\n            else {\n                // Don't actually change a primitive value to an object for a delete\n                return this;\n            }\n        }\n    };\n    ObjectValue.prototype.contains = function (path) {\n        return this.field(path) !== undefined;\n    };\n    ObjectValue.prototype.field = function (path) {\n        assert(!path.isEmpty(), \"Can't get field of empty path\");\n        var field = this;\n        path.forEach(function (pathSegment) {\n            if (field instanceof ObjectValue) {\n                field = field.internalValue.get(pathSegment) || undefined;\n            }\n            else {\n                field = undefined;\n            }\n        });\n        return field;\n    };\n    ObjectValue.prototype.toString = function () {\n        return JSON.stringify(this.value());\n    };\n    ObjectValue.prototype.child = function (childName) {\n        return this.internalValue.get(childName) || undefined;\n    };\n    ObjectValue.prototype.setChild = function (childName, value) {\n        return new ObjectValue(this.internalValue.insert(childName, value));\n    };\n    ObjectValue.EMPTY = new ObjectValue(new SortedMap(primitiveComparator));\n    return ObjectValue;\n}(field_value_FieldValue));\n\nvar field_value_ArrayValue = /** @class */ (function (_super) {\n    field_value___extends(ArrayValue, _super);\n    function ArrayValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.ArrayValue;\n        return _this;\n    }\n    ArrayValue.prototype.value = function (options) {\n        return this.internalValue.map(function (v) { return v.value(options); });\n    };\n    ArrayValue.prototype.forEach = function (action) {\n        this.internalValue.forEach(action);\n    };\n    ArrayValue.prototype.isEqual = function (other) {\n        if (other instanceof ArrayValue) {\n            if (this.internalValue.length !== other.internalValue.length) {\n                return false;\n            }\n            for (var i = 0; i < this.internalValue.length; i++) {\n                if (!this.internalValue[i].isEqual(other.internalValue[i])) {\n                    return false;\n                }\n            }\n            return true;\n        }\n        return false;\n    };\n    ArrayValue.prototype.compareTo = function (other) {\n        if (other instanceof ArrayValue) {\n            var minLength = Math.min(this.internalValue.length, other.internalValue.length);\n            for (var i = 0; i < minLength; i++) {\n                var cmp = this.internalValue[i].compareTo(other.internalValue[i]);\n                if (cmp) {\n                    return cmp;\n                }\n            }\n            return primitiveComparator(this.internalValue.length, other.internalValue.length);\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    ArrayValue.prototype.toString = function () {\n        return JSON.stringify(this.value());\n    };\n    return ArrayValue;\n}(field_value_FieldValue));\n\n\n//# sourceMappingURL=field_value.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/types.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Untyped Number alias we can use to check for ES6 methods / properties.\n// tslint:disable-next-line:no-any variable-name\nvar NumberAsAny = Number;\n/**\n * Minimum safe integer in Javascript because of floating point precision.\n * Added to not rely on ES6 features.\n */\nvar MIN_SAFE_INTEGER = NumberAsAny.MIN_SAFE_INTEGER || -(Math.pow(2, 53) - 1);\n/**\n * Maximum safe integer in Javascript because of floating point precision.\n * Added to not rely on ES6 features.\n */\nvar MAX_SAFE_INTEGER = NumberAsAny.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;\n/**\n * Returns whether an number is an integer, uses native implementation if\n * available.\n * Added to not rely on ES6 features.\n * @param value The value to test for being an integer\n */\nvar isInteger = NumberAsAny.isInteger ||\n    (function (value) {\n        return typeof value === 'number' &&\n            isFinite(value) &&\n            Math.floor(value) === value;\n    });\n/**\n * Returns whether a variable is either undefined or null.\n */\nfunction isNullOrUndefined(value) {\n    return value === null || value === undefined;\n}\n/**\n * Returns whether a value is an integer and in the safe integer range\n * @param value The value to test for being an integer and in the safe range\n */\nfunction isSafeInteger(value) {\n    return (isInteger(value) &&\n        value <= MAX_SAFE_INTEGER &&\n        value >= MIN_SAFE_INTEGER);\n}\n/**\n * Safely checks if the number is NaN.\n */\nfunction safeIsNaN(value) {\n    if (NumberAsAny.IsNaN) {\n        return NumberAsAny.IsNaN(value);\n    }\n    else {\n        return typeof value === 'number' && isNaN(value);\n    }\n}\n\n//# sourceMappingURL=types.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/query.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\nvar query_Query = /** @class */ (function () {\n    function Query(path, explicitOrderBy, filters, limit, startAt, endAt) {\n        if (explicitOrderBy === void 0) { explicitOrderBy = []; }\n        if (filters === void 0) { filters = []; }\n        if (limit === void 0) { limit = null; }\n        if (startAt === void 0) { startAt = null; }\n        if (endAt === void 0) { endAt = null; }\n        this.path = path;\n        this.explicitOrderBy = explicitOrderBy;\n        this.filters = filters;\n        this.limit = limit;\n        this.startAt = startAt;\n        this.endAt = endAt;\n        this.memoizedCanonicalId = null;\n        this.memoizedOrderBy = null;\n        if (this.startAt) {\n            this.assertValidBound(this.startAt);\n        }\n        if (this.endAt) {\n            this.assertValidBound(this.endAt);\n        }\n    }\n    Query.atPath = function (path) {\n        return new Query(path);\n    };\n    Object.defineProperty(Query.prototype, \"orderBy\", {\n        get: function () {\n            if (this.memoizedOrderBy === null) {\n                var inequalityField = this.getInequalityFilterField();\n                var firstOrderByField = this.getFirstOrderByField();\n                if (inequalityField !== null && firstOrderByField === null) {\n                    // In order to implicitly add key ordering, we must also add the\n                    // inequality filter field for it to be a valid query.\n                    // Note that the default inequality field and key ordering is ascending.\n                    if (inequalityField.isKeyField()) {\n                        this.memoizedOrderBy = [KEY_ORDERING_ASC];\n                    }\n                    else {\n                        this.memoizedOrderBy = [\n                            new query_OrderBy(inequalityField),\n                            KEY_ORDERING_ASC\n                        ];\n                    }\n                }\n                else {\n                    assert(inequalityField === null ||\n                        (firstOrderByField !== null &&\n                            inequalityField.isEqual(firstOrderByField)), 'First orderBy should match inequality field.');\n                    this.memoizedOrderBy = [];\n                    var foundKeyOrdering = false;\n                    for (var _i = 0, _a = this.explicitOrderBy; _i < _a.length; _i++) {\n                        var orderBy = _a[_i];\n                        this.memoizedOrderBy.push(orderBy);\n                        if (orderBy.field.isKeyField()) {\n                            foundKeyOrdering = true;\n                        }\n                    }\n                    if (!foundKeyOrdering) {\n                        // The order of the implicit key ordering always matches the last\n                        // explicit order by\n                        var lastDirection = this.explicitOrderBy.length > 0\n                            ? this.explicitOrderBy[this.explicitOrderBy.length - 1].dir\n                            : Direction.ASCENDING;\n                        this.memoizedOrderBy.push(lastDirection === Direction.ASCENDING\n                            ? KEY_ORDERING_ASC\n                            : KEY_ORDERING_DESC);\n                    }\n                }\n            }\n            return this.memoizedOrderBy;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Query.prototype.addFilter = function (filter) {\n        assert(this.getInequalityFilterField() == null ||\n            !(filter instanceof query_RelationFilter) ||\n            !filter.isInequality() ||\n            filter.field.isEqual(this.getInequalityFilterField()), 'Query must only have one inequality field.');\n        assert(!document_key_DocumentKey.isDocumentKey(this.path), 'No filtering allowed for document query');\n        var newFilters = this.filters.concat([filter]);\n        return new Query(this.path, this.explicitOrderBy.slice(), newFilters, this.limit, this.startAt, this.endAt);\n    };\n    Query.prototype.addOrderBy = function (orderBy) {\n        assert(!document_key_DocumentKey.isDocumentKey(this.path), 'No ordering allowed for document query');\n        assert(!this.startAt && !this.endAt, 'Bounds must be set after orderBy');\n        // TODO(dimond): validate that orderBy does not list the same key twice.\n        var newOrderBy = this.explicitOrderBy.concat([orderBy]);\n        return new Query(this.path, newOrderBy, this.filters.slice(), this.limit, this.startAt, this.endAt);\n    };\n    Query.prototype.withLimit = function (limit) {\n        return new Query(this.path, this.explicitOrderBy.slice(), this.filters.slice(), limit, this.startAt, this.endAt);\n    };\n    Query.prototype.withStartAt = function (bound) {\n        return new Query(this.path, this.explicitOrderBy.slice(), this.filters.slice(), this.limit, bound, this.endAt);\n    };\n    Query.prototype.withEndAt = function (bound) {\n        return new Query(this.path, this.explicitOrderBy.slice(), this.filters.slice(), this.limit, this.startAt, bound);\n    };\n    // TODO(b/29183165): This is used to get a unique string from a query to, for\n    // example, use as a dictionary key, but the implementation is subject to\n    // collisions. Make it collision-free.\n    Query.prototype.canonicalId = function () {\n        if (this.memoizedCanonicalId === null) {\n            var canonicalId = this.path.canonicalString();\n            canonicalId += '|f:';\n            for (var _i = 0, _a = this.filters; _i < _a.length; _i++) {\n                var filter = _a[_i];\n                canonicalId += filter.canonicalId();\n                canonicalId += ',';\n            }\n            canonicalId += '|ob:';\n            // TODO(dimond): make this collision resistant\n            for (var _b = 0, _c = this.orderBy; _b < _c.length; _b++) {\n                var orderBy = _c[_b];\n                canonicalId += orderBy.canonicalId();\n                canonicalId += ',';\n            }\n            if (!isNullOrUndefined(this.limit)) {\n                canonicalId += '|l:';\n                canonicalId += this.limit;\n            }\n            if (this.startAt) {\n                canonicalId += '|lb:';\n                canonicalId += this.startAt.canonicalId();\n            }\n            if (this.endAt) {\n                canonicalId += '|ub:';\n                canonicalId += this.endAt.canonicalId();\n            }\n            this.memoizedCanonicalId = canonicalId;\n        }\n        return this.memoizedCanonicalId;\n    };\n    Query.prototype.toString = function () {\n        var str = 'Query(' + this.path.canonicalString();\n        if (this.filters.length > 0) {\n            str += \", filters: [\" + this.filters.join(', ') + \"]\";\n        }\n        if (!isNullOrUndefined(this.limit)) {\n            str += ', limit: ' + this.limit;\n        }\n        if (this.explicitOrderBy.length > 0) {\n            str += \", orderBy: [\" + this.explicitOrderBy.join(', ') + \"]\";\n        }\n        if (this.startAt) {\n            str += ', startAt: ' + this.startAt.canonicalId();\n        }\n        if (this.endAt) {\n            str += ', endAt: ' + this.endAt.canonicalId();\n        }\n        return str + ')';\n    };\n    Query.prototype.isEqual = function (other) {\n        if (this.limit !== other.limit) {\n            return false;\n        }\n        if (this.orderBy.length !== other.orderBy.length) {\n            return false;\n        }\n        for (var i = 0; i < this.orderBy.length; i++) {\n            if (!this.orderBy[i].isEqual(other.orderBy[i])) {\n                return false;\n            }\n        }\n        if (this.filters.length !== other.filters.length) {\n            return false;\n        }\n        for (var i = 0; i < this.filters.length; i++) {\n            if (!this.filters[i].isEqual(other.filters[i])) {\n                return false;\n            }\n        }\n        if (!this.path.isEqual(other.path)) {\n            return false;\n        }\n        if (this.startAt !== null\n            ? !this.startAt.isEqual(other.startAt)\n            : other.startAt !== null) {\n            return false;\n        }\n        return this.endAt !== null\n            ? this.endAt.isEqual(other.endAt)\n            : other.endAt === null;\n    };\n    Query.prototype.docComparator = function (d1, d2) {\n        var comparedOnKeyField = false;\n        for (var _i = 0, _a = this.orderBy; _i < _a.length; _i++) {\n            var orderBy = _a[_i];\n            var comp = orderBy.compare(d1, d2);\n            if (comp !== 0)\n                return comp;\n            comparedOnKeyField = comparedOnKeyField || orderBy.field.isKeyField();\n        }\n        // Assert that we actually compared by key\n        assert(comparedOnKeyField, \"orderBy used that doesn't compare on key field\");\n        return 0;\n    };\n    Query.prototype.matches = function (doc) {\n        return (this.matchesAncestor(doc) &&\n            this.matchesOrderBy(doc) &&\n            this.matchesFilters(doc) &&\n            this.matchesBounds(doc));\n    };\n    Query.prototype.hasLimit = function () {\n        return !isNullOrUndefined(this.limit);\n    };\n    Query.prototype.getFirstOrderByField = function () {\n        return this.explicitOrderBy.length > 0\n            ? this.explicitOrderBy[0].field\n            : null;\n    };\n    Query.prototype.getInequalityFilterField = function () {\n        for (var _i = 0, _a = this.filters; _i < _a.length; _i++) {\n            var filter = _a[_i];\n            if (filter instanceof query_RelationFilter && filter.isInequality()) {\n                return filter.field;\n            }\n        }\n        return null;\n    };\n    Query.prototype.isDocumentQuery = function () {\n        return document_key_DocumentKey.isDocumentKey(this.path) && this.filters.length === 0;\n    };\n    Query.prototype.matchesAncestor = function (doc) {\n        var docPath = doc.key.path;\n        if (document_key_DocumentKey.isDocumentKey(this.path)) {\n            // exact match for document queries\n            return this.path.isEqual(docPath);\n        }\n        else {\n            // shallow ancestor queries by default\n            return (this.path.isPrefixOf(docPath) && this.path.length === docPath.length - 1);\n        }\n    };\n    /**\n     * A document must have a value for every ordering clause in order to show up\n     * in the results.\n     */\n    Query.prototype.matchesOrderBy = function (doc) {\n        for (var _i = 0, _a = this.explicitOrderBy; _i < _a.length; _i++) {\n            var orderBy = _a[_i];\n            // order by key always matches\n            if (!orderBy.field.isKeyField() &&\n                doc.field(orderBy.field) === undefined) {\n                return false;\n            }\n        }\n        return true;\n    };\n    Query.prototype.matchesFilters = function (doc) {\n        for (var _i = 0, _a = this.filters; _i < _a.length; _i++) {\n            var filter = _a[_i];\n            if (!filter.matches(doc)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    /**\n     * Makes sure a document is within the bounds, if provided.\n     */\n    Query.prototype.matchesBounds = function (doc) {\n        if (this.startAt && !this.startAt.sortsBeforeDocument(this.orderBy, doc)) {\n            return false;\n        }\n        if (this.endAt && this.endAt.sortsBeforeDocument(this.orderBy, doc)) {\n            return false;\n        }\n        return true;\n    };\n    Query.prototype.assertValidBound = function (bound) {\n        assert(bound.position.length <= this.orderBy.length, 'Bound is longer than orderBy');\n    };\n    return Query;\n}());\n\nvar query_RelationOp = /** @class */ (function () {\n    function RelationOp(name) {\n        this.name = name;\n    }\n    RelationOp.fromString = function (op) {\n        switch (op) {\n            case '<':\n                return RelationOp.LESS_THAN;\n            case '<=':\n                return RelationOp.LESS_THAN_OR_EQUAL;\n            case '==':\n                return RelationOp.EQUAL;\n            case '>=':\n                return RelationOp.GREATER_THAN_OR_EQUAL;\n            case '>':\n                return RelationOp.GREATER_THAN;\n            default:\n                return fail('Unknown relation: ' + op);\n        }\n    };\n    RelationOp.prototype.toString = function () {\n        return this.name;\n    };\n    RelationOp.prototype.isEqual = function (other) {\n        return this.name === other.name;\n    };\n    RelationOp.LESS_THAN = new RelationOp('<');\n    RelationOp.LESS_THAN_OR_EQUAL = new RelationOp('<=');\n    RelationOp.EQUAL = new RelationOp('==');\n    RelationOp.GREATER_THAN = new RelationOp('>');\n    RelationOp.GREATER_THAN_OR_EQUAL = new RelationOp('>=');\n    return RelationOp;\n}());\n\nvar query_RelationFilter = /** @class */ (function () {\n    function RelationFilter(field, op, value) {\n        this.field = field;\n        this.op = op;\n        this.value = value;\n    }\n    RelationFilter.prototype.matches = function (doc) {\n        if (this.field.isKeyField()) {\n            assert(this.value instanceof field_value_RefValue, 'Comparing on key, but filter value not a RefValue');\n            var refValue = this.value;\n            var comparison = document_key_DocumentKey.comparator(doc.key, refValue.key);\n            return this.matchesComparison(comparison);\n        }\n        else {\n            var val = doc.field(this.field);\n            return val !== undefined && this.matchesValue(val);\n        }\n    };\n    RelationFilter.prototype.matchesValue = function (value) {\n        // Only compare types with matching backend order (such as double and int).\n        if (this.value.typeOrder !== value.typeOrder) {\n            return false;\n        }\n        return this.matchesComparison(value.compareTo(this.value));\n    };\n    RelationFilter.prototype.matchesComparison = function (comparison) {\n        switch (this.op) {\n            case query_RelationOp.LESS_THAN:\n                return comparison < 0;\n            case query_RelationOp.LESS_THAN_OR_EQUAL:\n                return comparison <= 0;\n            case query_RelationOp.EQUAL:\n                return comparison === 0;\n            case query_RelationOp.GREATER_THAN:\n                return comparison > 0;\n            case query_RelationOp.GREATER_THAN_OR_EQUAL:\n                return comparison >= 0;\n            default:\n                return fail('Unknown relation op' + this.op);\n        }\n    };\n    RelationFilter.prototype.isInequality = function () {\n        return this.op !== query_RelationOp.EQUAL;\n    };\n    RelationFilter.prototype.canonicalId = function () {\n        // TODO(b/29183165): Technically, this won't be unique if two values have\n        // the same description, such as the int 3 and the string \"3\". So we should\n        // add the types in here somehow, too.\n        return (this.field.canonicalString() + this.op.toString() + this.value.toString());\n    };\n    RelationFilter.prototype.isEqual = function (other) {\n        if (other instanceof RelationFilter) {\n            return (this.op.isEqual(other.op) &&\n                this.field.isEqual(other.field) &&\n                this.value.isEqual(other.value));\n        }\n        else {\n            return false;\n        }\n    };\n    RelationFilter.prototype.toString = function () {\n        return this.field.canonicalString() + \" \" + this.op + \" \" + this.value.value();\n    };\n    return RelationFilter;\n}());\n\n/**\n * Filter that matches 'null' values.\n */\nvar NullFilter = /** @class */ (function () {\n    function NullFilter(field) {\n        this.field = field;\n    }\n    NullFilter.prototype.matches = function (doc) {\n        var val = doc.field(this.field);\n        return val !== undefined && val.value() === null;\n    };\n    NullFilter.prototype.canonicalId = function () {\n        return this.field.canonicalString() + ' IS null';\n    };\n    NullFilter.prototype.toString = function () {\n        return this.field.canonicalString() + \" IS null\";\n    };\n    NullFilter.prototype.isEqual = function (other) {\n        if (other instanceof NullFilter) {\n            return this.field.isEqual(other.field);\n        }\n        else {\n            return false;\n        }\n    };\n    return NullFilter;\n}());\n\n/**\n * Filter that matches 'NaN' values.\n */\nvar NanFilter = /** @class */ (function () {\n    function NanFilter(field) {\n        this.field = field;\n    }\n    NanFilter.prototype.matches = function (doc) {\n        var val = doc.field(this.field).value();\n        return typeof val === 'number' && isNaN(val);\n    };\n    NanFilter.prototype.canonicalId = function () {\n        return this.field.canonicalString() + ' IS NaN';\n    };\n    NanFilter.prototype.toString = function () {\n        return this.field.canonicalString() + \" IS NaN\";\n    };\n    NanFilter.prototype.isEqual = function (other) {\n        if (other instanceof NanFilter) {\n            return this.field.isEqual(other.field);\n        }\n        else {\n            return false;\n        }\n    };\n    return NanFilter;\n}());\n\n/**\n * Creates a filter based on the provided arguments.\n */\nfunction fieldFilter(field, op, value) {\n    if (value.isEqual(NullValue.INSTANCE)) {\n        if (op !== query_RelationOp.EQUAL) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You can only perform equals ' + 'comparisons on null.');\n        }\n        return new NullFilter(field);\n    }\n    else if (value.isEqual(DoubleValue.NAN)) {\n        if (op !== query_RelationOp.EQUAL) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You can only perform equals ' + 'comparisons on NaN.');\n        }\n        return new NanFilter(field);\n    }\n    else {\n        return new query_RelationFilter(field, op, value);\n    }\n}\n/**\n * The direction of sorting in an order by.\n */\nvar Direction = /** @class */ (function () {\n    function Direction(name) {\n        this.name = name;\n    }\n    Direction.prototype.toString = function () {\n        return this.name;\n    };\n    Direction.ASCENDING = new Direction('asc');\n    Direction.DESCENDING = new Direction('desc');\n    return Direction;\n}());\n\n/**\n * Represents a bound of a query.\n *\n * The bound is specified with the given components representing a position and\n * whether it's just before or just after the position (relative to whatever the\n * query order is).\n *\n * The position represents a logical index position for a query. It's a prefix\n * of values for the (potentially implicit) order by clauses of a query.\n *\n * Bound provides a function to determine whether a document comes before or\n * after a bound. This is influenced by whether the position is just before or\n * just after the provided values.\n */\nvar query_Bound = /** @class */ (function () {\n    function Bound(position, before) {\n        this.position = position;\n        this.before = before;\n    }\n    Bound.prototype.canonicalId = function () {\n        // TODO(b/29183165): Make this collision robust.\n        var canonicalId = this.before ? 'b:' : 'a:';\n        for (var _i = 0, _a = this.position; _i < _a.length; _i++) {\n            var component = _a[_i];\n            canonicalId += component.toString();\n        }\n        return canonicalId;\n    };\n    /**\n     * Returns true if a document sorts before a bound using the provided sort\n     * order.\n     */\n    Bound.prototype.sortsBeforeDocument = function (orderBy, doc) {\n        assert(this.position.length <= orderBy.length, \"Bound has more components than query's orderBy\");\n        var comparison = 0;\n        for (var i = 0; i < this.position.length; i++) {\n            var orderByComponent = orderBy[i];\n            var component = this.position[i];\n            if (orderByComponent.field.isKeyField()) {\n                assert(component instanceof field_value_RefValue, 'Bound has a non-key value where the key path is being used.');\n                comparison = document_key_DocumentKey.comparator(component.key, doc.key);\n            }\n            else {\n                var docValue = doc.field(orderByComponent.field);\n                assert(docValue !== undefined, 'Field should exist since document matched the orderBy already.');\n                comparison = component.compareTo(docValue);\n            }\n            if (orderByComponent.dir === Direction.DESCENDING) {\n                comparison = comparison * -1;\n            }\n            if (comparison !== 0) {\n                break;\n            }\n        }\n        return this.before ? comparison <= 0 : comparison < 0;\n    };\n    Bound.prototype.isEqual = function (other) {\n        if (other === null) {\n            return false;\n        }\n        if (this.before !== other.before ||\n            this.position.length !== other.position.length) {\n            return false;\n        }\n        for (var i = 0; i < this.position.length; i++) {\n            var thisPosition = this.position[i];\n            var otherPosition = other.position[i];\n            return thisPosition.isEqual(otherPosition);\n        }\n        return true;\n    };\n    return Bound;\n}());\n\n/**\n * An ordering on a field, in some Direction. Direction defaults to ASCENDING.\n */\nvar query_OrderBy = /** @class */ (function () {\n    function OrderBy(field, dir) {\n        this.field = field;\n        if (dir === undefined) {\n            dir = Direction.ASCENDING;\n        }\n        this.dir = dir;\n        this.isKeyOrderBy = field.isKeyField();\n    }\n    OrderBy.prototype.compare = function (d1, d2) {\n        var comparison = this.isKeyOrderBy\n            ? document_Document.compareByKey(d1, d2)\n            : document_Document.compareByField(this.field, d1, d2);\n        switch (this.dir) {\n            case Direction.ASCENDING:\n                return comparison;\n            case Direction.DESCENDING:\n                return -1 * comparison;\n            default:\n                return fail('Unknown direction: ' + this.dir);\n        }\n    };\n    OrderBy.prototype.canonicalId = function () {\n        // TODO(b/29183165): Make this collision robust.\n        return this.field.canonicalString() + this.dir.toString();\n    };\n    OrderBy.prototype.toString = function () {\n        return this.field.canonicalString() + \" (\" + this.dir + \")\";\n    };\n    OrderBy.prototype.isEqual = function (other) {\n        return this.dir === other.dir && this.field.isEqual(other.field);\n    };\n    return OrderBy;\n}());\n\nvar KEY_ORDERING_ASC = new query_OrderBy(path_FieldPath.keyField(), Direction.ASCENDING);\nvar KEY_ORDERING_DESC = new query_OrderBy(path_FieldPath.keyField(), Direction.DESCENDING);\n\n//# sourceMappingURL=query.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/timestamp.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n// A RegExp matching ISO 8601 UTC timestamps with optional fraction.\nvar isoRegExp = new RegExp(/^\\d{4}-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\d(?:\\.(\\d+))?Z$/);\nvar timestamp_Timestamp = /** @class */ (function () {\n    function Timestamp(seconds, nanos) {\n        this.seconds = seconds;\n        this.nanos = nanos;\n        assert(nanos >= 0, 'timestamp nanoseconds out of range: ' + nanos);\n        assert(nanos < 1e9, 'timestamp nanoseconds out of range' + nanos);\n        // Midnight at the beginning of 1/1/1 is the earliest Firestore supports.\n        assert(seconds >= -62135596800, 'timestamp seconds out of range: ' + seconds);\n        // This will break in the year 10,000.\n        assert(seconds < 253402300800, 'timestamp seconds out of range' + seconds);\n    }\n    Timestamp.now = function () {\n        return Timestamp.fromEpochMilliseconds(Date.now());\n    };\n    Timestamp.fromDate = function (date) {\n        return Timestamp.fromEpochMilliseconds(date.getTime());\n    };\n    Timestamp.fromEpochMilliseconds = function (milliseconds) {\n        var seconds = Math.floor(milliseconds / 1000);\n        var nanos = (milliseconds - seconds * 1000) * 1e6;\n        return new Timestamp(seconds, nanos);\n    };\n    Timestamp.fromISOString = function (utc) {\n        // The date string can have higher precision (nanos) than the Date class\n        // (millis), so we do some custom parsing here.\n        // Parse the nanos right out of the string.\n        var nanos = 0;\n        var fraction = isoRegExp.exec(utc);\n        assert(!!fraction, 'invalid timestamp: ' + utc);\n        if (fraction[1]) {\n            // Pad the fraction out to 9 digits (nanos).\n            var nanoStr = fraction[1];\n            nanoStr = (nanoStr + '000000000').substr(0, 9);\n            nanos = Number(nanoStr);\n        }\n        // Parse the date to get the seconds.\n        var date = new Date(utc);\n        var seconds = Math.floor(date.getTime() / 1000);\n        return new Timestamp(seconds, nanos);\n    };\n    Timestamp.prototype.toDate = function () {\n        return new Date(this.toEpochMilliseconds());\n    };\n    Timestamp.prototype.toEpochMilliseconds = function () {\n        return this.seconds * 1000 + this.nanos / 1e6;\n    };\n    Timestamp.prototype.compareTo = function (other) {\n        if (this.seconds === other.seconds) {\n            return primitiveComparator(this.nanos, other.nanos);\n        }\n        return primitiveComparator(this.seconds, other.seconds);\n    };\n    Timestamp.prototype.isEqual = function (other) {\n        return other.seconds === this.seconds && other.nanos === this.nanos;\n    };\n    Timestamp.prototype.toString = function () {\n        return 'Timestamp(seconds=' + this.seconds + ', nanos=' + this.nanos + ')';\n    };\n    return Timestamp;\n}());\n\n\n//# sourceMappingURL=timestamp.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/snapshot_version.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A version of a document in Firestore. This corresponds to the version\n * timestamp, such as update_time or read_time.\n */\nvar snapshot_version_SnapshotVersion = /** @class */ (function () {\n    function SnapshotVersion(timestamp) {\n        this.timestamp = timestamp;\n    }\n    // TODO(b/34176344): Once we no longer need to use the old alpha protos,\n    // delete this constructor and use a timestamp-backed version everywhere.\n    SnapshotVersion.fromMicroseconds = function (value) {\n        var seconds = Math.floor(value / 1e6);\n        var nanos = (value % 1e6) * 1e3;\n        return new SnapshotVersion(new timestamp_Timestamp(seconds, nanos));\n    };\n    SnapshotVersion.fromTimestamp = function (value) {\n        return new SnapshotVersion(value);\n    };\n    SnapshotVersion.forDeletedDoc = function () {\n        return SnapshotVersion.MIN;\n    };\n    SnapshotVersion.prototype.compareTo = function (other) {\n        return this.timestamp.compareTo(other.timestamp);\n    };\n    SnapshotVersion.prototype.isEqual = function (other) {\n        return this.timestamp.isEqual(other.timestamp);\n    };\n    /** Returns a number representation of the version for use in spec tests. */\n    SnapshotVersion.prototype.toMicroseconds = function () {\n        // Convert to microseconds.\n        return this.timestamp.seconds * 1e6 + this.timestamp.nanos / 1000;\n    };\n    SnapshotVersion.prototype.toString = function () {\n        return 'SnapshotVersion(' + this.timestamp.toString() + ')';\n    };\n    SnapshotVersion.prototype.toTimestamp = function () {\n        return this.timestamp;\n    };\n    SnapshotVersion.MIN = new SnapshotVersion(new timestamp_Timestamp(0, 0));\n    return SnapshotVersion;\n}());\n\n\n//# sourceMappingURL=snapshot_version.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/query_data.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/** An enumeration of the different purposes we have for queries. */\nvar QueryPurpose;\n(function (QueryPurpose) {\n    /** A regular, normal query. */\n    QueryPurpose[QueryPurpose[\"Listen\"] = 0] = \"Listen\";\n    /**\n     * The query was used to refill a query after an existence filter mismatch.\n     */\n    QueryPurpose[QueryPurpose[\"ExistenceFilterMismatch\"] = 1] = \"ExistenceFilterMismatch\";\n    /** The query was used to resolve a limbo document. */\n    QueryPurpose[QueryPurpose[\"LimboResolution\"] = 2] = \"LimboResolution\";\n})(QueryPurpose || (QueryPurpose = {}));\n/**\n * An immutable set of metadata that the local store tracks for each query.\n */\nvar query_data_QueryData = /** @class */ (function () {\n    function QueryData(\n        /** The query being listened to. */\n        query, \n        /**\n         * The target ID to which the query corresponds; Assigned by the\n         * LocalStore for user listens and by the SyncEngine for limbo watches.\n         */\n        targetId, \n        /** The purpose of the query. */\n        purpose, \n        /** The latest snapshot version seen for this target. */\n        snapshotVersion, \n        /**\n         * An opaque, server-assigned token that allows watching a query to be\n         * resumed after disconnecting without retransmitting all the data that\n         * matches the query. The resume token essentially identifies a point in\n         * time from which the server should resume sending results.\n         */\n        resumeToken) {\n        if (snapshotVersion === void 0) { snapshotVersion = snapshot_version_SnapshotVersion.MIN; }\n        if (resumeToken === void 0) { resumeToken = emptyByteString(); }\n        this.query = query;\n        this.targetId = targetId;\n        this.purpose = purpose;\n        this.snapshotVersion = snapshotVersion;\n        this.resumeToken = resumeToken;\n    }\n    /**\n     * Creates a new query data instance with an updated snapshot version and\n     * resume token.\n     */\n    QueryData.prototype.update = function (updated) {\n        return new QueryData(this.query, this.targetId, this.purpose, updated.snapshotVersion, updated.resumeToken);\n    };\n    QueryData.prototype.isEqual = function (other) {\n        return (this.targetId === other.targetId &&\n            this.purpose === other.purpose &&\n            this.snapshotVersion.isEqual(other.snapshotVersion) &&\n            this.resumeToken === other.resumeToken &&\n            this.query.isEqual(other.query));\n    };\n    return QueryData;\n}());\n\n\n//# sourceMappingURL=query_data.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/mutation.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar mutation___extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\n\n/**\n * Provides a set of fields that can be used to partially patch a document.\n * FieldMask is used in conjunction with ObjectValue.\n * Examples:\n *   foo - Overwrites foo entirely with the provided value. If foo is not\n *         present in the companion ObjectValue, the field is deleted.\n *   foo.bar - Overwrites only the field bar of the object foo.\n *             If foo is not an object, foo is replaced with an object\n *             containing foo\n */\nvar mutation_FieldMask = /** @class */ (function () {\n    function FieldMask(fields) {\n        this.fields = fields;\n        // TODO(dimond): validation of FieldMask\n    }\n    FieldMask.prototype.isEqual = function (other) {\n        return arrayEquals(this.fields, other.fields);\n    };\n    return FieldMask;\n}());\n\n/** Transforms a value into a server-generated timestamp. */\nvar ServerTimestampTransform = /** @class */ (function () {\n    function ServerTimestampTransform() {\n    }\n    ServerTimestampTransform.prototype.isEqual = function (other) {\n        return other instanceof ServerTimestampTransform;\n    };\n    ServerTimestampTransform.instance = new ServerTimestampTransform();\n    return ServerTimestampTransform;\n}());\n\n/** A field path and the TransformOperation to perform upon it. */\nvar FieldTransform = /** @class */ (function () {\n    function FieldTransform(field, transform) {\n        this.field = field;\n        this.transform = transform;\n    }\n    FieldTransform.prototype.isEqual = function (other) {\n        return (this.field.isEqual(other.field) && this.transform.isEqual(other.transform));\n    };\n    return FieldTransform;\n}());\n\n/** The result of successfully applying a mutation to the backend. */\nvar MutationResult = /** @class */ (function () {\n    function MutationResult(\n        /**\n         * The version at which the mutation was committed or null for a delete.\n         */\n        version, \n        /**\n         * The resulting fields returned from the backend after a\n         * TransformMutation has been committed. Contains one FieldValue for each\n         * FieldTransform that was in the mutation.\n         *\n         * Will be null if the mutation was not a TransformMutation.\n         */\n        transformResults) {\n        this.version = version;\n        this.transformResults = transformResults;\n    }\n    return MutationResult;\n}());\n\nvar MutationType;\n(function (MutationType) {\n    MutationType[MutationType[\"Set\"] = 0] = \"Set\";\n    MutationType[MutationType[\"Patch\"] = 1] = \"Patch\";\n    MutationType[MutationType[\"Transform\"] = 2] = \"Transform\";\n    MutationType[MutationType[\"Delete\"] = 3] = \"Delete\";\n})(MutationType || (MutationType = {}));\n/**\n * Encodes a precondition for a mutation. This follows the model that the\n * backend accepts with the special case of an explicit \"empty\" precondition\n * (meaning no precondition).\n */\nvar mutation_Precondition = /** @class */ (function () {\n    function Precondition(updateTime, exists) {\n        this.updateTime = updateTime;\n        this.exists = exists;\n        assert(updateTime === undefined || exists === undefined, 'Precondition can specify \"exists\" or \"updateTime\" but not both');\n    }\n    /** Creates a new Precondition with an exists flag. */\n    Precondition.exists = function (exists) {\n        return new Precondition(undefined, exists);\n    };\n    /** Creates a new Precondition based on a version a document exists at. */\n    Precondition.updateTime = function (version) {\n        return new Precondition(version);\n    };\n    Object.defineProperty(Precondition.prototype, \"isNone\", {\n        /** Returns whether this Precondition is empty. */\n        get: function () {\n            return this.updateTime === undefined && this.exists === undefined;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Returns true if the preconditions is valid for the given document\n     * (or null if no document is available).\n     */\n    Precondition.prototype.isValidFor = function (maybeDoc) {\n        if (this.updateTime !== undefined) {\n            return (maybeDoc instanceof document_Document &&\n                maybeDoc.version.isEqual(this.updateTime));\n        }\n        else if (this.exists !== undefined) {\n            if (this.exists) {\n                return maybeDoc instanceof document_Document;\n            }\n            else {\n                return maybeDoc === null || maybeDoc instanceof document_NoDocument;\n            }\n        }\n        else {\n            assert(this.isNone, 'Precondition should be empty');\n            return true;\n        }\n    };\n    Precondition.prototype.isEqual = function (other) {\n        return (equals(this.updateTime, other.updateTime) &&\n            this.exists === other.exists);\n    };\n    Precondition.NONE = new Precondition();\n    return Precondition;\n}());\n\n/**\n * A mutation describes a self-contained change to a document. Mutations can\n * create, replace, delete, and update subsets of documents.\n *\n * Mutations not only act on the value of the document but also it version.\n * In the case of Set, Patch, and Transform mutations we preserve the existing\n * version. In the case of Delete mutations, we reset the version to 0.\n *\n * Here's the expected transition table.\n *\n * MUTATION           APPLIED TO            RESULTS IN\n *\n * SetMutation        Document(v3)          Document(v3)\n * SetMutation        NoDocument(v3)        Document(v0)\n * SetMutation        null                  Document(v0)\n * PatchMutation      Document(v3)          Document(v3)\n * PatchMutation      NoDocument(v3)        NoDocument(v3)\n * PatchMutation      null                  null\n * TransformMutation  Document(v3)          Document(v3)\n * TransformMutation  NoDocument(v3)        NoDocument(v3)\n * TransformMutation  null                  null\n * DeleteMutation     Document(v3)          NoDocument(v0)\n * DeleteMutation     NoDocument(v3)        NoDocument(v0)\n * DeleteMutation     null                  NoDocument(v0)\n *\n * Note that TransformMutations don't create Documents (in the case of being\n * applied to a NoDocument), even though they would on the backend. This is\n * because the client always combines the TransformMutation with a SetMutation\n * or PatchMutation and we only want to apply the transform if the prior\n * mutation resulted in a Document (always true for a SetMutation, but not\n * necessarily for a PatchMutation).\n *\n * ## Subclassing Notes\n *\n * Subclasses of Mutation need to implement applyToRemoteDocument() and\n * applyToLocalView() to implement the actual behavior of applying the mutation\n * to some source document.\n */\nvar mutation_Mutation = /** @class */ (function () {\n    function Mutation() {\n    }\n    Mutation.prototype.verifyKeyMatches = function (maybeDoc) {\n        if (maybeDoc != null) {\n            assert(maybeDoc.key.isEqual(this.key), 'Can only apply a mutation to a document with the same key');\n        }\n    };\n    /**\n     * Returns the version from the given document for use as the result of a\n     * mutation. Mutations are defined to return the version of the base document\n     * only if it is an existing document. Deleted and unknown documents have a\n     * post-mutation version of SnapshotVersion.MIN.\n     */\n    Mutation.getPostMutationVersion = function (maybeDoc) {\n        if (maybeDoc instanceof document_Document) {\n            return maybeDoc.version;\n        }\n        else {\n            return snapshot_version_SnapshotVersion.MIN;\n        }\n    };\n    return Mutation;\n}());\n\n/**\n * A mutation that creates or replaces the document at the given key with the\n * object value contents.\n */\nvar mutation_SetMutation = /** @class */ (function (_super) {\n    mutation___extends(SetMutation, _super);\n    function SetMutation(key, value, precondition) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.value = value;\n        _this.precondition = precondition;\n        _this.type = MutationType.Set;\n        return _this;\n    }\n    SetMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults == null, 'Transform results received by SetMutation.');\n        // Unlike applyToLocalView, if we're applying a mutation to a remote\n        // document the server has accepted the mutation so the precondition must\n        // have held.\n        var version = mutation_Mutation.getPostMutationVersion(maybeDoc);\n        return new document_Document(this.key, version, this.value, {\n            hasLocalMutations: false\n        });\n    };\n    SetMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var version = mutation_Mutation.getPostMutationVersion(maybeDoc);\n        return new document_Document(this.key, version, this.value, {\n            hasLocalMutations: true\n        });\n    };\n    SetMutation.prototype.isEqual = function (other) {\n        return (other instanceof SetMutation &&\n            this.key.isEqual(other.key) &&\n            this.value.isEqual(other.value) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    return SetMutation;\n}(mutation_Mutation));\n\n/**\n * A mutation that modifies fields of the document at the given key with the\n * given values. The values are applied through a field mask:\n *\n *  * When a field is in both the mask and the values, the corresponding field\n *    is updated.\n *  * When a field is in neither the mask nor the values, the corresponding\n *    field is unmodified.\n *  * When a field is in the mask but not in the values, the corresponding field\n *    is deleted.\n *  * When a field is not in the mask but is in the values, the values map is\n *    ignored.\n */\nvar mutation_PatchMutation = /** @class */ (function (_super) {\n    mutation___extends(PatchMutation, _super);\n    function PatchMutation(key, data, fieldMask, precondition) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.data = data;\n        _this.fieldMask = fieldMask;\n        _this.precondition = precondition;\n        _this.type = MutationType.Patch;\n        return _this;\n    }\n    PatchMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults == null, 'Transform results received by PatchMutation.');\n        // TODO(mcg): Relax enforcement of this precondition\n        //\n        // We shouldn't actually enforce the precondition since it already passed on\n        // the backend, but we may not have a local version of the document to\n        // patch, so we use the precondition to prevent incorrectly putting a\n        // partial document into our cache.\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var version = mutation_Mutation.getPostMutationVersion(maybeDoc);\n        var newData = this.patchDocument(maybeDoc);\n        return new document_Document(this.key, version, newData, {\n            hasLocalMutations: false\n        });\n    };\n    PatchMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var version = mutation_Mutation.getPostMutationVersion(maybeDoc);\n        var newData = this.patchDocument(maybeDoc);\n        return new document_Document(this.key, version, newData, {\n            hasLocalMutations: true\n        });\n    };\n    PatchMutation.prototype.isEqual = function (other) {\n        return (other instanceof PatchMutation &&\n            this.key.isEqual(other.key) &&\n            this.fieldMask.isEqual(other.fieldMask) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    /**\n     * Patches the data of document if available or creates a new document. Note\n     * that this does not check whether or not the precondition of this patch\n     * holds.\n     */\n    PatchMutation.prototype.patchDocument = function (maybeDoc) {\n        var data;\n        if (maybeDoc instanceof document_Document) {\n            data = maybeDoc.data;\n        }\n        else {\n            data = field_value_ObjectValue.EMPTY;\n        }\n        return this.patchObject(data);\n    };\n    PatchMutation.prototype.patchObject = function (data) {\n        for (var _i = 0, _a = this.fieldMask.fields; _i < _a.length; _i++) {\n            var fieldPath = _a[_i];\n            var newValue = this.data.field(fieldPath);\n            if (newValue !== undefined) {\n                data = data.set(fieldPath, newValue);\n            }\n            else {\n                data = data.delete(fieldPath);\n            }\n        }\n        return data;\n    };\n    return PatchMutation;\n}(mutation_Mutation));\n\n/**\n * A mutation that modifies specific fields of the document with transform\n * operations. Currently the only supported transform is a server timestamp, but\n * IP Address, increment(n), etc. could be supported in the future.\n *\n * It is somewhat similar to a PatchMutation in that it patches specific fields\n * and has no effect when applied to a null or NoDocument (see comment on\n * Mutation for rationale).\n */\nvar mutation_TransformMutation = /** @class */ (function (_super) {\n    mutation___extends(TransformMutation, _super);\n    function TransformMutation(key, fieldTransforms) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.fieldTransforms = fieldTransforms;\n        _this.type = MutationType.Transform;\n        // NOTE: We set a precondition of exists: true as a safety-check, since we\n        // always combine TransformMutations with a SetMutation or PatchMutation which\n        // (if successful) should end up with an existing document.\n        _this.precondition = mutation_Precondition.exists(true);\n        return _this;\n    }\n    TransformMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults != null, 'Transform results missing for TransformMutation.');\n        var transformResults = mutationResult.transformResults;\n        // TODO(mcg): Relax enforcement of this precondition\n        //\n        // We shouldn't actually enforce the precondition since it already passed on\n        // the backend, but we may not have a local version of the document to\n        // patch, so we use the precondition to prevent incorrectly putting a\n        // partial document into our cache.\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var doc = this.requireDocument(maybeDoc);\n        var newData = this.transformObject(doc.data, transformResults);\n        return new document_Document(this.key, doc.version, newData, {\n            hasLocalMutations: false\n        });\n    };\n    TransformMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var doc = this.requireDocument(maybeDoc);\n        var transformResults = this.localTransformResults(localWriteTime, baseDoc);\n        var newData = this.transformObject(doc.data, transformResults);\n        return new document_Document(this.key, doc.version, newData, {\n            hasLocalMutations: true\n        });\n    };\n    TransformMutation.prototype.isEqual = function (other) {\n        return (other instanceof TransformMutation &&\n            this.key.isEqual(other.key) &&\n            arrayEquals(this.fieldTransforms, other.fieldTransforms) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    /**\n     * Asserts that the given MaybeDocument is actually a Document and verifies\n     * that it matches the key for this mutation. Since we only support\n     * transformations with precondition exists this method is guaranteed to be\n     * safe.\n     */\n    TransformMutation.prototype.requireDocument = function (maybeDoc) {\n        assert(maybeDoc instanceof document_Document, 'Unknown MaybeDocument type ' + maybeDoc);\n        var doc = maybeDoc;\n        assert(doc.key.isEqual(this.key), 'Can only transform a document with the same key');\n        return doc;\n    };\n    /**\n     * Creates a list of \"transform results\" (a transform result is a field value\n     * representing the result of applying a transform) for use when applying a\n     * TransformMutation locally.\n     *\n     * @param localWriteTime The local time of the transform mutation (used to\n     *     generate ServerTimestampValues).\n     * @param baseDoc The document prior to applying this mutation batch.\n     * @return The transform results list.\n     */\n    TransformMutation.prototype.localTransformResults = function (localWriteTime, baseDoc) {\n        var transformResults = [];\n        for (var _i = 0, _a = this.fieldTransforms; _i < _a.length; _i++) {\n            var fieldTransform = _a[_i];\n            var transform = fieldTransform.transform;\n            if (transform instanceof ServerTimestampTransform) {\n                var previousValue = null;\n                if (baseDoc instanceof document_Document) {\n                    previousValue = baseDoc.field(fieldTransform.field) || null;\n                }\n                transformResults.push(new ServerTimestampValue(localWriteTime, previousValue));\n            }\n            else {\n                return fail('Encountered unknown transform: ' + transform);\n            }\n        }\n        return transformResults;\n    };\n    TransformMutation.prototype.transformObject = function (data, transformResults) {\n        assert(transformResults.length === this.fieldTransforms.length, 'TransformResults length mismatch.');\n        for (var i = 0; i < this.fieldTransforms.length; i++) {\n            var fieldTransform = this.fieldTransforms[i];\n            var transform = fieldTransform.transform;\n            var fieldPath = fieldTransform.field;\n            if (transform instanceof ServerTimestampTransform) {\n                data = data.set(fieldPath, transformResults[i]);\n            }\n            else {\n                return fail('Encountered unknown transform: ' + transform);\n            }\n        }\n        return data;\n    };\n    return TransformMutation;\n}(mutation_Mutation));\n\n/** A mutation that deletes the document at the given key. */\nvar mutation_DeleteMutation = /** @class */ (function (_super) {\n    mutation___extends(DeleteMutation, _super);\n    function DeleteMutation(key, precondition) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.precondition = precondition;\n        _this.type = MutationType.Delete;\n        return _this;\n    }\n    DeleteMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults == null, 'Transform results received by DeleteMutation.');\n        // Unlike applyToLocalView, if we're applying a mutation to a remote\n        // document the server has accepted the mutation so the precondition must\n        // have held.\n        return new document_NoDocument(this.key, snapshot_version_SnapshotVersion.MIN);\n    };\n    DeleteMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        if (maybeDoc) {\n            assert(maybeDoc.key.isEqual(this.key), 'Can only apply mutation to document with same key');\n        }\n        return new document_NoDocument(this.key, snapshot_version_SnapshotVersion.forDeletedDoc());\n    };\n    DeleteMutation.prototype.isEqual = function (other) {\n        return (other instanceof DeleteMutation &&\n            this.key.isEqual(other.key) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    return DeleteMutation;\n}(mutation_Mutation));\n\n\n//# sourceMappingURL=mutation.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/existence_filter.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar ExistenceFilter = /** @class */ (function () {\n    // TODO(b/33078163): just use simplest form of existence filter for now\n    function ExistenceFilter(count) {\n        this.count = count;\n    }\n    ExistenceFilter.prototype.isEqual = function (other) {\n        return other && other.count === this.count;\n    };\n    return ExistenceFilter;\n}());\n\n\n//# sourceMappingURL=existence_filter.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/rpc_error.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * Error Codes describing the different ways GRPC can fail. These are copied\n * directly from GRPC's sources here:\n *\n * https://github.com/grpc/grpc/blob/bceec94ea4fc5f0085d81235d8e1c06798dc341a/include/grpc%2B%2B/impl/codegen/status_code_enum.h\n *\n * Important! The names of these identifiers matter because the string forms\n * are used for reverse lookups from the webchannel stream. Do NOT change the\n * names of these identifiers.\n */\nvar RpcCode;\n(function (RpcCode) {\n    RpcCode[RpcCode[\"OK\"] = 0] = \"OK\";\n    RpcCode[RpcCode[\"CANCELLED\"] = 1] = \"CANCELLED\";\n    RpcCode[RpcCode[\"UNKNOWN\"] = 2] = \"UNKNOWN\";\n    RpcCode[RpcCode[\"INVALID_ARGUMENT\"] = 3] = \"INVALID_ARGUMENT\";\n    RpcCode[RpcCode[\"DEADLINE_EXCEEDED\"] = 4] = \"DEADLINE_EXCEEDED\";\n    RpcCode[RpcCode[\"NOT_FOUND\"] = 5] = \"NOT_FOUND\";\n    RpcCode[RpcCode[\"ALREADY_EXISTS\"] = 6] = \"ALREADY_EXISTS\";\n    RpcCode[RpcCode[\"PERMISSION_DENIED\"] = 7] = \"PERMISSION_DENIED\";\n    RpcCode[RpcCode[\"UNAUTHENTICATED\"] = 16] = \"UNAUTHENTICATED\";\n    RpcCode[RpcCode[\"RESOURCE_EXHAUSTED\"] = 8] = \"RESOURCE_EXHAUSTED\";\n    RpcCode[RpcCode[\"FAILED_PRECONDITION\"] = 9] = \"FAILED_PRECONDITION\";\n    RpcCode[RpcCode[\"ABORTED\"] = 10] = \"ABORTED\";\n    RpcCode[RpcCode[\"OUT_OF_RANGE\"] = 11] = \"OUT_OF_RANGE\";\n    RpcCode[RpcCode[\"UNIMPLEMENTED\"] = 12] = \"UNIMPLEMENTED\";\n    RpcCode[RpcCode[\"INTERNAL\"] = 13] = \"INTERNAL\";\n    RpcCode[RpcCode[\"UNAVAILABLE\"] = 14] = \"UNAVAILABLE\";\n    RpcCode[RpcCode[\"DATA_LOSS\"] = 15] = \"DATA_LOSS\";\n})(RpcCode || (RpcCode = {}));\nfunction isPermanentError(code) {\n    switch (code) {\n        case Code.OK:\n            return fail('Treated status OK as error');\n        case Code.CANCELLED:\n        case Code.UNKNOWN:\n        case Code.DEADLINE_EXCEEDED:\n        case Code.RESOURCE_EXHAUSTED:\n        case Code.INTERNAL:\n        case Code.UNAVAILABLE:\n        // Unauthenticated means something went wrong with our token and we need\n        // to retry with new credentials which will happen automatically.\n        // TODO(b/37325376): Give up after second unauthenticated error.\n        case Code.UNAUTHENTICATED:\n            return false;\n        case Code.INVALID_ARGUMENT:\n        case Code.NOT_FOUND:\n        case Code.ALREADY_EXISTS:\n        case Code.PERMISSION_DENIED:\n        case Code.FAILED_PRECONDITION:\n        // Aborted might be retried in some scenarios, but that is dependant on\n        // the context and should handled individually by the calling code.\n        // See https://cloud.google.com/apis/design/errors.\n        case Code.ABORTED:\n        case Code.OUT_OF_RANGE:\n        case Code.UNIMPLEMENTED:\n        case Code.DATA_LOSS:\n            return true;\n        default:\n            return fail('Unknown status code: ' + code);\n    }\n}\n/**\n * Maps an error Code from a GRPC status identifier like 'NOT_FOUND'.\n *\n * @returns The Code equivalent to the given status string or undefined if\n *     there is no match.\n */\nfunction mapCodeFromRpcStatus(status) {\n    // tslint:disable-next-line:no-any lookup by string\n    var code = RpcCode[status];\n    if (code === undefined) {\n        return undefined;\n    }\n    return mapCodeFromRpcCode(code);\n}\n/**\n * Maps an error Code from GRPC status code number, like 0, 1, or 14. These\n * are not the same as HTTP status codes.\n *\n * @returns The Code equivalent to the given GRPC status code. Fails if there\n *     is no match.\n */\nfunction mapCodeFromRpcCode(code) {\n    if (code === undefined) {\n        // This shouldn't normally happen, but in certain error cases (like trying\n        // to send invalid proto messages) we may get an error with no GRPC code.\n        log_error('GRPC error has no .code');\n        return Code.UNKNOWN;\n    }\n    switch (code) {\n        case RpcCode.OK:\n            return Code.OK;\n        case RpcCode.CANCELLED:\n            return Code.CANCELLED;\n        case RpcCode.UNKNOWN:\n            return Code.UNKNOWN;\n        case RpcCode.DEADLINE_EXCEEDED:\n            return Code.DEADLINE_EXCEEDED;\n        case RpcCode.RESOURCE_EXHAUSTED:\n            return Code.RESOURCE_EXHAUSTED;\n        case RpcCode.INTERNAL:\n            return Code.INTERNAL;\n        case RpcCode.UNAVAILABLE:\n            return Code.UNAVAILABLE;\n        case RpcCode.UNAUTHENTICATED:\n            return Code.UNAUTHENTICATED;\n        case RpcCode.INVALID_ARGUMENT:\n            return Code.INVALID_ARGUMENT;\n        case RpcCode.NOT_FOUND:\n            return Code.NOT_FOUND;\n        case RpcCode.ALREADY_EXISTS:\n            return Code.ALREADY_EXISTS;\n        case RpcCode.PERMISSION_DENIED:\n            return Code.PERMISSION_DENIED;\n        case RpcCode.FAILED_PRECONDITION:\n            return Code.FAILED_PRECONDITION;\n        case RpcCode.ABORTED:\n            return Code.ABORTED;\n        case RpcCode.OUT_OF_RANGE:\n            return Code.OUT_OF_RANGE;\n        case RpcCode.UNIMPLEMENTED:\n            return Code.UNIMPLEMENTED;\n        case RpcCode.DATA_LOSS:\n            return Code.DATA_LOSS;\n        default:\n            return fail('Unknown status code: ' + code);\n    }\n}\n/**\n * Maps an RPC code from a Code. This is the reverse operation from\n * mapCodeFromRpcCode and should really only be used in tests.\n */\nfunction mapRpcCodeFromCode(code) {\n    if (code === undefined) {\n        return RpcCode.OK;\n    }\n    switch (code) {\n        case Code.OK:\n            return RpcCode.OK;\n        case Code.CANCELLED:\n            return RpcCode.CANCELLED;\n        case Code.UNKNOWN:\n            return RpcCode.UNKNOWN;\n        case Code.DEADLINE_EXCEEDED:\n            return RpcCode.DEADLINE_EXCEEDED;\n        case Code.RESOURCE_EXHAUSTED:\n            return RpcCode.RESOURCE_EXHAUSTED;\n        case Code.INTERNAL:\n            return RpcCode.INTERNAL;\n        case Code.UNAVAILABLE:\n            return RpcCode.UNAVAILABLE;\n        case Code.UNAUTHENTICATED:\n            return RpcCode.UNAUTHENTICATED;\n        case Code.INVALID_ARGUMENT:\n            return RpcCode.INVALID_ARGUMENT;\n        case Code.NOT_FOUND:\n            return RpcCode.NOT_FOUND;\n        case Code.ALREADY_EXISTS:\n            return RpcCode.ALREADY_EXISTS;\n        case Code.PERMISSION_DENIED:\n            return RpcCode.PERMISSION_DENIED;\n        case Code.FAILED_PRECONDITION:\n            return RpcCode.FAILED_PRECONDITION;\n        case Code.ABORTED:\n            return RpcCode.ABORTED;\n        case Code.OUT_OF_RANGE:\n            return RpcCode.OUT_OF_RANGE;\n        case Code.UNIMPLEMENTED:\n            return RpcCode.UNIMPLEMENTED;\n        case Code.DATA_LOSS:\n            return RpcCode.DATA_LOSS;\n        default:\n            return fail('Unknown status code: ' + code);\n    }\n}\n/**\n * Converts an HTTP Status Code to the equivalent error code.\n *\n * @param status An HTTP Status Code, like 200, 404, 503, etc.\n * @returns The equivalent Code. Unknown status codes are mapped to\n *     Code.UNKNOWN.\n */\nfunction mapCodeFromHttpStatus(status) {\n    // The canonical error codes for Google APIs [1] specify mapping onto HTTP\n    // status codes but the mapping is not bijective. In each case of ambiguity\n    // this function chooses a primary error.\n    //\n    // [1]\n    // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto\n    switch (status) {\n        case 200:// OK\n            return Code.OK;\n        case 400:// Bad Request\n            return Code.INVALID_ARGUMENT;\n        // Other possibilities based on the forward mapping\n        // return Code.FAILED_PRECONDITION;\n        // return Code.OUT_OF_RANGE;\n        case 401:// Unauthorized\n            return Code.UNAUTHENTICATED;\n        case 403:// Forbidden\n            return Code.PERMISSION_DENIED;\n        case 404:// Not Found\n            return Code.NOT_FOUND;\n        case 409:// Conflict\n            return Code.ABORTED;\n        // Other possibilities:\n        // return Code.ALREADY_EXISTS;\n        case 416:// Range Not Satisfiable\n            return Code.OUT_OF_RANGE;\n        case 429:// Too Many Requests\n            return Code.RESOURCE_EXHAUSTED;\n        case 499:// Client Closed Request\n            return Code.CANCELLED;\n        case 500:// Internal Server Error\n            return Code.UNKNOWN;\n        // Other possibilities:\n        // return Code.INTERNAL;\n        // return Code.DATA_LOSS;\n        case 501:// Unimplemented\n            return Code.UNIMPLEMENTED;\n        case 503:// Service Unavailable\n            return Code.UNAVAILABLE;\n        case 504:// Gateway Timeout\n            return Code.DEADLINE_EXCEEDED;\n        default:\n            if (status >= 200 && status < 300)\n                return Code.OK;\n            if (status >= 400 && status < 500)\n                return Code.FAILED_PRECONDITION;\n            if (status >= 500 && status < 600)\n                return Code.INTERNAL;\n            return Code.UNKNOWN;\n    }\n}\n\n//# sourceMappingURL=rpc_error.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/sorted_set.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * SortedSet is an immutable (copy-on-write) collection that holds elements\n * in order specified by the provided comparator.\n *\n * NOTE: if provided comparator returns 0 for two elements, we consider them to\n * be equal!\n */\nvar sorted_set_SortedSet = /** @class */ (function () {\n    function SortedSet(comparator) {\n        this.comparator = comparator;\n        this.data = new SortedMap(this.comparator);\n    }\n    /**\n     * Creates a SortedSet from the keys of the map.\n     * This is currently implemented as an O(n) copy.\n     */\n    SortedSet.fromMapKeys = function (map) {\n        var keys = new SortedSet(map.comparator);\n        map.forEach(function (key) {\n            keys = keys.add(key);\n        });\n        return keys;\n    };\n    SortedSet.prototype.has = function (elem) {\n        return this.data.get(elem) !== null;\n    };\n    SortedSet.prototype.first = function () {\n        return this.data.minKey();\n    };\n    SortedSet.prototype.last = function () {\n        return this.data.maxKey();\n    };\n    Object.defineProperty(SortedSet.prototype, \"size\", {\n        get: function () {\n            return this.data.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    SortedSet.prototype.indexOf = function (elem) {\n        return this.data.indexOf(elem);\n    };\n    /** Iterates elements in order defined by \"comparator\" */\n    SortedSet.prototype.forEach = function (cb) {\n        this.data.inorderTraversal(function (k, v) {\n            cb(k);\n            return false;\n        });\n    };\n    /** Iterates over `elem`s such that: range[0] <= elem < range[1]. */\n    SortedSet.prototype.forEachInRange = function (range, cb) {\n        var iter = this.data.getIteratorFrom(range[0]);\n        while (iter.hasNext()) {\n            var elem = iter.getNext();\n            if (this.comparator(elem.key, range[1]) >= 0)\n                return;\n            cb(elem.key);\n        }\n    };\n    /**\n     * Iterates over `elem`s such that: start <= elem until false is returned.\n     */\n    SortedSet.prototype.forEachWhile = function (cb, start) {\n        var iter;\n        if (start !== undefined) {\n            iter = this.data.getIteratorFrom(start);\n        }\n        else {\n            iter = this.data.getIterator();\n        }\n        while (iter.hasNext()) {\n            var elem = iter.getNext();\n            var result = cb(elem.key);\n            if (!result)\n                return;\n        }\n    };\n    /** Finds the least element greater than or equal to `elem`. */\n    SortedSet.prototype.firstAfterOrEqual = function (elem) {\n        var iter = this.data.getIteratorFrom(elem);\n        return iter.hasNext() ? iter.getNext().key : null;\n    };\n    /** Inserts or updates an element */\n    SortedSet.prototype.add = function (elem) {\n        return this.copy(this.data.remove(elem).insert(elem, true));\n    };\n    /** Deletes an element */\n    SortedSet.prototype.delete = function (elem) {\n        if (!this.has(elem))\n            return this;\n        return this.copy(this.data.remove(elem));\n    };\n    SortedSet.prototype.isEmpty = function () {\n        return this.data.isEmpty();\n    };\n    SortedSet.prototype.unionWith = function (other) {\n        var result = this;\n        other.forEach(function (elem) {\n            result = result.add(elem);\n        });\n        return result;\n    };\n    SortedSet.prototype.isEqual = function (other) {\n        if (!(other instanceof SortedSet))\n            return false;\n        if (this.size !== other.size)\n            return false;\n        var thisIt = this.data.getIterator();\n        var otherIt = other.data.getIterator();\n        while (thisIt.hasNext()) {\n            var thisElem = thisIt.getNext().key;\n            var otherElem = otherIt.getNext().key;\n            if (this.comparator(thisElem, otherElem) !== 0)\n                return false;\n        }\n        return true;\n    };\n    SortedSet.prototype.toString = function () {\n        var result = [];\n        this.forEach(function (elem) { return result.push(elem); });\n        return 'SortedSet(' + result.toString() + ')';\n    };\n    SortedSet.prototype.copy = function (data) {\n        var result = new SortedSet(this.comparator);\n        result.data = data;\n        return result;\n    };\n    return SortedSet;\n}());\n\n\n//# sourceMappingURL=sorted_set.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/collections.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\nvar EMPTY_MAYBE_DOCUMENT_MAP = new SortedMap(document_key_DocumentKey.comparator);\nfunction maybeDocumentMap() {\n    return EMPTY_MAYBE_DOCUMENT_MAP;\n}\nvar EMPTY_DOCUMENT_MAP = new SortedMap(document_key_DocumentKey.comparator);\nfunction documentMap() {\n    return EMPTY_DOCUMENT_MAP;\n}\nvar EMPTY_DOCUMENT_VERSION_MAP = new SortedMap(document_key_DocumentKey.comparator);\nfunction documentVersionMap() {\n    return EMPTY_DOCUMENT_VERSION_MAP;\n}\nvar EMPTY_DOCUMENT_KEY_SET = new sorted_set_SortedSet(document_key_DocumentKey.comparator);\nfunction documentKeySet() {\n    return EMPTY_DOCUMENT_KEY_SET;\n}\n\n//# sourceMappingURL=collections.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/remote_event.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * An event from the RemoteStore. It is split into targetChanges (changes to the\n * state or the set of documents in our watched targets) and documentUpdates\n * (changes to the actual documents).\n */\nvar remote_event_RemoteEvent = /** @class */ (function () {\n    function RemoteEvent(\n        /**\n         * The snapshot version this event brings us up to, or MIN if not set.\n         */\n        snapshotVersion, \n        /**\n         * A map from target to changes to the target. See TargetChange.\n         */\n        targetChanges, \n        /**\n         * A set of which documents have changed or been deleted, along with the\n         * doc's new values (if not deleted).\n         */\n        documentUpdates) {\n        this.snapshotVersion = snapshotVersion;\n        this.targetChanges = targetChanges;\n        this.documentUpdates = documentUpdates;\n    }\n    RemoteEvent.prototype.addDocumentUpdate = function (doc) {\n        this.documentUpdates = this.documentUpdates.insert(doc.key, doc);\n    };\n    RemoteEvent.prototype.handleExistenceFilterMismatch = function (targetId) {\n        /*\n         * An existence filter mismatch will reset the query and we need to reset\n         * the mapping to contain no documents and an empty resume token.\n         *\n         * Note:\n         *   * The reset mapping is empty, specifically forcing the consumer of the\n         *     change to forget all keys for this targetID;\n         *   * The resume snapshot for this target must be reset\n         *   * The target must be unacked because unwatching and rewatching\n         *     introduces a race for changes.\n         */\n        this.targetChanges[targetId] = {\n            mapping: new ResetMapping(),\n            snapshotVersion: snapshot_version_SnapshotVersion.MIN,\n            currentStatusUpdate: CurrentStatusUpdate.MarkNotCurrent,\n            resumeToken: emptyByteString()\n        };\n    };\n    return RemoteEvent;\n}());\n\n/**\n * Represents an update to the current status of a target, either explicitly\n * having no new state, or the new value to set. Note \"current\" has special\n * meaning for in the RPC protocol that implies that a target is both up-to-date\n * and consistent with the rest of the watch stream.\n */\nvar CurrentStatusUpdate;\n(function (CurrentStatusUpdate) {\n    /** The current status is not affected and should not be modified. */\n    CurrentStatusUpdate[CurrentStatusUpdate[\"None\"] = 0] = \"None\";\n    /** The target must be marked as no longer \"current\". */\n    CurrentStatusUpdate[CurrentStatusUpdate[\"MarkNotCurrent\"] = 1] = \"MarkNotCurrent\";\n    /** The target must be marked as \"current\". */\n    CurrentStatusUpdate[CurrentStatusUpdate[\"MarkCurrent\"] = 2] = \"MarkCurrent\";\n})(CurrentStatusUpdate || (CurrentStatusUpdate = {}));\nvar EMPTY_KEY_SET = documentKeySet();\nvar ResetMapping = /** @class */ (function () {\n    function ResetMapping() {\n        this.docs = EMPTY_KEY_SET;\n    }\n    Object.defineProperty(ResetMapping.prototype, \"documents\", {\n        get: function () {\n            return this.docs;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ResetMapping.prototype.add = function (key) {\n        this.docs = this.docs.add(key);\n    };\n    ResetMapping.prototype.delete = function (key) {\n        this.docs = this.docs.delete(key);\n    };\n    ResetMapping.prototype.isEqual = function (other) {\n        return other !== null && this.docs.isEqual(other.docs);\n    };\n    return ResetMapping;\n}());\n\nvar UpdateMapping = /** @class */ (function () {\n    function UpdateMapping() {\n        this.addedDocuments = EMPTY_KEY_SET;\n        this.removedDocuments = EMPTY_KEY_SET;\n    }\n    UpdateMapping.prototype.applyToKeySet = function (keys) {\n        var result = keys;\n        this.addedDocuments.forEach(function (key) { return (result = result.add(key)); });\n        this.removedDocuments.forEach(function (key) { return (result = result.delete(key)); });\n        return result;\n    };\n    UpdateMapping.prototype.add = function (key) {\n        this.addedDocuments = this.addedDocuments.add(key);\n        this.removedDocuments = this.removedDocuments.delete(key);\n    };\n    UpdateMapping.prototype.delete = function (key) {\n        this.addedDocuments = this.addedDocuments.delete(key);\n        this.removedDocuments = this.removedDocuments.add(key);\n    };\n    UpdateMapping.prototype.isEqual = function (other) {\n        return (other !== null &&\n            this.addedDocuments.isEqual(other.addedDocuments) &&\n            this.removedDocuments.isEqual(other.removedDocuments));\n    };\n    return UpdateMapping;\n}());\n\n\n//# sourceMappingURL=remote_event.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/watch_change.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n/**\n * Represents a changed document and a list of target ids to which this change\n * applies.\n *\n * If document has been deleted NoDocument will be provided.\n */\nvar DocumentWatchChange = /** @class */ (function () {\n    function DocumentWatchChange(\n        /** The new document applies to all of these targets. */\n        updatedTargetIds, \n        /** The new document is removed from all of these targets. */\n        removedTargetIds, \n        /** The key of the document for this change. */\n        key, \n        /**\n         * The new document or NoDocument if it was deleted. Is null if the\n         * document went out of view without the server sending a new document.\n         */\n        newDoc) {\n        this.updatedTargetIds = updatedTargetIds;\n        this.removedTargetIds = removedTargetIds;\n        this.key = key;\n        this.newDoc = newDoc;\n    }\n    return DocumentWatchChange;\n}());\n\nvar ExistenceFilterChange = /** @class */ (function () {\n    function ExistenceFilterChange(targetId, existenceFilter) {\n        this.targetId = targetId;\n        this.existenceFilter = existenceFilter;\n    }\n    return ExistenceFilterChange;\n}());\n\nvar WatchTargetChangeState;\n(function (WatchTargetChangeState) {\n    WatchTargetChangeState[WatchTargetChangeState[\"NoChange\"] = 0] = \"NoChange\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Added\"] = 1] = \"Added\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Removed\"] = 2] = \"Removed\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Current\"] = 3] = \"Current\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Reset\"] = 4] = \"Reset\";\n})(WatchTargetChangeState || (WatchTargetChangeState = {}));\nvar watch_change_WatchTargetChange = /** @class */ (function () {\n    function WatchTargetChange(\n        /** What kind of change occurred to the watch target. */\n        state, \n        /** The target IDs that were added/removed/set. */\n        targetIds, \n        /**\n         * An opaque, server-assigned token that allows watching a query to be\n         * resumed after disconnecting without retransmitting all the data that\n         * matches the query. The resume token essentially identifies a point in\n         * time from which the server should resume sending results.\n         */\n        resumeToken, \n        /** An RPC error indicating why the watch failed. */\n        cause) {\n        if (resumeToken === void 0) { resumeToken = emptyByteString(); }\n        if (cause === void 0) { cause = null; }\n        this.state = state;\n        this.targetIds = targetIds;\n        this.resumeToken = resumeToken;\n        this.cause = cause;\n    }\n    return WatchTargetChange;\n}());\n\n/**\n * A helper class to accumulate watch changes into a RemoteEvent and other\n * target information.\n */\nvar watch_change_WatchChangeAggregator = /** @class */ (function () {\n    function WatchChangeAggregator(snapshotVersion, listenTargets, pendingTargetResponses) {\n        this.snapshotVersion = snapshotVersion;\n        this.listenTargets = listenTargets;\n        /** The existence filter - if any - for the given target IDs. */\n        this.existenceFilters = {};\n        /** Keeps track of the current target mappings */\n        this.targetChanges = {};\n        /** Keeps track of document to update */\n        this.documentUpdates = maybeDocumentMap();\n        /** Whether this aggregator was frozen and can no longer be modified */\n        this.frozen = false;\n        this.pendingTargetResponses = shallowCopy(pendingTargetResponses);\n    }\n    /** Aggregates a watch change into the current state */\n    WatchChangeAggregator.prototype.add = function (watchChange) {\n        assert(!this.frozen, 'Trying to modify frozen WatchChangeAggregator.');\n        if (watchChange instanceof DocumentWatchChange) {\n            this.addDocumentChange(watchChange);\n        }\n        else if (watchChange instanceof watch_change_WatchTargetChange) {\n            this.addTargetChange(watchChange);\n        }\n        else if (watchChange instanceof ExistenceFilterChange) {\n            this.addExistenceFilterChange(watchChange);\n        }\n        else {\n            fail('Unknown watch change: ' + watchChange);\n        }\n    };\n    /** Aggregates all provided watch changes to the current state in order */\n    WatchChangeAggregator.prototype.addChanges = function (watchChanges) {\n        var _this = this;\n        assert(!this.frozen, 'Trying to modify frozen WatchChangeAggregator.');\n        watchChanges.forEach(function (change) { return _this.add(change); });\n    };\n    /**\n     * Converts the current state into a remote event with the snapshot version\n     * provided via the constructor.\n     */\n    WatchChangeAggregator.prototype.createRemoteEvent = function () {\n        var _this = this;\n        var targetChanges = this.targetChanges;\n        // Remove all the non-active targets from the remote event.\n        forEachNumber(this.targetChanges, function (targetId) {\n            if (!_this.isActiveTarget(targetId)) {\n                delete targetChanges[targetId];\n            }\n        });\n        // Mark this aggregator as frozen so no further modifications are made\n        this.frozen = true;\n        return new remote_event_RemoteEvent(this.snapshotVersion, targetChanges, this.documentUpdates);\n    };\n    WatchChangeAggregator.prototype.ensureTargetChange = function (targetId) {\n        var change = this.targetChanges[targetId];\n        if (!change) {\n            // Create an UpdateMapping by default, since resets are always explicit.\n            change = {\n                currentStatusUpdate: CurrentStatusUpdate.None,\n                snapshotVersion: this.snapshotVersion,\n                mapping: new UpdateMapping(),\n                resumeToken: emptyByteString()\n            };\n            this.targetChanges[targetId] = change;\n        }\n        return change;\n    };\n    /**\n     * We need to wait for watch to ack targets before we process those events,\n     * so to know if a target is active, there must be no pending acks we're\n     * waiting for and it must be in the current list of targets that the client\n     * cares about.\n     *\n     * This method is visible for testing.\n     */\n    WatchChangeAggregator.prototype.isActiveTarget = function (targetId) {\n        return (!contains(this.pendingTargetResponses, targetId) &&\n            contains(this.listenTargets, targetId));\n    };\n    WatchChangeAggregator.prototype.addDocumentChange = function (docChange) {\n        var relevant = false;\n        for (var _i = 0, _a = docChange.updatedTargetIds; _i < _a.length; _i++) {\n            var targetId = _a[_i];\n            if (this.isActiveTarget(targetId)) {\n                var change = this.ensureTargetChange(targetId);\n                change.mapping.add(docChange.key);\n                relevant = true;\n            }\n        }\n        for (var _b = 0, _c = docChange.removedTargetIds; _b < _c.length; _b++) {\n            var targetId = _c[_b];\n            if (this.isActiveTarget(targetId)) {\n                var change = this.ensureTargetChange(targetId);\n                change.mapping.delete(docChange.key);\n                relevant = true;\n            }\n        }\n        // Only update the document if there is a new document to replace to an\n        // active target that is being listened to, this might be just a target\n        // update instead.\n        if (docChange.newDoc && relevant) {\n            this.documentUpdates = this.documentUpdates.insert(docChange.key, docChange.newDoc);\n        }\n    };\n    WatchChangeAggregator.prototype.addTargetChange = function (targetChange) {\n        var _this = this;\n        targetChange.targetIds.forEach(function (targetId) {\n            var change = _this.ensureTargetChange(targetId);\n            switch (targetChange.state) {\n                case WatchTargetChangeState.NoChange:\n                    if (_this.isActiveTarget(targetId)) {\n                        // Creating the change above satisfies the semantics of no-change.\n                        applyResumeToken(change, targetChange.resumeToken);\n                    }\n                    break;\n                case WatchTargetChangeState.Added:\n                    // We need to decrement the number of pending acks needed from watch\n                    // for this targetId.\n                    _this.recordTargetResponse(targetId);\n                    if (!contains(_this.pendingTargetResponses, targetId)) {\n                        // We have a freshly added target, so we need to reset any state\n                        // that we had previously This can happen e.g. when remove and add\n                        // back a target for existence filter mismatches.\n                        change.mapping = new UpdateMapping();\n                        change.currentStatusUpdate = CurrentStatusUpdate.None;\n                        delete _this.existenceFilters[targetId];\n                    }\n                    applyResumeToken(change, targetChange.resumeToken);\n                    break;\n                case WatchTargetChangeState.Removed:\n                    // We need to keep track of removed targets to we can\n                    // post-filter and remove any target changes.\n                    // We need to decrement the number of pending acks needed from watch\n                    // for this targetId.\n                    _this.recordTargetResponse(targetId);\n                    assert(!targetChange.cause, 'WatchChangeAggregator does not handle errored targets');\n                    break;\n                case WatchTargetChangeState.Current:\n                    if (_this.isActiveTarget(targetId)) {\n                        change.currentStatusUpdate = CurrentStatusUpdate.MarkCurrent;\n                        applyResumeToken(change, targetChange.resumeToken);\n                    }\n                    break;\n                case WatchTargetChangeState.Reset:\n                    if (_this.isActiveTarget(targetId)) {\n                        // Overwrite any existing target mapping with a reset\n                        // mapping. Every subsequent update will modify the reset\n                        // mapping, not an update mapping.\n                        change.mapping = new ResetMapping();\n                        applyResumeToken(change, targetChange.resumeToken);\n                    }\n                    break;\n                default:\n                    fail('Unknown target watch change state: ' + targetChange.state);\n            }\n        });\n    };\n    /**\n     * Record that we get a watch target add/remove by decrementing the number of\n     * pending target responses that we have.\n     */\n    WatchChangeAggregator.prototype.recordTargetResponse = function (targetId) {\n        var newCount = (this.pendingTargetResponses[targetId] || 0) - 1;\n        if (newCount === 0) {\n            delete this.pendingTargetResponses[targetId];\n        }\n        else {\n            this.pendingTargetResponses[targetId] = newCount;\n        }\n    };\n    WatchChangeAggregator.prototype.addExistenceFilterChange = function (change) {\n        if (this.isActiveTarget(change.targetId)) {\n            this.existenceFilters[change.targetId] = change.existenceFilter;\n        }\n    };\n    return WatchChangeAggregator;\n}());\n\n/**\n * Applies the resume token to the TargetChange, but only when it has a new\n * value. null and empty resumeTokens are discarded.\n */\nfunction applyResumeToken(change, resumeToken) {\n    if (resumeToken.length > 0) {\n        change.resumeToken = resumeToken;\n    }\n}\n\n//# sourceMappingURL=watch_change.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/serializer.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar DIRECTIONS = (function () {\n    var dirs = {};\n    dirs[Direction.ASCENDING.name] = 'ASCENDING';\n    dirs[Direction.DESCENDING.name] = 'DESCENDING';\n    return dirs;\n})();\nvar OPERATORS = (function () {\n    var ops = {};\n    ops[query_RelationOp.LESS_THAN.name] = 'LESS_THAN';\n    ops[query_RelationOp.LESS_THAN_OR_EQUAL.name] = 'LESS_THAN_OR_EQUAL';\n    ops[query_RelationOp.GREATER_THAN.name] = 'GREATER_THAN';\n    ops[query_RelationOp.GREATER_THAN_OR_EQUAL.name] = 'GREATER_THAN_OR_EQUAL';\n    ops[query_RelationOp.EQUAL.name] = 'EQUAL';\n    return ops;\n})();\nfunction assertPresent(value, description) {\n    assert(!isNullOrUndefined(value), description + ' is missing');\n}\nfunction parseInt64(value) {\n    // TODO(bjornick): Handle int64 greater than 53 bits.\n    if (typeof value === 'number') {\n        return value;\n    }\n    else if (typeof value === 'string') {\n        return Number(value);\n    }\n    else {\n        return fail(\"can't parse \" + value);\n    }\n}\n/**\n * Generates JsonObject values for the Datastore API suitable for sending to\n * either GRPC stub methods or via the JSON/HTTP REST API.\n * TODO(klimt): We can remove the databaseId argument if we keep the full\n * resource name in documents.\n */\nvar serializer_JsonProtoSerializer = /** @class */ (function () {\n    function JsonProtoSerializer(databaseId, options) {\n        this.databaseId = databaseId;\n        this.options = options;\n    }\n    JsonProtoSerializer.prototype.emptyByteString = function () {\n        if (this.options.useProto3Json) {\n            return '';\n        }\n        else {\n            return new Uint8Array(0);\n        }\n    };\n    JsonProtoSerializer.prototype.unsafeCastProtoByteString = function (byteString) {\n        // byteStrings can be either string or UInt8Array, but the typings say\n        // it's always a string. Cast as string to avoid type check failing\n        return byteString;\n    };\n    JsonProtoSerializer.prototype.fromRpcStatus = function (status) {\n        var code = status.code === undefined\n            ? Code.UNKNOWN\n            : mapCodeFromRpcCode(status.code);\n        return new FirestoreError(code, status.message || '');\n    };\n    /**\n     * Returns a value for a number (or undefined) that's appropriate to put into\n     * a google.protobuf.Int32Value proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as returning \"number\" because that's what\n     * our generated proto interfaces say Int32Value must be. But GRPC actually\n     * expects a { value: <number> } struct.\n     */\n    JsonProtoSerializer.prototype.toInt32Value = function (val) {\n        if (!isNullOrUndefined(val)) {\n            // tslint:disable-next-line:no-any We need to match generated Proto types.\n            return { value: val };\n        }\n        else {\n            return undefined;\n        }\n    };\n    /**\n     * Returns a number (or null) from a google.protobuf.Int32Value proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as accepting \"number\" because that's what\n     * our generated proto interfaces say Int32Value must be, but it actually\n     * accepts { value: number } to match our serialization in toInt32Value().\n     */\n    JsonProtoSerializer.prototype.fromInt32Value = function (val) {\n        var result;\n        if (typeof val === 'object') {\n            // tslint:disable-next-line:no-any We need to match generated Proto types.\n            result = val.value;\n        }\n        else {\n            // We accept raw numbers (without the {value: ... } wrapper) for\n            // compatibility with legacy persisted data.\n            result = val;\n        }\n        return isNullOrUndefined(result) ? null : result;\n    };\n    /**\n     * Returns a value for a Date that's appropriate to put into a proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as returning \"string\" because that's what\n     * our generated proto interfaces say dates must be. But it's easier and safer\n     * to actually return a Timestamp proto.\n     */\n    JsonProtoSerializer.prototype.toTimestamp = function (timestamp) {\n        return {\n            seconds: timestamp.seconds,\n            nanos: timestamp.nanos\n            // tslint:disable-next-line:no-any\n        };\n    };\n    JsonProtoSerializer.prototype.fromTimestamp = function (date) {\n        // The json interface (for the browser) will return an iso timestamp string,\n        // while the proto js library (for node) will return a\n        // google.protobuf.Timestamp instance.\n        if (typeof date === 'string') {\n            // TODO(b/37282237): Use strings for Proto3 timestamps\n            // assert(this.options.useProto3Json,\n            //   'The timestamp string format requires Proto3.');\n            return timestamp_Timestamp.fromISOString(date);\n        }\n        else {\n            assert(!!date, 'Cannot deserialize null or undefined timestamp.');\n            // TODO(b/37282237): Use strings for Proto3 timestamps\n            // assert(!this.options.useProto3Json,\n            //   'The timestamp instance format requires Proto JS.');\n            var seconds = parseInt64(date.seconds || '0');\n            var nanos = date.nanos || 0;\n            return new timestamp_Timestamp(seconds, nanos);\n        }\n    };\n    /**\n     * Returns a value for bytes that's appropriate to put in a proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as returning \"string\" because that's what\n     * our generated proto interfaces say bytes must be. But it should return\n     * an Uint8Array in Node.\n     */\n    JsonProtoSerializer.prototype.toBytes = function (bytes) {\n        if (this.options.useProto3Json) {\n            return bytes.toBase64();\n        }\n        else {\n            // The typings say it's a string, but it needs to be a Uint8Array in Node.\n            return this.unsafeCastProtoByteString(bytes.toUint8Array());\n        }\n    };\n    /**\n     * Parse the blob from the protos into the internal Blob class. Note that the\n     * typings assume all blobs are strings, but they are actually Uint8Arrays\n     * on Node.\n     */\n    JsonProtoSerializer.prototype.fromBlob = function (blob) {\n        if (typeof blob === 'string') {\n            assert(this.options.useProto3Json, 'Expected bytes to be passed in as Uint8Array, but got a string instead.');\n            return blob_Blob.fromBase64String(blob);\n        }\n        else {\n            assert(!this.options.useProto3Json, 'Expected bytes to be passed in as string, but got something else instead.');\n            return blob_Blob.fromUint8Array(blob);\n        }\n    };\n    JsonProtoSerializer.prototype.toVersion = function (version) {\n        return this.toTimestamp(version.toTimestamp());\n    };\n    JsonProtoSerializer.prototype.fromVersion = function (version) {\n        assert(!!version, \"Trying to deserialize version that isn't set\");\n        return snapshot_version_SnapshotVersion.fromTimestamp(this.fromTimestamp(version));\n    };\n    JsonProtoSerializer.prototype.toResourceName = function (databaseId, path) {\n        return this.fullyQualifiedPrefixPath(databaseId)\n            .child('documents')\n            .child(path)\n            .canonicalString();\n    };\n    JsonProtoSerializer.prototype.fromResourceName = function (name) {\n        var resource = path_ResourcePath.fromString(name);\n        assert(this.isValidResourceName(resource), 'Tried to deserialize invalid key ' + resource.toString());\n        return resource;\n    };\n    JsonProtoSerializer.prototype.toName = function (key) {\n        return this.toResourceName(this.databaseId, key.path);\n    };\n    JsonProtoSerializer.prototype.fromName = function (name) {\n        var resource = this.fromResourceName(name);\n        assert(resource.get(1) === this.databaseId.projectId, 'Tried to deserialize key from different project: ' +\n            resource.get(1) +\n            ' vs ' +\n            this.databaseId.projectId);\n        assert((!resource.get(3) && !this.databaseId.database) ||\n            resource.get(3) === this.databaseId.database, 'Tried to deserialize key from different database: ' +\n            resource.get(3) +\n            ' vs ' +\n            this.databaseId.database);\n        return new document_key_DocumentKey(this.extractLocalPathFromResourceName(resource));\n    };\n    JsonProtoSerializer.prototype.toQueryPath = function (path) {\n        if (path.length === 0) {\n            // If the path is empty, the backend requires we leave off the /documents\n            // at the end.\n            return this.encodedDatabaseId;\n        }\n        return this.toResourceName(this.databaseId, path);\n    };\n    JsonProtoSerializer.prototype.fromQueryPath = function (name) {\n        var resourceName = this.fromResourceName(name);\n        if (resourceName.length === 4) {\n            return path_ResourcePath.EMPTY_PATH;\n        }\n        return this.extractLocalPathFromResourceName(resourceName);\n    };\n    Object.defineProperty(JsonProtoSerializer.prototype, \"encodedDatabaseId\", {\n        get: function () {\n            var path = new path_ResourcePath([\n                'projects',\n                this.databaseId.projectId,\n                'databases',\n                this.databaseId.database\n            ]);\n            return path.canonicalString();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    JsonProtoSerializer.prototype.fullyQualifiedPrefixPath = function (databaseId) {\n        return new path_ResourcePath([\n            'projects',\n            databaseId.projectId,\n            'databases',\n            databaseId.database\n        ]);\n    };\n    JsonProtoSerializer.prototype.extractLocalPathFromResourceName = function (resourceName) {\n        assert(resourceName.length > 4 && resourceName.get(4) === 'documents', 'tried to deserialize invalid key ' + resourceName.toString());\n        return resourceName.popFirst(5);\n    };\n    JsonProtoSerializer.prototype.isValidResourceName = function (path) {\n        // Resource names have at least 4 components (project ID, database ID)\n        return (path.length >= 4 &&\n            path.get(0) === 'projects' &&\n            path.get(2) === 'databases');\n    };\n    JsonProtoSerializer.prototype.toValue = function (val) {\n        if (val instanceof NullValue) {\n            return { nullValue: 'NULL_VALUE' };\n        }\n        else if (val instanceof field_value_BooleanValue) {\n            return { booleanValue: val.value() };\n        }\n        else if (val instanceof IntegerValue) {\n            return { integerValue: '' + val.value() };\n        }\n        else if (val instanceof DoubleValue) {\n            var doubleValue = val.value();\n            if (this.options.useProto3Json) {\n                // Proto 3 let's us encode NaN and Infinity as string values as\n                // expected by the backend. This is currently not checked by our unit\n                // tests because they rely on protobuf.js.\n                if (isNaN(doubleValue)) {\n                    return { doubleValue: 'NaN' };\n                }\n                else if (doubleValue === Infinity) {\n                    return { doubleValue: 'Infinity' };\n                }\n                else if (doubleValue === -Infinity) {\n                    return { doubleValue: '-Infinity' };\n                }\n            }\n            return { doubleValue: val.value() };\n        }\n        else if (val instanceof field_value_StringValue) {\n            return { stringValue: val.value() };\n        }\n        else if (val instanceof field_value_ObjectValue) {\n            return { mapValue: this.toMapValue(val) };\n        }\n        else if (val instanceof field_value_ArrayValue) {\n            return { arrayValue: this.toArrayValue(val) };\n        }\n        else if (val instanceof TimestampValue) {\n            return {\n                timestampValue: this.toTimestamp(val.internalValue)\n            };\n        }\n        else if (val instanceof GeoPointValue) {\n            return {\n                geoPointValue: {\n                    latitude: val.value().latitude,\n                    longitude: val.value().longitude\n                }\n            };\n        }\n        else if (val instanceof BlobValue) {\n            return {\n                bytesValue: this.toBytes(val.value())\n            };\n        }\n        else if (val instanceof field_value_RefValue) {\n            return {\n                referenceValue: this.toResourceName(val.databaseId, val.key.path)\n            };\n        }\n        else {\n            return fail('Unknown FieldValue ' + JSON.stringify(val));\n        }\n    };\n    JsonProtoSerializer.prototype.fromValue = function (obj) {\n        var _this = this;\n        // tslint:disable-next-line:no-any\n        var type = obj['value_type'];\n        if (hasTag(obj, type, 'nullValue')) {\n            return NullValue.INSTANCE;\n        }\n        else if (hasTag(obj, type, 'booleanValue')) {\n            return field_value_BooleanValue.of(obj.booleanValue);\n        }\n        else if (hasTag(obj, type, 'integerValue')) {\n            return new IntegerValue(parseInt64(obj.integerValue));\n        }\n        else if (hasTag(obj, type, 'doubleValue')) {\n            if (this.options.useProto3Json) {\n                // Proto 3 uses the string values 'NaN' and 'Infinity'.\n                if (obj.doubleValue === 'NaN') {\n                    return DoubleValue.NAN;\n                }\n                else if (obj.doubleValue === 'Infinity') {\n                    return DoubleValue.POSITIVE_INFINITY;\n                }\n                else if (obj.doubleValue === '-Infinity') {\n                    return DoubleValue.NEGATIVE_INFINITY;\n                }\n            }\n            return new DoubleValue(obj.doubleValue);\n        }\n        else if (hasTag(obj, type, 'stringValue')) {\n            return new field_value_StringValue(obj.stringValue);\n        }\n        else if (hasTag(obj, type, 'mapValue')) {\n            return this.fromFields(obj.mapValue.fields || {});\n        }\n        else if (hasTag(obj, type, 'arrayValue')) {\n            // \"values\" is not present if the array is empty\n            assertPresent(obj.arrayValue, 'arrayValue');\n            var values = obj.arrayValue.values || [];\n            return new field_value_ArrayValue(values.map(function (v) { return _this.fromValue(v); }));\n        }\n        else if (hasTag(obj, type, 'timestampValue')) {\n            assertPresent(obj.timestampValue, 'timestampValue');\n            return new TimestampValue(this.fromTimestamp(obj.timestampValue));\n        }\n        else if (hasTag(obj, type, 'geoPointValue')) {\n            assertPresent(obj.geoPointValue, 'geoPointValue');\n            var latitude = obj.geoPointValue.latitude || 0;\n            var longitude = obj.geoPointValue.longitude || 0;\n            return new GeoPointValue(new geo_point_GeoPoint(latitude, longitude));\n        }\n        else if (hasTag(obj, type, 'bytesValue')) {\n            assertPresent(obj.bytesValue, 'bytesValue');\n            var blob = this.fromBlob(obj.bytesValue);\n            return new BlobValue(blob);\n        }\n        else if (hasTag(obj, type, 'referenceValue')) {\n            assertPresent(obj.referenceValue, 'referenceValue');\n            var resourceName = this.fromResourceName(obj.referenceValue);\n            var dbId = new database_info_DatabaseId(resourceName.get(1), resourceName.get(3));\n            var key = new document_key_DocumentKey(this.extractLocalPathFromResourceName(resourceName));\n            return new field_value_RefValue(dbId, key);\n        }\n        else {\n            return fail('Unknown Value proto ' + JSON.stringify(obj));\n        }\n    };\n    /** Creates an api.Document from key and fields (but no create/update time) */\n    JsonProtoSerializer.prototype.toMutationDocument = function (key, fields) {\n        return {\n            name: this.toName(key),\n            fields: this.toFields(fields)\n        };\n    };\n    JsonProtoSerializer.prototype.toDocument = function (document) {\n        assert(!document.hasLocalMutations, \"Can't serialize documents with mutations.\");\n        return {\n            name: this.toName(document.key),\n            fields: this.toFields(document.data),\n            updateTime: this.toTimestamp(document.version.toTimestamp())\n        };\n    };\n    JsonProtoSerializer.prototype.fromDocument = function (document) {\n        return new document_Document(this.fromName(document.name), this.fromVersion(document.updateTime), this.fromFields(document.fields || {}), { hasLocalMutations: false });\n    };\n    JsonProtoSerializer.prototype.toFields = function (fields) {\n        var _this = this;\n        var result = {};\n        fields.forEach(function (key, value) {\n            result[key] = _this.toValue(value);\n        });\n        return result;\n    };\n    JsonProtoSerializer.prototype.fromFields = function (object) {\n        var _this = this;\n        // Proto map<string, Value> gets mapped to Object, so cast it.\n        var map = object;\n        var result = field_value_ObjectValue.EMPTY;\n        forEach(map, function (key, value) {\n            result = result.set(new path_FieldPath([key]), _this.fromValue(value));\n        });\n        return result;\n    };\n    JsonProtoSerializer.prototype.toMapValue = function (map) {\n        return {\n            fields: this.toFields(map)\n        };\n    };\n    JsonProtoSerializer.prototype.toArrayValue = function (array) {\n        var _this = this;\n        var result = [];\n        array.forEach(function (value) {\n            result.push(_this.toValue(value));\n        });\n        return { values: result };\n    };\n    JsonProtoSerializer.prototype.fromFound = function (doc) {\n        assert(!!doc.found, 'Tried to deserialize a found document from a missing document.');\n        assertPresent(doc.found.name, 'doc.found.name');\n        assertPresent(doc.found.updateTime, 'doc.found.updateTime');\n        var key = this.fromName(doc.found.name);\n        var version = this.fromVersion(doc.found.updateTime);\n        var fields = this.fromFields(doc.found.fields || {});\n        return new document_Document(key, version, fields, { hasLocalMutations: false });\n    };\n    JsonProtoSerializer.prototype.fromMissing = function (result) {\n        assert(!!result.missing, 'Tried to deserialize a missing document from a found document.');\n        assert(!!result.readTime, 'Tried to deserialize a missing document without a read time.');\n        var key = this.fromName(result.missing);\n        var version = this.fromVersion(result.readTime);\n        return new document_NoDocument(key, version);\n    };\n    JsonProtoSerializer.prototype.fromMaybeDocument = function (result) {\n        // tslint:disable-next-line:no-any\n        var type = result['result'];\n        if (hasTag(result, type, 'found')) {\n            return this.fromFound(result);\n        }\n        else if (hasTag(result, type, 'missing')) {\n            return this.fromMissing(result);\n        }\n        return fail('invalid batch get response: ' + JSON.stringify(result));\n    };\n    JsonProtoSerializer.prototype.toWatchTargetChangeState = function (state) {\n        switch (state) {\n            case WatchTargetChangeState.Added:\n                return 'ADD';\n            case WatchTargetChangeState.Current:\n                return 'CURRENT';\n            case WatchTargetChangeState.NoChange:\n                return 'NO_CHANGE';\n            case WatchTargetChangeState.Removed:\n                return 'REMOVE';\n            case WatchTargetChangeState.Reset:\n                return 'RESET';\n            default:\n                return fail('Unknown WatchTargetChangeState: ' + state);\n        }\n    };\n    JsonProtoSerializer.prototype.toTestWatchChange = function (watchChange) {\n        if (watchChange instanceof ExistenceFilterChange) {\n            return {\n                filter: {\n                    count: watchChange.existenceFilter.count,\n                    targetId: watchChange.targetId\n                }\n            };\n        }\n        if (watchChange instanceof DocumentWatchChange) {\n            if (watchChange.newDoc instanceof document_Document) {\n                var doc = watchChange.newDoc;\n                return {\n                    documentChange: {\n                        document: {\n                            name: this.toName(doc.key),\n                            fields: this.toFields(doc.data),\n                            updateTime: this.toVersion(doc.version)\n                        },\n                        targetIds: watchChange.updatedTargetIds,\n                        removedTargetIds: watchChange.removedTargetIds\n                    }\n                };\n            }\n            else if (watchChange.newDoc instanceof document_NoDocument) {\n                var doc = watchChange.newDoc;\n                return {\n                    documentDelete: {\n                        document: this.toName(doc.key),\n                        readTime: this.toVersion(doc.version),\n                        removedTargetIds: watchChange.removedTargetIds\n                    }\n                };\n            }\n            else if (watchChange.newDoc === null) {\n                return {\n                    documentRemove: {\n                        document: this.toName(watchChange.key),\n                        removedTargetIds: watchChange.removedTargetIds\n                    }\n                };\n            }\n        }\n        if (watchChange instanceof watch_change_WatchTargetChange) {\n            var cause = undefined;\n            if (watchChange.cause) {\n                cause = {\n                    code: mapRpcCodeFromCode(watchChange.cause.code),\n                    message: watchChange.cause.message\n                };\n            }\n            return {\n                targetChange: {\n                    targetChangeType: this.toWatchTargetChangeState(watchChange.state),\n                    targetIds: watchChange.targetIds,\n                    resumeToken: this.unsafeCastProtoByteString(watchChange.resumeToken),\n                    cause: cause\n                }\n            };\n        }\n        return fail('Unrecognized watch change: ' + JSON.stringify(watchChange));\n    };\n    JsonProtoSerializer.prototype.fromWatchChange = function (change) {\n        // tslint:disable-next-line:no-any\n        var type = change['response_type'];\n        var watchChange;\n        if (hasTag(change, type, 'targetChange')) {\n            assertPresent(change.targetChange, 'targetChange');\n            // proto3 default value is unset in JSON (undefined), so use 'NO_CHANGE'\n            // if unset\n            var state = this.fromWatchTargetChangeState(change.targetChange.targetChangeType || 'NO_CHANGE');\n            var targetIds = change.targetChange.targetIds || [];\n            var resumeToken = change.targetChange.resumeToken || this.emptyByteString();\n            var causeProto = change.targetChange.cause;\n            var cause = causeProto && this.fromRpcStatus(causeProto);\n            watchChange = new watch_change_WatchTargetChange(state, targetIds, resumeToken, cause || null);\n        }\n        else if (hasTag(change, type, 'documentChange')) {\n            assertPresent(change.documentChange, 'documentChange');\n            assertPresent(change.documentChange.document, 'documentChange.name');\n            assertPresent(change.documentChange.document.name, 'documentChange.document.name');\n            assertPresent(change.documentChange.document.updateTime, 'documentChange.document.updateTime');\n            var entityChange = change.documentChange;\n            var key = this.fromName(entityChange.document.name);\n            var version = this.fromVersion(entityChange.document.updateTime);\n            var fields = this.fromFields(entityChange.document.fields || {});\n            var doc = new document_Document(key, version, fields, {\n                hasLocalMutations: false\n            });\n            var updatedTargetIds = entityChange.targetIds || [];\n            var removedTargetIds = entityChange.removedTargetIds || [];\n            watchChange = new DocumentWatchChange(updatedTargetIds, removedTargetIds, doc.key, doc);\n        }\n        else if (hasTag(change, type, 'documentDelete')) {\n            assertPresent(change.documentDelete, 'documentDelete');\n            assertPresent(change.documentDelete.document, 'documentDelete.document');\n            var docDelete = change.documentDelete;\n            var key = this.fromName(docDelete.document);\n            var version = docDelete.readTime\n                ? this.fromVersion(docDelete.readTime)\n                : snapshot_version_SnapshotVersion.forDeletedDoc();\n            var doc = new document_NoDocument(key, version);\n            var removedTargetIds = docDelete.removedTargetIds || [];\n            watchChange = new DocumentWatchChange([], removedTargetIds, doc.key, doc);\n        }\n        else if (hasTag(change, type, 'documentRemove')) {\n            assertPresent(change.documentRemove, 'documentRemove');\n            assertPresent(change.documentRemove.document, 'documentRemove');\n            var docRemove = change.documentRemove;\n            var key = this.fromName(docRemove.document);\n            var removedTargetIds = docRemove.removedTargetIds || [];\n            watchChange = new DocumentWatchChange([], removedTargetIds, key, null);\n        }\n        else if (hasTag(change, type, 'filter')) {\n            // TODO(dimond): implement existence filter parsing with strategy.\n            assertPresent(change.filter, 'filter');\n            assertPresent(change.filter.targetId, 'filter.targetId');\n            var filter = change.filter;\n            var count = filter.count || 0;\n            var existenceFilter = new ExistenceFilter(count);\n            var targetId = filter.targetId;\n            watchChange = new ExistenceFilterChange(targetId, existenceFilter);\n        }\n        else {\n            return fail('Unknown change type ' + JSON.stringify(change));\n        }\n        return watchChange;\n    };\n    JsonProtoSerializer.prototype.fromWatchTargetChangeState = function (state) {\n        if (state === 'NO_CHANGE') {\n            return WatchTargetChangeState.NoChange;\n        }\n        else if (state === 'ADD') {\n            return WatchTargetChangeState.Added;\n        }\n        else if (state === 'REMOVE') {\n            return WatchTargetChangeState.Removed;\n        }\n        else if (state === 'CURRENT') {\n            return WatchTargetChangeState.Current;\n        }\n        else if (state === 'RESET') {\n            return WatchTargetChangeState.Reset;\n        }\n        else {\n            return fail('Got unexpected TargetChange.state: ' + state);\n        }\n    };\n    JsonProtoSerializer.prototype.versionFromListenResponse = function (change) {\n        // We have only reached a consistent snapshot for the entire stream if there\n        // is a read_time set and it applies to all targets (i.e. the list of\n        // targets is empty). The backend is guaranteed to send such responses.\n        // tslint:disable-next-line:no-any\n        var type = change['response_type'];\n        if (!hasTag(change, type, 'targetChange')) {\n            return snapshot_version_SnapshotVersion.MIN;\n        }\n        var targetChange = change.targetChange;\n        if (targetChange.targetIds && targetChange.targetIds.length) {\n            return snapshot_version_SnapshotVersion.MIN;\n        }\n        if (!targetChange.readTime) {\n            return snapshot_version_SnapshotVersion.MIN;\n        }\n        return this.fromVersion(targetChange.readTime);\n    };\n    JsonProtoSerializer.prototype.toMutation = function (mutation) {\n        var _this = this;\n        var result;\n        if (mutation instanceof mutation_SetMutation) {\n            result = {\n                update: this.toMutationDocument(mutation.key, mutation.value)\n            };\n        }\n        else if (mutation instanceof mutation_DeleteMutation) {\n            result = { delete: this.toName(mutation.key) };\n        }\n        else if (mutation instanceof mutation_PatchMutation) {\n            result = {\n                update: this.toMutationDocument(mutation.key, mutation.data),\n                updateMask: this.toDocumentMask(mutation.fieldMask)\n            };\n        }\n        else if (mutation instanceof mutation_TransformMutation) {\n            result = {\n                transform: {\n                    document: this.toName(mutation.key),\n                    fieldTransforms: mutation.fieldTransforms.map(function (transform) {\n                        return _this.toFieldTransform(transform);\n                    })\n                }\n            };\n        }\n        else {\n            return fail('Unknown mutation type ' + mutation.type);\n        }\n        if (!mutation.precondition.isNone) {\n            result.currentDocument = this.toPrecondition(mutation.precondition);\n        }\n        return result;\n    };\n    JsonProtoSerializer.prototype.fromMutation = function (proto) {\n        var _this = this;\n        var precondition = proto.currentDocument\n            ? this.fromPrecondition(proto.currentDocument)\n            : mutation_Precondition.NONE;\n        if (proto.update) {\n            assertPresent(proto.update.name, 'name');\n            var key = this.fromName(proto.update.name);\n            var value = this.fromFields(proto.update.fields || {});\n            if (proto.updateMask) {\n                var fieldMask = this.fromDocumentMask(proto.updateMask);\n                return new mutation_PatchMutation(key, value, fieldMask, precondition);\n            }\n            else {\n                return new mutation_SetMutation(key, value, precondition);\n            }\n        }\n        else if (proto.delete) {\n            var key = this.fromName(proto.delete);\n            return new mutation_DeleteMutation(key, precondition);\n        }\n        else if (proto.transform) {\n            var key = this.fromName(proto.transform.document);\n            var fieldTransforms = proto.transform.fieldTransforms.map(function (transform) {\n                return _this.fromFieldTransform(transform);\n            });\n            assert(precondition.exists === true, 'Transforms only support precondition \"exists == true\"');\n            return new mutation_TransformMutation(key, fieldTransforms);\n        }\n        else {\n            return fail('unknown mutation proto: ' + JSON.stringify(proto));\n        }\n    };\n    JsonProtoSerializer.prototype.toPrecondition = function (precondition) {\n        assert(!precondition.isNone, \"Can't serialize an empty precondition\");\n        if (precondition.updateTime !== undefined) {\n            return {\n                updateTime: this.toVersion(precondition.updateTime)\n            };\n        }\n        else if (precondition.exists !== undefined) {\n            return { exists: precondition.exists };\n        }\n        else {\n            return fail('Unknown precondition');\n        }\n    };\n    JsonProtoSerializer.prototype.fromPrecondition = function (precondition) {\n        if (precondition.updateTime !== undefined) {\n            return mutation_Precondition.updateTime(this.fromVersion(precondition.updateTime));\n        }\n        else if (precondition.exists !== undefined) {\n            return mutation_Precondition.exists(precondition.exists);\n        }\n        else {\n            return mutation_Precondition.NONE;\n        }\n    };\n    JsonProtoSerializer.prototype.fromWriteResult = function (proto) {\n        var _this = this;\n        // NOTE: Deletes don't have an updateTime.\n        var version = proto.updateTime\n            ? this.fromVersion(proto.updateTime)\n            : null;\n        var transformResults = null;\n        if (proto.transformResults && proto.transformResults.length > 0) {\n            transformResults = proto.transformResults.map(function (result) {\n                return _this.fromValue(result);\n            });\n        }\n        return new MutationResult(version, transformResults);\n    };\n    JsonProtoSerializer.prototype.fromWriteResults = function (protos) {\n        var _this = this;\n        return (protos || []).map(function (proto) { return _this.fromWriteResult(proto); });\n    };\n    JsonProtoSerializer.prototype.toFieldTransform = function (fieldTransform) {\n        assert(fieldTransform.transform instanceof ServerTimestampTransform, 'Unknown transform: ' + fieldTransform.transform);\n        return {\n            fieldPath: fieldTransform.field.canonicalString(),\n            setToServerValue: 'REQUEST_TIME'\n        };\n    };\n    JsonProtoSerializer.prototype.fromFieldTransform = function (proto) {\n        assert(proto.setToServerValue === 'REQUEST_TIME', 'Unknown transform proto: ' + JSON.stringify(proto));\n        var fieldPath = path_FieldPath.fromServerFormat(proto.fieldPath);\n        return new FieldTransform(fieldPath, ServerTimestampTransform.instance);\n    };\n    JsonProtoSerializer.prototype.toDocumentsTarget = function (query) {\n        return { documents: [this.toQueryPath(query.path)] };\n    };\n    JsonProtoSerializer.prototype.fromDocumentsTarget = function (documentsTarget) {\n        var count = documentsTarget.documents.length;\n        assert(count === 1, 'DocumentsTarget contained other than 1 document: ' + count);\n        var name = documentsTarget.documents[0];\n        return query_Query.atPath(this.fromQueryPath(name));\n    };\n    JsonProtoSerializer.prototype.toQueryTarget = function (query) {\n        // Dissect the path into parent, collectionId, and optional key filter.\n        var result = { structuredQuery: {} };\n        if (query.path.isEmpty()) {\n            result.parent = this.toQueryPath(path_ResourcePath.EMPTY_PATH);\n        }\n        else {\n            var path = query.path;\n            assert(path.length % 2 !== 0, 'Document queries with filters are not supported.');\n            result.parent = this.toQueryPath(path.popLast());\n            result.structuredQuery.from = [{ collectionId: path.lastSegment() }];\n        }\n        var where = this.toFilter(query.filters);\n        if (where) {\n            result.structuredQuery.where = where;\n        }\n        var orderBy = this.toOrder(query.orderBy);\n        if (orderBy) {\n            result.structuredQuery.orderBy = orderBy;\n        }\n        var limit = this.toInt32Value(query.limit);\n        if (limit !== undefined) {\n            result.structuredQuery.limit = limit;\n        }\n        if (query.startAt) {\n            result.structuredQuery.startAt = this.toCursor(query.startAt);\n        }\n        if (query.endAt) {\n            result.structuredQuery.endAt = this.toCursor(query.endAt);\n        }\n        return result;\n    };\n    JsonProtoSerializer.prototype.fromQueryTarget = function (target) {\n        var path = this.fromQueryPath(target.parent);\n        var query = target.structuredQuery;\n        var fromCount = query.from ? query.from.length : 0;\n        if (fromCount > 0) {\n            assert(fromCount === 1, 'StructuredQuery.from with more than one collection is not supported.');\n            var from = query.from[0];\n            path = path.child(from.collectionId);\n        }\n        var filterBy = [];\n        if (query.where) {\n            filterBy = this.fromFilter(query.where);\n        }\n        var orderBy = [];\n        if (query.orderBy) {\n            orderBy = this.fromOrder(query.orderBy);\n        }\n        var limit = null;\n        if (query.limit) {\n            limit = this.fromInt32Value(query.limit);\n        }\n        var startAt = null;\n        if (query.startAt) {\n            startAt = this.fromCursor(query.startAt);\n        }\n        var endAt = null;\n        if (query.endAt) {\n            endAt = this.fromCursor(query.endAt);\n        }\n        return new query_Query(path, orderBy, filterBy, limit, startAt, endAt);\n    };\n    JsonProtoSerializer.prototype.toListenRequestLabels = function (queryData) {\n        var value = this.toLabel(queryData.purpose);\n        if (value == null) {\n            return null;\n        }\n        else {\n            return {\n                'goog-listen-tags': value\n            };\n        }\n    };\n    JsonProtoSerializer.prototype.toLabel = function (purpose) {\n        switch (purpose) {\n            case QueryPurpose.Listen:\n                return null;\n            case QueryPurpose.ExistenceFilterMismatch:\n                return 'existence-filter-mismatch';\n            case QueryPurpose.LimboResolution:\n                return 'limbo-document';\n            default:\n                return fail('Unrecognized query purpose: ' + purpose);\n        }\n    };\n    JsonProtoSerializer.prototype.toTarget = function (queryData) {\n        var result;\n        var query = queryData.query;\n        if (query.isDocumentQuery()) {\n            result = { documents: this.toDocumentsTarget(query) };\n        }\n        else {\n            result = { query: this.toQueryTarget(query) };\n        }\n        result.targetId = queryData.targetId;\n        if (queryData.resumeToken.length > 0) {\n            result.resumeToken = this.unsafeCastProtoByteString(queryData.resumeToken);\n        }\n        return result;\n    };\n    JsonProtoSerializer.prototype.toFilter = function (filters) {\n        var _this = this;\n        if (filters.length === 0)\n            return;\n        var protos = filters.map(function (filter) {\n            return filter instanceof query_RelationFilter\n                ? _this.toRelationFilter(filter)\n                : _this.toUnaryFilter(filter);\n        });\n        if (protos.length === 1) {\n            return protos[0];\n        }\n        return { compositeFilter: { op: 'AND', filters: protos } };\n    };\n    JsonProtoSerializer.prototype.fromFilter = function (filter) {\n        var _this = this;\n        if (!filter) {\n            return [];\n        }\n        else if (filter.unaryFilter !== undefined) {\n            return [this.fromUnaryFilter(filter)];\n        }\n        else if (filter.fieldFilter !== undefined) {\n            return [this.fromRelationFilter(filter)];\n        }\n        else if (filter.compositeFilter !== undefined) {\n            return filter.compositeFilter.filters\n                .map(function (f) { return _this.fromFilter(f); })\n                .reduce(function (accum, current) { return accum.concat(current); });\n        }\n        else {\n            return fail('Unknown filter: ' + JSON.stringify(filter));\n        }\n    };\n    JsonProtoSerializer.prototype.toOrder = function (orderBys) {\n        var _this = this;\n        if (orderBys.length === 0)\n            return;\n        return orderBys.map(function (order) { return _this.toPropertyOrder(order); });\n    };\n    JsonProtoSerializer.prototype.fromOrder = function (orderBys) {\n        var _this = this;\n        return orderBys.map(function (order) { return _this.fromPropertyOrder(order); });\n    };\n    JsonProtoSerializer.prototype.toCursor = function (cursor) {\n        var _this = this;\n        return {\n            before: cursor.before,\n            values: cursor.position.map(function (component) { return _this.toValue(component); })\n        };\n    };\n    JsonProtoSerializer.prototype.fromCursor = function (cursor) {\n        var _this = this;\n        var before = !!cursor.before;\n        var position = cursor.values.map(function (component) { return _this.fromValue(component); });\n        return new query_Bound(position, before);\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toDirection = function (dir) {\n        return DIRECTIONS[dir.name];\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.fromDirection = function (dir) {\n        switch (dir) {\n            case 'ASCENDING':\n                return Direction.ASCENDING;\n            case 'DESCENDING':\n                return Direction.DESCENDING;\n            default:\n                return undefined;\n        }\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toOperatorName = function (op) {\n        return OPERATORS[op.name];\n    };\n    JsonProtoSerializer.prototype.fromOperatorName = function (op) {\n        switch (op) {\n            case 'EQUAL':\n                return query_RelationOp.EQUAL;\n            case 'GREATER_THAN':\n                return query_RelationOp.GREATER_THAN;\n            case 'GREATER_THAN_OR_EQUAL':\n                return query_RelationOp.GREATER_THAN_OR_EQUAL;\n            case 'LESS_THAN':\n                return query_RelationOp.LESS_THAN;\n            case 'LESS_THAN_OR_EQUAL':\n                return query_RelationOp.LESS_THAN_OR_EQUAL;\n            case 'OPERATOR_UNSPECIFIED':\n                return fail('Unspecified relation');\n            default:\n                return fail('Unknown relation');\n        }\n    };\n    JsonProtoSerializer.prototype.toFieldPathReference = function (path) {\n        return { fieldPath: path.canonicalString() };\n    };\n    JsonProtoSerializer.prototype.fromFieldPathReference = function (fieldReference) {\n        return path_FieldPath.fromServerFormat(fieldReference.fieldPath);\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toPropertyOrder = function (orderBy) {\n        return {\n            field: this.toFieldPathReference(orderBy.field),\n            direction: this.toDirection(orderBy.dir)\n        };\n    };\n    JsonProtoSerializer.prototype.fromPropertyOrder = function (orderBy) {\n        return new query_OrderBy(this.fromFieldPathReference(orderBy.field), this.fromDirection(orderBy.direction));\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toRelationFilter = function (filter) {\n        if (filter instanceof query_RelationFilter) {\n            return {\n                fieldFilter: {\n                    field: this.toFieldPathReference(filter.field),\n                    op: this.toOperatorName(filter.op),\n                    value: this.toValue(filter.value)\n                }\n            };\n        }\n        else {\n            return fail('Unrecognized filter: ' + JSON.stringify(filter));\n        }\n    };\n    JsonProtoSerializer.prototype.fromRelationFilter = function (filter) {\n        return new query_RelationFilter(this.fromFieldPathReference(filter.fieldFilter.field), this.fromOperatorName(filter.fieldFilter.op), this.fromValue(filter.fieldFilter.value));\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toUnaryFilter = function (filter) {\n        if (filter instanceof NanFilter) {\n            return {\n                unaryFilter: {\n                    field: this.toFieldPathReference(filter.field),\n                    op: 'IS_NAN'\n                }\n            };\n        }\n        else if (filter instanceof NullFilter) {\n            return {\n                unaryFilter: {\n                    field: this.toFieldPathReference(filter.field),\n                    op: 'IS_NULL'\n                }\n            };\n        }\n        else {\n            return fail('Unrecognized filter: ' + JSON.stringify(filter));\n        }\n    };\n    JsonProtoSerializer.prototype.fromUnaryFilter = function (filter) {\n        switch (filter.unaryFilter.op) {\n            case 'IS_NAN':\n                var nanField = this.fromFieldPathReference(filter.unaryFilter.field);\n                return new NanFilter(nanField);\n            case 'IS_NULL':\n                var nullField = this.fromFieldPathReference(filter.unaryFilter.field);\n                return new NullFilter(nullField);\n            case 'OPERATOR_UNSPECIFIED':\n                return fail('Unspecified filter');\n            default:\n                return fail('Unknown filter');\n        }\n    };\n    JsonProtoSerializer.prototype.toDocumentMask = function (fieldMask) {\n        return {\n            fieldPaths: fieldMask.fields.map(function (field) { return field.canonicalString(); })\n        };\n    };\n    JsonProtoSerializer.prototype.fromDocumentMask = function (proto) {\n        var paths = proto.fieldPaths || [];\n        var fields = paths.map(function (path) { return path_FieldPath.fromServerFormat(path); });\n        return new mutation_FieldMask(fields);\n    };\n    return JsonProtoSerializer;\n}());\n\n/**\n * Checks for a specific oneof tag in a protocol buffer message.\n *\n * This intentionally accommodates two distinct cases:\n *\n * 1) Messages containing a type tag: these are the format produced by GRPC in\n * return values. These may contain default-value mappings for all tags in the\n * oneof but the type tag specifies which one was actually set.\n *\n * 2) Messages that don't contain a type tag: these are the format required by\n * GRPC as inputs. If we emitted objects with type tags, ProtoBuf.js would\n * choke claiming that the tags aren't fields in the Message.\n *\n * Allowing both formats here makes the serializer able to consume the outputs\n * it produces: for all messages it supports, fromX(toX(value)) == value.\n *\n * Note that case 2 suffers from ambiguity: if multiple tags are present\n * without a type tag then the callers are structured in such a way that the\n * first invocation will win. Since we only parse in this mode when parsing\n * the output of a serialize method this works, but it's not a general\n * solution.\n *\n * Unfortunately there is no general solution here because proto3 makes it\n * impossible to distinguish unset from explicitly set fields: both have the\n * default value for the type. Without the type tag but multiple value tags\n * it's possible to have default values for each tag in the oneof and not be\n * able to know which was actually in effect.\n */\nfunction hasTag(obj, type, tag) {\n    return type === tag || (!type && tag in obj);\n}\n\n//# sourceMappingURL=serializer.js.map\n\n// EXTERNAL MODULE: ../webchannel-wrapper/dist/index.js\nvar dist = __webpack_require__(115);\nvar dist_default = /*#__PURE__*/__webpack_require__.n(dist);\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/stream_bridge.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Provides a simple helper class that implements the Stream interface to\n * bridge to other implementations that are streams but do not implement the\n * interface. The stream callbacks are invoked with the callOn... methods.\n */\nvar stream_bridge_StreamBridge = /** @class */ (function () {\n    function StreamBridge(args) {\n        this.sendFn = args.sendFn;\n        this.closeFn = args.closeFn;\n    }\n    StreamBridge.prototype.onOpen = function (callback) {\n        assert(!this.wrappedOnOpen, 'Called onOpen on stream twice!');\n        this.wrappedOnOpen = callback;\n    };\n    StreamBridge.prototype.onClose = function (callback) {\n        assert(!this.wrappedOnClose, 'Called onClose on stream twice!');\n        this.wrappedOnClose = callback;\n    };\n    StreamBridge.prototype.onMessage = function (callback) {\n        assert(!this.wrappedOnMessage, 'Called onMessage on stream twice!');\n        this.wrappedOnMessage = callback;\n    };\n    StreamBridge.prototype.close = function () {\n        this.closeFn();\n    };\n    StreamBridge.prototype.send = function (msg) {\n        this.sendFn(msg);\n    };\n    StreamBridge.prototype.callOnOpen = function () {\n        assert(this.wrappedOnOpen !== undefined, 'Cannot call onOpen because no callback was set');\n        this.wrappedOnOpen();\n    };\n    StreamBridge.prototype.callOnClose = function (err) {\n        assert(this.wrappedOnClose !== undefined, 'Cannot call onClose because no callback was set');\n        this.wrappedOnClose(err);\n    };\n    StreamBridge.prototype.callOnMessage = function (msg) {\n        assert(this.wrappedOnMessage !== undefined, 'Cannot call onMessage because no callback was set');\n        this.wrappedOnMessage(msg);\n    };\n    return StreamBridge;\n}());\n\n\n//# sourceMappingURL=stream_bridge.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/platform_browser/webchannel_connection.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\nvar LOG_TAG = 'Connection';\nvar RPC_STREAM_SERVICE = 'google.firestore.v1beta1.Firestore';\nvar RPC_URL_VERSION = 'v1beta1';\n/** Maps RPC names to the corresponding REST endpoint name. */\nvar RPC_NAME_REST_MAPPING = {\n    BatchGetDocuments: 'batchGet',\n    Commit: 'commit'\n};\n// TODO(b/38203344): The SDK_VERSION is set independently from Firebase because\n// we are doing out-of-band releases. Once we release as part of Firebase, we\n// should use the Firebase version instead.\nvar X_GOOG_API_CLIENT_VALUE = 'gl-js/ fire/' + SDK_VERSION;\nvar XHR_TIMEOUT_SECS = 15;\nvar webchannel_connection_WebChannelConnection = /** @class */ (function () {\n    function WebChannelConnection(info) {\n        this.databaseId = info.databaseId;\n        this.pool = new dist[\"XhrIoPool\"]();\n        var proto = info.ssl ? 'https' : 'http';\n        this.baseUrl = proto + '://' + info.host;\n    }\n    /**\n     * Modifies the headers for a request, adding any authorization token if\n     * present and any additional headers for the request.\n     */\n    WebChannelConnection.prototype.modifyHeadersForRequest = function (headers, token) {\n        if (token) {\n            for (var header in token.authHeaders) {\n                if (token.authHeaders.hasOwnProperty(header)) {\n                    headers[header] = token.authHeaders[header];\n                }\n            }\n        }\n        headers['X-Goog-Api-Client'] = X_GOOG_API_CLIENT_VALUE;\n        // This header is used to improve routing and project isolation by the\n        // backend.\n        headers['google-cloud-resource-prefix'] =\n            \"projects/\" + this.databaseId.projectId + \"/\" +\n                (\"databases/\" + this.databaseId.database);\n    };\n    WebChannelConnection.prototype.invokeRPC = function (rpcName, request, token) {\n        var _this = this;\n        var url = this.makeUrl(rpcName);\n        return new Promise(function (resolve, reject) {\n            // tslint:disable-next-line:no-any XhrIoPool doesn't have TS typings.\n            _this.pool.getObject(function (xhr) {\n                xhr.listenOnce(dist[\"EventType\"].COMPLETE, function () {\n                    try {\n                        switch (xhr.getLastErrorCode()) {\n                            case dist[\"ErrorCode\"].NO_ERROR:\n                                var json = xhr.getResponseJson();\n                                debug(LOG_TAG, 'XHR received:', JSON.stringify(json));\n                                resolve(json);\n                                break;\n                            case dist[\"ErrorCode\"].TIMEOUT:\n                                debug(LOG_TAG, 'RPC \"' + rpcName + '\" timed out');\n                                reject(new FirestoreError(Code.DEADLINE_EXCEEDED, 'Request time out'));\n                                break;\n                            case dist[\"ErrorCode\"].HTTP_ERROR:\n                                var status_1 = xhr.getStatus();\n                                debug(LOG_TAG, 'RPC \"' + rpcName + '\" failed with status:', status_1, 'response text:', xhr.getResponseText());\n                                if (status_1 > 0) {\n                                    reject(new FirestoreError(mapCodeFromHttpStatus(status_1), 'Server responded with status ' + xhr.getStatusText()));\n                                }\n                                else {\n                                    // If we received an HTTP_ERROR but there's no status code,\n                                    // it's most probably a connection issue\n                                    debug(LOG_TAG, 'RPC \"' + rpcName + '\" failed');\n                                    reject(new FirestoreError(Code.UNAVAILABLE, 'Connection failed.'));\n                                }\n                                break;\n                            default:\n                                fail('RPC \"' +\n                                    rpcName +\n                                    '\" failed with unanticipated ' +\n                                    'webchannel error ' +\n                                    xhr.getLastErrorCode() +\n                                    ': ' +\n                                    xhr.getLastError() +\n                                    ', giving up.');\n                        }\n                    }\n                    finally {\n                        debug(LOG_TAG, 'RPC \"' + rpcName + '\" completed.');\n                        _this.pool.releaseObject(xhr);\n                    }\n                });\n                var requestString = JSON.stringify(request);\n                debug(LOG_TAG, 'XHR sending: ', url + ' ' + requestString);\n                // Content-Type: text/plain will avoid preflight requests which might\n                // mess with CORS and redirects by proxies. If we add custom headers\n                // we will need to change this code to potentially use the\n                // $httpOverwrite parameter supported by ESF to avoid\n                // triggering preflight requests.\n                var headers = { 'Content-Type': 'text/plain' };\n                _this.modifyHeadersForRequest(headers, token);\n                xhr.send(url, 'POST', requestString, headers, XHR_TIMEOUT_SECS);\n            });\n        });\n    };\n    WebChannelConnection.prototype.invokeStreamingRPC = function (rpcName, request, token) {\n        // The REST API automatically aggregates all of the streamed results, so we\n        // can just use the normal invoke() method.\n        return this.invokeRPC(rpcName, request, token);\n    };\n    WebChannelConnection.prototype.openStream = function (rpcName, token) {\n        var urlParts = [\n            this.baseUrl,\n            '/',\n            RPC_STREAM_SERVICE,\n            '/',\n            rpcName,\n            '/channel'\n        ];\n        var webchannelTransport = Object(dist[\"createWebChannelTransport\"])();\n        var request = {\n            // Background channel test avoids the initial two test calls and decreases\n            // initial cold start time.\n            // TODO(dimond): wenboz@ mentioned this might affect use with proxies and\n            // we should monitor closely for any reports.\n            backgroundChannelTest: true,\n            // Required for backend stickiness, routing behavior is based on this\n            // parameter.\n            httpSessionIdParam: 'gsessionid',\n            initMessageHeaders: {},\n            // Send our custom headers as a '$httpHeaders=' url param to avoid CORS\n            // preflight round-trip. This is formally defined here:\n            // https://github.com/google/closure-library/blob/b0e1815b13fb92a46d7c9b3c30de5d6a396a3245/closure/goog/net/rpc/httpcors.js#L40\n            httpHeadersOverwriteParam: '$httpHeaders',\n            sendRawJson: true,\n            supportsCrossDomainXhr: true\n        };\n        this.modifyHeadersForRequest(request.initMessageHeaders, token);\n        var url = urlParts.join('');\n        debug(LOG_TAG, 'Creating WebChannel: ' + url + ' ' + request);\n        // tslint:disable-next-line:no-any Because listen isn't defined on it.\n        var channel = webchannelTransport.createWebChannel(url, request);\n        // WebChannel supports sending the first message with the handshake - saving\n        // a network round trip. However, it will have to call send in the same\n        // JS event loop as open. In order to enforce this, we delay actually\n        // opening the WebChannel until send is called. Whether we have called\n        // open is tracked with this variable.\n        var opened = false;\n        // A flag to determine whether the stream was closed (by us or through an\n        // error/close event) to avoid delivering multiple close events or sending\n        // on a closed stream\n        var closed = false;\n        var streamBridge = new stream_bridge_StreamBridge({\n            sendFn: function (msg) {\n                if (!closed) {\n                    if (!opened) {\n                        debug(LOG_TAG, 'Opening WebChannel transport.');\n                        channel.open();\n                        opened = true;\n                    }\n                    debug(LOG_TAG, 'WebChannel sending:', msg);\n                    channel.send(msg);\n                }\n                else {\n                    debug(LOG_TAG, 'Not sending because WebChannel is closed:', msg);\n                }\n            },\n            closeFn: function () { return channel.close(); }\n        });\n        // Closure events are guarded and exceptions are swallowed, so catch any\n        // exception and rethrow using a setTimeout so they become visible again.\n        // Note that eventually this function could go away if we are confident\n        // enough the code is exception free.\n        var unguardedEventListen = function (type, fn) {\n            // TODO(dimond): closure typing seems broken because WebChannel does\n            // not implement goog.events.Listenable\n            channel.listen(type, function (param) {\n                try {\n                    fn(param);\n                }\n                catch (e) {\n                    setTimeout(function () {\n                        throw e;\n                    }, 0);\n                }\n            });\n        };\n        unguardedEventListen(dist[\"WebChannel\"].EventType.OPEN, function () {\n            if (!closed) {\n                debug(LOG_TAG, 'WebChannel transport opened.');\n            }\n        });\n        unguardedEventListen(dist[\"WebChannel\"].EventType.CLOSE, function () {\n            if (!closed) {\n                closed = true;\n                debug(LOG_TAG, 'WebChannel transport closed');\n                streamBridge.callOnClose();\n            }\n        });\n        unguardedEventListen(dist[\"WebChannel\"].EventType.ERROR, function (err) {\n            if (!closed) {\n                closed = true;\n                debug(LOG_TAG, 'WebChannel transport errored:', err);\n                streamBridge.callOnClose(new FirestoreError(Code.UNAVAILABLE, 'The operation could not be completed'));\n            }\n        });\n        unguardedEventListen(dist[\"WebChannel\"].EventType.MESSAGE, function (msg) {\n            if (!closed) {\n                var msgData = msg.data[0];\n                assert(!!msgData, 'Got a webchannel message without data.');\n                // TODO(b/35143891): There is a bug in One Platform that caused errors\n                // (and only errors) to be wrapped in an extra array. To be forward\n                // compatible with the bug we need to check either condition. The latter\n                // can be removed once the fix has been rolled out.\n                var error = \n                // tslint:disable-next-line:no-any msgData.error is not typed.\n                msgData.error || (msgData[0] && msgData[0].error);\n                if (error) {\n                    debug(LOG_TAG, 'WebChannel received error:', error);\n                    // error.status will be a string like 'OK' or 'NOT_FOUND'.\n                    var status_2 = error.status;\n                    var code = mapCodeFromRpcStatus(status_2);\n                    var message = error.message;\n                    if (code === undefined) {\n                        code = Code.INTERNAL;\n                        message =\n                            'Unknown error status: ' +\n                                status_2 +\n                                ' with message ' +\n                                error.message;\n                    }\n                    // Mark closed so no further events are propagated\n                    closed = true;\n                    streamBridge.callOnClose(new FirestoreError(code, message));\n                    channel.close();\n                }\n                else {\n                    debug(LOG_TAG, 'WebChannel received:', msgData);\n                    streamBridge.callOnMessage(msgData);\n                }\n            }\n        });\n        setTimeout(function () {\n            // Technically we could/should wait for the WebChannel opened event,\n            // but because we want to send the first message with the WebChannel\n            // handshake we pretend the channel opened here (asynchronously), and\n            // then delay the actual open until the first message is sent.\n            streamBridge.callOnOpen();\n        }, 0);\n        return streamBridge;\n    };\n    // visible for testing\n    WebChannelConnection.prototype.makeUrl = function (rpcName) {\n        var urlRpcName = RPC_NAME_REST_MAPPING[rpcName];\n        assert(urlRpcName !== undefined, 'Unknown REST mapping for: ' + rpcName);\n        var url = [this.baseUrl, '/', RPC_URL_VERSION];\n        url.push('/projects/');\n        url.push(this.databaseId.projectId);\n        url.push('/databases/');\n        url.push(this.databaseId.database);\n        url.push('/documents');\n        url.push(':');\n        url.push(urlRpcName);\n        return url.join('');\n    };\n    return WebChannelConnection;\n}());\n\n\n//# sourceMappingURL=webchannel_connection.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/platform_browser/browser_platform.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nvar browser_platform_BrowserPlatform = /** @class */ (function () {\n    function BrowserPlatform() {\n        this.emptyByteString = '';\n        this.base64Available = typeof atob !== 'undefined';\n    }\n    BrowserPlatform.prototype.loadConnection = function (databaseInfo) {\n        return Promise.resolve(new webchannel_connection_WebChannelConnection(databaseInfo));\n    };\n    BrowserPlatform.prototype.newSerializer = function (databaseId) {\n        return new serializer_JsonProtoSerializer(databaseId, { useProto3Json: true });\n    };\n    BrowserPlatform.prototype.formatJSON = function (value) {\n        return JSON.stringify(value);\n    };\n    BrowserPlatform.prototype.atob = function (encoded) {\n        return atob(encoded);\n    };\n    BrowserPlatform.prototype.btoa = function (raw) {\n        return btoa(raw);\n    };\n    return BrowserPlatform;\n}());\n\n\n//# sourceMappingURL=browser_platform.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/platform_browser/browser_init.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * This code needs to run before Firestore is used. This can be achieved in\n * several ways:\n *   1) Through the JSCompiler compiling this code and then (automatically)\n *      executing it before exporting the Firestore symbols.\n *   2) Through importing this module first in a Firestore main module\n */\nplatform_PlatformSupport.setPlatform(new browser_platform_BrowserPlatform());\n\n//# sourceMappingURL=browser_init.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/field_path.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n// The objects that are a part of this API are exposed to third-parties as\n// compiled javascript so we want to flag our private members with a leading\n// underscore to discourage their use.\n// tslint:disable:strip-private-property-underscore\n/**\n * A FieldPath refers to a field in a document. The path may consist of a single\n * field name (referring to a top-level field in the document), or a list of\n * field names (referring to a nested field in the document).\n */\nvar field_path_FieldPath = /** @class */ (function () {\n    /**\n     * Creates a FieldPath from the provided field names. If more than one field\n     * name is provided, the path will point to a nested field in a document.\n     *\n     * @param fieldNames A list of field names.\n     */\n    function FieldPath() {\n        var fieldNames = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            fieldNames[_i] = arguments[_i];\n        }\n        validateNamedArrayAtLeastNumberOfElements('FieldPath', fieldNames, 'fieldNames', 1);\n        for (var i = 0; i < fieldNames.length; ++i) {\n            validateArgType('FieldPath', 'string', i, fieldNames[i]);\n            if (fieldNames[i].length === 0) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field name at argument $(i + 1). \" +\n                    'Field names must not be empty.');\n            }\n        }\n        this._internalPath = new path_FieldPath(fieldNames);\n    }\n    FieldPath.documentId = function () {\n        return FieldPath._DOCUMENT_ID;\n    };\n    FieldPath.prototype.isEqual = function (other) {\n        if (!(other instanceof FieldPath)) {\n            throw invalidClassError('isEqual', 'FieldPath', 1, other);\n        }\n        return this._internalPath.isEqual(other._internalPath);\n    };\n    /**\n     * Internal Note: The backend doesn't technically support querying by\n     * document ID. Instead it queries by the entire document name (full path\n     * included), but in the cases we currently support documentId(), the net\n     * effect is the same.\n     */\n    FieldPath._DOCUMENT_ID = new FieldPath(path_FieldPath.keyField().canonicalString());\n    return FieldPath;\n}());\n\n/**\n * Matches any characters in a field path string that are reserved.\n */\nvar RESERVED = new RegExp('[~\\\\*/\\\\[\\\\]]');\n/**\n * Parses a field path string into a FieldPath, treating dots as separators.\n */\nfunction fromDotSeparatedString(path) {\n    var found = path.search(RESERVED);\n    if (found >= 0) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field path (\" + path + \"). Paths must not contain \" +\n            \"'~', '*', '/', '[', or ']'\");\n    }\n    try {\n        return new (field_path_FieldPath.bind.apply(field_path_FieldPath, [void 0].concat(path.split('.'))))();\n    }\n    catch (e) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field path (\" + path + \"). Paths must not be empty, \" +\n            \"begin with '.', end with '.', or contain '..'\");\n    }\n}\n\n//# sourceMappingURL=field_path.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/types.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Describes the online state of the Firestore client. Note that this does not\n * indicate whether or not the remote store is trying to connect or not. This is\n * primarily used by the View / EventManager code to change their behavior while\n * offline (e.g. get() calls shouldn't wait for data from the server and\n * snapshot events should set metadata.isFromCache=true).\n */\nvar OnlineState;\n(function (OnlineState) {\n    /**\n     * The Firestore client is in an unknown online state. This means the client\n     * is either not actively trying to establish a connection or it is currently\n     * trying to establish a connection, but it has not succeeded or failed yet.\n     * Higher-level components should not operate in offline mode.\n     */\n    OnlineState[OnlineState[\"Unknown\"] = 0] = \"Unknown\";\n    /**\n     * The client is connected and the connections are healthy. This state is\n     * reached after a successful connection and there has been at least one\n     * successful message received from the backends.\n     */\n    OnlineState[OnlineState[\"Healthy\"] = 1] = \"Healthy\";\n    /**\n     * The client is either trying to establish a connection but failing, or it\n     * has been explicitly marked offline via a call to disableNetwork().\n     * Higher-level components should operate in offline mode.\n     */\n    OnlineState[OnlineState[\"Failed\"] = 2] = \"Failed\";\n})(OnlineState || (OnlineState = {}));\n\n//# sourceMappingURL=types.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/view_snapshot.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\nvar ChangeType;\n(function (ChangeType) {\n    ChangeType[ChangeType[\"Added\"] = 0] = \"Added\";\n    ChangeType[ChangeType[\"Removed\"] = 1] = \"Removed\";\n    ChangeType[ChangeType[\"Modified\"] = 2] = \"Modified\";\n    ChangeType[ChangeType[\"Metadata\"] = 3] = \"Metadata\";\n})(ChangeType || (ChangeType = {}));\nvar SyncState;\n(function (SyncState) {\n    SyncState[SyncState[\"Local\"] = 0] = \"Local\";\n    SyncState[SyncState[\"Synced\"] = 1] = \"Synced\";\n})(SyncState || (SyncState = {}));\n/**\n * DocumentChangeSet keeps track of a set of changes to docs in a query, merging\n * duplicate events for the same doc.\n */\nvar view_snapshot_DocumentChangeSet = /** @class */ (function () {\n    function DocumentChangeSet() {\n        this.changeMap = new SortedMap(document_key_DocumentKey.comparator);\n    }\n    DocumentChangeSet.prototype.track = function (change) {\n        var key = change.doc.key;\n        var oldChange = this.changeMap.get(key);\n        if (!oldChange) {\n            this.changeMap = this.changeMap.insert(key, change);\n            return;\n        }\n        // Merge the new change with the existing change.\n        if (change.type !== ChangeType.Added &&\n            oldChange.type === ChangeType.Metadata) {\n            this.changeMap = this.changeMap.insert(key, change);\n        }\n        else if (change.type === ChangeType.Metadata &&\n            oldChange.type !== ChangeType.Removed) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: oldChange.type,\n                doc: change.doc\n            });\n        }\n        else if (change.type === ChangeType.Modified &&\n            oldChange.type === ChangeType.Modified) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Modified,\n                doc: change.doc\n            });\n        }\n        else if (change.type === ChangeType.Modified &&\n            oldChange.type === ChangeType.Added) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Added,\n                doc: change.doc\n            });\n        }\n        else if (change.type === ChangeType.Removed &&\n            oldChange.type === ChangeType.Added) {\n            this.changeMap = this.changeMap.remove(key);\n        }\n        else if (change.type === ChangeType.Removed &&\n            oldChange.type === ChangeType.Modified) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Removed,\n                doc: oldChange.doc\n            });\n        }\n        else if (change.type === ChangeType.Added &&\n            oldChange.type === ChangeType.Removed) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Modified,\n                doc: change.doc\n            });\n        }\n        else {\n            // This includes these cases, which don't make sense:\n            // Added->Added\n            // Removed->Removed\n            // Modified->Added\n            // Removed->Modified\n            // Metadata->Added\n            // Removed->Metadata\n            fail('unsupported combination of changes: ' +\n                JSON.stringify(change) +\n                ' after ' +\n                JSON.stringify(oldChange));\n        }\n    };\n    DocumentChangeSet.prototype.getChanges = function () {\n        var changes = [];\n        this.changeMap.inorderTraversal(function (key, change) {\n            changes.push(change);\n        });\n        return changes;\n    };\n    return DocumentChangeSet;\n}());\n\nvar ViewSnapshot = /** @class */ (function () {\n    function ViewSnapshot(query, docs, oldDocs, docChanges, fromCache, hasPendingWrites, syncStateChanged) {\n        this.query = query;\n        this.docs = docs;\n        this.oldDocs = oldDocs;\n        this.docChanges = docChanges;\n        this.fromCache = fromCache;\n        this.hasPendingWrites = hasPendingWrites;\n        this.syncStateChanged = syncStateChanged;\n    }\n    ViewSnapshot.prototype.isEqual = function (other) {\n        if (this.fromCache !== other.fromCache ||\n            this.hasPendingWrites !== other.hasPendingWrites ||\n            this.syncStateChanged !== other.syncStateChanged ||\n            !this.query.isEqual(other.query) ||\n            !this.docs.isEqual(other.docs) ||\n            !this.oldDocs.isEqual(other.oldDocs)) {\n            return false;\n        }\n        var changes = this.docChanges;\n        var otherChanges = other.docChanges;\n        if (changes.length !== otherChanges.length) {\n            return false;\n        }\n        for (var i = 0; i < changes.length; i++) {\n            if (changes[i].type !== otherChanges[i].type ||\n                !changes[i].doc.isEqual(otherChanges[i].doc)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    return ViewSnapshot;\n}());\n\n\n//# sourceMappingURL=view_snapshot.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/document_set.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * DocumentSet is an immutable (copy-on-write) collection that holds documents\n * in order specified by the provided comparator. We always add a document key\n * comparator on top of what is provided to guarantee document equality based on\n * the key.\n */\nvar document_set_DocumentSet = /** @class */ (function () {\n    /** The default ordering is by key if the comparator is omitted */\n    function DocumentSet(comp) {\n        // We are adding document key comparator to the end as it's the only\n        // guaranteed unique property of a document.\n        if (comp) {\n            this.comparator = function (d1, d2) {\n                return comp(d1, d2) || document_key_DocumentKey.comparator(d1.key, d2.key);\n            };\n        }\n        else {\n            this.comparator = function (d1, d2) {\n                return document_key_DocumentKey.comparator(d1.key, d2.key);\n            };\n        }\n        this.keyedMap = documentMap();\n        this.sortedSet = new SortedMap(this.comparator);\n    }\n    /**\n     * Returns an empty copy of the existing DocumentSet, using the same\n     * comparator.\n     */\n    DocumentSet.emptySet = function (oldSet) {\n        return new DocumentSet(oldSet.comparator);\n    };\n    DocumentSet.prototype.has = function (key) {\n        return this.keyedMap.get(key) != null;\n    };\n    DocumentSet.prototype.get = function (key) {\n        return this.keyedMap.get(key);\n    };\n    DocumentSet.prototype.first = function () {\n        return this.sortedSet.minKey();\n    };\n    DocumentSet.prototype.last = function () {\n        return this.sortedSet.maxKey();\n    };\n    DocumentSet.prototype.isEmpty = function () {\n        return this.sortedSet.isEmpty();\n    };\n    /**\n     * Returns the index of the provided key in the document set, or -1 if the\n     * document key is not present in the set;\n     */\n    DocumentSet.prototype.indexOf = function (key) {\n        var doc = this.keyedMap.get(key);\n        return doc ? this.sortedSet.indexOf(doc) : -1;\n    };\n    Object.defineProperty(DocumentSet.prototype, \"size\", {\n        get: function () {\n            return this.sortedSet.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** Iterates documents in order defined by \"comparator\" */\n    DocumentSet.prototype.forEach = function (cb) {\n        this.sortedSet.inorderTraversal(function (k, v) {\n            cb(k);\n            return false;\n        });\n    };\n    /** Inserts or updates a document with the same key */\n    DocumentSet.prototype.add = function (doc) {\n        // First remove the element if we have it.\n        var set = this.delete(doc.key);\n        return set.copy(set.keyedMap.insert(doc.key, doc), set.sortedSet.insert(doc, null));\n    };\n    /** Deletes a document with a given key */\n    DocumentSet.prototype.delete = function (key) {\n        var doc = this.get(key);\n        if (!doc) {\n            return this;\n        }\n        return this.copy(this.keyedMap.remove(key), this.sortedSet.remove(doc));\n    };\n    DocumentSet.prototype.isEqual = function (other) {\n        if (!(other instanceof DocumentSet))\n            return false;\n        if (this.size !== other.size)\n            return false;\n        var thisIt = this.sortedSet.getIterator();\n        var otherIt = other.sortedSet.getIterator();\n        while (thisIt.hasNext()) {\n            var thisDoc = thisIt.getNext().key;\n            var otherDoc = otherIt.getNext().key;\n            if (!thisDoc.isEqual(otherDoc))\n                return false;\n        }\n        return true;\n    };\n    DocumentSet.prototype.toString = function () {\n        var docStrings = [];\n        this.forEach(function (doc) {\n            docStrings.push(doc.toString());\n        });\n        if (docStrings.length === 0) {\n            return 'DocumentSet ()';\n        }\n        else {\n            return 'DocumentSet (\\n  ' + docStrings.join('  \\n') + '\\n)';\n        }\n    };\n    DocumentSet.prototype.copy = function (keyedMap, sortedSet) {\n        var newSet = new DocumentSet();\n        newSet.comparator = this.comparator;\n        newSet.keyedMap = keyedMap;\n        newSet.sortedSet = sortedSet;\n        return newSet;\n    };\n    return DocumentSet;\n}());\n\n\n//# sourceMappingURL=document_set.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/obj_map.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * A map implementation that uses objects as keys. Objects must implement the\n * Equatable interface and must be immutable. Entries in the map are stored\n * together with the key being produced from the mapKeyFn. This map\n * automatically handles collisions of keys.\n */\nvar obj_map_ObjectMap = /** @class */ (function () {\n    function ObjectMap(mapKeyFn) {\n        this.mapKeyFn = mapKeyFn;\n        /**\n         * The inner map for a key -> value pair. Due to the possibility of\n         * collisions we keep a list of entries that we do a linear search through\n         * to find an actual match. Note that collisions should be rare, so we still\n         * expect near constant time lookups in practice.\n         */\n        this.inner = {};\n    }\n    /** Get a value for this key, or undefined if it does not exist. */\n    ObjectMap.prototype.get = function (key) {\n        var id = this.mapKeyFn(key);\n        var matches = this.inner[id];\n        if (matches === undefined) {\n            return undefined;\n        }\n        for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {\n            var _a = matches_1[_i], otherKey = _a[0], value = _a[1];\n            if (otherKey.isEqual(key)) {\n                return value;\n            }\n        }\n        return undefined;\n    };\n    ObjectMap.prototype.has = function (key) {\n        return this.get(key) !== undefined;\n    };\n    /** Put this key and value in the map. */\n    ObjectMap.prototype.set = function (key, value) {\n        var id = this.mapKeyFn(key);\n        var matches = this.inner[id];\n        if (matches === undefined) {\n            this.inner[id] = [[key, value]];\n            return;\n        }\n        for (var i = 0; i < matches.length; i++) {\n            if (matches[i][0].isEqual(key)) {\n                matches[i] = [key, value];\n                return;\n            }\n        }\n        matches.push([key, value]);\n    };\n    /**\n     * Remove this key from the map. Returns a boolean if anything was deleted.\n     */\n    ObjectMap.prototype.delete = function (key) {\n        var id = this.mapKeyFn(key);\n        var matches = this.inner[id];\n        if (matches === undefined) {\n            return false;\n        }\n        for (var i = 0; i < matches.length; i++) {\n            if (matches[i][0].isEqual(key)) {\n                if (matches.length === 1) {\n                    delete this.inner[id];\n                }\n                else {\n                    matches.splice(i, 1);\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    ObjectMap.prototype.forEach = function (fn) {\n        forEach(this.inner, function (_, entries) {\n            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n                var _a = entries_1[_i], k = _a[0], v = _a[1];\n                fn(k, v);\n            }\n        });\n    };\n    ObjectMap.prototype.isEmpty = function () {\n        return isEmpty(this.inner);\n    };\n    return ObjectMap;\n}());\n\n\n//# sourceMappingURL=obj_map.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/event_manager.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n/**\n * Holds the listeners and the last received ViewSnapshot for a query being\n * tracked by EventManager.\n */\nvar QueryListenersInfo = /** @class */ (function () {\n    function QueryListenersInfo() {\n        this.listeners = [];\n    }\n    return QueryListenersInfo;\n}());\n/**\n * EventManager is responsible for mapping queries to query event emitters.\n * It handles \"fan-out\". -- Identical queries will re-use the same watch on the\n * backend.\n */\nvar event_manager_EventManager = /** @class */ (function () {\n    function EventManager(syncEngine) {\n        this.syncEngine = syncEngine;\n        this.queries = new obj_map_ObjectMap(function (q) {\n            return q.canonicalId();\n        });\n        this.onlineState = OnlineState.Unknown;\n        this.syncEngine.subscribe(this.onChange.bind(this), this.onError.bind(this));\n    }\n    EventManager.prototype.listen = function (listener) {\n        var query = listener.query;\n        var firstListen = false;\n        var queryInfo = this.queries.get(query);\n        if (!queryInfo) {\n            firstListen = true;\n            queryInfo = new QueryListenersInfo();\n            this.queries.set(query, queryInfo);\n        }\n        queryInfo.listeners.push(listener);\n        listener.applyOnlineStateChange(this.onlineState);\n        if (queryInfo.viewSnap)\n            listener.onViewSnapshot(queryInfo.viewSnap);\n        if (firstListen) {\n            return this.syncEngine.listen(query).then(function (targetId) {\n                queryInfo.targetId = targetId;\n                return targetId;\n            });\n        }\n        else {\n            return Promise.resolve(queryInfo.targetId);\n        }\n    };\n    EventManager.prototype.unlisten = function (listener) {\n        var query = listener.query;\n        var lastListen = false;\n        var queryInfo = this.queries.get(query);\n        if (queryInfo) {\n            var i = queryInfo.listeners.indexOf(listener);\n            if (i >= 0) {\n                queryInfo.listeners.splice(i, 1);\n                lastListen = queryInfo.listeners.length === 0;\n            }\n        }\n        if (lastListen) {\n            this.queries.delete(query);\n            return this.syncEngine.unlisten(query);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    EventManager.prototype.onChange = function (viewSnaps) {\n        for (var _i = 0, viewSnaps_1 = viewSnaps; _i < viewSnaps_1.length; _i++) {\n            var viewSnap = viewSnaps_1[_i];\n            var query = viewSnap.query;\n            var queryInfo = this.queries.get(query);\n            if (queryInfo) {\n                for (var _a = 0, _b = queryInfo.listeners; _a < _b.length; _a++) {\n                    var listener = _b[_a];\n                    listener.onViewSnapshot(viewSnap);\n                }\n                queryInfo.viewSnap = viewSnap;\n            }\n        }\n    };\n    EventManager.prototype.onError = function (query, error) {\n        var queryInfo = this.queries.get(query);\n        if (queryInfo) {\n            for (var _i = 0, _a = queryInfo.listeners; _i < _a.length; _i++) {\n                var listener = _a[_i];\n                listener.onError(error);\n            }\n        }\n        // Remove all listeners. NOTE: We don't need to call syncEngine.unlisten()\n        // after an error.\n        this.queries.delete(query);\n    };\n    EventManager.prototype.applyOnlineStateChange = function (onlineState) {\n        this.onlineState = onlineState;\n        this.queries.forEach(function (_, queryInfo) {\n            for (var _i = 0, _a = queryInfo.listeners; _i < _a.length; _i++) {\n                var listener = _a[_i];\n                listener.applyOnlineStateChange(onlineState);\n            }\n        });\n    };\n    return EventManager;\n}());\n\n/**\n * QueryListener takes a series of internal view snapshots and determines\n * when to raise the event.\n *\n * It uses an Observer to dispatch events.\n */\nvar event_manager_QueryListener = /** @class */ (function () {\n    function QueryListener(query, queryObserver, options) {\n        this.query = query;\n        this.queryObserver = queryObserver;\n        /**\n         * Initial snapshots (e.g. from cache) may not be propagated to the wrapped\n         * observer. This flag is set to true once we've actually raised an event.\n         */\n        this.raisedInitialEvent = false;\n        this.onlineState = OnlineState.Unknown;\n        this.options = options || {};\n    }\n    QueryListener.prototype.onViewSnapshot = function (snap) {\n        assert(snap.docChanges.length > 0 || snap.syncStateChanged, 'We got a new snapshot with no changes?');\n        if (!this.options.includeDocumentMetadataChanges) {\n            // Remove the metadata only changes.\n            var docChanges = [];\n            for (var _i = 0, _a = snap.docChanges; _i < _a.length; _i++) {\n                var docChange = _a[_i];\n                if (docChange.type !== ChangeType.Metadata) {\n                    docChanges.push(docChange);\n                }\n            }\n            snap = new ViewSnapshot(snap.query, snap.docs, snap.oldDocs, docChanges, snap.fromCache, snap.hasPendingWrites, snap.syncStateChanged);\n        }\n        if (!this.raisedInitialEvent) {\n            if (this.shouldRaiseInitialEvent(snap, this.onlineState)) {\n                this.raiseInitialEvent(snap);\n            }\n        }\n        else if (this.shouldRaiseEvent(snap)) {\n            this.queryObserver.next(snap);\n        }\n        this.snap = snap;\n    };\n    QueryListener.prototype.onError = function (error) {\n        this.queryObserver.error(error);\n    };\n    QueryListener.prototype.applyOnlineStateChange = function (onlineState) {\n        this.onlineState = onlineState;\n        if (this.snap &&\n            !this.raisedInitialEvent &&\n            this.shouldRaiseInitialEvent(this.snap, onlineState)) {\n            this.raiseInitialEvent(this.snap);\n        }\n    };\n    QueryListener.prototype.shouldRaiseInitialEvent = function (snap, onlineState) {\n        assert(!this.raisedInitialEvent, 'Determining whether to raise first event but already had first event');\n        // Always raise the first event when we're synced\n        if (!snap.fromCache) {\n            return true;\n        }\n        // NOTE: We consider OnlineState.Unknown as online (it should become Failed\n        // or Online if we wait long enough).\n        var maybeOnline = onlineState !== OnlineState.Failed;\n        // Don't raise the event if we're online, aren't synced yet (checked\n        // above) and are waiting for a sync.\n        if (this.options.waitForSyncWhenOnline && maybeOnline) {\n            assert(snap.fromCache, 'Waiting for sync, but snapshot is not from cache');\n            return false;\n        }\n        // Raise data from cache if we have any documents or we are offline\n        return !snap.docs.isEmpty() || onlineState === OnlineState.Failed;\n    };\n    QueryListener.prototype.shouldRaiseEvent = function (snap) {\n        // We don't need to handle includeDocumentMetadataChanges here because\n        // the Metadata only changes have already been stripped out if needed.\n        // At this point the only changes we will see are the ones we should\n        // propagate.\n        if (snap.docChanges.length > 0) {\n            return true;\n        }\n        var hasPendingWritesChanged = this.snap && this.snap.hasPendingWrites !== snap.hasPendingWrites;\n        if (snap.syncStateChanged || hasPendingWritesChanged) {\n            return this.options.includeQueryMetadataChanges === true;\n        }\n        // Generally we should have hit one of the cases above, but it's possible\n        // to get here if there were only metadata docChanges and they got\n        // stripped out.\n        return false;\n    };\n    QueryListener.prototype.raiseInitialEvent = function (snap) {\n        assert(!this.raisedInitialEvent, 'Trying to raise initial events for second time');\n        snap = new ViewSnapshot(snap.query, snap.docs, document_set_DocumentSet.emptySet(snap.docs), QueryListener.getInitialViewChanges(snap), snap.fromCache, snap.hasPendingWrites, true);\n        this.raisedInitialEvent = true;\n        this.queryObserver.next(snap);\n    };\n    /** Returns changes as if all documents in the snap were added. */\n    QueryListener.getInitialViewChanges = function (snap) {\n        var result = [];\n        snap.docs.forEach(function (doc) {\n            result.push({ type: ChangeType.Added, doc: doc });\n        });\n        return result;\n    };\n    return QueryListener;\n}());\n\n\n//# sourceMappingURL=event_manager.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/persistence_promise.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * PersistencePromise<> is essentially a re-implementation of Promise<> except\n * it has a .next() method instead of .then() and .next() and .catch() callbacks\n * are executed synchronously when a PersistencePromise resolves rather than\n * asynchronously (Promise<> implementations use setImmediate() or similar).\n *\n * This is necessary to interoperate with IndexedDB which will automatically\n * commit transactions if control is returned to the event loop without\n * synchronously initiating another operation on the transaction.\n *\n * NOTE: .then() and .catch() only allow a single consumer, unlike normal\n * Promises.\n */\nvar persistence_promise_PersistencePromise = /** @class */ (function () {\n    function PersistencePromise(callback) {\n        var _this = this;\n        // NOTE: next/catchCallback will always point to our own wrapper functions,\n        // not the user's raw next() or catch() callbacks.\n        // tslint:disable-next-line:no-any Accept any result type for the next call in the Promise chain.\n        this.nextCallback = null;\n        // tslint:disable-next-line:no-any Accept any result type for the error handler.\n        this.catchCallback = null;\n        // When the operation resolves, we'll set result or error and mark isDone.\n        this.result = undefined;\n        this.error = undefined;\n        this.isDone = false;\n        // Set to true when .then() or .catch() are called and prevents additional\n        // chaining.\n        this.callbackAttached = false;\n        callback(function (value) {\n            _this.isDone = true;\n            _this.result = value;\n            if (_this.nextCallback) {\n                // value should be defined unless T is Void, but we can't express\n                // that in the type system.\n                _this.nextCallback(value);\n            }\n        }, function (error) {\n            _this.isDone = true;\n            _this.error = error;\n            if (_this.catchCallback) {\n                _this.catchCallback(error);\n            }\n        });\n    }\n    PersistencePromise.prototype.catch = function (fn) {\n        return this.next(undefined, fn);\n    };\n    PersistencePromise.prototype.next = function (nextFn, catchFn) {\n        var _this = this;\n        if (this.callbackAttached) {\n            fail('Called next() or catch() twice for PersistencePromise');\n        }\n        this.callbackAttached = true;\n        if (this.isDone) {\n            if (!this.error) {\n                return this.wrapSuccess(nextFn, this.result);\n            }\n            else {\n                return this.wrapFailure(catchFn, this.error);\n            }\n        }\n        else {\n            return new PersistencePromise(function (resolve, reject) {\n                _this.nextCallback = function (value) {\n                    _this.wrapSuccess(nextFn, value).next(resolve, reject);\n                };\n                _this.catchCallback = function (error) {\n                    _this.wrapFailure(catchFn, error).next(resolve, reject);\n                };\n            });\n        }\n    };\n    PersistencePromise.prototype.toPromise = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            _this.next(resolve, reject);\n        });\n    };\n    PersistencePromise.prototype.wrapUserFunction = function (fn) {\n        try {\n            var result = fn();\n            if (result instanceof PersistencePromise) {\n                return result;\n            }\n            else {\n                return PersistencePromise.resolve(result);\n            }\n        }\n        catch (e) {\n            return PersistencePromise.reject(e);\n        }\n    };\n    PersistencePromise.prototype.wrapSuccess = function (nextFn, value) {\n        if (nextFn) {\n            return this.wrapUserFunction(function () { return nextFn(value); });\n        }\n        else {\n            // If there's no nextFn, then R must be the same as T but we\n            // can't express that in the type system.\n            // tslint:disable-next-line:no-any\n            return PersistencePromise.resolve(value);\n        }\n    };\n    PersistencePromise.prototype.wrapFailure = function (catchFn, error) {\n        if (catchFn) {\n            return this.wrapUserFunction(function () { return catchFn(error); });\n        }\n        else {\n            return PersistencePromise.reject(error);\n        }\n    };\n    PersistencePromise.resolve = function (result) {\n        return new PersistencePromise(function (resolve, reject) {\n            resolve(result);\n        });\n    };\n    PersistencePromise.reject = function (error) {\n        return new PersistencePromise(function (resolve, reject) {\n            reject(error);\n        });\n    };\n    PersistencePromise.waitFor = function (\n        // tslint:disable-next-line:no-any Accept all Promise types in waitFor().\n        all) {\n        return all.reduce(function (promise, nextPromise, idx) {\n            return promise.next(function () {\n                return nextPromise;\n            });\n        }, PersistencePromise.resolve());\n    };\n    PersistencePromise.map = function (all) {\n        var results = [];\n        var first = true;\n        // initial is ignored, so we can cheat on the type.\n        // tslint:disable-next-line:no-any\n        var initial = PersistencePromise.resolve(null);\n        return all\n            .reduce(function (promise, nextPromise) {\n            return promise.next(function (result) {\n                if (!first) {\n                    results.push(result);\n                }\n                first = false;\n                return nextPromise;\n            });\n        }, initial)\n            .next(function (result) {\n            results.push(result);\n            return results;\n        });\n    };\n    return PersistencePromise;\n}());\n\n\n//# sourceMappingURL=persistence_promise.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/eager_garbage_collector.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * A garbage collector implementation that eagerly collects documents as soon as\n * they're no longer referenced in any of its registered GarbageSources.\n *\n * This implementation keeps track of a set of keys that are potentially garbage\n * without keeping an exact reference count. During collectGarbage, the\n * collector verifies that all potential garbage keys actually have no\n * references by consulting its list of garbage sources.\n */\nvar eager_garbage_collector_EagerGarbageCollector = /** @class */ (function () {\n    function EagerGarbageCollector() {\n        this.isEager = true;\n        /**\n         * The garbage collectible sources to double-check during garbage collection.\n         */\n        this.sources = [];\n        /**\n         * A set of potentially garbage keys.\n         * PORTING NOTE: This would be a mutable set if Javascript had one.\n         */\n        this.potentialGarbage = documentKeySet();\n    }\n    EagerGarbageCollector.prototype.addGarbageSource = function (garbageSource) {\n        this.sources.push(garbageSource);\n        garbageSource.setGarbageCollector(this);\n    };\n    EagerGarbageCollector.prototype.removeGarbageSource = function (garbageSource) {\n        this.sources.splice(this.sources.indexOf(garbageSource), 1);\n        garbageSource.setGarbageCollector(null);\n    };\n    EagerGarbageCollector.prototype.addPotentialGarbageKey = function (key) {\n        this.potentialGarbage = this.potentialGarbage.add(key);\n    };\n    EagerGarbageCollector.prototype.collectGarbage = function (txn) {\n        var _this = this;\n        var promises = [];\n        var garbageKeys = documentKeySet();\n        this.potentialGarbage.forEach(function (key) {\n            var hasRefsPromise = _this.documentHasAnyReferences(txn, key);\n            promises.push(hasRefsPromise.next(function (hasRefs) {\n                // If there are no references, get the key.\n                if (!hasRefs) {\n                    garbageKeys = garbageKeys.add(key);\n                }\n                return persistence_promise_PersistencePromise.resolve();\n            }));\n        });\n        // Clear locally retained potential keys and returned confirmed garbage.\n        this.potentialGarbage = documentKeySet();\n        return persistence_promise_PersistencePromise.waitFor(promises).next(function () { return garbageKeys; });\n    };\n    EagerGarbageCollector.prototype.documentHasAnyReferences = function (txn, key) {\n        var initial = persistence_promise_PersistencePromise.resolve(false);\n        return this.sources\n            .map(function (source) { return function () { return source.containsKey(txn, key); }; })\n            .reduce(function (promise, nextPromise) {\n            return promise.next(function (result) {\n                if (result) {\n                    return persistence_promise_PersistencePromise.resolve(true);\n                }\n                else {\n                    return nextPromise();\n                }\n            });\n        }, initial);\n    };\n    return EagerGarbageCollector;\n}());\n\n\n//# sourceMappingURL=eager_garbage_collector.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/local_view_changes.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * A set of changes to what documents are currently in view and out of view for\n * a given query. These changes are sent to the LocalStore by the View (via\n * the SyncEngine) and are used to pin / unpin documents as appropriate.\n */\nvar local_view_changes_LocalViewChanges = /** @class */ (function () {\n    function LocalViewChanges(query, addedKeys, removedKeys) {\n        this.query = query;\n        this.addedKeys = addedKeys;\n        this.removedKeys = removedKeys;\n    }\n    LocalViewChanges.fromSnapshot = function (viewSnapshot) {\n        var addedKeys = documentKeySet();\n        var removedKeys = documentKeySet();\n        for (var _i = 0, _a = viewSnapshot.docChanges; _i < _a.length; _i++) {\n            var docChange = _a[_i];\n            switch (docChange.type) {\n                case ChangeType.Added:\n                    addedKeys = addedKeys.add(docChange.doc.key);\n                    break;\n                case ChangeType.Removed:\n                    removedKeys = removedKeys.add(docChange.doc.key);\n                    break;\n                default:\n            }\n        }\n        return new LocalViewChanges(viewSnapshot.query, addedKeys, removedKeys);\n    };\n    return LocalViewChanges;\n}());\n\n\n//# sourceMappingURL=local_view_changes.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/reference_set.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n/**\n * A collection of references to a document from some kind of numbered entity\n * (either a target ID or batch ID). As references are added to or removed from\n * the set corresponding events are emitted to a registered garbage collector.\n *\n * Each reference is represented by a DocumentReference object. Each of them\n * contains enough information to uniquely identify the reference. They are all\n * stored primarily in a set sorted by key. A document is considered garbage if\n * there's no references in that set (this can be efficiently checked thanks to\n * sorting by key).\n *\n * ReferenceSet also keeps a secondary set that contains references sorted by\n * IDs. This one is used to efficiently implement removal of all references by\n * some target ID.\n */\nvar reference_set_ReferenceSet = /** @class */ (function () {\n    function ReferenceSet() {\n        // A set of outstanding references to a document sorted by key.\n        this.refsByKey = new sorted_set_SortedSet(reference_set_DocReference.compareByKey);\n        // A set of outstanding references to a document sorted by target id.\n        this.refsByTarget = new sorted_set_SortedSet(reference_set_DocReference.compareByTargetId);\n        /** Keeps track of keys that have references */\n        this.garbageCollector = null;\n    }\n    /** Returns true if the reference set contains no references. */\n    ReferenceSet.prototype.isEmpty = function () {\n        return this.refsByKey.isEmpty();\n    };\n    /** Adds a reference to the given document key for the given ID. */\n    ReferenceSet.prototype.addReference = function (key, id) {\n        var ref = new reference_set_DocReference(key, id);\n        this.refsByKey = this.refsByKey.add(ref);\n        this.refsByTarget = this.refsByTarget.add(ref);\n    };\n    /** Add references to the given document keys for the given ID. */\n    ReferenceSet.prototype.addReferences = function (keys, id) {\n        var _this = this;\n        keys.forEach(function (key) { return _this.addReference(key, id); });\n    };\n    /**\n     * Removes a reference to the given document key for the given\n     * ID.\n     */\n    ReferenceSet.prototype.removeReference = function (key, id) {\n        this.removeRef(new reference_set_DocReference(key, id));\n    };\n    ReferenceSet.prototype.removeReferences = function (keys, id) {\n        var _this = this;\n        keys.forEach(function (key) { return _this.removeReference(key, id); });\n    };\n    /**\n     * Clears all references with a given ID. Calls removeRef() for each key\n     * removed.\n     */\n    ReferenceSet.prototype.removeReferencesForId = function (id) {\n        var _this = this;\n        var emptyKey = document_key_DocumentKey.EMPTY;\n        var startRef = new reference_set_DocReference(emptyKey, id);\n        var endRef = new reference_set_DocReference(emptyKey, id + 1);\n        this.refsByTarget.forEachInRange([startRef, endRef], function (ref) {\n            _this.removeRef(ref);\n        });\n    };\n    ReferenceSet.prototype.removeAllReferences = function () {\n        var _this = this;\n        this.refsByKey.forEach(function (ref) { return _this.removeRef(ref); });\n    };\n    ReferenceSet.prototype.removeRef = function (ref) {\n        this.refsByKey = this.refsByKey.delete(ref);\n        this.refsByTarget = this.refsByTarget.delete(ref);\n        if (this.garbageCollector !== null) {\n            this.garbageCollector.addPotentialGarbageKey(ref.key);\n        }\n    };\n    ReferenceSet.prototype.referencesForId = function (id) {\n        var emptyKey = document_key_DocumentKey.EMPTY;\n        var startRef = new reference_set_DocReference(emptyKey, id);\n        var endRef = new reference_set_DocReference(emptyKey, id + 1);\n        var keys = documentKeySet();\n        this.refsByTarget.forEachInRange([startRef, endRef], function (ref) {\n            keys = keys.add(ref.key);\n        });\n        return keys;\n    };\n    ReferenceSet.prototype.setGarbageCollector = function (garbageCollector) {\n        this.garbageCollector = garbageCollector;\n    };\n    ReferenceSet.prototype.containsKey = function (txn, key) {\n        var ref = new reference_set_DocReference(key, 0);\n        var firstRef = this.refsByKey.firstAfterOrEqual(ref);\n        return persistence_promise_PersistencePromise.resolve(firstRef !== null && key.isEqual(firstRef.key));\n    };\n    return ReferenceSet;\n}());\n\nvar reference_set_DocReference = /** @class */ (function () {\n    function DocReference(key, targetOrBatchId) {\n        this.key = key;\n        this.targetOrBatchId = targetOrBatchId;\n    }\n    /** Compare by key then by ID */\n    DocReference.compareByKey = function (left, right) {\n        return (document_key_DocumentKey.comparator(left.key, right.key) ||\n            primitiveComparator(left.targetOrBatchId, right.targetOrBatchId));\n    };\n    /** Compare by ID then by key */\n    DocReference.compareByTargetId = function (left, right) {\n        return (primitiveComparator(left.targetOrBatchId, right.targetOrBatchId) ||\n            document_key_DocumentKey.comparator(left.key, right.key));\n    };\n    return DocReference;\n}());\n\n\n//# sourceMappingURL=reference_set.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/target_id_generator.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar RESERVED_BITS = 1;\nvar GeneratorIds;\n(function (GeneratorIds) {\n    GeneratorIds[GeneratorIds[\"LocalStore\"] = 0] = \"LocalStore\";\n    GeneratorIds[GeneratorIds[\"SyncEngine\"] = 1] = \"SyncEngine\";\n})(GeneratorIds || (GeneratorIds = {}));\n/**\n * TargetIdGenerator generates monotonically increasing integer IDs. There are\n * separate generators for different scopes. While these generators will operate\n * independently of each other, they are scoped, such that no two generators\n * will ever produce the same ID. This is useful, because sometimes the backend\n * may group IDs from separate parts of the client into the same ID space.\n */\nvar TargetIdGenerator = /** @class */ (function () {\n    function TargetIdGenerator(generatorId, initAfter) {\n        if (initAfter === void 0) { initAfter = 0; }\n        this.generatorId = generatorId;\n        // Replace the generator part of initAfter with this generator's ID.\n        var afterWithoutGenerator = (initAfter >> RESERVED_BITS) << RESERVED_BITS;\n        var afterGenerator = initAfter - afterWithoutGenerator;\n        if (afterGenerator >= generatorId) {\n            // For example, if:\n            //   this.generatorId = 0b0000\n            //   after = 0b1011\n            //   afterGenerator = 0b0001\n            // Then:\n            //   previous = 0b1010\n            //   next = 0b1100\n            this.previousId = afterWithoutGenerator | this.generatorId;\n        }\n        else {\n            // For example, if:\n            //   this.generatorId = 0b0001\n            //   after = 0b1010\n            //   afterGenerator = 0b0000\n            // Then:\n            //   previous = 0b1001\n            //   next = 0b1011\n            this.previousId =\n                (afterWithoutGenerator | this.generatorId) - (1 << RESERVED_BITS);\n        }\n    }\n    TargetIdGenerator.prototype.next = function () {\n        this.previousId += 1 << RESERVED_BITS;\n        return this.previousId;\n    };\n    TargetIdGenerator.forLocalStore = function (initAfter) {\n        if (initAfter === void 0) { initAfter = 0; }\n        return new TargetIdGenerator(GeneratorIds.LocalStore, initAfter);\n    };\n    TargetIdGenerator.forSyncEngine = function () {\n        return new TargetIdGenerator(GeneratorIds.SyncEngine);\n    };\n    return TargetIdGenerator;\n}());\n\n\n//# sourceMappingURL=target_id_generator.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/view.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\nvar AddedLimboDocument = /** @class */ (function () {\n    function AddedLimboDocument(key) {\n        this.key = key;\n    }\n    return AddedLimboDocument;\n}());\n\nvar RemovedLimboDocument = /** @class */ (function () {\n    function RemovedLimboDocument(key) {\n        this.key = key;\n    }\n    return RemovedLimboDocument;\n}());\n\n/**\n * View is responsible for computing the final merged truth of what docs are in\n * a query. It gets notified of local and remote changes to docs, and applies\n * the query filters and limits to determine the most correct possible results.\n */\nvar view_View = /** @class */ (function () {\n    function View(query, \n        /** Documents included in the remote target */\n        syncedDocuments) {\n        this.query = query;\n        this.syncedDocuments = syncedDocuments;\n        this.syncState = null;\n        /**\n         * A flag whether the view is current with the backend. A view is considered\n         * current after it has seen the current flag from the backend and did not\n         * lose consistency within the watch stream (e.g. because of an existence\n         * filter mismatch).\n         */\n        this.current = false;\n        /** Documents in the view but not in the remote target */\n        this.limboDocuments = documentKeySet();\n        /** Document Keys that have local changes */\n        this.mutatedKeys = documentKeySet();\n        this.documentSet = new document_set_DocumentSet(query.docComparator.bind(query));\n    }\n    /**\n     * Iterates over a set of doc changes, applies the query limit, and computes\n     * what the new results should be, what the changes were, and whether we may\n     * need to go back to the local cache for more results. Does not make any\n     * changes to the view.\n     * @param docChanges The doc changes to apply to this view.\n     * @param previousChanges If this is being called with a refill, then start\n     *        with this set of docs and changes instead of the current view.\n     * @return a new set of docs, changes, and refill flag.\n     */\n    View.prototype.computeDocChanges = function (docChanges, previousChanges) {\n        var _this = this;\n        var changeSet = previousChanges\n            ? previousChanges.changeSet\n            : new view_snapshot_DocumentChangeSet();\n        var oldDocumentSet = previousChanges\n            ? previousChanges.documentSet\n            : this.documentSet;\n        var newMutatedKeys = previousChanges\n            ? previousChanges.mutatedKeys\n            : this.mutatedKeys;\n        var newDocumentSet = oldDocumentSet;\n        var needsRefill = false;\n        // Track the last doc in a (full) limit. This is necessary, because some\n        // update (a delete, or an update moving a doc past the old limit) might\n        // mean there is some other document in the local cache that either should\n        // come (1) between the old last limit doc and the new last document, in the\n        // case of updates, or (2) after the new last document, in the case of\n        // deletes. So we keep this doc at the old limit to compare the updates to.\n        //\n        // Note that this should never get used in a refill (when previousChanges is\n        // set), because there will only be adds -- no deletes or updates.\n        var lastDocInLimit = this.query.hasLimit() && oldDocumentSet.size === this.query.limit\n            ? oldDocumentSet.last()\n            : null;\n        docChanges.inorderTraversal(function (key, newMaybeDoc) {\n            var oldDoc = oldDocumentSet.get(key);\n            var newDoc = newMaybeDoc instanceof document_Document ? newMaybeDoc : null;\n            if (newDoc) {\n                assert(key.isEqual(newDoc.key), 'Mismatching keys found in document changes: ' +\n                    key +\n                    ' != ' +\n                    newDoc.key);\n                newDoc = _this.query.matches(newDoc) ? newDoc : null;\n            }\n            if (newDoc) {\n                newDocumentSet = newDocumentSet.add(newDoc);\n                if (newDoc.hasLocalMutations) {\n                    newMutatedKeys = newMutatedKeys.add(key);\n                }\n                else {\n                    newMutatedKeys = newMutatedKeys.delete(key);\n                }\n            }\n            else {\n                newDocumentSet = newDocumentSet.delete(key);\n                newMutatedKeys = newMutatedKeys.delete(key);\n            }\n            // Calculate change\n            if (oldDoc && newDoc) {\n                var docsEqual = oldDoc.data.isEqual(newDoc.data);\n                if (!docsEqual ||\n                    oldDoc.hasLocalMutations !== newDoc.hasLocalMutations) {\n                    // only report a change if document actually changed\n                    if (docsEqual) {\n                        changeSet.track({ type: ChangeType.Metadata, doc: newDoc });\n                    }\n                    else {\n                        changeSet.track({ type: ChangeType.Modified, doc: newDoc });\n                    }\n                    if (lastDocInLimit &&\n                        _this.query.docComparator(newDoc, lastDocInLimit) > 0) {\n                        // This doc moved from inside the limit to after the limit.\n                        // That means there may be some doc in the local cache that's\n                        // actually less than this one.\n                        needsRefill = true;\n                    }\n                }\n            }\n            else if (!oldDoc && newDoc) {\n                changeSet.track({ type: ChangeType.Added, doc: newDoc });\n            }\n            else if (oldDoc && !newDoc) {\n                changeSet.track({ type: ChangeType.Removed, doc: oldDoc });\n                if (lastDocInLimit) {\n                    // A doc was removed from a full limit query. We'll need to\n                    // requery from the local cache to see if we know about some other\n                    // doc that should be in the results.\n                    needsRefill = true;\n                }\n            }\n        });\n        if (this.query.hasLimit()) {\n            // TODO(klimt): Make DocumentSet size be constant time.\n            while (newDocumentSet.size > this.query.limit) {\n                var oldDoc = newDocumentSet.last();\n                newDocumentSet = newDocumentSet.delete(oldDoc.key);\n                changeSet.track({ type: ChangeType.Removed, doc: oldDoc });\n            }\n        }\n        assert(!needsRefill || !previousChanges, 'View was refilled using docs that themselves needed refilling.');\n        return {\n            documentSet: newDocumentSet,\n            changeSet: changeSet,\n            needsRefill: needsRefill,\n            mutatedKeys: newMutatedKeys\n        };\n    };\n    /**\n     * Updates the view with the given ViewDocumentChanges and updates limbo docs\n     * and sync state from the given (optional) target change.\n     * @param docChanges The set of changes to make to the view's docs.\n     * @param targetChange A target change to apply for computing limbo docs and\n     *        sync state.\n     * @return A new ViewChange with the given docs, changes, and sync state.\n     */\n    View.prototype.applyChanges = function (docChanges, targetChange) {\n        var _this = this;\n        assert(!docChanges.needsRefill, 'Cannot apply changes that need a refill');\n        var oldDocs = this.documentSet;\n        this.documentSet = docChanges.documentSet;\n        this.mutatedKeys = docChanges.mutatedKeys;\n        // Sort changes based on type and query comparator\n        var changes = docChanges.changeSet.getChanges();\n        changes.sort(function (c1, c2) {\n            return (compareChangeType(c1.type, c2.type) ||\n                _this.query.docComparator(c1.doc, c2.doc));\n        });\n        this.applyTargetChange(targetChange);\n        var limboChanges = this.updateLimboDocuments();\n        var synced = this.limboDocuments.size === 0 && this.current;\n        var newSyncState = synced ? SyncState.Synced : SyncState.Local;\n        var syncStateChanged = newSyncState !== this.syncState;\n        this.syncState = newSyncState;\n        if (changes.length === 0 && !syncStateChanged) {\n            // no changes\n            return { limboChanges: limboChanges };\n        }\n        else {\n            var snap = new ViewSnapshot(this.query, docChanges.documentSet, oldDocs, changes, newSyncState === SyncState.Local, !docChanges.mutatedKeys.isEmpty(), syncStateChanged);\n            return {\n                snapshot: snap,\n                limboChanges: limboChanges\n            };\n        }\n    };\n    /**\n     * Applies an OnlineState change to the view, potentially generating a\n     * ViewChange if the view's syncState changes as a result.\n     */\n    View.prototype.applyOnlineStateChange = function (onlineState) {\n        if (this.current && onlineState === OnlineState.Failed) {\n            // If we're offline, set `current` to false and then call applyChanges()\n            // to refresh our syncState and generate a ViewChange as appropriate. We\n            // are guaranteed to get a new TargetChange that sets `current` back to\n            // true once the client is back online.\n            this.current = false;\n            return this.applyChanges({\n                documentSet: this.documentSet,\n                changeSet: new view_snapshot_DocumentChangeSet(),\n                mutatedKeys: this.mutatedKeys,\n                needsRefill: false\n            });\n        }\n        else {\n            // No effect, just return a no-op ViewChange.\n            return { limboChanges: [] };\n        }\n    };\n    /**\n     * Returns whether the doc for the given key should be in limbo.\n     */\n    View.prototype.shouldBeInLimbo = function (key) {\n        // If the remote end says it's part of this query, it's not in limbo.\n        if (this.syncedDocuments.has(key)) {\n            return false;\n        }\n        // The local store doesn't think it's a result, so it shouldn't be in limbo.\n        if (!this.documentSet.has(key)) {\n            return false;\n        }\n        // If there are local changes to the doc, they might explain why the server\n        // doesn't know that it's part of the query. So don't put it in limbo.\n        // TODO(klimt): Ideally, we would only consider changes that might actually\n        // affect this specific query.\n        if (this.documentSet.get(key).hasLocalMutations) {\n            return false;\n        }\n        // Everything else is in limbo.\n        return true;\n    };\n    /**\n     * Updates syncedDocuments, current, and limbo docs based on the given change.\n     * Returns the list of changes to which docs are in limbo.\n     */\n    View.prototype.applyTargetChange = function (targetChange) {\n        if (targetChange) {\n            var targetMapping = targetChange.mapping;\n            if (targetMapping instanceof ResetMapping) {\n                this.syncedDocuments = targetMapping.documents;\n            }\n            else if (targetMapping instanceof UpdateMapping) {\n                this.syncedDocuments = targetMapping.applyToKeySet(this.syncedDocuments);\n            }\n            switch (targetChange.currentStatusUpdate) {\n                case CurrentStatusUpdate.MarkCurrent:\n                    this.current = true;\n                    break;\n                case CurrentStatusUpdate.MarkNotCurrent:\n                    this.current = false;\n                    break;\n                case CurrentStatusUpdate.None:\n                    break;\n                default:\n                    fail('Unknown current status update: ' + targetChange.currentStatusUpdate);\n            }\n        }\n    };\n    View.prototype.updateLimboDocuments = function () {\n        var _this = this;\n        // We can only determine limbo documents when we're in-sync with the server.\n        if (!this.current) {\n            return [];\n        }\n        // TODO(klimt): Do this incrementally so that it's not quadratic when\n        // updating many documents.\n        var oldLimboDocuments = this.limboDocuments;\n        this.limboDocuments = documentKeySet();\n        this.documentSet.forEach(function (doc) {\n            if (_this.shouldBeInLimbo(doc.key)) {\n                _this.limboDocuments = _this.limboDocuments.add(doc.key);\n            }\n        });\n        // Diff the new limbo docs with the old limbo docs.\n        var changes = [];\n        oldLimboDocuments.forEach(function (key) {\n            if (!_this.limboDocuments.has(key)) {\n                changes.push(new RemovedLimboDocument(key));\n            }\n        });\n        this.limboDocuments.forEach(function (key) {\n            if (!oldLimboDocuments.has(key)) {\n                changes.push(new AddedLimboDocument(key));\n            }\n        });\n        return changes;\n    };\n    return View;\n}());\n\nfunction compareChangeType(c1, c2) {\n    var order = function (change) {\n        switch (change) {\n            case ChangeType.Added:\n                return 1;\n            case ChangeType.Modified:\n                return 2;\n            case ChangeType.Metadata:\n                // A metadata change is converted to a modified change at the public\n                // api layer.  Since we sort by document key and then change type,\n                // metadata and modified changes must be sorted equivalently.\n                return 2;\n            case ChangeType.Removed:\n                return 0;\n            default:\n                return fail('Unknown ChangeType: ' + change);\n        }\n    };\n    return order(c1) - order(c2);\n}\n\n//# sourceMappingURL=view.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/sync_engine.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar sync_engine_LOG_TAG = 'SyncEngine';\n/**\n * QueryView contains all of the data that SyncEngine needs to keep track of for\n * a particular query.\n */\nvar QueryView = /** @class */ (function () {\n    function QueryView(\n        /**\n         * The query itself.\n         */\n        query, \n        /**\n         * The target number created by the client that is used in the watch\n         * stream to identify this query.\n         */\n        targetId, \n        /**\n         * An identifier from the datastore backend that indicates the last state\n         * of the results that was received. This can be used to indicate where\n         * to continue receiving new doc changes for the query.\n         */\n        resumeToken, \n        /**\n         * The view is responsible for computing the final merged truth of what\n         * docs are in the query. It gets notified of local and remote changes,\n         * and applies the query filters and limits to determine the most correct\n         * possible results.\n         */\n        view) {\n        this.query = query;\n        this.targetId = targetId;\n        this.resumeToken = resumeToken;\n        this.view = view;\n    }\n    return QueryView;\n}());\n/**\n * SyncEngine is the central controller in the client SDK architecture. It is\n * the glue code between the EventManager, LocalStore, and RemoteStore. Some of\n * SyncEngine's responsibilities include:\n * 1. Coordinating client requests and remote events between the EventManager\n *    and the local and remote data stores.\n * 2. Managing a View object for each query, providing the unified view between\n *    the local and remote data stores.\n * 3. Notifying the RemoteStore when the LocalStore has new mutations in its\n *    queue that need sending to the backend.\n *\n * The SyncEngine’s methods should only ever be called by methods running in the\n * global async queue.\n */\nvar sync_engine_SyncEngine = /** @class */ (function () {\n    function SyncEngine(localStore, remoteStore, currentUser) {\n        this.localStore = localStore;\n        this.remoteStore = remoteStore;\n        this.currentUser = currentUser;\n        this.viewHandler = null;\n        this.errorHandler = null;\n        this.queryViewsByQuery = new obj_map_ObjectMap(function (q) {\n            return q.canonicalId();\n        });\n        this.queryViewsByTarget = {};\n        this.limboTargetsByKey = new SortedMap(document_key_DocumentKey.comparator);\n        this.limboKeysByTarget = {};\n        this.limboDocumentRefs = new reference_set_ReferenceSet();\n        this.limboCollector = new eager_garbage_collector_EagerGarbageCollector();\n        /** Stores user completion handlers, indexed by User and BatchId. */\n        this.mutationUserCallbacks = {};\n        this.targetIdGenerator = TargetIdGenerator.forSyncEngine();\n    }\n    /** Subscribes view and error handler. Can be called only once. */\n    SyncEngine.prototype.subscribe = function (viewHandler, errorHandler) {\n        assert(viewHandler !== null && errorHandler !== null, 'View and error handlers cannot be null');\n        assert(this.viewHandler === null && this.errorHandler === null, 'SyncEngine already has a subscriber.');\n        this.viewHandler = viewHandler;\n        this.errorHandler = errorHandler;\n        this.limboCollector.addGarbageSource(this.limboDocumentRefs);\n    };\n    /**\n     * Initiates the new listen, resolves promise when listen enqueued to the\n     * server. All the subsequent view snapshots or errors are sent to the\n     * subscribed handlers. Returns the targetId of the query.\n     */\n    SyncEngine.prototype.listen = function (query) {\n        var _this = this;\n        this.assertSubscribed('listen()');\n        assert(!this.queryViewsByQuery.has(query), 'We already listen to the query: ' + query);\n        return this.localStore.allocateQuery(query).then(function (queryData) {\n            return _this.localStore\n                .executeQuery(query)\n                .then(function (docs) {\n                return _this.localStore\n                    .remoteDocumentKeys(queryData.targetId)\n                    .then(function (remoteKeys) {\n                    var view = new view_View(query, remoteKeys);\n                    var viewDocChanges = view.computeDocChanges(docs);\n                    var viewChange = view.applyChanges(viewDocChanges);\n                    assert(viewChange.limboChanges.length === 0, 'View returned limbo docs before target ack from the server.');\n                    assert(!!viewChange.snapshot, 'applyChanges for new view should always return a snapshot');\n                    var data = new QueryView(query, queryData.targetId, queryData.resumeToken, view);\n                    _this.queryViewsByQuery.set(query, data);\n                    _this.queryViewsByTarget[queryData.targetId] = data;\n                    _this.viewHandler([viewChange.snapshot]);\n                    _this.remoteStore.listen(queryData);\n                });\n            })\n                .then(function () {\n                return queryData.targetId;\n            });\n        });\n    };\n    /** Stops listening to the query. */\n    SyncEngine.prototype.unlisten = function (query) {\n        var _this = this;\n        this.assertSubscribed('unlisten()');\n        var queryView = this.queryViewsByQuery.get(query);\n        assert(!!queryView, 'Trying to unlisten on query not found:' + query);\n        return this.localStore.releaseQuery(query).then(function () {\n            _this.remoteStore.unlisten(queryView.targetId);\n            return _this.removeAndCleanupQuery(queryView).then(function () {\n                return _this.localStore.collectGarbage();\n            });\n        });\n    };\n    /**\n     * Initiates the write of local mutation batch which involves adding the\n     * writes to the mutation queue, notifying the remote store about new\n     * mutations and raising events for any changes this write caused.\n     *\n     * The promise returned by this call is resolved when the above steps\n     * have completed, *not* when the write was acked by the backend. The\n     * userCallback is resolved once the write was acked/rejected by the\n     * backend (or failed locally for any other reason).\n     */\n    SyncEngine.prototype.write = function (batch, userCallback) {\n        var _this = this;\n        this.assertSubscribed('write()');\n        return this.localStore\n            .localWrite(batch)\n            .then(function (result) {\n            _this.addMutationCallback(result.batchId, userCallback);\n            return _this.emitNewSnapsAndNotifyLocalStore(result.changes);\n        })\n            .then(function () {\n            return _this.remoteStore.fillWritePipeline();\n        });\n    };\n    // TODO(klimt): Wrap the given error in a standard Firestore error object.\n    SyncEngine.prototype.wrapUpdateFunctionError = function (error) {\n        return error;\n    };\n    /**\n     * Takes an updateFunction in which a set of reads and writes can be performed\n     * atomically. In the updateFunction, the client can read and write values\n     * using the supplied transaction object. After the updateFunction, all\n     * changes will be committed. If some other client has changed any of the data\n     * referenced, then the updateFunction will be called again. If the\n     * updateFunction still fails after the given number of retries, then the\n     * transaction will be rejection.\n     *\n     * The transaction object passed to the updateFunction contains methods for\n     * accessing documents and collections. Unlike other datastore access, data\n     * accessed with the transaction will not reflect local changes that have not\n     * been committed. For this reason, it is required that all reads are\n     * performed before any writes. Transactions must be performed while online.\n     *\n     * The promise returned is resolved when the transaction is fully committed.\n     */\n    SyncEngine.prototype.runTransaction = function (updateFunction, retries) {\n        var _this = this;\n        if (retries === void 0) { retries = 5; }\n        assert(retries >= 0, 'Got negative number of retries for transaction.');\n        var transaction = this.remoteStore.createTransaction();\n        var wrappedUpdateFunction = function () {\n            try {\n                var userPromise = updateFunction(transaction);\n                if (isNullOrUndefined(userPromise) ||\n                    !userPromise.catch ||\n                    !userPromise.then) {\n                    return Promise.reject(Error('Transaction callback must return a Promise'));\n                }\n                return userPromise.catch(function (e) {\n                    return Promise.reject(_this.wrapUpdateFunctionError(e));\n                });\n            }\n            catch (e) {\n                return Promise.reject(_this.wrapUpdateFunctionError(e));\n            }\n        };\n        return wrappedUpdateFunction().then(function (result) {\n            return transaction\n                .commit()\n                .then(function () {\n                return result;\n            })\n                .catch(function (error) {\n                if (retries === 0) {\n                    return Promise.reject(error);\n                }\n                // TODO(klimt): Put in a retry delay?\n                return _this.runTransaction(updateFunction, retries - 1);\n            });\n        });\n    };\n    SyncEngine.prototype.applyRemoteEvent = function (remoteEvent) {\n        var _this = this;\n        this.assertSubscribed('applyRemoteEvent()');\n        // Make sure limbo documents are deleted if there were no results\n        forEachNumber(remoteEvent.targetChanges, function (targetId, targetChange) {\n            var limboKey = _this.limboKeysByTarget[targetId];\n            if (limboKey &&\n                targetChange.currentStatusUpdate ===\n                    CurrentStatusUpdate.MarkCurrent &&\n                !remoteEvent.documentUpdates.get(limboKey)) {\n                // When listening to a query the server responds with a snapshot\n                // containing documents matching the query and a current marker\n                // telling us we're now in sync. It's possible for these to arrive\n                // as separate remote events or as a single remote event.\n                // For a document query, there will be no documents sent in the\n                // response if the document doesn't exist.\n                //\n                // If the snapshot arrives separately from the current marker,\n                // we handle it normally and updateTrackedLimbos will resolve the\n                // limbo status of the document, removing it from limboDocumentRefs.\n                // This works because clients only initiate limbo resolution when\n                // a target is current and because all current targets are\n                // always at a consistent snapshot.\n                //\n                // However, if the document doesn't exist and the current marker\n                // arrives, the document is not present in the snapshot and our\n                // normal view handling would consider the document to remain in\n                // limbo indefinitely because there are no updates to the document.\n                // To avoid this, we specially handle this just this case here:\n                // synthesizing a delete.\n                //\n                // TODO(dimond): Ideally we would have an explicit lookup query\n                // instead resulting in an explicit delete message and we could\n                // remove this special logic.\n                remoteEvent.addDocumentUpdate(new document_NoDocument(limboKey, remoteEvent.snapshotVersion));\n            }\n        });\n        return this.localStore.applyRemoteEvent(remoteEvent).then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes, remoteEvent);\n        });\n    };\n    /**\n     * Applies an OnlineState change to the sync engine and notifies any views of\n     * the change.\n     */\n    SyncEngine.prototype.applyOnlineStateChange = function (onlineState) {\n        var newViewSnapshots = [];\n        this.queryViewsByQuery.forEach(function (query, queryView) {\n            var viewChange = queryView.view.applyOnlineStateChange(onlineState);\n            assert(viewChange.limboChanges.length === 0, 'OnlineState should not affect limbo documents.');\n            if (viewChange.snapshot) {\n                newViewSnapshots.push(viewChange.snapshot);\n            }\n        });\n        this.viewHandler(newViewSnapshots);\n    };\n    SyncEngine.prototype.rejectListen = function (targetId, err) {\n        var _this = this;\n        this.assertSubscribed('rejectListens()');\n        var limboKey = this.limboKeysByTarget[targetId];\n        if (limboKey) {\n            // Since this query failed, we won't want to manually unlisten to it.\n            // So go ahead and remove it from bookkeeping.\n            this.limboTargetsByKey = this.limboTargetsByKey.remove(limboKey);\n            delete this.limboKeysByTarget[targetId];\n            // TODO(klimt): We really only should do the following on permission\n            // denied errors, but we don't have the cause code here.\n            // It's a limbo doc. Create a synthetic event saying it was deleted.\n            // This is kind of a hack. Ideally, we would have a method in the local\n            // store to purge a document. However, it would be tricky to keep all of\n            // the local store's invariants with another method.\n            var docMap = new SortedMap(document_key_DocumentKey.comparator);\n            docMap = docMap.insert(limboKey, new document_NoDocument(limboKey, snapshot_version_SnapshotVersion.forDeletedDoc()));\n            var event_1 = new remote_event_RemoteEvent(snapshot_version_SnapshotVersion.MIN, {}, docMap);\n            return this.applyRemoteEvent(event_1);\n        }\n        else {\n            var queryView_1 = this.queryViewsByTarget[targetId];\n            assert(!!queryView_1, 'Unknown targetId: ' + targetId);\n            return this.localStore.releaseQuery(queryView_1.query).then(function () {\n                return _this.removeAndCleanupQuery(queryView_1).then(function () {\n                    _this.errorHandler(queryView_1.query, err);\n                });\n            });\n        }\n    };\n    SyncEngine.prototype.applySuccessfulWrite = function (mutationBatchResult) {\n        var _this = this;\n        this.assertSubscribed('applySuccessfulWrite()');\n        // The local store may or may not be able to apply the write result and\n        // raise events immediately (depending on whether the watcher is caught\n        // up), so we raise user callbacks first so that they consistently happen\n        // before listen events.\n        this.processUserCallback(mutationBatchResult.batch.batchId, \n        /*error=*/ null);\n        return this.localStore\n            .acknowledgeBatch(mutationBatchResult)\n            .then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes);\n        });\n    };\n    SyncEngine.prototype.rejectFailedWrite = function (batchId, error) {\n        var _this = this;\n        this.assertSubscribed('rejectFailedWrite()');\n        // The local store may or may not be able to apply the write result and\n        // raise events immediately (depending on whether the watcher is caught up),\n        // so we raise user callbacks first so that they consistently happen before\n        // listen events.\n        this.processUserCallback(batchId, error);\n        return this.localStore.rejectBatch(batchId).then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes);\n        });\n    };\n    SyncEngine.prototype.addMutationCallback = function (batchId, callback) {\n        var newCallbacks = this.mutationUserCallbacks[this.currentUser.toKey()];\n        if (!newCallbacks) {\n            newCallbacks = new SortedMap(primitiveComparator);\n        }\n        newCallbacks = newCallbacks.insert(batchId, callback);\n        this.mutationUserCallbacks[this.currentUser.toKey()] = newCallbacks;\n    };\n    /**\n     * Resolves or rejects the user callback for the given batch and then discards\n     * it.\n     */\n    SyncEngine.prototype.processUserCallback = function (batchId, error) {\n        var newCallbacks = this.mutationUserCallbacks[this.currentUser.toKey()];\n        // NOTE: Mutations restored from persistence won't have callbacks, so it's\n        // okay for there to be no callback for this ID.\n        if (newCallbacks) {\n            var callback = newCallbacks.get(batchId);\n            if (callback) {\n                assert(batchId === newCallbacks.minKey(), 'Mutation callbacks processed out-of-order?');\n                if (error) {\n                    callback.reject(error);\n                }\n                else {\n                    callback.resolve();\n                }\n                newCallbacks = newCallbacks.remove(batchId);\n            }\n            this.mutationUserCallbacks[this.currentUser.toKey()] = newCallbacks;\n        }\n    };\n    SyncEngine.prototype.removeAndCleanupQuery = function (queryView) {\n        this.queryViewsByQuery.delete(queryView.query);\n        delete this.queryViewsByTarget[queryView.targetId];\n        this.limboDocumentRefs.removeReferencesForId(queryView.targetId);\n        return this.gcLimboDocuments();\n    };\n    SyncEngine.prototype.updateTrackedLimbos = function (targetId, limboChanges) {\n        for (var _i = 0, limboChanges_1 = limboChanges; _i < limboChanges_1.length; _i++) {\n            var limboChange = limboChanges_1[_i];\n            if (limboChange instanceof AddedLimboDocument) {\n                this.limboDocumentRefs.addReference(limboChange.key, targetId);\n                this.trackLimboChange(limboChange);\n            }\n            else if (limboChange instanceof RemovedLimboDocument) {\n                debug(sync_engine_LOG_TAG, 'Document no longer in limbo: ' + limboChange.key);\n                this.limboDocumentRefs.removeReference(limboChange.key, targetId);\n            }\n            else {\n                fail('Unknown limbo change: ' + JSON.stringify(limboChange));\n            }\n        }\n        return this.gcLimboDocuments();\n    };\n    SyncEngine.prototype.trackLimboChange = function (limboChange) {\n        var key = limboChange.key;\n        if (!this.limboTargetsByKey.get(key)) {\n            debug(sync_engine_LOG_TAG, 'New document in limbo: ' + key);\n            var limboTargetId = this.targetIdGenerator.next();\n            var query = query_Query.atPath(key.path);\n            this.limboKeysByTarget[limboTargetId] = key;\n            this.remoteStore.listen(new query_data_QueryData(query, limboTargetId, QueryPurpose.Listen));\n            this.limboTargetsByKey = this.limboTargetsByKey.insert(key, limboTargetId);\n        }\n    };\n    SyncEngine.prototype.gcLimboDocuments = function () {\n        var _this = this;\n        // HACK: We can use a null transaction here, because we know that the\n        // reference set is entirely within memory and doesn't need a store engine.\n        return this.limboCollector\n            .collectGarbage(null)\n            .next(function (keys) {\n            keys.forEach(function (key) {\n                var limboTargetId = _this.limboTargetsByKey.get(key);\n                if (limboTargetId === null) {\n                    // This target already got removed, because the query failed.\n                    return;\n                }\n                _this.remoteStore.unlisten(limboTargetId);\n                _this.limboTargetsByKey = _this.limboTargetsByKey.remove(key);\n                delete _this.limboKeysByTarget[limboTargetId];\n            });\n        })\n            .toPromise();\n    };\n    // Visible for testing\n    SyncEngine.prototype.currentLimboDocs = function () {\n        return this.limboTargetsByKey;\n    };\n    SyncEngine.prototype.emitNewSnapsAndNotifyLocalStore = function (changes, remoteEvent) {\n        var _this = this;\n        var newSnaps = [];\n        var docChangesInAllViews = [];\n        var queriesProcessed = [];\n        this.queryViewsByQuery.forEach(function (_, queryView) {\n            queriesProcessed.push(Promise.resolve()\n                .then(function () {\n                var viewDocChanges = queryView.view.computeDocChanges(changes);\n                if (!viewDocChanges.needsRefill) {\n                    return viewDocChanges;\n                }\n                // The query has a limit and some docs were removed, so we need\n                // to re-run the query against the local store to make sure we\n                // didn't lose any good docs that had been past the limit.\n                return _this.localStore.executeQuery(queryView.query).then(function (docs) {\n                    return queryView.view.computeDocChanges(docs, viewDocChanges);\n                });\n            })\n                .then(function (viewDocChanges) {\n                var targetChange = remoteEvent && remoteEvent.targetChanges[queryView.targetId];\n                var viewChange = queryView.view.applyChanges(viewDocChanges, targetChange);\n                return _this.updateTrackedLimbos(queryView.targetId, viewChange.limboChanges).then(function () {\n                    if (viewChange.snapshot) {\n                        newSnaps.push(viewChange.snapshot);\n                        var docChanges = local_view_changes_LocalViewChanges.fromSnapshot(viewChange.snapshot);\n                        docChangesInAllViews.push(docChanges);\n                    }\n                });\n            }));\n        });\n        return Promise.all(queriesProcessed)\n            .then(function () {\n            _this.viewHandler(newSnaps);\n            return _this.localStore.notifyLocalViewChanges(docChangesInAllViews);\n        })\n            .then(function () {\n            return _this.localStore.collectGarbage();\n        });\n    };\n    SyncEngine.prototype.assertSubscribed = function (fnName) {\n        assert(this.viewHandler !== null && this.errorHandler !== null, 'Trying to call ' + fnName + ' before calling subscribe().');\n    };\n    SyncEngine.prototype.handleUserChange = function (user) {\n        var _this = this;\n        this.currentUser = user;\n        return this.localStore\n            .handleUserChange(user)\n            .then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes);\n        })\n            .then(function () {\n            return _this.remoteStore.handleUserChange(user);\n        });\n    };\n    return SyncEngine;\n}());\n\n\n//# sourceMappingURL=sync_engine.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/model/mutation_batch.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\nvar BATCHID_UNKNOWN = -1;\n/**\n * A batch of mutations that will be sent as one unit to the backend.\n */\nvar mutation_batch_MutationBatch = /** @class */ (function () {\n    function MutationBatch(batchId, localWriteTime, mutations) {\n        this.batchId = batchId;\n        this.localWriteTime = localWriteTime;\n        this.mutations = mutations;\n    }\n    /**\n     * Applies all the mutations in this MutationBatch to the specified document\n     * to create a new remote document\n     *\n     * @param docKey The key of the document to apply mutations to.\n     * @param maybeDoc The document to apply mutations to.\n     * @param batchResult The result of applying the MutationBatch to the\n     * backend.\n     */\n    MutationBatch.prototype.applyToRemoteDocument = function (docKey, maybeDoc, batchResult) {\n        if (maybeDoc) {\n            assert(maybeDoc.key.isEqual(docKey), \"applyToRemoteDocument: key \" + docKey + \" should match maybeDoc key\\n        \" + maybeDoc.key);\n        }\n        var mutationResults = batchResult.mutationResults;\n        assert(mutationResults.length === this.mutations.length, \"Mismatch between mutations length\\n      (\" + this.mutations.length + \") and mutation results length\\n      (\" + mutationResults.length + \").\");\n        for (var i = 0; i < this.mutations.length; i++) {\n            var mutation = this.mutations[i];\n            if (mutation.key.isEqual(docKey)) {\n                var mutationResult = mutationResults[i];\n                maybeDoc = mutation.applyToRemoteDocument(maybeDoc, mutationResult);\n            }\n        }\n        return maybeDoc;\n    };\n    /**\n     * Computes the local view of a document given all the mutations in this\n     * batch.\n     *\n     * @param docKey The key of the document to apply mutations to.\n     * @param maybeDoc The document to apply mutations to.\n     */\n    MutationBatch.prototype.applyToLocalView = function (docKey, maybeDoc) {\n        if (maybeDoc) {\n            assert(maybeDoc.key.isEqual(docKey), \"applyToLocalDocument: key \" + docKey + \" should match maybeDoc key\\n        \" + maybeDoc.key);\n        }\n        var baseDoc = maybeDoc;\n        for (var i = 0; i < this.mutations.length; i++) {\n            var mutation = this.mutations[i];\n            if (mutation.key.isEqual(docKey)) {\n                maybeDoc = mutation.applyToLocalView(maybeDoc, baseDoc, this.localWriteTime);\n            }\n        }\n        return maybeDoc;\n    };\n    MutationBatch.prototype.keys = function () {\n        var keySet = documentKeySet();\n        for (var _i = 0, _a = this.mutations; _i < _a.length; _i++) {\n            var mutation = _a[_i];\n            keySet = keySet.add(mutation.key);\n        }\n        return keySet;\n    };\n    MutationBatch.prototype.isEqual = function (other) {\n        return (this.batchId === other.batchId &&\n            arrayEquals(this.mutations, other.mutations));\n    };\n    /**\n     * Returns true if this mutation batch has already been removed from the\n     * mutation queue.\n     *\n     * Note that not all implementations of the MutationQueue necessarily use\n     * tombstones as part of their implementation and generally speaking no code\n     * outside the mutation queues should really care about this.\n     */\n    MutationBatch.prototype.isTombstone = function () {\n        return this.mutations.length === 0;\n    };\n    /** Converts this batch into a tombstone */\n    MutationBatch.prototype.toTombstone = function () {\n        return new MutationBatch(this.batchId, this.localWriteTime, []);\n    };\n    return MutationBatch;\n}());\n\n/** The result of applying a mutation batch to the backend. */\nvar mutation_batch_MutationBatchResult = /** @class */ (function () {\n    function MutationBatchResult(batch, commitVersion, mutationResults, streamToken, \n        /**\n         * A pre-computed mapping from each mutated document to the resulting\n         * version.\n         */\n        docVersions) {\n        this.batch = batch;\n        this.commitVersion = commitVersion;\n        this.mutationResults = mutationResults;\n        this.streamToken = streamToken;\n        this.docVersions = docVersions;\n    }\n    /**\n     * Creates a new MutationBatchResult for the given batch and results. There\n     * must be one result for each mutation in the batch. This static factory\n     * caches a document=>version mapping (docVersions).\n     */\n    MutationBatchResult.from = function (batch, commitVersion, results, streamToken) {\n        assert(batch.mutations.length === results.length, 'Mutations sent ' +\n            batch.mutations.length +\n            ' must equal results received ' +\n            results.length);\n        var versionMap = documentVersionMap();\n        var mutations = batch.mutations;\n        for (var i = 0; i < mutations.length; i++) {\n            var version = results[i].version;\n            if (version === null) {\n                // deletes don't have a version, so we substitute the commitVersion\n                // of the entire batch.\n                version = commitVersion;\n            }\n            versionMap = versionMap.insert(mutations[i].key, version);\n        }\n        return new MutationBatchResult(batch, commitVersion, results, streamToken, versionMap);\n    };\n    return MutationBatchResult;\n}());\n\n\n//# sourceMappingURL=mutation_batch.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/encoded_resource_path.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nvar escapeChar = '\\u0001';\nvar encodedSeparatorChar = '\\u0001';\nvar encodedNul = '\\u0010';\nvar encodedEscape = '\\u0011';\n/**\n * Encodes a resource path into a IndexedDb-compatible string form.\n */\nfunction encode(path) {\n    var result = '';\n    for (var i = 0; i < path.length; i++) {\n        if (result.length > 0) {\n            result = encodeSeparator(result);\n        }\n        result = encodeSegment(path.get(i), result);\n    }\n    return encodeSeparator(result);\n}\n/** Encodes a single segment of a resource path into the given result */\nfunction encodeSegment(segment, resultBuf) {\n    var result = resultBuf;\n    var length = segment.length;\n    for (var i = 0; i < length; i++) {\n        var c = segment.charAt(i);\n        switch (c) {\n            case '\\0':\n                result += escapeChar + encodedNul;\n                break;\n            case escapeChar:\n                result += escapeChar + encodedEscape;\n                break;\n            default:\n                result += c;\n        }\n    }\n    return result;\n}\n/** Encodes a path separator into the given result */\nfunction encodeSeparator(result) {\n    return result + escapeChar + encodedSeparatorChar;\n}\n/**\n * Decodes the given IndexedDb-compatible string form of a resource path into\n * a ResourcePath instance. Note that this method is not suitable for use with\n * decoding resource names from the server; those are One Platform format\n * strings.\n */\nfunction decode(path) {\n    // Event the empty path must encode as a path of at least length 2. A path\n    // with exactly 2 must be the empty path.\n    var length = path.length;\n    assert(length >= 2, 'Invalid path ' + path);\n    if (length === 2) {\n        assert(path.charAt(0) === escapeChar && path.charAt(1) === encodedSeparatorChar, 'Non-empty path ' + path + ' had length 2');\n        return path_ResourcePath.EMPTY_PATH;\n    }\n    // Escape characters cannot exist past the second-to-last position in the\n    // source value.\n    var lastReasonableEscapeIndex = length - 2;\n    var segments = [];\n    var segmentBuilder = '';\n    for (var start = 0; start < length;) {\n        // The last two characters of a valid encoded path must be a separator, so\n        // there must be an end to this segment.\n        var end = path.indexOf(escapeChar, start);\n        if (end < 0 || end > lastReasonableEscapeIndex) {\n            fail('Invalid encoded resource path: \"' + path + '\"');\n        }\n        var next = path.charAt(end + 1);\n        switch (next) {\n            case encodedSeparatorChar:\n                var currentPiece = path.substring(start, end);\n                var segment = void 0;\n                if (segmentBuilder.length === 0) {\n                    // Avoid copying for the common case of a segment that excludes \\0\n                    // and \\001\n                    segment = currentPiece;\n                }\n                else {\n                    segmentBuilder += currentPiece;\n                    segment = segmentBuilder;\n                    segmentBuilder = '';\n                }\n                segments.push(segment);\n                break;\n            case encodedNul:\n                segmentBuilder += path.substring(start, end);\n                segmentBuilder += '\\0';\n                break;\n            case encodedEscape:\n                // The escape character can be used in the output to encode itself.\n                segmentBuilder += path.substring(start, end + 1);\n                break;\n            default:\n                fail('Invalid encoded resource path: \"' + path + '\"');\n        }\n        start = end + 2;\n    }\n    return new path_ResourcePath(segments);\n}\n/**\n * Computes the prefix successor of the given path, computed by encode above.\n * A prefix successor is the first key that cannot be prefixed by the given\n * path. It's useful for defining the end of a prefix scan such that all keys\n * in the scan have the same prefix.\n *\n * Note that this is not a general prefix successor implementation, which is\n * tricky to get right with Strings, given that they encode down to UTF-8.\n * Instead this relies on the fact that all paths encoded by this class are\n * always terminated with a separator, and so a successor can always be\n * cheaply computed by incrementing the last character of the path.\n */\nfunction prefixSuccessor(path) {\n    var c = path.charCodeAt(path.length - 1);\n    // TODO(mcg): this really should be a general thing, but not worth it right\n    // now\n    assert(c === 1, 'successor may only operate on paths generated by encode');\n    return path.substring(0, path.length - 1) + String.fromCharCode(c + 1);\n}\n\n//# sourceMappingURL=encoded_resource_path.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/indexeddb_schema.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\nvar SCHEMA_VERSION = 1;\n/** Performs database creation and (in the future) upgrades between versions. */\nfunction createOrUpgradeDb(db, oldVersion) {\n    assert(oldVersion === 0, 'Unexpected upgrade from version ' + oldVersion);\n    db.createObjectStore(DbMutationQueue.store, {\n        keyPath: DbMutationQueue.keyPath\n    });\n    // TODO(mikelehen): Get rid of \"as any\" if/when TypeScript fixes their\n    // types. https://github.com/Microsoft/TypeScript/issues/14322\n    db.createObjectStore(DbMutationBatch.store, \n    // tslint:disable-next-line:no-any\n    { keyPath: DbMutationBatch.keyPath });\n    var targetDocumentsStore = db.createObjectStore(DbTargetDocument.store, \n    // tslint:disable-next-line:no-any\n    { keyPath: DbTargetDocument.keyPath });\n    targetDocumentsStore.createIndex(DbTargetDocument.documentTargetsIndex, DbTargetDocument.documentTargetsKeyPath, { unique: true });\n    var targetStore = db.createObjectStore(DbTarget.store, {\n        keyPath: DbTarget.keyPath\n    });\n    // NOTE: This is unique only because the TargetId is the suffix.\n    targetStore.createIndex(DbTarget.queryTargetsIndexName, DbTarget.queryTargetsKeyPath, { unique: true });\n    // NOTE: keys for these stores are specified explicitly rather than using a\n    // keyPath.\n    db.createObjectStore(indexeddb_schema_DbDocumentMutation.store);\n    db.createObjectStore(DbRemoteDocument.store);\n    db.createObjectStore(DbOwner.store);\n    db.createObjectStore(DbTargetGlobal.store);\n}\n/**\n * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.\n */\nvar DbTimestamp = /** @class */ (function () {\n    function DbTimestamp(seconds, nanos) {\n        this.seconds = seconds;\n        this.nanos = nanos;\n    }\n    return DbTimestamp;\n}());\n\n/**\n * A singleton object to be stored in the 'owner' store in IndexedDb.\n *\n * A given database can be owned by a single tab at a given time. That tab\n * must validate that it is still the owner before every write operation and\n * should regularly write an updated timestamp to prevent other tabs from\n * \"stealing\" ownership of the db.\n */\nvar DbOwner = /** @class */ (function () {\n    function DbOwner(ownerId, leaseTimestampMs) {\n        this.ownerId = ownerId;\n        this.leaseTimestampMs = leaseTimestampMs;\n    }\n    /** Name of the IndexedDb object store. */\n    DbOwner.store = 'owner';\n    return DbOwner;\n}());\n\n/**\n * An object to be stored in the 'mutationQueues' store in IndexedDb.\n *\n * Each user gets a single queue of MutationBatches to apply to the server.\n * DbMutationQueue tracks the metadata about the queue.\n */\nvar DbMutationQueue = /** @class */ (function () {\n    function DbMutationQueue(\n        /**\n         * The normalized user ID to which this queue belongs.\n         */\n        userId, \n        /**\n         * An identifier for the highest numbered batch that has been acknowledged\n         * by the server. All MutationBatches in this queue with batchIds less\n         * than or equal to this value are considered to have been acknowledged by\n         * the server.\n         */\n        lastAcknowledgedBatchId, \n        /**\n         * A stream token that was previously sent by the server.\n         *\n         * See StreamingWriteRequest in datastore.proto for more details about\n         * usage.\n         *\n         * After sending this token, earlier tokens may not be used anymore so\n         * only a single stream token is retained.\n         */\n        lastStreamToken) {\n        this.userId = userId;\n        this.lastAcknowledgedBatchId = lastAcknowledgedBatchId;\n        this.lastStreamToken = lastStreamToken;\n    }\n    /** Name of the IndexedDb object store.  */\n    DbMutationQueue.store = 'mutationQueues';\n    /** Keys are automatically assigned via the userId property. */\n    DbMutationQueue.keyPath = 'userId';\n    return DbMutationQueue;\n}());\n\n/**\n * An object to be stored in the 'mutations' store in IndexedDb.\n *\n * Represents a batch of user-level mutations intended to be sent to the server\n * in a single write. Each user-level batch gets a separate DbMutationBatch\n * with a new batchId.\n */\nvar DbMutationBatch = /** @class */ (function () {\n    function DbMutationBatch(\n        /**\n         * The normalized user ID to which this batch belongs.\n         */\n        userId, \n        /**\n         * An identifier for this batch, allocated by the mutation queue in a\n         * monotonically increasing manner.\n         */\n        batchId, \n        /**\n         * The local write time of the batch, stored as milliseconds since the\n         * epoch.\n         */\n        localWriteTimeMs, \n        /**\n         * A list of mutations to apply. All mutations will be applied atomically.\n         *\n         * Mutations are serialized via JsonProtoSerializer.toMutation().\n         */\n        mutations) {\n        this.userId = userId;\n        this.batchId = batchId;\n        this.localWriteTimeMs = localWriteTimeMs;\n        this.mutations = mutations;\n    }\n    /** Name of the IndexedDb object store.  */\n    DbMutationBatch.store = 'mutations';\n    /** Keys are automatically assigned via the userId, batchId properties. */\n    DbMutationBatch.keyPath = ['userId', 'batchId'];\n    return DbMutationBatch;\n}());\n\n/**\n * An object to be stored in the 'documentMutations' store in IndexedDb.\n *\n * A manually maintained index of all the mutation batches that affect a given\n * document key. The rows in this table are references based on the contents of\n * DbMutationBatch.mutations.\n */\nvar indexeddb_schema_DbDocumentMutation = /** @class */ (function () {\n    function DbDocumentMutation() {\n    }\n    /**\n     * Creates a [userId] key for use in the DbDocumentMutations index to iterate\n     * over all of a user's document mutations.\n     */\n    DbDocumentMutation.prefixForUser = function (userId) {\n        return [userId];\n    };\n    /**\n     * Creates a [userId, encodedPath] key for use in the DbDocumentMutations\n     * index to iterate over all at document mutations for a given path or lower.\n     */\n    DbDocumentMutation.prefixForPath = function (userId, path) {\n        return [userId, encode(path)];\n    };\n    /**\n     * Creates a full index key of [userId, encodedPath, batchId] for inserting\n     * and deleting into the DbDocumentMutations index.\n     */\n    DbDocumentMutation.key = function (userId, path, batchId) {\n        return [userId, encode(path), batchId];\n    };\n    DbDocumentMutation.store = 'documentMutations';\n    /**\n     * Because we store all the useful information for this store in the key,\n     * there is no useful information to store as the value. The raw (unencoded)\n     * path cannot be stored because IndexedDb doesn't store prototype\n     * information.\n     */\n    DbDocumentMutation.PLACEHOLDER = new DbDocumentMutation();\n    return DbDocumentMutation;\n}());\n\n/**\n * Represents the known absence of a document at a particular version.\n * Stored in IndexedDb as part of a DbRemoteDocument object.\n */\nvar DbNoDocument = /** @class */ (function () {\n    function DbNoDocument(path, readTime) {\n        this.path = path;\n        this.readTime = readTime;\n    }\n    return DbNoDocument;\n}());\n\n/**\n * An object to be stored in the 'remoteDocuments' store in IndexedDb. It\n * represents either a cached document (if it exists) or a cached \"no-document\"\n * (if it is known to not exist).\n *\n * Note: This is the persisted equivalent of a MaybeDocument and could perhaps\n * be made more general if necessary.\n */\nvar DbRemoteDocument = /** @class */ (function () {\n    function DbRemoteDocument(\n        /**\n         * Set to an instance of a DbNoDocument if it is known that no document\n         * exists.\n         */\n        noDocument, \n        /**\n         * Set to an instance of a Document if there's a cached version of the\n         * document.\n         */\n        document) {\n        this.noDocument = noDocument;\n        this.document = document;\n    }\n    DbRemoteDocument.store = 'remoteDocuments';\n    return DbRemoteDocument;\n}());\n\n/**\n * An object to be stored in the 'targets' store in IndexedDb.\n *\n * This is based on and should be kept in sync with the proto used in the iOS\n * client.\n *\n * Each query the client listens to against the server is tracked on disk so\n * that the query can be efficiently resumed on restart.\n */\nvar DbTarget = /** @class */ (function () {\n    function DbTarget(\n        /**\n         * An auto-generated sequential numeric identifier for the query.\n         *\n         * Queries are stored using their canonicalId as the key, but these\n         * canonicalIds can be quite long so we additionally assign a unique\n         * queryId which can be used by referenced data structures (e.g.\n         * indexes) to minimize the on-disk cost.\n         */\n        targetId, \n        /**\n         * The canonical string representing this query. This is not unique.\n         */\n        canonicalId, \n        /**\n         * The last readTime received from the Watch Service for this query.\n         *\n         * This is the same value as TargetChange.read_time in the protos.\n         */\n        readTime, \n        /**\n         * An opaque, server-assigned token that allows watching a query to be\n         * resumed after disconnecting without retransmitting all the data\n         * that matches the query. The resume token essentially identifies a\n         * point in time from which the server should resume sending results.\n         *\n         * This is related to the snapshotVersion in that the resumeToken\n         * effectively also encodes that value, but the resumeToken is opaque\n         * and sometimes encodes additional information.\n         *\n         * A consequence of this is that the resumeToken should be used when\n         * asking the server to reason about where this client is in the watch\n         * stream, but the client should use the snapshotVersion for its own\n         * purposes.\n         *\n         * This is the same value as TargetChange.resume_token in the protos.\n         */\n        resumeToken, \n        /**\n         * A sequence number representing the last time this query was\n         * listened to, used for garbage collection purposes.\n         *\n         * Conventionally this would be a timestamp value, but device-local\n         * clocks are unreliable and they must be able to create new listens\n         * even while disconnected. Instead this should be a monotonically\n         * increasing number that's incremented on each listen call.\n         *\n         * This is different from the queryId since the queryId is an\n         * immutable identifier assigned to the Query on first use while\n         * lastListenSequenceNumber is updated every time the query is\n         * listened to.\n         */\n        lastListenSequenceNumber, \n        /**\n         * The query for this target.\n         *\n         * Because canonical ids are not unique we must store the actual query. We\n         * use the proto to have an object we can persist without having to\n         * duplicate translation logic to and from a `Query` object.\n         */\n        query) {\n        this.targetId = targetId;\n        this.canonicalId = canonicalId;\n        this.readTime = readTime;\n        this.resumeToken = resumeToken;\n        this.lastListenSequenceNumber = lastListenSequenceNumber;\n        this.query = query;\n    }\n    DbTarget.store = 'targets';\n    /** Keys are automatically assigned via the targetId property. */\n    DbTarget.keyPath = 'targetId';\n    /** The name of the queryTargets index. */\n    DbTarget.queryTargetsIndexName = 'queryTargetsIndex';\n    /**\n     * The index of all canonicalIds to the targets that they match. This is not\n     * a unique mapping because canonicalId does not promise a unique name for all\n     * possible queries, so we append the targetId to make the mapping unique.\n     */\n    DbTarget.queryTargetsKeyPath = ['canonicalId', 'targetId'];\n    return DbTarget;\n}());\n\n/**\n * An object representing an association between a target and a document.\n * Stored in the targetDocument object store to store the documents tracked by a\n * particular target.\n */\nvar DbTargetDocument = /** @class */ (function () {\n    function DbTargetDocument(\n        /**\n         * The targetId identifying a target.\n         */\n        targetId, \n        /**\n         * The path to the document, as encoded in the key.\n         */\n        path) {\n        this.targetId = targetId;\n        this.path = path;\n    }\n    /** Name of the IndexedDb object store.  */\n    DbTargetDocument.store = 'targetDocuments';\n    /** Keys are automatically assigned via the targetId, path properties. */\n    DbTargetDocument.keyPath = ['targetId', 'path'];\n    /** The index name for the reverse index. */\n    DbTargetDocument.documentTargetsIndex = 'documentTargetsIndex';\n    /** We also need to create the reverse index for these properties. */\n    DbTargetDocument.documentTargetsKeyPath = ['path', 'targetId'];\n    return DbTargetDocument;\n}());\n\n/**\n * A record of global state tracked across all Targets, tracked separately\n * to avoid the need for extra indexes.\n *\n * This should be kept in-sync with the proto used in the iOS client.\n */\nvar DbTargetGlobal = /** @class */ (function () {\n    function DbTargetGlobal(\n        /**\n         * The highest numbered target id across all targets.\n         *\n         * See DbTarget.targetId.\n         */\n        highestTargetId, \n        /**\n         * The highest numbered lastListenSequenceNumber across all targets.\n         *\n         * See DbTarget.lastListenSequenceNumber.\n         */\n        highestListenSequenceNumber, \n        /**\n         * A global snapshot version representing the last consistent snapshot we\n         * received from the backend. This is monotonically increasing and any\n         * snapshots received from the backend prior to this version (e.g. for\n         * targets resumed with a resumeToken) should be suppressed (buffered)\n         * until the backend has caught up to this snapshot version again. This\n         * prevents our cache from ever going backwards in time.\n         */\n        lastRemoteSnapshotVersion) {\n        this.highestTargetId = highestTargetId;\n        this.highestListenSequenceNumber = highestListenSequenceNumber;\n        this.lastRemoteSnapshotVersion = lastRemoteSnapshotVersion;\n    }\n    /**\n     * The key string used for the single object that exists in the\n     * DbTargetGlobal store.\n     */\n    DbTargetGlobal.key = 'targetGlobalKey';\n    DbTargetGlobal.store = 'targetGlobal';\n    return DbTargetGlobal;\n}());\n\n/**\n * The list of all IndexedDB stored used by the SDK. This is used when creating\n * transactions so that access across all stores is done atomically.\n */\nvar ALL_STORES = [\n    DbMutationQueue.store,\n    DbMutationBatch.store,\n    indexeddb_schema_DbDocumentMutation.store,\n    DbRemoteDocument.store,\n    DbTarget.store,\n    DbOwner.store,\n    DbTargetGlobal.store,\n    DbTargetDocument.store\n];\n\n//# sourceMappingURL=indexeddb_schema.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/simple_db.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\nvar simple_db_LOG_TAG = 'SimpleDb';\n/**\n * Provides a wrapper around IndexedDb with a simplified interface that uses\n * Promise-like return values to chain operations. Real promises cannot be used\n * since .then() continuations are executed asynchronously (e.g. via\n * .setImmediate), which would cause IndexedDB to end the transaction.\n * See PersistencePromise for more details.\n */\nvar simple_db_SimpleDb = /** @class */ (function () {\n    function SimpleDb(db) {\n        this.db = db;\n    }\n    /** Opens the specified database, creating or upgrading it if necessary. */\n    SimpleDb.openOrCreate = function (name, version, runUpgrade) {\n        assert(SimpleDb.isAvailable(), 'IndexedDB not supported in current environment.');\n        debug(simple_db_LOG_TAG, 'Opening database:', name);\n        return new persistence_promise_PersistencePromise(function (resolve, reject) {\n            // TODO(mikelehen): Investigate browser compatibility.\n            // https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB\n            // suggests IE9 and older WebKit browsers handle upgrade\n            // differently.\n            var request = window.indexedDB.open(name, version);\n            request.onsuccess = function (event) {\n                var db = event.target.result;\n                resolve(new SimpleDb(db));\n            };\n            request.onerror = function (event) {\n                reject(event.target.error);\n            };\n            request.onupgradeneeded = function (event) {\n                debug(simple_db_LOG_TAG, 'Database \"' + name + '\" requires upgrade from version:', event.oldVersion);\n                // TODO(mikelehen): If/when we need to do an actual data\n                // migration, we'll want to wrap db in a SimpleDb and have the\n                // runUpgrade function return a PersistencePromise, since we'll\n                // likely need to do async reads and writes. For now we're\n                // cheating and just passing the raw IndexedDB in, since\n                // createObjectStore(), etc. are synchronous.\n                var db = event.target.result;\n                runUpgrade(db, event.oldVersion);\n            };\n        }).toPromise();\n    };\n    /** Deletes the specified database. */\n    SimpleDb.delete = function (name) {\n        debug(simple_db_LOG_TAG, 'Removing database:', name);\n        return wrapRequest(window.indexedDB.deleteDatabase(name)).toPromise();\n    };\n    /** Returns true if IndexedDB is available in the current environment. */\n    SimpleDb.isAvailable = function () {\n        if (typeof window === 'undefined' || window.indexedDB == null) {\n            return false;\n        }\n        // We extensively use indexed array values and compound keys,\n        // which IE and Edge do not support. However, they still have indexedDB\n        // defined on the window, so we need to check for them here and make sure\n        // to return that persistence is not enabled for those browsers.\n        // For tracking support of this feature, see here:\n        // https://developer.microsoft.com/en-us/microsoft-edge/platform/status/indexeddbarraysandmultientrysupport/\n        // Check the UA string to find out the browser.\n        var ua = window.navigator.userAgent;\n        // IE 10\n        // ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)';\n        // IE 11\n        // ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko';\n        // Edge\n        // ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML,\n        // like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0';\n        if (ua.indexOf('MSIE ') > 0 ||\n            ua.indexOf('Trident/') > 0 ||\n            ua.indexOf('Edge/') > 0) {\n            return false;\n        }\n        else {\n            return true;\n        }\n    };\n    SimpleDb.prototype.runTransaction = function (mode, objectStores, transactionFn) {\n        var transaction = new simple_db_SimpleDbTransaction(this.db, mode, objectStores);\n        var transactionFnResult = transactionFn(transaction)\n            .catch(function (error) {\n            // Abort the transaction if there was an\n            // error.\n            transaction.abort();\n            return persistence_promise_PersistencePromise.reject(error);\n        })\n            .toPromise();\n        // Wait for the transaction to complete (i.e. IndexedDb's onsuccess event to\n        // fire), but still return the original transactionFnResult back to the\n        // caller.\n        return transaction.completionPromise.then(function () { return transactionFnResult; });\n    };\n    SimpleDb.prototype.close = function () {\n        this.db.close();\n    };\n    return SimpleDb;\n}());\n\n/**\n * A controller for iterating over a key range or index. It allows an iterate\n * callback to delete the currently-referenced object, or jump to a new key\n * within the key range or index.\n */\nvar IterationController = /** @class */ (function () {\n    function IterationController(dbCursor) {\n        this.dbCursor = dbCursor;\n        this.shouldStop = false;\n        this.nextKey = null;\n    }\n    Object.defineProperty(IterationController.prototype, \"isDone\", {\n        get: function () {\n            return this.shouldStop;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(IterationController.prototype, \"skipToKey\", {\n        get: function () {\n            return this.nextKey;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(IterationController.prototype, \"cursor\", {\n        set: function (value) {\n            this.dbCursor = value;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * This function can be called to stop iteration at any point.\n     */\n    IterationController.prototype.done = function () {\n        this.shouldStop = true;\n    };\n    /**\n     * This function can be called to skip to that next key, which could be\n     * an index or a primary key.\n     */\n    IterationController.prototype.skip = function (key) {\n        this.nextKey = key;\n    };\n    /**\n     * Delete the current cursor value from the object store.\n     *\n     * NOTE: You CANNOT do this with a keysOnly query.\n     */\n    IterationController.prototype.delete = function () {\n        return wrapRequest(this.dbCursor.delete());\n    };\n    return IterationController;\n}());\n\n/**\n * Wraps an IDBTransaction and exposes a store() method to get a handle to a\n * specific object store.\n */\nvar simple_db_SimpleDbTransaction = /** @class */ (function () {\n    function SimpleDbTransaction(db, mode, objectStoresNames) {\n        var _this = this;\n        this.aborted = false;\n        this.transaction = db.transaction(objectStoresNames, mode);\n        this.completionPromise = new Promise(function (resolve, reject) {\n            // We consider aborting to be \"normal\" and just resolve the promise.\n            // May need to revisit if/when we actually need to abort transactions.\n            _this.transaction.onabort = _this.transaction.oncomplete = function (event) {\n                resolve();\n            };\n            _this.transaction.onerror = function (event) {\n                reject(event.target.error);\n            };\n        });\n    }\n    SimpleDbTransaction.prototype.abort = function () {\n        if (!this.aborted) {\n            debug(simple_db_LOG_TAG, 'Aborting transaction.');\n            this.aborted = true;\n            this.transaction.abort();\n        }\n    };\n    /**\n     * Returns a SimpleDbStore<KeyType, ValueType> for the specified store. All\n     * operations performed on the SimpleDbStore happen within the context of this\n     * transaction and it cannot be used anymore once the transaction is\n     * completed.\n     *\n     * Note that we can't actually enforce that the KeyType and ValueType are\n     * correct, but they allow type safety through the rest of the consuming code.\n     */\n    SimpleDbTransaction.prototype.store = function (storeName) {\n        var store = this.transaction.objectStore(storeName);\n        assert(!!store, 'Object store not part of transaction: ' + storeName);\n        return new simple_db_SimpleDbStore(store);\n    };\n    return SimpleDbTransaction;\n}());\n\n/**\n * A wrapper around an IDBObjectStore providing an API that:\n *\n * 1) Has generic KeyType / ValueType parameters to provide strongly-typed\n * methods for acting against the object store.\n * 2) Deals with IndexedDB's onsuccess / onerror event callbacks, making every\n * method return a PersistencePromise instead.\n * 3) Provides a higher-level API to avoid needing to do excessive wrapping of\n * intermediate IndexedDB types (IDBCursorWithValue, etc.)\n */\nvar simple_db_SimpleDbStore = /** @class */ (function () {\n    function SimpleDbStore(store) {\n        this.store = store;\n    }\n    SimpleDbStore.prototype.put = function (keyOrValue, value) {\n        var request;\n        if (value !== undefined) {\n            debug(simple_db_LOG_TAG, 'PUT', this.store.name, keyOrValue, value);\n            request = this.store.put(value, keyOrValue);\n        }\n        else {\n            debug(simple_db_LOG_TAG, 'PUT', this.store.name, '<auto-key>', keyOrValue);\n            request = this.store.put(keyOrValue);\n        }\n        return wrapRequest(request);\n    };\n    /**\n     * Gets the object with the specified key from the specified store, or null\n     * if no object exists with the specified key.\n     *\n     * @key The key of the object to get.\n     * @return The object with the specified key or null if no object exists.\n     */\n    SimpleDbStore.prototype.get = function (key) {\n        var _this = this;\n        var request = this.store.get(key);\n        // tslint:disable-next-line:no-any We're doing an unsafe cast to ValueType.\n        return wrapRequest(request).next(function (result) {\n            // Normalize nonexistence to null.\n            if (result === undefined) {\n                result = null;\n            }\n            debug(simple_db_LOG_TAG, 'GET', _this.store.name, key, result);\n            return result;\n        });\n    };\n    SimpleDbStore.prototype.delete = function (key) {\n        debug(simple_db_LOG_TAG, 'DELETE', this.store.name, key);\n        var request = this.store.delete(key);\n        return wrapRequest(request);\n    };\n    SimpleDbStore.prototype.loadAll = function (indexOrRange, range) {\n        var cursor = this.cursor(this.options(indexOrRange, range));\n        var results = [];\n        return this.iterateCursor(cursor, function (key, value) {\n            results.push(value);\n        }).next(function () {\n            return results;\n        });\n    };\n    SimpleDbStore.prototype.deleteAll = function (indexOrRange, range) {\n        debug(simple_db_LOG_TAG, 'DELETE ALL', this.store.name);\n        var options = this.options(indexOrRange, range);\n        options.keysOnly = false;\n        var cursor = this.cursor(options);\n        return this.iterateCursor(cursor, function (key, value, control) {\n            // NOTE: Calling delete() on a cursor is documented as more efficient than\n            // calling delete() on an object store with a single key\n            // (https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/delete),\n            // however, this requires us *not* to use a keysOnly cursor\n            // (https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor/delete). We\n            // may want to compare the performance of each method.\n            return control.delete();\n        });\n    };\n    SimpleDbStore.prototype.iterate = function (optionsOrCallback, callback) {\n        var options;\n        if (!callback) {\n            options = {};\n            callback = optionsOrCallback;\n        }\n        else {\n            options = optionsOrCallback;\n        }\n        var cursor = this.cursor(options);\n        return this.iterateCursor(cursor, callback);\n    };\n    SimpleDbStore.prototype.iterateCursor = function (cursorRequest, fn) {\n        var results = [];\n        return new persistence_promise_PersistencePromise(function (resolve, reject) {\n            cursorRequest.onerror = function (event) {\n                reject(event.target.error);\n            };\n            cursorRequest.onsuccess = function (event) {\n                var cursor = event.target.result;\n                if (!cursor) {\n                    resolve();\n                    return;\n                }\n                var controller = new IterationController(cursor);\n                var userResult = fn(cursor.primaryKey, cursor.value, controller);\n                if (userResult instanceof persistence_promise_PersistencePromise) {\n                    results.push(userResult);\n                }\n                if (controller.isDone) {\n                    resolve();\n                }\n                else if (controller.skipToKey === null) {\n                    cursor.continue();\n                }\n                else {\n                    cursor.continue(controller.skipToKey);\n                }\n            };\n        }).next(function () {\n            return persistence_promise_PersistencePromise.waitFor(results);\n        });\n    };\n    SimpleDbStore.prototype.options = function (indexOrRange, range) {\n        var indexName = undefined;\n        if (indexOrRange !== undefined) {\n            if (typeof indexOrRange === 'string') {\n                indexName = indexOrRange;\n            }\n            else {\n                assert(range === undefined, '3rd argument must not be defined if 2nd is a range.');\n                range = indexOrRange;\n            }\n        }\n        return { index: indexName, range: range };\n    };\n    SimpleDbStore.prototype.cursor = function (options) {\n        var direction = 'next';\n        if (options.reverse) {\n            direction = 'prev';\n        }\n        if (options.index) {\n            var index = this.store.index(options.index);\n            if (options.keysOnly) {\n                return index.openKeyCursor(options.range, direction);\n            }\n            else {\n                return index.openCursor(options.range, direction);\n            }\n        }\n        else {\n            return this.store.openCursor(options.range, direction);\n        }\n    };\n    return SimpleDbStore;\n}());\n\n/**\n * Wraps an IDBRequest in a PersistencePromise, using the onsuccess / onerror\n * handlers to resolve / reject the PersistencePromise as appropriate.\n */\nfunction wrapRequest(request) {\n    return new persistence_promise_PersistencePromise(function (resolve, reject) {\n        request.onsuccess = function (event) {\n            var result = event.target.result;\n            resolve(result);\n        };\n        request.onerror = function (event) {\n            reject(event.target.error);\n        };\n    });\n}\n\n//# sourceMappingURL=simple_db.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/indexeddb_mutation_queue.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n/** A mutation queue for a specific user, backed by IndexedDB. */\nvar indexeddb_mutation_queue_IndexedDbMutationQueue = /** @class */ (function () {\n    function IndexedDbMutationQueue(\n        /**\n         * The normalized userId (e.g. null UID => \"\" userId) used to store /\n         * retrieve mutations.\n         */\n        userId, serializer) {\n        this.userId = userId;\n        this.serializer = serializer;\n        this.garbageCollector = null;\n    }\n    /**\n     * Creates a new mutation queue for the given user.\n     * @param user The user for which to create a mutation queue.\n     * @param serializer The serializer to use when persisting to IndexedDb.\n     */\n    IndexedDbMutationQueue.forUser = function (user, serializer) {\n        // TODO(mcg): Figure out what constraints there are on userIDs\n        // In particular, are there any reserved characters? are empty ids allowed?\n        // For the moment store these together in the same mutations table assuming\n        // that empty userIDs aren't allowed.\n        assert(user.uid !== '', 'UserID must not be an empty string.');\n        var userId = user.isAuthenticated() ? user.uid : '';\n        return new IndexedDbMutationQueue(userId, serializer);\n    };\n    IndexedDbMutationQueue.prototype.start = function (transaction) {\n        var _this = this;\n        return IndexedDbMutationQueue.loadNextBatchIdFromDb(transaction)\n            .next(function (nextBatchId) {\n            _this.nextBatchId = nextBatchId;\n            return mutationQueuesStore(transaction).get(_this.userId);\n        })\n            .next(function (metadata) {\n            if (!metadata) {\n                metadata = new DbMutationQueue(_this.userId, BATCHID_UNKNOWN, \n                /*lastStreamToken=*/ '');\n            }\n            _this.metadata = metadata;\n            // On restart, nextBatchId may end up lower than\n            // lastAcknowledgedBatchId since it's computed from the queue\n            // contents, and there may be no mutations in the queue. In this\n            // case, we need to reset lastAcknowledgedBatchId (which is safe\n            // since the queue must be empty).\n            if (_this.metadata.lastAcknowledgedBatchId >= _this.nextBatchId) {\n                return _this.checkEmpty(transaction).next(function (empty) {\n                    assert(empty, 'Reset nextBatchID is only possible when the queue is empty');\n                    _this.metadata.lastAcknowledgedBatchId = BATCHID_UNKNOWN;\n                    return mutationQueuesStore(transaction).put(_this.metadata);\n                });\n            }\n            else {\n                return persistence_promise_PersistencePromise.resolve();\n            }\n        });\n    };\n    /**\n     * Returns one larger than the largest batch ID that has been stored. If there\n     * are no mutations returns 0. Note that batch IDs are global.\n     */\n    IndexedDbMutationQueue.loadNextBatchIdFromDb = function (txn) {\n        var maxBatchId = BATCHID_UNKNOWN;\n        return mutationsStore(txn)\n            .iterate({ reverse: true }, function (key, batch, control) {\n            var userId = key[0], batchId = key[1];\n            if (batchId > maxBatchId) {\n                maxBatchId = batch.batchId;\n            }\n            if (userId === '') {\n                // We can't compute a predecessor for the empty string, since it\n                // is lexographically first. That also means that no other\n                // userIds can come before this one, so we can just exit early.\n                control.done();\n            }\n            else {\n                var nextUser = immediatePredecessor(userId);\n                control.skip([nextUser]);\n            }\n        })\n            .next(function () { return maxBatchId + 1; });\n    };\n    IndexedDbMutationQueue.prototype.checkEmpty = function (transaction) {\n        var empty = true;\n        var range = IDBKeyRange.bound(this.keyForBatchId(Number.NEGATIVE_INFINITY), this.keyForBatchId(Number.POSITIVE_INFINITY));\n        return mutationsStore(transaction)\n            .iterate({ range: range }, function (key, value, control) {\n            empty = false;\n            control.done();\n        })\n            .next(function () { return empty; });\n    };\n    IndexedDbMutationQueue.prototype.getNextBatchId = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.nextBatchId);\n    };\n    IndexedDbMutationQueue.prototype.getHighestAcknowledgedBatchId = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.metadata.lastAcknowledgedBatchId);\n    };\n    IndexedDbMutationQueue.prototype.acknowledgeBatch = function (transaction, batch, streamToken) {\n        var batchId = batch.batchId;\n        assert(batchId > this.metadata.lastAcknowledgedBatchId, 'Mutation batchIDs must be acknowledged in order');\n        this.metadata.lastAcknowledgedBatchId = batchId;\n        this.metadata.lastStreamToken = validateStreamToken(streamToken);\n        return mutationQueuesStore(transaction).put(this.metadata);\n    };\n    IndexedDbMutationQueue.prototype.getLastStreamToken = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.metadata.lastStreamToken);\n    };\n    IndexedDbMutationQueue.prototype.setLastStreamToken = function (transaction, streamToken) {\n        this.metadata.lastStreamToken = validateStreamToken(streamToken);\n        return mutationQueuesStore(transaction).put(this.metadata);\n    };\n    IndexedDbMutationQueue.prototype.addMutationBatch = function (transaction, localWriteTime, mutations) {\n        var _this = this;\n        var batchId = this.nextBatchId;\n        this.nextBatchId++;\n        var batch = new mutation_batch_MutationBatch(batchId, localWriteTime, mutations);\n        var dbBatch = this.serializer.toDbMutationBatch(this.userId, batch);\n        return mutationsStore(transaction)\n            .put(dbBatch)\n            .next(function () {\n            var promises = [];\n            for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n                var mutation = mutations_1[_i];\n                var indexKey = indexeddb_schema_DbDocumentMutation.key(_this.userId, mutation.key.path, batchId);\n                documentMutationsStore(transaction).put(indexKey, indexeddb_schema_DbDocumentMutation.PLACEHOLDER);\n            }\n            return persistence_promise_PersistencePromise.waitFor(promises);\n        })\n            .next(function () {\n            return batch;\n        });\n    };\n    IndexedDbMutationQueue.prototype.lookupMutationBatch = function (transaction, batchId) {\n        var _this = this;\n        return mutationsStore(transaction)\n            .get(this.keyForBatchId(batchId))\n            .next(function (dbBatch) {\n            return dbBatch ? _this.serializer.fromDbMutationBatch(dbBatch) : null;\n        });\n    };\n    IndexedDbMutationQueue.prototype.getNextMutationBatchAfterBatchId = function (transaction, batchId) {\n        var _this = this;\n        var range = IDBKeyRange.lowerBound(this.keyForBatchId(batchId + 1));\n        var foundBatch = null;\n        return mutationsStore(transaction)\n            .iterate({ range: range }, function (key, dbBatch, control) {\n            if (dbBatch.userId === _this.userId) {\n                assert(dbBatch.batchId > batchId, 'Should have found mutation after ' + batchId);\n                foundBatch = _this.serializer.fromDbMutationBatch(dbBatch);\n            }\n            control.done();\n        })\n            .next(function () { return foundBatch; });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatches = function (transaction) {\n        var _this = this;\n        var range = IDBKeyRange.bound(this.keyForBatchId(BATCHID_UNKNOWN), this.keyForBatchId(Number.POSITIVE_INFINITY));\n        return mutationsStore(transaction)\n            .loadAll(range)\n            .next(function (dbBatches) {\n            return dbBatches.map(function (dbBatch) { return _this.serializer.fromDbMutationBatch(dbBatch); });\n        });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatchesThroughBatchId = function (transaction, batchId) {\n        var _this = this;\n        var range = IDBKeyRange.bound(this.keyForBatchId(BATCHID_UNKNOWN), this.keyForBatchId(batchId));\n        return mutationsStore(transaction)\n            .loadAll(range)\n            .next(function (dbBatches) {\n            return dbBatches.map(function (dbBatch) { return _this.serializer.fromDbMutationBatch(dbBatch); });\n        });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatchesAffectingDocumentKey = function (transaction, documentKey) {\n        var _this = this;\n        // Scan the document-mutation index starting with a prefix starting with\n        // the given documentKey.\n        var indexPrefix = indexeddb_schema_DbDocumentMutation.prefixForPath(this.userId, documentKey.path);\n        var indexStart = IDBKeyRange.lowerBound(indexPrefix);\n        var results = [];\n        return documentMutationsStore(transaction)\n            .iterate({ range: indexStart }, function (indexKey, _, control) {\n            var userID = indexKey[0], encodedPath = indexKey[1], batchID = indexKey[2];\n            // Only consider rows matching exactly the specific key of\n            // interest. Note that because we order by path first, and we\n            // order terminators before path separators, we'll encounter all\n            // the index rows for documentKey contiguously. In particular, all\n            // the rows for documentKey will occur before any rows for\n            // documents nested in a subcollection beneath documentKey so we\n            // can stop as soon as we hit any such row.\n            var path = decode(encodedPath);\n            if (userID !== _this.userId || !documentKey.path.isEqual(path)) {\n                control.done();\n                return;\n            }\n            var mutationKey = _this.keyForBatchId(batchID);\n            // Look up the mutation batch in the store.\n            // PORTING NOTE: because iteration is callback driven in the web,\n            // we just look up the key instead of keeping an open iterator\n            // like iOS.\n            return mutationsStore(transaction)\n                .get(mutationKey)\n                .next(function (dbBatch) {\n                if (dbBatch === null) {\n                    fail('Dangling document-mutation reference found: ' +\n                        indexKey +\n                        ' which points to ' +\n                        mutationKey);\n                }\n                results.push(_this.serializer.fromDbMutationBatch(dbBatch));\n            });\n        })\n            .next(function () { return results; });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatchesAffectingQuery = function (transaction, query) {\n        var _this = this;\n        assert(!query.isDocumentQuery(), \"Document queries shouldn't go down this path\");\n        var queryPath = query.path;\n        var immediateChildrenLength = queryPath.length + 1;\n        // TODO(mcg): Actually implement a single-collection query\n        //\n        // This is actually executing an ancestor query, traversing the whole\n        // subtree below the collection which can be horrifically inefficient for\n        // some structures. The right way to solve this is to implement the full\n        // value index, but that's not in the cards in the near future so this is\n        // the best we can do for the moment.\n        //\n        // Since we don't yet index the actual properties in the mutations, our\n        // current approach is to just return all mutation batches that affect\n        // documents in the collection being queried.\n        var indexPrefix = indexeddb_schema_DbDocumentMutation.prefixForPath(this.userId, queryPath);\n        var indexStart = IDBKeyRange.lowerBound(indexPrefix);\n        // Collect up unique batchIDs encountered during a scan of the index. Use a\n        // SortedSet to accumulate batch IDs so they can be traversed in order in a\n        // scan of the main table.\n        var uniqueBatchIDs = new sorted_set_SortedSet(primitiveComparator);\n        return documentMutationsStore(transaction)\n            .iterate({ range: indexStart }, function (indexKey, _, control) {\n            var userID = indexKey[0], encodedPath = indexKey[1], batchID = indexKey[2];\n            var path = decode(encodedPath);\n            if (userID !== _this.userId || !queryPath.isPrefixOf(path)) {\n                control.done();\n                return;\n            }\n            // Rows with document keys more than one segment longer than the\n            // query path can't be matches. For example, a query on 'rooms'\n            // can't match the document /rooms/abc/messages/xyx.\n            // TODO(mcg): we'll need a different scanner when we implement\n            // ancestor queries.\n            if (path.length !== immediateChildrenLength) {\n                return;\n            }\n            uniqueBatchIDs = uniqueBatchIDs.add(batchID);\n        })\n            .next(function () {\n            var results = [];\n            var promises = [];\n            // TODO(rockwood): Implement this using iterate.\n            uniqueBatchIDs.forEach(function (batchID) {\n                var mutationKey = _this.keyForBatchId(batchID);\n                promises.push(mutationsStore(transaction)\n                    .get(mutationKey)\n                    .next(function (mutation) {\n                    if (mutation === null) {\n                        fail('Dangling document-mutation reference found, ' +\n                            'which points to ' +\n                            mutationKey);\n                    }\n                    results.push(_this.serializer.fromDbMutationBatch(mutation));\n                }));\n            });\n            return persistence_promise_PersistencePromise.waitFor(promises).next(function () { return results; });\n        });\n    };\n    IndexedDbMutationQueue.prototype.removeMutationBatches = function (transaction, batches) {\n        var txn = mutationsStore(transaction);\n        var indexTxn = documentMutationsStore(transaction);\n        var promises = [];\n        var _loop_1 = function (batch) {\n            var range = IDBKeyRange.only(this_1.keyForBatchId(batch.batchId));\n            var numDeleted = 0;\n            var removePromise = txn.iterate({ range: range }, function (key, value, control) {\n                numDeleted++;\n                return control.delete();\n            });\n            promises.push(removePromise.next(function () {\n                assert(numDeleted === 1, 'Dangling document-mutation reference found: Missing batch ' +\n                    batch.batchId);\n            }));\n            for (var _i = 0, _a = batch.mutations; _i < _a.length; _i++) {\n                var mutation = _a[_i];\n                var indexKey = indexeddb_schema_DbDocumentMutation.key(this_1.userId, mutation.key.path, batch.batchId);\n                promises.push(indexTxn.delete(indexKey));\n                if (this_1.garbageCollector !== null) {\n                    this_1.garbageCollector.addPotentialGarbageKey(mutation.key);\n                }\n            }\n        };\n        var this_1 = this;\n        for (var _i = 0, batches_1 = batches; _i < batches_1.length; _i++) {\n            var batch = batches_1[_i];\n            _loop_1(batch);\n        }\n        return persistence_promise_PersistencePromise.waitFor(promises);\n    };\n    IndexedDbMutationQueue.prototype.performConsistencyCheck = function (txn) {\n        var _this = this;\n        return this.checkEmpty(txn).next(function (empty) {\n            if (!empty) {\n                return persistence_promise_PersistencePromise.resolve();\n            }\n            // Verify that there are no entries in the documentMutations index if\n            // the queue is empty.\n            var startRange = IDBKeyRange.lowerBound(indexeddb_schema_DbDocumentMutation.prefixForUser(_this.userId));\n            var danglingMutationReferences = [];\n            return documentMutationsStore(txn)\n                .iterate({ range: startRange }, function (key, _, control) {\n                var userID = key[0];\n                if (userID !== _this.userId) {\n                    control.done();\n                    return;\n                }\n                else {\n                    var path = decode(key[1]);\n                    danglingMutationReferences.push(path);\n                }\n            })\n                .next(function () {\n                assert(danglingMutationReferences.length === 0, 'Document leak -- detected dangling mutation references when queue is empty. Dangling keys: ' +\n                    danglingMutationReferences.map(function (p) { return p.canonicalString(); }));\n            });\n        });\n    };\n    IndexedDbMutationQueue.prototype.setGarbageCollector = function (gc) {\n        this.garbageCollector = gc;\n    };\n    IndexedDbMutationQueue.prototype.containsKey = function (txn, key) {\n        var _this = this;\n        var indexKey = indexeddb_schema_DbDocumentMutation.prefixForPath(this.userId, key.path);\n        var encodedPath = indexKey[1];\n        var startRange = IDBKeyRange.lowerBound(indexKey);\n        var containsKey = false;\n        return documentMutationsStore(txn)\n            .iterate({ range: startRange, keysOnly: true }, function (key, value, control) {\n            var userID = key[0], keyPath = key[1], /*batchID*/ _ = key[2];\n            if (userID === _this.userId && keyPath === encodedPath) {\n                containsKey = true;\n            }\n            control.done();\n        })\n            .next(function () { return containsKey; });\n    };\n    /**\n     * Creates a [userId, batchId] key for use with the DbMutationQueue object\n     * store.\n     */\n    IndexedDbMutationQueue.prototype.keyForBatchId = function (batchId) {\n        return [this.userId, batchId];\n    };\n    return IndexedDbMutationQueue;\n}());\n\nfunction validateStreamToken(token) {\n    assert(typeof token === 'string', 'Persisting non-string stream token not supported.');\n    return token;\n}\n/**\n * Helper to get a typed SimpleDbStore for the mutations object store.\n */\nfunction mutationsStore(txn) {\n    return getStore(txn, DbMutationBatch.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the mutationQueues object store.\n */\nfunction documentMutationsStore(txn) {\n    return getStore(txn, indexeddb_schema_DbDocumentMutation.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the mutationQueues object store.\n */\nfunction mutationQueuesStore(txn) {\n    return getStore(txn, DbMutationQueue.store);\n}\n/**\n * Helper to get a typed SimpleDbStore from a transaction.\n */\nfunction getStore(txn, store) {\n    if (txn instanceof simple_db_SimpleDbTransaction) {\n        return txn.store(store);\n    }\n    else {\n        return fail('Invalid transaction object provided!');\n    }\n}\n\n//# sourceMappingURL=indexeddb_mutation_queue.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/indexeddb_query_cache.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\nvar indexeddb_query_cache_IndexedDbQueryCache = /** @class */ (function () {\n    function IndexedDbQueryCache(serializer) {\n        this.serializer = serializer;\n        /**\n         * The last received snapshot version. We store this seperately from the\n         * metadata to avoid the extra conversion to/from DbTimestamp.\n         */\n        this.lastRemoteSnapshotVersion = snapshot_version_SnapshotVersion.MIN;\n        /**\n         * A cached copy of the metadata for the query cache.\n         */\n        this.metadata = new DbTargetGlobal(\n        /*highestTargetId=*/ 0, \n        /*lastListenSequenceNumber=*/ 0, snapshot_version_SnapshotVersion.MIN.toTimestamp());\n        /** The garbage collector to notify about potential garbage keys. */\n        this.garbageCollector = null;\n    }\n    IndexedDbQueryCache.prototype.start = function (transaction) {\n        var _this = this;\n        return globalTargetStore(transaction)\n            .get(DbTargetGlobal.key)\n            .next(function (metadata) {\n            if (metadata !== null) {\n                _this.metadata = metadata;\n                var lastSavedVersion = metadata.lastRemoteSnapshotVersion;\n                _this.lastRemoteSnapshotVersion = snapshot_version_SnapshotVersion.fromTimestamp(new timestamp_Timestamp(lastSavedVersion.seconds, lastSavedVersion.nanos));\n            }\n            return persistence_promise_PersistencePromise.resolve();\n        });\n    };\n    IndexedDbQueryCache.prototype.getHighestTargetId = function () {\n        return this.metadata.highestTargetId;\n    };\n    IndexedDbQueryCache.prototype.getLastRemoteSnapshotVersion = function () {\n        return this.lastRemoteSnapshotVersion;\n    };\n    IndexedDbQueryCache.prototype.setLastRemoteSnapshotVersion = function (transaction, snapshotVersion) {\n        this.lastRemoteSnapshotVersion = snapshotVersion;\n        this.metadata.lastRemoteSnapshotVersion = snapshotVersion.toTimestamp();\n        return globalTargetStore(transaction).put(DbTargetGlobal.key, this.metadata);\n    };\n    IndexedDbQueryCache.prototype.addQueryData = function (transaction, queryData) {\n        var _this = this;\n        var targetId = queryData.targetId;\n        var addedQueryPromise = targetsStore(transaction).put(this.serializer.toDbTarget(queryData));\n        if (targetId > this.metadata.highestTargetId) {\n            this.metadata.highestTargetId = targetId;\n            return addedQueryPromise.next(function () {\n                return globalTargetStore(transaction).put(DbTargetGlobal.key, _this.metadata);\n            });\n        }\n        else {\n            return addedQueryPromise;\n        }\n    };\n    IndexedDbQueryCache.prototype.removeQueryData = function (transaction, queryData) {\n        return this.removeMatchingKeysForTargetId(transaction, queryData.targetId).next(function () {\n            targetsStore(transaction).delete(queryData.targetId);\n        });\n    };\n    IndexedDbQueryCache.prototype.getQueryData = function (transaction, query) {\n        var _this = this;\n        // Iterating by the canonicalId may yield more than one result because\n        // canonicalId values are not required to be unique per target. This query\n        // depends on the queryTargets index to be efficent.\n        var canonicalId = query.canonicalId();\n        var range = IDBKeyRange.bound([canonicalId, Number.NEGATIVE_INFINITY], [canonicalId, Number.POSITIVE_INFINITY]);\n        var result = null;\n        return targetsStore(transaction)\n            .iterate({ range: range, index: DbTarget.queryTargetsIndexName }, function (key, value, control) {\n            var found = _this.serializer.fromDbTarget(value);\n            // After finding a potential match, check that the query is\n            // actually equal to the requested query.\n            if (query.isEqual(found.query)) {\n                result = found;\n                control.done();\n            }\n        })\n            .next(function () { return result; });\n    };\n    IndexedDbQueryCache.prototype.addMatchingKeys = function (txn, keys, targetId) {\n        // PORTING NOTE: The reverse index (documentsTargets) is maintained by\n        // Indexeddb.\n        var promises = [];\n        var store = documentTargetStore(txn);\n        keys.forEach(function (key) {\n            var path = encode(key.path);\n            promises.push(store.put(new DbTargetDocument(targetId, path)));\n        });\n        return persistence_promise_PersistencePromise.waitFor(promises);\n    };\n    IndexedDbQueryCache.prototype.removeMatchingKeys = function (txn, keys, targetId) {\n        var _this = this;\n        // PORTING NOTE: The reverse index (documentsTargets) is maintained by\n        // IndexedDb.\n        var promises = [];\n        var store = documentTargetStore(txn);\n        keys.forEach(function (key) {\n            var path = encode(key.path);\n            promises.push(store.delete([targetId, path]));\n            if (_this.garbageCollector !== null) {\n                _this.garbageCollector.addPotentialGarbageKey(key);\n            }\n        });\n        return persistence_promise_PersistencePromise.waitFor(promises);\n    };\n    IndexedDbQueryCache.prototype.removeMatchingKeysForTargetId = function (txn, targetId) {\n        var store = documentTargetStore(txn);\n        var range = IDBKeyRange.bound([targetId], [targetId + 1], \n        /*lowerOpen=*/ false, \n        /*upperOpen=*/ true);\n        return this.notifyGCForRemovedKeys(txn, range).next(function () {\n            return store.delete(range);\n        });\n    };\n    IndexedDbQueryCache.prototype.notifyGCForRemovedKeys = function (txn, range) {\n        var _this = this;\n        var store = documentTargetStore(txn);\n        if (this.garbageCollector !== null && this.garbageCollector.isEager) {\n            // In order to generate garbage events properly, we need to read these\n            // keys before deleting.\n            return store.iterate({ range: range, keysOnly: true }, function (key, _, control) {\n                var path = decode(key[1]);\n                var docKey = new document_key_DocumentKey(path);\n                // Paranoid assertion in case the the collector is set to null\n                // during the iteration.\n                assert(_this.garbageCollector !== null, 'GarbageCollector for query cache set to null during key removal.');\n                _this.garbageCollector.addPotentialGarbageKey(docKey);\n            });\n        }\n        else {\n            return persistence_promise_PersistencePromise.resolve();\n        }\n    };\n    IndexedDbQueryCache.prototype.getMatchingKeysForTargetId = function (txn, targetId) {\n        var range = IDBKeyRange.bound([targetId], [targetId + 1], \n        /*lowerOpen=*/ false, \n        /*upperOpen=*/ true);\n        var store = documentTargetStore(txn);\n        var result = documentKeySet();\n        return store\n            .iterate({ range: range, keysOnly: true }, function (key, _, control) {\n            var path = decode(key[1]);\n            var docKey = new document_key_DocumentKey(path);\n            result = result.add(docKey);\n        })\n            .next(function () { return result; });\n    };\n    IndexedDbQueryCache.prototype.setGarbageCollector = function (gc) {\n        this.garbageCollector = gc;\n    };\n    IndexedDbQueryCache.prototype.containsKey = function (txn, key) {\n        assert(txn !== null, 'Persistence Transaction cannot be null for query cache containsKey');\n        var path = encode(key.path);\n        var range = IDBKeyRange.bound([path], [immediateSuccessor(path)], \n        /*lowerOpen=*/ false, \n        /*upperOpen=*/ true);\n        var count = 0;\n        return documentTargetStore(txn)\n            .iterate({\n            index: DbTargetDocument.documentTargetsIndex,\n            keysOnly: true,\n            range: range\n        }, function (key, _, control) {\n            count++;\n            control.done();\n        })\n            .next(function () { return count > 0; });\n    };\n    return IndexedDbQueryCache;\n}());\n\n/**\n * Helper to get a typed SimpleDbStore for the queries object store.\n */\nfunction targetsStore(txn) {\n    return indexeddb_query_cache_getStore(txn, DbTarget.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the target globals object store.\n */\nfunction globalTargetStore(txn) {\n    return indexeddb_query_cache_getStore(txn, DbTargetGlobal.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the document target object store.\n */\nfunction documentTargetStore(txn) {\n    return indexeddb_query_cache_getStore(txn, DbTargetDocument.store);\n}\n/**\n * Helper to get a typed SimpleDbStore from a transaction.\n */\nfunction indexeddb_query_cache_getStore(txn, store) {\n    if (txn instanceof simple_db_SimpleDbTransaction) {\n        return txn.store(store);\n    }\n    else {\n        return fail('Invalid transaction object provided!');\n    }\n}\n\n//# sourceMappingURL=indexeddb_query_cache.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/indexeddb_remote_document_cache.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\nvar indexeddb_remote_document_cache_IndexedDbRemoteDocumentCache = /** @class */ (function () {\n    function IndexedDbRemoteDocumentCache(serializer) {\n        this.serializer = serializer;\n    }\n    IndexedDbRemoteDocumentCache.prototype.addEntry = function (transaction, maybeDocument) {\n        return remoteDocumentsStore(transaction).put(dbKey(maybeDocument.key), this.serializer.toDbRemoteDocument(maybeDocument));\n    };\n    IndexedDbRemoteDocumentCache.prototype.removeEntry = function (transaction, documentKey) {\n        return remoteDocumentsStore(transaction).delete(dbKey(documentKey));\n    };\n    IndexedDbRemoteDocumentCache.prototype.getEntry = function (transaction, documentKey) {\n        var _this = this;\n        return remoteDocumentsStore(transaction)\n            .get(dbKey(documentKey))\n            .next(function (dbRemoteDoc) {\n            return dbRemoteDoc\n                ? _this.serializer.fromDbRemoteDocument(dbRemoteDoc)\n                : null;\n        });\n    };\n    IndexedDbRemoteDocumentCache.prototype.getDocumentsMatchingQuery = function (transaction, query) {\n        var _this = this;\n        var results = documentMap();\n        // Documents are ordered by key, so we can use a prefix scan to narrow down\n        // the documents we need to match the query against.\n        var startKey = query.path.toArray();\n        var range = IDBKeyRange.lowerBound(startKey);\n        return remoteDocumentsStore(transaction)\n            .iterate({ range: range }, function (key, dbRemoteDoc, control) {\n            var maybeDoc = _this.serializer.fromDbRemoteDocument(dbRemoteDoc);\n            if (!query.path.isPrefixOf(maybeDoc.key.path)) {\n                control.done();\n            }\n            else if (maybeDoc instanceof document_Document && query.matches(maybeDoc)) {\n                results = results.insert(maybeDoc.key, maybeDoc);\n            }\n        })\n            .next(function () { return results; });\n    };\n    return IndexedDbRemoteDocumentCache;\n}());\n\n/**\n * Helper to get a typed SimpleDbStore for the remoteDocuments object store.\n */\nfunction remoteDocumentsStore(txn) {\n    if (txn instanceof simple_db_SimpleDbTransaction) {\n        return txn.store(DbRemoteDocument.store);\n    }\n    else {\n        return fail('Invalid transaction object provided!');\n    }\n}\nfunction dbKey(docKey) {\n    return docKey.path.toArray();\n}\n\n//# sourceMappingURL=indexeddb_remote_document_cache.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/local_serializer.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n/** Serializer for values stored in the LocalStore. */\nvar local_serializer_LocalSerializer = /** @class */ (function () {\n    function LocalSerializer(remoteSerializer) {\n        this.remoteSerializer = remoteSerializer;\n    }\n    /** Decodes a remote document from storage locally to a Document. */\n    LocalSerializer.prototype.fromDbRemoteDocument = function (remoteDoc) {\n        if (remoteDoc.document) {\n            return this.remoteSerializer.fromDocument(remoteDoc.document);\n        }\n        else if (remoteDoc.noDocument) {\n            var key = document_key_DocumentKey.fromSegments(remoteDoc.noDocument.path);\n            var readTime = remoteDoc.noDocument.readTime;\n            var timestamp = new timestamp_Timestamp(readTime.seconds, readTime.nanos);\n            return new document_NoDocument(key, snapshot_version_SnapshotVersion.fromTimestamp(timestamp));\n        }\n        else {\n            return fail('Unexpected DbRemoteDocument');\n        }\n    };\n    /** Encodes a document for storage locally. */\n    LocalSerializer.prototype.toDbRemoteDocument = function (maybeDoc) {\n        if (maybeDoc instanceof document_Document) {\n            var doc = this.remoteSerializer.toDocument(maybeDoc);\n            return new DbRemoteDocument(null, doc);\n        }\n        else {\n            var path = maybeDoc.key.path.toArray();\n            var timestamp = maybeDoc.version.toTimestamp();\n            var readTime = new DbTimestamp(timestamp.seconds, timestamp.nanos);\n            return new DbRemoteDocument(new DbNoDocument(path, readTime), null);\n        }\n    };\n    /** Encodes a batch of mutations into a DbMutationBatch for local storage. */\n    LocalSerializer.prototype.toDbMutationBatch = function (userId, batch) {\n        var _this = this;\n        var serializedMutations = batch.mutations.map(function (m) {\n            return _this.remoteSerializer.toMutation(m);\n        });\n        return new DbMutationBatch(userId, batch.batchId, batch.localWriteTime.toEpochMilliseconds(), serializedMutations);\n    };\n    /** Decodes a DbMutationBatch into a MutationBatch */\n    LocalSerializer.prototype.fromDbMutationBatch = function (dbBatch) {\n        var _this = this;\n        var mutations = dbBatch.mutations.map(function (m) {\n            return _this.remoteSerializer.fromMutation(m);\n        });\n        var timestamp = timestamp_Timestamp.fromEpochMilliseconds(dbBatch.localWriteTimeMs);\n        return new mutation_batch_MutationBatch(dbBatch.batchId, timestamp, mutations);\n    };\n    /** Decodes a DbTarget into QueryData */\n    LocalSerializer.prototype.fromDbTarget = function (dbTarget) {\n        var readTime = new timestamp_Timestamp(dbTarget.readTime.seconds, dbTarget.readTime.nanos);\n        var version = snapshot_version_SnapshotVersion.fromTimestamp(readTime);\n        var query;\n        if (isDocumentQuery(dbTarget.query)) {\n            query = this.remoteSerializer.fromDocumentsTarget(dbTarget.query);\n        }\n        else {\n            query = this.remoteSerializer.fromQueryTarget(dbTarget.query);\n        }\n        return new query_data_QueryData(query, dbTarget.targetId, QueryPurpose.Listen, version, dbTarget.resumeToken);\n    };\n    /** Encodes QueryData into a DbTarget for storage locally. */\n    LocalSerializer.prototype.toDbTarget = function (queryData) {\n        assert(QueryPurpose.Listen === queryData.purpose, 'Only queries with purpose ' +\n            QueryPurpose.Listen +\n            ' may be stored, got ' +\n            queryData.purpose);\n        var timestamp = queryData.snapshotVersion.toTimestamp();\n        var dbTimestamp = new DbTimestamp(timestamp.seconds, timestamp.nanos);\n        var queryProto;\n        if (queryData.query.isDocumentQuery()) {\n            queryProto = this.remoteSerializer.toDocumentsTarget(queryData.query);\n        }\n        else {\n            queryProto = this.remoteSerializer.toQueryTarget(queryData.query);\n        }\n        assert(typeof queryData.resumeToken === 'string', 'Persisting non-string resume token not supported.');\n        var resumeToken = queryData.resumeToken;\n        // lastListenSequenceNumber is always 0 until we do real GC.\n        return new DbTarget(queryData.targetId, queryData.query.canonicalId(), dbTimestamp, resumeToken, 0, queryProto);\n    };\n    return LocalSerializer;\n}());\n\n/**\n * A helper function for figuring out what kind of query has been stored.\n */\nfunction isDocumentQuery(dbQuery) {\n    return dbQuery.documents !== undefined;\n}\n\n//# sourceMappingURL=local_serializer.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/indexeddb_persistence.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\nvar indexeddb_persistence_LOG_TAG = 'IndexedDbPersistence';\n/** If the owner lease is older than 5 seconds, try to take ownership. */\nvar OWNER_LEASE_MAX_AGE_MS = 5000;\n/** Refresh the owner lease every 4 seconds while owner. */\nvar OWNER_LEASE_REFRESH_INTERVAL_MS = 4000;\n/** LocalStorage location to indicate a zombied ownerId (see class comment). */\nvar ZOMBIE_OWNER_LOCALSTORAGE_SUFFIX = 'zombiedOwnerId';\n/** Error when the owner lease cannot be acquired or is lost. */\nvar EXISTING_OWNER_ERROR_MSG = 'There is another tab open with offline' +\n    ' persistence enabled. Only one such tab is allowed at a time. The' +\n    ' other tab must be closed or persistence must be disabled.';\nvar UNSUPPORTED_PLATFORM_ERROR_MSG = 'This platform is either missing' +\n    ' IndexedDB or is known to have an incomplete implementation. Offline' +\n    ' persistence has been disabled.';\n/**\n * An IndexedDB-backed instance of Persistence. Data is stored persistently\n * across sessions.\n *\n * Currently the Firestore SDK only supports a single consumer of the database,\n * but browsers obviously support multiple tabs. IndexedDbPersistence ensures a\n * single consumer of the database via an \"owner lease\" stored in the database.\n *\n * On startup, IndexedDbPersistence assigns itself a random \"ownerId\" and writes\n * it to a special \"owner\" object in the database (if no entry exists already or\n * the current entry is expired). This owner lease is then verified inside every\n * transaction to ensure the lease has not been lost.\n *\n * If a tab opts not to acquire the owner lease (because there's an existing\n * non-expired owner) or loses the owner lease, IndexedDbPersistence enters a\n * failed state and all subsequent operations will automatically fail.\n *\n * The current owner regularly refreshes the owner lease with new timestamps to\n * prevent newly-opened tabs from taking over ownership.\n *\n * Additionally there is an optimization so that when a tab is closed, the owner\n * lease is released immediately (this is especially important to make sure that\n * a refreshed tab is able to immediately re-acquire the owner lease).\n * Unfortunately, IndexedDB cannot be reliably used in window.unload since it is\n * an asynchronous API. So in addition to attempting to give up the lease,\n * the owner writes its ownerId to a \"zombiedOwnerId\" entry in LocalStorage\n * which acts as an indicator that another tab should go ahead and take the\n * owner lease immediately regardless of the current lease timestamp.\n */\nvar indexeddb_persistence_IndexedDbPersistence = /** @class */ (function () {\n    function IndexedDbPersistence(prefix, serializer) {\n        this.ownerId = this.generateOwnerId();\n        this.dbName = prefix + IndexedDbPersistence.MAIN_DATABASE;\n        this.serializer = new local_serializer_LocalSerializer(serializer);\n        this.localStoragePrefix = prefix;\n    }\n    IndexedDbPersistence.prototype.start = function () {\n        var _this = this;\n        if (!IndexedDbPersistence.isAvailable()) {\n            this.persistenceError = new FirestoreError(Code.UNIMPLEMENTED, UNSUPPORTED_PLATFORM_ERROR_MSG);\n            return Promise.reject(this.persistenceError);\n        }\n        assert(!this.started, 'IndexedDbPersistence double-started!');\n        this.started = true;\n        return simple_db_SimpleDb.openOrCreate(this.dbName, SCHEMA_VERSION, createOrUpgradeDb)\n            .then(function (db) {\n            _this.simpleDb = db;\n        })\n            .then(function () { return _this.tryAcquireOwnerLease(); })\n            .then(function () {\n            _this.scheduleOwnerLeaseRefreshes();\n            _this.attachWindowUnloadHook();\n        });\n    };\n    IndexedDbPersistence.prototype.shutdown = function () {\n        var _this = this;\n        assert(this.started, 'IndexedDbPersistence shutdown without start!');\n        this.started = false;\n        this.detachWindowUnloadHook();\n        this.stopOwnerLeaseRefreshes();\n        return this.releaseOwnerLease().then(function () {\n            _this.simpleDb.close();\n        });\n    };\n    IndexedDbPersistence.prototype.getMutationQueue = function (user) {\n        return indexeddb_mutation_queue_IndexedDbMutationQueue.forUser(user, this.serializer);\n    };\n    IndexedDbPersistence.prototype.getQueryCache = function () {\n        return new indexeddb_query_cache_IndexedDbQueryCache(this.serializer);\n    };\n    IndexedDbPersistence.prototype.getRemoteDocumentCache = function () {\n        return new indexeddb_remote_document_cache_IndexedDbRemoteDocumentCache(this.serializer);\n    };\n    IndexedDbPersistence.prototype.runTransaction = function (action, operation) {\n        var _this = this;\n        if (this.persistenceError) {\n            return Promise.reject(this.persistenceError);\n        }\n        debug(indexeddb_persistence_LOG_TAG, 'Starting transaction:', action);\n        // Do all transactions as readwrite against all object stores, since we\n        // are the only reader/writer.\n        return this.simpleDb.runTransaction('readwrite', ALL_STORES, function (txn) {\n            // Verify that we still have the owner lease as part of every transaction.\n            return _this.ensureOwnerLease(txn).next(function () { return operation(txn); });\n        });\n    };\n    IndexedDbPersistence.isAvailable = function () {\n        return simple_db_SimpleDb.isAvailable();\n    };\n    /**\n     * Generates a string used as a prefix when storing data in IndexedDB and\n     * LocalStorage.\n     */\n    IndexedDbPersistence.buildStoragePrefix = function (databaseInfo) {\n        // Use two different prefix formats:\n        //\n        //   * firestore / persistenceKey / projectID . databaseID / ...\n        //   * firestore / persistenceKey / projectID / ...\n        //\n        // projectIDs are DNS-compatible names and cannot contain dots\n        // so there's no danger of collisions.\n        var database = databaseInfo.databaseId.projectId;\n        if (!databaseInfo.databaseId.isDefaultDatabase) {\n            database += '.' + databaseInfo.databaseId.database;\n        }\n        return 'firestore/' + databaseInfo.persistenceKey + '/' + database + '/';\n    };\n    /**\n     * Acquires the owner lease if there's no valid owner. Else returns a rejected\n     * promise.\n     */\n    IndexedDbPersistence.prototype.tryAcquireOwnerLease = function () {\n        var _this = this;\n        // NOTE: Don't use this.runTransaction, since it requires us to already\n        // have the lease.\n        return this.simpleDb.runTransaction('readwrite', [DbOwner.store], function (txn) {\n            var store = txn.store(DbOwner.store);\n            return store.get('owner').next(function (dbOwner) {\n                if (!_this.validOwner(dbOwner)) {\n                    var newDbOwner = new DbOwner(_this.ownerId, Date.now());\n                    debug(indexeddb_persistence_LOG_TAG, 'No valid owner. Acquiring owner lease. Current owner:', dbOwner, 'New owner:', newDbOwner);\n                    return store.put('owner', newDbOwner);\n                }\n                else {\n                    debug(indexeddb_persistence_LOG_TAG, 'Valid owner already. Failing. Current owner:', dbOwner);\n                    _this.persistenceError = new FirestoreError(Code.FAILED_PRECONDITION, EXISTING_OWNER_ERROR_MSG);\n                    return persistence_promise_PersistencePromise.reject(_this.persistenceError);\n                }\n            });\n        });\n    };\n    /** Checks the owner lease and deletes it if we are the current owner. */\n    IndexedDbPersistence.prototype.releaseOwnerLease = function () {\n        var _this = this;\n        // NOTE: Don't use this.runTransaction, since it requires us to already\n        // have the lease.\n        return this.simpleDb.runTransaction('readwrite', [DbOwner.store], function (txn) {\n            var store = txn.store(DbOwner.store);\n            return store.get('owner').next(function (dbOwner) {\n                if (dbOwner !== null && dbOwner.ownerId === _this.ownerId) {\n                    debug(indexeddb_persistence_LOG_TAG, 'Releasing owner lease.');\n                    return store.delete('owner');\n                }\n                else {\n                    return persistence_promise_PersistencePromise.resolve();\n                }\n            });\n        });\n    };\n    /**\n     * Checks the owner lease and returns a rejected promise if we are not the\n     * current owner. This should be included in every transaction to guard\n     * against losing the owner lease.\n     */\n    IndexedDbPersistence.prototype.ensureOwnerLease = function (txn) {\n        var _this = this;\n        var store = txn.store(DbOwner.store);\n        return store.get('owner').next(function (dbOwner) {\n            if (dbOwner === null || dbOwner.ownerId !== _this.ownerId) {\n                _this.persistenceError = new FirestoreError(Code.FAILED_PRECONDITION, EXISTING_OWNER_ERROR_MSG);\n                return persistence_promise_PersistencePromise.reject(_this.persistenceError);\n            }\n            else {\n                return persistence_promise_PersistencePromise.resolve();\n            }\n        });\n    };\n    /**\n     * Returns true if the provided owner exists, has a recent timestamp, and\n     * isn't zombied.\n     *\n     * NOTE: To determine if the owner is zombied, this method reads from\n     * LocalStorage which could be mildly expensive.\n     */\n    IndexedDbPersistence.prototype.validOwner = function (dbOwner) {\n        var now = Date.now();\n        var minAcceptable = now - OWNER_LEASE_MAX_AGE_MS;\n        var maxAcceptable = now;\n        if (dbOwner === null) {\n            return false; // no owner.\n        }\n        else if (dbOwner.leaseTimestampMs < minAcceptable) {\n            return false; // owner lease has expired.\n        }\n        else if (dbOwner.leaseTimestampMs > maxAcceptable) {\n            log_error('Persistence owner-lease is in the future. Discarding.', dbOwner);\n            return false;\n        }\n        else if (dbOwner.ownerId === this.getZombiedOwnerId()) {\n            return false; // owner's tab closed.\n        }\n        else {\n            return true;\n        }\n    };\n    /**\n     * Schedules a recurring timer to update the owner lease timestamp to prevent\n     * other tabs from taking the lease.\n     */\n    IndexedDbPersistence.prototype.scheduleOwnerLeaseRefreshes = function () {\n        var _this = this;\n        // NOTE: This doesn't need to be scheduled on the async queue and doing so\n        // would increase the chances of us not refreshing on time if the queue is\n        // backed up for some reason.\n        this.ownerLeaseRefreshHandle = setInterval(function () {\n            var txResult = _this.runTransaction('Refresh owner timestamp', function (txn) {\n                // NOTE: We don't need to validate the current owner contents, since\n                // runTransaction does that automatically.\n                var store = txn.store(DbOwner.store);\n                return store.put('owner', new DbOwner(_this.ownerId, Date.now()));\n            });\n            txResult.catch(function (reason) {\n                // Probably means we lost the lease. Report the error and stop trying to\n                // refresh the lease.\n                log_error(reason);\n                _this.stopOwnerLeaseRefreshes();\n            });\n        }, OWNER_LEASE_REFRESH_INTERVAL_MS);\n    };\n    IndexedDbPersistence.prototype.stopOwnerLeaseRefreshes = function () {\n        if (this.ownerLeaseRefreshHandle) {\n            clearInterval(this.ownerLeaseRefreshHandle);\n            this.ownerLeaseRefreshHandle = null;\n        }\n    };\n    /**\n     * Attaches a window.unload handler that will synchronously write our\n     * ownerId to a \"zombie owner id\" location in localstorage. This can be used\n     * by tabs trying to acquire the lease to determine that the lease should be\n     * acquired immediately even if the timestamp is recent. This is particularly\n     * important for the refresh case (so the tab correctly re-acquires the owner\n     * lease). LocalStorage is used for this rather than IndexedDb because it is\n     * a synchronous API and so can be used reliably from an unload handler.\n     */\n    IndexedDbPersistence.prototype.attachWindowUnloadHook = function () {\n        var _this = this;\n        this.windowUnloadHandler = function () {\n            // Record that we're zombied.\n            _this.setZombiedOwnerId(_this.ownerId);\n            // Attempt graceful shutdown (including releasing our owner lease), but\n            // there's no guarantee it will complete.\n            _this.shutdown();\n        };\n        window.addEventListener('unload', this.windowUnloadHandler);\n    };\n    IndexedDbPersistence.prototype.detachWindowUnloadHook = function () {\n        if (this.windowUnloadHandler) {\n            window.removeEventListener('unload', this.windowUnloadHandler);\n            this.windowUnloadHandler = null;\n        }\n    };\n    /**\n     * Returns any recorded \"zombied owner\" (i.e. a previous owner that became\n     * zombied due to their tab closing) from LocalStorage, or null if no such\n     * record exists.\n     */\n    IndexedDbPersistence.prototype.getZombiedOwnerId = function () {\n        try {\n            var zombiedOwnerId = window.localStorage.getItem(this.zombiedOwnerLocalStorageKey());\n            debug(indexeddb_persistence_LOG_TAG, 'Zombied ownerID from LocalStorage:', zombiedOwnerId);\n            return zombiedOwnerId;\n        }\n        catch (e) {\n            // Gracefully handle if LocalStorage isn't available / working.\n            log_error('Failed to get zombie owner id.', e);\n            return null;\n        }\n    };\n    /**\n     * Records a zombied owner (an owner that had its tab closed) in LocalStorage\n     * or, if passed null, deletes any recorded zombied owner.\n     */\n    IndexedDbPersistence.prototype.setZombiedOwnerId = function (zombieOwnerId) {\n        try {\n            if (zombieOwnerId === null) {\n                window.localStorage.removeItem(this.zombiedOwnerLocalStorageKey());\n            }\n            else {\n                window.localStorage.setItem(this.zombiedOwnerLocalStorageKey(), zombieOwnerId);\n            }\n        }\n        catch (e) {\n            // Gracefully handle if LocalStorage isn't available / working.\n            log_error('Failed to set zombie owner id.', e);\n        }\n    };\n    IndexedDbPersistence.prototype.zombiedOwnerLocalStorageKey = function () {\n        return this.localStoragePrefix + ZOMBIE_OWNER_LOCALSTORAGE_SUFFIX;\n    };\n    IndexedDbPersistence.prototype.generateOwnerId = function () {\n        // For convenience, just use an AutoId.\n        return misc_AutoId.newId();\n    };\n    /**\n     * The name of the main (and currently only) IndexedDB database. this name is\n     * appended to the prefix provided to the IndexedDbPersistence constructor.\n     */\n    IndexedDbPersistence.MAIN_DATABASE = 'main';\n    return IndexedDbPersistence;\n}());\n\n\n//# sourceMappingURL=indexeddb_persistence.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/local_documents_view.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n/**\n * A readonly view of the local state of all documents we're tracking (i.e. we\n * have a cached version in remoteDocumentCache or local mutations for the\n * document). The view is computed by applying the mutations in the\n * MutationQueue to the RemoteDocumentCache.\n */\nvar local_documents_view_LocalDocumentsView = /** @class */ (function () {\n    function LocalDocumentsView(remoteDocumentCache, mutationQueue) {\n        this.remoteDocumentCache = remoteDocumentCache;\n        this.mutationQueue = mutationQueue;\n    }\n    /**\n     * Get the local view of the document identified by `key`.\n     *\n     * @return Local view of the document or null if we don't have any cached\n     * state for it.\n     */\n    LocalDocumentsView.prototype.getDocument = function (transaction, key) {\n        var _this = this;\n        return this.remoteDocumentCache\n            .getEntry(transaction, key)\n            .next(function (remoteDoc) {\n            return _this.computeLocalDocument(transaction, key, remoteDoc);\n        });\n    };\n    /**\n     * Gets the local view of the documents identified by `keys`.\n     *\n     * If we don't have cached state for a document in `keys`, a NoDocument will\n     * be stored for that key in the resulting set.\n     */\n    LocalDocumentsView.prototype.getDocuments = function (transaction, keys) {\n        var _this = this;\n        var promises = [];\n        var results = maybeDocumentMap();\n        keys.forEach(function (key) {\n            promises.push(_this.getDocument(transaction, key).next(function (maybeDoc) {\n                // TODO(http://b/32275378): Don't conflate missing / deleted.\n                if (!maybeDoc) {\n                    maybeDoc = new document_NoDocument(key, snapshot_version_SnapshotVersion.forDeletedDoc());\n                }\n                results = results.insert(key, maybeDoc);\n            }));\n        });\n        return persistence_promise_PersistencePromise.waitFor(promises).next(function () { return results; });\n    };\n    /** Performs a query against the local view of all documents. */\n    LocalDocumentsView.prototype.getDocumentsMatchingQuery = function (transaction, query) {\n        if (document_key_DocumentKey.isDocumentKey(query.path)) {\n            return this.getDocumentsMatchingDocumentQuery(transaction, query.path);\n        }\n        else {\n            return this.getDocumentsMatchingCollectionQuery(transaction, query);\n        }\n    };\n    LocalDocumentsView.prototype.getDocumentsMatchingDocumentQuery = function (transaction, docPath) {\n        // Just do a simple document lookup.\n        return this.getDocument(transaction, new document_key_DocumentKey(docPath)).next(function (maybeDoc) {\n            var result = documentMap();\n            if (maybeDoc instanceof document_Document) {\n                result = result.insert(maybeDoc.key, maybeDoc);\n            }\n            return result;\n        });\n    };\n    LocalDocumentsView.prototype.getDocumentsMatchingCollectionQuery = function (transaction, query) {\n        var _this = this;\n        // Query the remote documents and overlay mutations.\n        // TODO(mikelehen): There may be significant overlap between the mutations\n        // affecting these remote documents and the\n        // getAllMutationBatchesAffectingQuery() mutations. Consider optimizing.\n        var results;\n        return this.remoteDocumentCache\n            .getDocumentsMatchingQuery(transaction, query)\n            .next(function (queryResults) {\n            return _this.computeLocalDocuments(transaction, queryResults);\n        })\n            .next(function (promisedResults) {\n            results = promisedResults;\n            // Now use the mutation queue to discover any other documents that may\n            // match the query after applying mutations.\n            return _this.mutationQueue.getAllMutationBatchesAffectingQuery(transaction, query);\n        })\n            .next(function (matchingMutationBatches) {\n            var matchingKeys = documentKeySet();\n            for (var _i = 0, matchingMutationBatches_1 = matchingMutationBatches; _i < matchingMutationBatches_1.length; _i++) {\n                var batch = matchingMutationBatches_1[_i];\n                for (var _a = 0, _b = batch.mutations; _a < _b.length; _a++) {\n                    var mutation = _b[_a];\n                    // TODO(mikelehen): PERF: Check if this mutation actually\n                    // affects the query to reduce work.\n                    if (!results.get(mutation.key)) {\n                        matchingKeys = matchingKeys.add(mutation.key);\n                    }\n                }\n            }\n            // Now add in the results for the matchingKeys.\n            var promises = [];\n            matchingKeys.forEach(function (key) {\n                promises.push(_this.getDocument(transaction, key).next(function (doc) {\n                    if (doc instanceof document_Document) {\n                        results = results.insert(doc.key, doc);\n                    }\n                }));\n            });\n            return persistence_promise_PersistencePromise.waitFor(promises);\n        })\n            .next(function () {\n            // Finally, filter out any documents that don't actually match\n            // the query.\n            results.forEach(function (key, doc) {\n                if (!query.matches(doc)) {\n                    results = results.remove(key);\n                }\n            });\n            return results;\n        });\n    };\n    /**\n     * Takes a remote document and applies local mutations to generate the local\n     * view of the document.\n     * @param transaction The transaction in which to perform any persistence\n     *     operations.\n     * @param documentKey The key of the document (necessary when remoteDocument\n     *     is null).\n     * @param document The base remote document to apply mutations to or null.\n     */\n    LocalDocumentsView.prototype.computeLocalDocument = function (transaction, documentKey, document) {\n        return this.mutationQueue\n            .getAllMutationBatchesAffectingDocumentKey(transaction, documentKey)\n            .next(function (batches) {\n            for (var _i = 0, batches_1 = batches; _i < batches_1.length; _i++) {\n                var batch = batches_1[_i];\n                document = batch.applyToLocalView(documentKey, document);\n            }\n            return document;\n        });\n    };\n    /**\n     * Takes a set of remote documents and applies local mutations to generate the\n     * local view of the documents.\n     * @param transaction The transaction in which to perform any persistence\n     *     operations.\n     * @param documents The base remote documents to apply mutations to.\n     * @return The local view of the documents.\n     */\n    LocalDocumentsView.prototype.computeLocalDocuments = function (transaction, documents) {\n        var _this = this;\n        var promises = [];\n        documents.forEach(function (key, doc) {\n            promises.push(_this.computeLocalDocument(transaction, key, doc).next(function (mutatedDoc) {\n                if (mutatedDoc instanceof document_Document) {\n                    documents = documents.insert(mutatedDoc.key, mutatedDoc);\n                }\n                else if (mutatedDoc instanceof document_NoDocument) {\n                    documents = documents.remove(mutatedDoc.key);\n                }\n                else {\n                    fail('Unknown MaybeDocument: ' + mutatedDoc);\n                }\n            }));\n        });\n        return persistence_promise_PersistencePromise.waitFor(promises).next(function () { return documents; });\n    };\n    return LocalDocumentsView;\n}());\n\n\n//# sourceMappingURL=local_documents_view.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/remote_document_change_buffer.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * An in-memory buffer of entries to be written to a RemoteDocumentCache.\n * It can be used to batch up a set of changes to be written to the cache, but\n * additionally supports reading entries back with the `getEntry()` method,\n * falling back to the underlying RemoteDocumentCache if no entry is\n * buffered.\n *\n * NOTE: This class was introduced in iOS to work around a limitation in\n * LevelDB. Given IndexedDb has full transaction support with\n * read-your-own-writes capability, this class is not technically needed, but\n * has been preserved as a convenience and to aid portability.\n */\nvar remote_document_change_buffer_RemoteDocumentChangeBuffer = /** @class */ (function () {\n    function RemoteDocumentChangeBuffer(remoteDocumentCache) {\n        this.remoteDocumentCache = remoteDocumentCache;\n        this.changes = maybeDocumentMap();\n    }\n    /** Buffers a `RemoteDocumentCache.addEntry()` call. */\n    RemoteDocumentChangeBuffer.prototype.addEntry = function (maybeDocument) {\n        var changes = this.assertChanges();\n        this.changes = changes.insert(maybeDocument.key, maybeDocument);\n    };\n    // NOTE: removeEntry() is not presently necessary and so is omitted.\n    /**\n     * Looks up an entry in the cache. The buffered changes will first be checked,\n     * and if no buffered change applies, this will forward to\n     * `RemoteDocumentCache.getEntry()`.\n     *\n     * @param transaction The transaction in which to perform any persistence\n     *     operations.\n     * @param documentKey The key of the entry to look up.\n     * @return The cached Document or NoDocument entry, or null if we have nothing\n     * cached.\n     */\n    RemoteDocumentChangeBuffer.prototype.getEntry = function (transaction, documentKey) {\n        var changes = this.assertChanges();\n        var bufferedEntry = changes.get(documentKey);\n        if (bufferedEntry) {\n            return persistence_promise_PersistencePromise.resolve(bufferedEntry);\n        }\n        else {\n            return this.remoteDocumentCache.getEntry(transaction, documentKey);\n        }\n    };\n    /**\n     * Applies buffered changes to the underlying RemoteDocumentCache, using\n     * the provided transaction.\n     */\n    RemoteDocumentChangeBuffer.prototype.apply = function (transaction) {\n        var _this = this;\n        var changes = this.assertChanges();\n        var promises = [];\n        changes.forEach(function (key, maybeDoc) {\n            promises.push(_this.remoteDocumentCache.addEntry(transaction, maybeDoc));\n        });\n        // We should not be used to buffer any more changes.\n        this.changes = null;\n        return persistence_promise_PersistencePromise.waitFor(promises);\n    };\n    /** Helper to assert this.changes is not null and return it. */\n    RemoteDocumentChangeBuffer.prototype.assertChanges = function () {\n        assert(this.changes !== null, 'Changes have already been applied.');\n        return this.changes;\n    };\n    return RemoteDocumentChangeBuffer;\n}());\n\n\n//# sourceMappingURL=remote_document_change_buffer.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/local_store.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar local_store_LOG_TAG = 'LocalStore';\n/**\n * Local storage in the Firestore client. Coordinates persistence components\n * like the mutation queue and remote document cache to present a\n * latency-compensated view of stored data.\n *\n * The LocalStore is responsible for accepting mutations from the Sync Engine.\n * Writes from the client are put into a queue as provisional Mutations until\n * they are processed by the RemoteStore and confirmed as having been written\n * to the server.\n *\n * The local store provides the local version of documents that have been\n * modified locally. It maintains the constraint:\n *\n *   LocalDocument = RemoteDocument + Active(LocalMutations)\n *\n * (Active mutations are those that are enqueued and have not been previously\n * acknowledged or rejected).\n *\n * The RemoteDocument (\"ground truth\") state is provided via the\n * applyChangeBatch method. It will be some version of a server-provided\n * document OR will be a server-provided document PLUS acknowledged mutations:\n *\n *   RemoteDocument' = RemoteDocument + Acknowledged(LocalMutations)\n *\n * Note that this \"dirty\" version of a RemoteDocument will not be identical to a\n * server base version, since it has LocalMutations added to it pending getting\n * an authoritative copy from the server.\n *\n * Since LocalMutations can be rejected by the server, we have to be able to\n * revert a LocalMutation that has already been applied to the LocalDocument\n * (typically done by replaying all remaining LocalMutations to the\n * RemoteDocument to re-apply).\n *\n * The LocalStore is responsible for the garbage collection of the documents it\n * contains. For now, it every doc referenced by a view, the mutation queue, or\n * the RemoteStore.\n *\n * It also maintains the persistence of mapping queries to resume tokens and\n * target ids. It needs to know this data about queries to properly know what\n * docs it would be allowed to garbage collect.\n *\n * The LocalStore must be able to efficiently execute queries against its local\n * cache of the documents, to provide the initial set of results before any\n * remote changes have been received.\n *\n * Note: In TypeScript, most methods return Promises since the implementation\n * may rely on fetching data from IndexedDB which is async.\n * These Promises will only be rejected on an I/O error or other internal\n * (unexpected) failure (e.g. failed assert) and always represent an\n * unrecoverable error (should be caught / reported by the async_queue).\n */\nvar local_store_LocalStore = /** @class */ (function () {\n    function LocalStore(\n        /** Manages our in-memory or durable persistence. */\n        persistence, initialUser, \n        /**\n         * The garbage collector collects documents that should no longer be\n         * cached (e.g. if they are no longer retained by the above reference sets\n         * and the garbage collector is performing eager collection).\n         */\n        garbageCollector) {\n        this.persistence = persistence;\n        this.garbageCollector = garbageCollector;\n        /**\n         * The set of document references maintained by any local views.\n         */\n        this.localViewReferences = new reference_set_ReferenceSet();\n        /** Maps a targetID to data about its query. */\n        this.targetIds = {};\n        /** Used to generate targetIDs for queries tracked locally. */\n        this.targetIdGenerator = TargetIdGenerator.forLocalStore();\n        /**\n         * A heldBatchResult is a mutation batch result (from a write acknowledgement)\n         * that arrived before the watch stream got notified of a snapshot that\n         * includes the write. So we \"hold\" it until the watch stream catches up. It\n         * ensures that the local write remains visible (latency compensation) and\n         * doesn't temporarily appear reverted because the watch stream is slower than\n         * the write stream and so wasn't reflecting it.\n         *\n         * NOTE: Eventually we want to move this functionality into the remote store.\n         */\n        this.heldBatchResults = [];\n        this.mutationQueue = persistence.getMutationQueue(initialUser);\n        this.remoteDocuments = persistence.getRemoteDocumentCache();\n        this.queryCache = persistence.getQueryCache();\n        this.localDocuments = new local_documents_view_LocalDocumentsView(this.remoteDocuments, this.mutationQueue);\n        this.garbageCollector.addGarbageSource(this.localViewReferences);\n        this.garbageCollector.addGarbageSource(this.queryCache);\n        this.garbageCollector.addGarbageSource(this.mutationQueue);\n    }\n    /** Performs any initial startup actions required by the local store. */\n    LocalStore.prototype.start = function () {\n        var _this = this;\n        return this.persistence.runTransaction('Start LocalStore', function (txn) {\n            return _this.startMutationQueue(txn).next(function () { return _this.startQueryCache(txn); });\n        });\n    };\n    /**\n     * Tells the LocalStore that the currently authenticated user has changed.\n     *\n     * In response the local store switches the mutation queue to the new user and\n     * returns any resulting document changes.\n     */\n    LocalStore.prototype.handleUserChange = function (user) {\n        var _this = this;\n        return this.persistence.runTransaction('Handle user change', function (txn) {\n            // Swap out the mutation queue, grabbing the pending mutation batches\n            // before and after.\n            var oldBatches;\n            return _this.mutationQueue\n                .getAllMutationBatches(txn)\n                .next(function (promisedOldBatches) {\n                oldBatches = promisedOldBatches;\n                _this.garbageCollector.removeGarbageSource(_this.mutationQueue);\n                _this.mutationQueue = _this.persistence.getMutationQueue(user);\n                _this.garbageCollector.addGarbageSource(_this.mutationQueue);\n                return _this.startMutationQueue(txn);\n            })\n                .next(function () {\n                // Recreate our LocalDocumentsView using the new\n                // MutationQueue.\n                _this.localDocuments = new local_documents_view_LocalDocumentsView(_this.remoteDocuments, _this.mutationQueue);\n                return _this.mutationQueue.getAllMutationBatches(txn);\n            })\n                .next(function (newBatches) {\n                // Union the old/new changed keys.\n                var changedKeys = documentKeySet();\n                for (var _i = 0, _a = [oldBatches, newBatches]; _i < _a.length; _i++) {\n                    var batches = _a[_i];\n                    for (var _b = 0, batches_1 = batches; _b < batches_1.length; _b++) {\n                        var batch = batches_1[_b];\n                        for (var _c = 0, _d = batch.mutations; _c < _d.length; _c++) {\n                            var mutation = _d[_c];\n                            changedKeys = changedKeys.add(mutation.key);\n                        }\n                    }\n                }\n                // Return the set of all (potentially) changed documents as the\n                // result of the user change.\n                return _this.localDocuments.getDocuments(txn, changedKeys);\n            });\n        });\n    };\n    LocalStore.prototype.startQueryCache = function (txn) {\n        var _this = this;\n        return this.queryCache.start(txn).next(function () {\n            var targetId = _this.queryCache.getHighestTargetId();\n            _this.targetIdGenerator = TargetIdGenerator.forLocalStore(targetId);\n        });\n    };\n    LocalStore.prototype.startMutationQueue = function (txn) {\n        var _this = this;\n        return this.mutationQueue\n            .start(txn)\n            .next(function () {\n            // If we have any leftover mutation batch results from a prior run,\n            // just drop them.\n            // TODO(http://b/33446471): We probably need to repopulate\n            // heldBatchResults or similar instead, but that is not\n            // straightforward since we're not persisting the write ack versions.\n            _this.heldBatchResults = [];\n            return _this.mutationQueue.getHighestAcknowledgedBatchId(txn);\n        })\n            .next(function (highestAck) {\n            // TODO(mikelehen): This is the only usage of\n            // getAllMutationBatchesThroughBatchId(). Consider removing it in\n            // favor of a getAcknowledgedBatches() method.\n            if (highestAck !== BATCHID_UNKNOWN) {\n                return _this.mutationQueue.getAllMutationBatchesThroughBatchId(txn, highestAck);\n            }\n            else {\n                return persistence_promise_PersistencePromise.resolve([]);\n            }\n        })\n            .next(function (ackedBatches) {\n            if (ackedBatches.length > 0) {\n                return _this.mutationQueue.removeMutationBatches(txn, ackedBatches);\n            }\n            else {\n                return persistence_promise_PersistencePromise.resolve();\n            }\n        });\n    };\n    /* Accept locally generated Mutations and commit them to storage. */\n    LocalStore.prototype.localWrite = function (mutations) {\n        var _this = this;\n        return this.persistence.runTransaction('Locally write mutations', function (txn) {\n            var batch;\n            var localWriteTime = timestamp_Timestamp.now();\n            return _this.mutationQueue\n                .addMutationBatch(txn, localWriteTime, mutations)\n                .next(function (promisedBatch) {\n                batch = promisedBatch;\n                // TODO(koss): This is doing an N^2 update by replaying ALL the\n                // mutations on each document (instead of just the ones added) in\n                // this batch.\n                var keys = batch.keys();\n                return _this.localDocuments.getDocuments(txn, keys);\n            })\n                .next(function (changedDocuments) {\n                return { batchId: batch.batchId, changes: changedDocuments };\n            });\n        });\n    };\n    /**\n     * Acknowledge the given batch.\n     *\n     * On the happy path when a batch is acknowledged, the local store will\n     *\n     *  + remove the batch from the mutation queue;\n     *  + apply the changes to the remote document cache;\n     *  + recalculate the latency compensated view implied by those changes (there\n     *    may be mutations in the queue that affect the documents but haven't been\n     *    acknowledged yet); and\n     *  + give the changed documents back the sync engine\n     *\n     * @returns The resulting (modified) documents.\n     */\n    LocalStore.prototype.acknowledgeBatch = function (batchResult) {\n        var _this = this;\n        return this.persistence.runTransaction('Acknowledge batch', function (txn) {\n            var affected;\n            return _this.mutationQueue\n                .acknowledgeBatch(txn, batchResult.batch, batchResult.streamToken)\n                .next(function () {\n                if (_this.shouldHoldBatchResult(batchResult.commitVersion)) {\n                    _this.heldBatchResults.push(batchResult);\n                    affected = documentKeySet();\n                    return persistence_promise_PersistencePromise.resolve();\n                }\n                else {\n                    var documentBuffer_1 = new remote_document_change_buffer_RemoteDocumentChangeBuffer(_this.remoteDocuments);\n                    return _this.releaseBatchResults(txn, [batchResult], documentBuffer_1).next(function (promisedAffectedKeys) {\n                        affected = promisedAffectedKeys;\n                        return documentBuffer_1.apply(txn);\n                    });\n                }\n            })\n                .next(function () {\n                return _this.mutationQueue.performConsistencyCheck(txn);\n            })\n                .next(function () {\n                return _this.localDocuments.getDocuments(txn, affected);\n            });\n        });\n    };\n    /**\n     * Remove mutations from the MutationQueue for the specified batch;\n     * LocalDocuments will be recalculated.\n     *\n     * @returns The resulting modified documents.\n     */\n    LocalStore.prototype.rejectBatch = function (batchId) {\n        var _this = this;\n        return this.persistence.runTransaction('Reject batch', function (txn) {\n            var toReject;\n            var affectedKeys;\n            return _this.mutationQueue\n                .lookupMutationBatch(txn, batchId)\n                .next(function (promisedToReject) {\n                assert(promisedToReject != null, 'Attempt to reject nonexistent batch!');\n                toReject = promisedToReject;\n                return _this.mutationQueue\n                    .getHighestAcknowledgedBatchId(txn)\n                    .next(function (lastAcked) {\n                    assert(batchId > lastAcked, \"Acknowledged batches can't be rejected.\");\n                    return toReject;\n                });\n            })\n                .next(function () {\n                return _this.removeMutationBatch(txn, toReject);\n            })\n                .next(function (promisedAffectedKeys) {\n                affectedKeys = promisedAffectedKeys;\n                return _this.mutationQueue.performConsistencyCheck(txn);\n            })\n                .next(function () {\n                return _this.localDocuments.getDocuments(txn, affectedKeys);\n            });\n        });\n    };\n    /** Returns the last recorded stream token for the current user. */\n    LocalStore.prototype.getLastStreamToken = function () {\n        var _this = this;\n        return this.persistence.runTransaction('Get last stream token', function (txn) {\n            return _this.mutationQueue.getLastStreamToken(txn);\n        });\n    };\n    /**\n     * Sets the stream token for the current user without acknowledging any\n     * mutation batch. This is usually only useful after a stream handshake or in\n     * response to an error that requires clearing the stream token.\n     */\n    LocalStore.prototype.setLastStreamToken = function (streamToken) {\n        var _this = this;\n        return this.persistence.runTransaction('Set last stream token', function (txn) {\n            return _this.mutationQueue.setLastStreamToken(txn, streamToken);\n        });\n    };\n    /**\n     * Returns the last consistent snapshot processed (used by the RemoteStore to\n     * determine whether to buffer incoming snapshots from the backend).\n     */\n    LocalStore.prototype.getLastRemoteSnapshotVersion = function () {\n        return this.queryCache.getLastRemoteSnapshotVersion();\n    };\n    /**\n     * Update the \"ground-state\" (remote) documents. We assume that the remote\n     * event reflects any write batches that have been acknowledged or rejected\n     * (i.e. we do not re-apply local mutations to updates from this event).\n     *\n     * LocalDocuments are re-calculated if there are remaining mutations in the\n     * queue.\n     */\n    LocalStore.prototype.applyRemoteEvent = function (remoteEvent) {\n        var _this = this;\n        var documentBuffer = new remote_document_change_buffer_RemoteDocumentChangeBuffer(this.remoteDocuments);\n        return this.persistence.runTransaction('Apply remote event', function (txn) {\n            var promises = [];\n            forEachNumber(remoteEvent.targetChanges, function (targetId, change) {\n                // Do not ref/unref unassigned targetIds - it may lead to leaks.\n                var queryData = _this.targetIds[targetId];\n                if (!queryData)\n                    return;\n                var mapping = change.mapping;\n                if (mapping) {\n                    // First make sure that all references are deleted\n                    if (mapping instanceof ResetMapping) {\n                        promises.push(_this.queryCache\n                            .removeMatchingKeysForTargetId(txn, targetId)\n                            .next(function () {\n                            return _this.queryCache.addMatchingKeys(txn, mapping.documents, targetId);\n                        }));\n                    }\n                    else if (mapping instanceof UpdateMapping) {\n                        promises.push(_this.queryCache\n                            .removeMatchingKeys(txn, mapping.removedDocuments, targetId)\n                            .next(function () {\n                            return _this.queryCache.addMatchingKeys(txn, mapping.addedDocuments, targetId);\n                        }));\n                    }\n                    else {\n                        return fail('Unknown mapping type: ' + JSON.stringify(mapping));\n                    }\n                }\n                // Update the resume token if the change includes one. Don't clear\n                // any preexisting value.\n                var resumeToken = change.resumeToken;\n                if (resumeToken.length > 0) {\n                    queryData = queryData.update({\n                        resumeToken: resumeToken,\n                        snapshotVersion: change.snapshotVersion\n                    });\n                    _this.targetIds[targetId] = queryData;\n                    promises.push(_this.queryCache.addQueryData(txn, queryData));\n                }\n            });\n            var changedDocKeys = documentKeySet();\n            remoteEvent.documentUpdates.forEach(function (key, doc) {\n                changedDocKeys = changedDocKeys.add(key);\n                promises.push(documentBuffer.getEntry(txn, key).next(function (existingDoc) {\n                    // Make sure we don't apply an old document version to the remote\n                    // cache, though we make an exception for SnapshotVersion.MIN which\n                    // can happen for manufactured events (e.g. in the case of a limbo\n                    // document resolution failing).\n                    if (existingDoc == null ||\n                        doc.version.isEqual(snapshot_version_SnapshotVersion.MIN) ||\n                        doc.version.compareTo(existingDoc.version) >= 0) {\n                        documentBuffer.addEntry(doc);\n                    }\n                    else {\n                        debug(local_store_LOG_TAG, 'Ignoring outdated watch update for ', key, '. Current version:', existingDoc.version, ' Watch version:', doc.version);\n                    }\n                    // The document might be garbage because it was unreferenced by\n                    // everything. Make sure to mark it as garbage if it is...\n                    _this.garbageCollector.addPotentialGarbageKey(key);\n                }));\n            });\n            // HACK: The only reason we allow a null snapshot version is so that we\n            // can synthesize remote events when we get permission denied errors while\n            // trying to resolve the state of a locally cached document that is in\n            // limbo.\n            var lastRemoteVersion = _this.queryCache.getLastRemoteSnapshotVersion();\n            var remoteVersion = remoteEvent.snapshotVersion;\n            if (!remoteVersion.isEqual(snapshot_version_SnapshotVersion.MIN)) {\n                assert(remoteVersion.compareTo(lastRemoteVersion) >= 0, 'Watch stream reverted to previous snapshot?? ' +\n                    remoteVersion +\n                    ' < ' +\n                    lastRemoteVersion);\n                promises.push(_this.queryCache.setLastRemoteSnapshotVersion(txn, remoteVersion));\n            }\n            var releasedWriteKeys;\n            return persistence_promise_PersistencePromise.waitFor(promises)\n                .next(function () { return _this.releaseHeldBatchResults(txn, documentBuffer); })\n                .next(function (promisedReleasedWriteKeys) {\n                releasedWriteKeys = promisedReleasedWriteKeys;\n                return documentBuffer.apply(txn);\n            })\n                .next(function () {\n                return _this.localDocuments.getDocuments(txn, changedDocKeys.unionWith(releasedWriteKeys));\n            });\n        });\n    };\n    /**\n     * Notify local store of the changed views to locally pin documents.\n     */\n    LocalStore.prototype.notifyLocalViewChanges = function (viewChanges) {\n        var _this = this;\n        return this.persistence.runTransaction('Notify local view changes', function (txn) {\n            var promises = [];\n            var _loop_1 = function (view) {\n                promises.push(_this.queryCache\n                    .getQueryData(txn, view.query)\n                    .next(function (queryData) {\n                    assert(queryData !== null, 'Local view changes contain unallocated query.');\n                    var targetId = queryData.targetId;\n                    _this.localViewReferences.addReferences(view.addedKeys, targetId);\n                    _this.localViewReferences.removeReferences(view.removedKeys, targetId);\n                }));\n            };\n            for (var _i = 0, viewChanges_1 = viewChanges; _i < viewChanges_1.length; _i++) {\n                var view = viewChanges_1[_i];\n                _loop_1(view);\n            }\n            return persistence_promise_PersistencePromise.waitFor(promises);\n        });\n    };\n    /**\n     * Gets the mutation batch after the passed in batchId in the mutation queue\n     * or null if empty.\n     * @param afterBatchId If provided, the batch to search after.\n     * @returns The next mutation or null if there wasn't one.\n     */\n    LocalStore.prototype.nextMutationBatch = function (afterBatchId) {\n        var _this = this;\n        return this.persistence.runTransaction('Get next mutation batch', function (txn) {\n            if (afterBatchId === undefined) {\n                afterBatchId = BATCHID_UNKNOWN;\n            }\n            return _this.mutationQueue.getNextMutationBatchAfterBatchId(txn, afterBatchId);\n        });\n    };\n    /**\n     * Read the current value of a Document with a given key or null if not\n     * found - used for testing.\n     */\n    LocalStore.prototype.readDocument = function (key) {\n        var _this = this;\n        return this.persistence.runTransaction('read document', function (txn) {\n            return _this.localDocuments.getDocument(txn, key);\n        });\n    };\n    /**\n     * Assigns the given query an internal ID so that its results can be pinned so\n     * they don't get GC'd. A query must be allocated in the local store before\n     * the store can be used to manage its view.\n     */\n    LocalStore.prototype.allocateQuery = function (query) {\n        var _this = this;\n        return this.persistence.runTransaction('Allocate query', function (txn) {\n            var queryData;\n            return _this.queryCache\n                .getQueryData(txn, query)\n                .next(function (cached) {\n                if (cached) {\n                    // This query has been listened to previously, so reuse the\n                    // previous targetID.\n                    // TODO(mcg): freshen last accessed date?\n                    queryData = cached;\n                    return persistence_promise_PersistencePromise.resolve();\n                }\n                else {\n                    var targetId = _this.targetIdGenerator.next();\n                    queryData = new query_data_QueryData(query, targetId, QueryPurpose.Listen);\n                    return _this.queryCache.addQueryData(txn, queryData);\n                }\n            })\n                .next(function () {\n                assert(!_this.targetIds[queryData.targetId], 'Tried to allocate an already allocated query: ' + query);\n                _this.targetIds[queryData.targetId] = queryData;\n                return queryData;\n            });\n        });\n    };\n    /** Unpin all the documents associated with the given query. */\n    LocalStore.prototype.releaseQuery = function (query) {\n        var _this = this;\n        return this.persistence.runTransaction('Release query', function (txn) {\n            return _this.queryCache\n                .getQueryData(txn, query)\n                .next(function (queryData) {\n                assert(queryData != null, 'Tried to release nonexistent query: ' + query);\n                _this.localViewReferences.removeReferencesForId(queryData.targetId);\n                delete _this.targetIds[queryData.targetId];\n                if (_this.garbageCollector.isEager) {\n                    return _this.queryCache.removeQueryData(txn, queryData);\n                }\n                else {\n                    return persistence_promise_PersistencePromise.resolve();\n                }\n            })\n                .next(function () {\n                // If this was the last watch target, then we won't get any more\n                // watch snapshots, so we should release any held batch results.\n                if (isEmpty(_this.targetIds)) {\n                    var documentBuffer_2 = new remote_document_change_buffer_RemoteDocumentChangeBuffer(_this.remoteDocuments);\n                    return _this.releaseHeldBatchResults(txn, documentBuffer_2).next(function () {\n                        documentBuffer_2.apply(txn);\n                    });\n                }\n                else {\n                    return persistence_promise_PersistencePromise.resolve();\n                }\n            });\n        });\n    };\n    /**\n     * Runs the specified query against all the documents in the local store and\n     * returns the results.\n     */\n    LocalStore.prototype.executeQuery = function (query) {\n        var _this = this;\n        return this.persistence.runTransaction('Execute query', function (txn) {\n            return _this.localDocuments.getDocumentsMatchingQuery(txn, query);\n        });\n    };\n    /**\n     * Returns the keys of the documents that are associated with the given\n     * target id in the remote table.\n     */\n    LocalStore.prototype.remoteDocumentKeys = function (targetId) {\n        var _this = this;\n        return this.persistence.runTransaction('Remote document keys', function (txn) {\n            return _this.queryCache.getMatchingKeysForTargetId(txn, targetId);\n        });\n    };\n    /**\n     * Collect garbage if necessary.\n     * Should be called periodically by Sync Engine to recover resources. The\n     * implementation must guarantee that GC won't happen in other places than\n     * this method call.\n     */\n    LocalStore.prototype.collectGarbage = function () {\n        var _this = this;\n        // Call collectGarbage regardless of whether isGCEnabled so the referenceSet\n        // doesn't continue to accumulate the garbage keys.\n        return this.persistence.runTransaction('Garbage collection', function (txn) {\n            return _this.garbageCollector.collectGarbage(txn).next(function (garbage) {\n                var promises = [];\n                garbage.forEach(function (key) {\n                    promises.push(_this.remoteDocuments.removeEntry(txn, key));\n                });\n                return persistence_promise_PersistencePromise.waitFor(promises);\n            });\n        });\n    };\n    LocalStore.prototype.releaseHeldBatchResults = function (txn, documentBuffer) {\n        var toRelease = [];\n        for (var _i = 0, _a = this.heldBatchResults; _i < _a.length; _i++) {\n            var batchResult = _a[_i];\n            if (!this.isRemoteUpToVersion(batchResult.commitVersion)) {\n                break;\n            }\n            toRelease.push(batchResult);\n        }\n        if (toRelease.length === 0) {\n            return persistence_promise_PersistencePromise.resolve(documentKeySet());\n        }\n        else {\n            this.heldBatchResults.splice(0, toRelease.length);\n            return this.releaseBatchResults(txn, toRelease, documentBuffer);\n        }\n    };\n    LocalStore.prototype.isRemoteUpToVersion = function (version) {\n        // If there are no watch targets, then we won't get remote snapshots, and\n        // we are always \"up-to-date.\"\n        var lastRemoteVersion = this.queryCache.getLastRemoteSnapshotVersion();\n        return (version.compareTo(lastRemoteVersion) <= 0 ||\n            isEmpty(this.targetIds));\n    };\n    LocalStore.prototype.shouldHoldBatchResult = function (version) {\n        // Check if watcher isn't up to date or prior results are already held.\n        return (!this.isRemoteUpToVersion(version) || this.heldBatchResults.length > 0);\n    };\n    LocalStore.prototype.releaseBatchResults = function (txn, batchResults, documentBuffer) {\n        var _this = this;\n        var promiseChain = persistence_promise_PersistencePromise.resolve();\n        var _loop_2 = function (batchResult) {\n            promiseChain = promiseChain.next(function () {\n                return _this.applyWriteToRemoteDocuments(txn, batchResult, documentBuffer);\n            });\n        };\n        for (var _i = 0, batchResults_1 = batchResults; _i < batchResults_1.length; _i++) {\n            var batchResult = batchResults_1[_i];\n            _loop_2(batchResult);\n        }\n        return promiseChain.next(function () {\n            return _this.removeMutationBatches(txn, batchResults.map(function (result) { return result.batch; }));\n        });\n    };\n    LocalStore.prototype.removeMutationBatch = function (txn, batch) {\n        return this.removeMutationBatches(txn, [batch]);\n    };\n    /** Removes all the mutation batches named in the given array. */\n    LocalStore.prototype.removeMutationBatches = function (txn, batches) {\n        var affectedDocs = documentKeySet();\n        for (var _i = 0, batches_2 = batches; _i < batches_2.length; _i++) {\n            var batch = batches_2[_i];\n            for (var _a = 0, _b = batch.mutations; _a < _b.length; _a++) {\n                var mutation = _b[_a];\n                var key = mutation.key;\n                affectedDocs = affectedDocs.add(key);\n            }\n        }\n        return this.mutationQueue\n            .removeMutationBatches(txn, batches)\n            .next(function () { return affectedDocs; });\n    };\n    LocalStore.prototype.applyWriteToRemoteDocuments = function (txn, batchResult, documentBuffer) {\n        var batch = batchResult.batch;\n        var docKeys = batch.keys();\n        var promiseChain = persistence_promise_PersistencePromise.resolve();\n        docKeys.forEach(function (docKey) {\n            promiseChain = promiseChain\n                .next(function () {\n                return documentBuffer.getEntry(txn, docKey);\n            })\n                .next(function (remoteDoc) {\n                var doc = remoteDoc;\n                var ackVersion = batchResult.docVersions.get(docKey);\n                assert(ackVersion !== null, 'ackVersions should contain every doc in the write.');\n                if (!doc || doc.version.compareTo(ackVersion) < 0) {\n                    doc = batch.applyToRemoteDocument(docKey, doc, batchResult);\n                    if (!doc) {\n                        assert(!remoteDoc, 'Mutation batch ' +\n                            batch +\n                            ' applied to document ' +\n                            remoteDoc +\n                            ' resulted in null');\n                    }\n                    else {\n                        documentBuffer.addEntry(doc);\n                    }\n                }\n            });\n        });\n        return promiseChain;\n    };\n    return LocalStore;\n}());\n\n\n//# sourceMappingURL=local_store.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/memory_mutation_queue.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\nvar memory_mutation_queue_MemoryMutationQueue = /** @class */ (function () {\n    function MemoryMutationQueue() {\n        /**\n         * The set of all mutations that have been sent but not yet been applied to\n         * the backend.\n         */\n        this.mutationQueue = [];\n        /** Next value to use when assigning sequential IDs to each mutation batch. */\n        this.nextBatchId = 1;\n        /** The highest acknowledged mutation in the queue. */\n        this.highestAcknowledgedBatchId = BATCHID_UNKNOWN;\n        /** The last received stream token from the server, used to acknowledge which\n         * responses the client has processed. Stream tokens are opaque checkpoint\n         * markers whose only real value is their inclusion in the next request.\n         */\n        this.lastStreamToken = emptyByteString();\n        /** The garbage collector to notify about potential garbage keys. */\n        this.garbageCollector = null;\n        /** An ordered mapping between documents and the mutations batch IDs. */\n        this.batchesByDocumentKey = new sorted_set_SortedSet(reference_set_DocReference.compareByKey);\n    }\n    MemoryMutationQueue.prototype.start = function (transaction) {\n        // NOTE: The queue may be shutdown / started multiple times, since we\n        // maintain the queue for the duration of the app session in case a user\n        // logs out / back in. To behave like the LevelDB-backed MutationQueue (and\n        // accommodate tests that expect as much), we reset nextBatchId and\n        // highestAcknowledgedBatchId if the queue is empty.\n        if (this.mutationQueue.length === 0) {\n            this.nextBatchId = 1;\n            this.highestAcknowledgedBatchId = BATCHID_UNKNOWN;\n        }\n        assert(this.highestAcknowledgedBatchId < this.nextBatchId, 'highestAcknowledgedBatchId must be less than the nextBatchId');\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.checkEmpty = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.mutationQueue.length === 0);\n    };\n    MemoryMutationQueue.prototype.getNextBatchId = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.nextBatchId);\n    };\n    MemoryMutationQueue.prototype.getHighestAcknowledgedBatchId = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.highestAcknowledgedBatchId);\n    };\n    MemoryMutationQueue.prototype.acknowledgeBatch = function (transaction, batch, streamToken) {\n        var batchId = batch.batchId;\n        assert(batchId > this.highestAcknowledgedBatchId, 'Mutation batchIDs must be acknowledged in order');\n        var batchIndex = this.indexOfExistingBatchId(batchId, 'acknowledged');\n        // Verify that the batch in the queue is the one to be acknowledged.\n        var check = this.mutationQueue[batchIndex];\n        assert(batchId === check.batchId, 'Queue ordering failure: expected batch ' +\n            batchId +\n            ', got batch ' +\n            check.batchId);\n        assert(!check.isTombstone(), \"Can't acknowledge a previously removed batch\");\n        this.highestAcknowledgedBatchId = batchId;\n        this.lastStreamToken = streamToken;\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.getLastStreamToken = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.lastStreamToken);\n    };\n    MemoryMutationQueue.prototype.setLastStreamToken = function (transaction, streamToken) {\n        this.lastStreamToken = streamToken;\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.addMutationBatch = function (transaction, localWriteTime, mutations) {\n        assert(mutations.length !== 0, 'Mutation batches should not be empty');\n        var batchId = this.nextBatchId;\n        this.nextBatchId++;\n        if (this.mutationQueue.length > 0) {\n            var prior = this.mutationQueue[this.mutationQueue.length - 1];\n            assert(prior.batchId < batchId, 'Mutation batchIDs must be monotonically increasing order');\n        }\n        var batch = new mutation_batch_MutationBatch(batchId, localWriteTime, mutations);\n        this.mutationQueue.push(batch);\n        // Track references by document key.\n        for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n            var mutation = mutations_1[_i];\n            this.batchesByDocumentKey = this.batchesByDocumentKey.add(new reference_set_DocReference(mutation.key, batchId));\n        }\n        return persistence_promise_PersistencePromise.resolve(batch);\n    };\n    MemoryMutationQueue.prototype.lookupMutationBatch = function (transaction, batchId) {\n        return persistence_promise_PersistencePromise.resolve(this.findMutationBatch(batchId));\n    };\n    MemoryMutationQueue.prototype.getNextMutationBatchAfterBatchId = function (transaction, batchId) {\n        var size = this.mutationQueue.length;\n        // All batches with batchId <= this.highestAcknowledgedBatchId have been\n        // acknowledged so the first unacknowledged batch after batchID will have a\n        // batchID larger than both of these values.\n        batchId = Math.max(batchId + 1, this.highestAcknowledgedBatchId);\n        // The requested batchId may still be out of range so normalize it to the\n        // start of the queue.\n        var rawIndex = this.indexOfBatchId(batchId);\n        var index = rawIndex < 0 ? 0 : rawIndex;\n        // Finally return the first non-tombstone batch.\n        for (; index < size; index++) {\n            var batch = this.mutationQueue[index];\n            if (!batch.isTombstone()) {\n                return persistence_promise_PersistencePromise.resolve(batch);\n            }\n        }\n        return persistence_promise_PersistencePromise.resolve(null);\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatches = function (transaction) {\n        return persistence_promise_PersistencePromise.resolve(this.getAllLiveMutationBatchesBeforeIndex(this.mutationQueue.length));\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatchesThroughBatchId = function (transaction, batchId) {\n        var count = this.mutationQueue.length;\n        var endIndex = this.indexOfBatchId(batchId);\n        if (endIndex < 0) {\n            endIndex = 0;\n        }\n        else if (endIndex >= count) {\n            endIndex = count;\n        }\n        else {\n            // The endIndex is in the queue so increment to pull everything in the\n            // queue including it.\n            endIndex++;\n        }\n        return persistence_promise_PersistencePromise.resolve(this.getAllLiveMutationBatchesBeforeIndex(endIndex));\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatchesAffectingDocumentKey = function (transaction, documentKey) {\n        var _this = this;\n        var start = new reference_set_DocReference(documentKey, 0);\n        var end = new reference_set_DocReference(documentKey, Number.POSITIVE_INFINITY);\n        var result = [];\n        this.batchesByDocumentKey.forEachInRange([start, end], function (ref) {\n            assert(documentKey.isEqual(ref.key), \"Should only iterate over a single key's batches\");\n            var batch = _this.findMutationBatch(ref.targetOrBatchId);\n            assert(batch !== null, 'Batches in the index must exist in the main table');\n            result.push(batch);\n        });\n        return persistence_promise_PersistencePromise.resolve(result);\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatchesAffectingQuery = function (transaction, query) {\n        var _this = this;\n        // Use the query path as a prefix for testing if a document matches the\n        // query.\n        var prefix = query.path;\n        var immediateChildrenPathLength = prefix.length + 1;\n        // Construct a document reference for actually scanning the index. Unlike\n        // the prefix the document key in this reference must have an even number of\n        // segments. The empty segment can be used a suffix of the query path\n        // because it precedes all other segments in an ordered traversal.\n        var startPath = prefix;\n        if (!document_key_DocumentKey.isDocumentKey(startPath)) {\n            startPath = startPath.child('');\n        }\n        var start = new reference_set_DocReference(new document_key_DocumentKey(startPath), 0);\n        // Find unique batchIDs referenced by all documents potentially matching the\n        // query.\n        var uniqueBatchIDs = new sorted_set_SortedSet(primitiveComparator);\n        this.batchesByDocumentKey.forEachWhile(function (ref) {\n            var rowKeyPath = ref.key.path;\n            if (!prefix.isPrefixOf(rowKeyPath)) {\n                return false;\n            }\n            else {\n                // Rows with document keys more than one segment longer than the query\n                // path can't be matches. For example, a query on 'rooms' can't match\n                // the document /rooms/abc/messages/xyx.\n                // TODO(mcg): we'll need a different scanner when we implement\n                // ancestor queries.\n                if (rowKeyPath.length === immediateChildrenPathLength) {\n                    uniqueBatchIDs = uniqueBatchIDs.add(ref.targetOrBatchId);\n                }\n                return true;\n            }\n        }, start);\n        // Construct an array of matching batches, sorted by batchID to ensure that\n        // multiple mutations affecting the same document key are applied in order.\n        var result = [];\n        uniqueBatchIDs.forEach(function (batchId) {\n            var batch = _this.findMutationBatch(batchId);\n            if (batch !== null) {\n                result.push(batch);\n            }\n        });\n        return persistence_promise_PersistencePromise.resolve(result);\n    };\n    MemoryMutationQueue.prototype.removeMutationBatches = function (transaction, batches) {\n        var batchCount = batches.length;\n        assert(batchCount > 0, 'Should not remove mutations when none exist.');\n        var firstBatchId = batches[0].batchId;\n        var queueCount = this.mutationQueue.length;\n        // Find the position of the first batch for removal. This need not be the\n        // first entry in the queue.\n        var startIndex = this.indexOfExistingBatchId(firstBatchId, 'removed');\n        assert(this.mutationQueue[startIndex].batchId === firstBatchId, 'Removed batches must exist in the queue');\n        // Check that removed batches are contiguous (while excluding tombstones).\n        var batchIndex = 1;\n        var queueIndex = startIndex + 1;\n        while (batchIndex < batchCount && queueIndex < queueCount) {\n            var batch = this.mutationQueue[queueIndex];\n            if (batch.isTombstone()) {\n                queueIndex++;\n                continue;\n            }\n            assert(batch.batchId === batches[batchIndex].batchId, 'Removed batches must be contiguous in the queue');\n            batchIndex++;\n            queueIndex++;\n        }\n        // Only actually remove batches if removing at the front of the queue.\n        // Previously rejected batches may have left tombstones in the queue, so\n        // expand the removal range to include any tombstones.\n        if (startIndex === 0) {\n            for (; queueIndex < queueCount; queueIndex++) {\n                var batch = this.mutationQueue[queueIndex];\n                if (!batch.isTombstone()) {\n                    break;\n                }\n            }\n            var length_1 = queueIndex - startIndex;\n            this.mutationQueue.splice(startIndex, length_1);\n        }\n        else {\n            // Mark the tombstones\n            for (var i = startIndex; i < queueIndex; i++) {\n                this.mutationQueue[i] = this.mutationQueue[i].toTombstone();\n            }\n        }\n        var references = this.batchesByDocumentKey;\n        for (var _i = 0, batches_1 = batches; _i < batches_1.length; _i++) {\n            var batch = batches_1[_i];\n            var batchId = batch.batchId;\n            for (var _a = 0, _b = batch.mutations; _a < _b.length; _a++) {\n                var mutation = _b[_a];\n                var key = mutation.key;\n                if (this.garbageCollector !== null) {\n                    this.garbageCollector.addPotentialGarbageKey(key);\n                }\n                var ref = new reference_set_DocReference(key, batchId);\n                references = references.delete(ref);\n            }\n        }\n        this.batchesByDocumentKey = references;\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.setGarbageCollector = function (garbageCollector) {\n        this.garbageCollector = garbageCollector;\n    };\n    MemoryMutationQueue.prototype.containsKey = function (txn, key) {\n        var ref = new reference_set_DocReference(key, 0);\n        var firstRef = this.batchesByDocumentKey.firstAfterOrEqual(ref);\n        return persistence_promise_PersistencePromise.resolve(key.isEqual(firstRef && firstRef.key));\n    };\n    MemoryMutationQueue.prototype.performConsistencyCheck = function (txn) {\n        if (this.mutationQueue.length === 0) {\n            assert(this.batchesByDocumentKey.isEmpty(), 'Document leak -- detected dangling mutation references when queue is empty.');\n        }\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    /**\n     * A private helper that collects all the mutations batches in the queue up to\n     * but not including the given endIndex. All tombstones in the queue are\n     * excluded.\n     */\n    MemoryMutationQueue.prototype.getAllLiveMutationBatchesBeforeIndex = function (endIndex) {\n        var result = [];\n        for (var i = 0; i < endIndex; i++) {\n            var batch = this.mutationQueue[i];\n            if (!batch.isTombstone()) {\n                result.push(batch);\n            }\n        }\n        return result;\n    };\n    /**\n     * Finds the index of the given batchId in the mutation queue and asserts that\n     * the resulting index is within the bounds of the queue.\n     *\n     * @param batchId The batchId to search for\n     * @param action A description of what the caller is doing, phrased in passive\n     * form (e.g. \"acknowledged\" in a routine that acknowledges batches).\n     */\n    MemoryMutationQueue.prototype.indexOfExistingBatchId = function (batchId, action) {\n        var index = this.indexOfBatchId(batchId);\n        assert(index >= 0 && index < this.mutationQueue.length, 'Batches must exist to be ' + action);\n        return index;\n    };\n    /**\n     * Finds the index of the given batchId in the mutation queue. This operation\n     * is O(1).\n     *\n     * @return The computed index of the batch with the given batchId, based on\n     * the state of the queue. Note this index can be negative if the requested\n     * batchId has already been remvoed from the queue or past the end of the\n     * queue if the batchId is larger than the last added batch.\n     */\n    MemoryMutationQueue.prototype.indexOfBatchId = function (batchId) {\n        if (this.mutationQueue.length === 0) {\n            // As an index this is past the end of the queue\n            return 0;\n        }\n        // Examine the front of the queue to figure out the difference between the\n        // batchId and indexes in the array. Note that since the queue is ordered\n        // by batchId, if the first batch has a larger batchId then the requested\n        // batchId doesn't exist in the queue.\n        var firstBatchId = this.mutationQueue[0].batchId;\n        return batchId - firstBatchId;\n    };\n    /**\n     * A version of lookupMutationBatch that doesn't return a promise, this makes\n     * other functions that uses this code easier to read and more efficent.\n     */\n    MemoryMutationQueue.prototype.findMutationBatch = function (batchId) {\n        var index = this.indexOfBatchId(batchId);\n        if (index < 0 || index >= this.mutationQueue.length) {\n            return null;\n        }\n        var batch = this.mutationQueue[index];\n        assert(batch.batchId === batchId, 'If found batch must match');\n        return batch.isTombstone() ? null : batch;\n    };\n    return MemoryMutationQueue;\n}());\n\n\n//# sourceMappingURL=memory_mutation_queue.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/memory_query_cache.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\nvar memory_query_cache_MemoryQueryCache = /** @class */ (function () {\n    function MemoryQueryCache() {\n        /**\n         * Maps a query to the data about that query\n         */\n        this.queries = new obj_map_ObjectMap(function (q) { return q.canonicalId(); });\n        /** The last received snapshot version. */\n        this.lastRemoteSnapshotVersion = snapshot_version_SnapshotVersion.MIN;\n        /** The highest numbered target ID encountered. */\n        this.highestTargetId = 0;\n        /**\n         * A ordered bidirectional mapping between documents and the remote target\n         * IDs.\n         */\n        this.references = new reference_set_ReferenceSet();\n    }\n    MemoryQueryCache.prototype.start = function (transaction) {\n        // Nothing to do.\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.getLastRemoteSnapshotVersion = function () {\n        return this.lastRemoteSnapshotVersion;\n    };\n    MemoryQueryCache.prototype.getHighestTargetId = function () {\n        return this.highestTargetId;\n    };\n    MemoryQueryCache.prototype.setLastRemoteSnapshotVersion = function (transaction, snapshotVersion) {\n        this.lastRemoteSnapshotVersion = snapshotVersion;\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.addQueryData = function (transaction, queryData) {\n        this.queries.set(queryData.query, queryData);\n        var targetId = queryData.targetId;\n        if (targetId > this.highestTargetId) {\n            this.highestTargetId = targetId;\n        }\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.removeQueryData = function (transaction, queryData) {\n        this.queries.delete(queryData.query);\n        this.references.removeReferencesForId(queryData.targetId);\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.getQueryData = function (transaction, query) {\n        var queryData = this.queries.get(query) || null;\n        return persistence_promise_PersistencePromise.resolve(queryData);\n    };\n    MemoryQueryCache.prototype.addMatchingKeys = function (txn, keys, targetId) {\n        this.references.addReferences(keys, targetId);\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.removeMatchingKeys = function (txn, keys, targetId) {\n        this.references.removeReferences(keys, targetId);\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.removeMatchingKeysForTargetId = function (txn, targetId) {\n        this.references.removeReferencesForId(targetId);\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.getMatchingKeysForTargetId = function (txn, targetId) {\n        var matchingKeys = this.references.referencesForId(targetId);\n        return persistence_promise_PersistencePromise.resolve(matchingKeys);\n    };\n    MemoryQueryCache.prototype.setGarbageCollector = function (gc) {\n        this.references.setGarbageCollector(gc);\n    };\n    MemoryQueryCache.prototype.containsKey = function (txn, key) {\n        return this.references.containsKey(txn, key);\n    };\n    return MemoryQueryCache;\n}());\n\n\n//# sourceMappingURL=memory_query_cache.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/memory_remote_document_cache.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\nvar memory_remote_document_cache_MemoryRemoteDocumentCache = /** @class */ (function () {\n    function MemoryRemoteDocumentCache() {\n        this.docs = maybeDocumentMap();\n    }\n    MemoryRemoteDocumentCache.prototype.addEntry = function (transaction, maybeDocument) {\n        this.docs = this.docs.insert(maybeDocument.key, maybeDocument);\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryRemoteDocumentCache.prototype.removeEntry = function (transaction, documentKey) {\n        this.docs = this.docs.remove(documentKey);\n        return persistence_promise_PersistencePromise.resolve();\n    };\n    MemoryRemoteDocumentCache.prototype.getEntry = function (transaction, documentKey) {\n        return persistence_promise_PersistencePromise.resolve(this.docs.get(documentKey));\n    };\n    MemoryRemoteDocumentCache.prototype.getDocumentsMatchingQuery = function (transaction, query) {\n        var results = documentMap();\n        // Documents are ordered by key, so we can use a prefix scan to narrow down\n        // the documents we need to match the query against.\n        var prefix = new document_key_DocumentKey(query.path.child(''));\n        var iterator = this.docs.getIteratorFrom(prefix);\n        while (iterator.hasNext()) {\n            var _a = iterator.getNext(), key = _a.key, maybeDoc = _a.value;\n            if (!query.path.isPrefixOf(key.path)) {\n                break;\n            }\n            if (maybeDoc instanceof document_Document && query.matches(maybeDoc)) {\n                results = results.insert(maybeDoc.key, maybeDoc);\n            }\n        }\n        return persistence_promise_PersistencePromise.resolve(results);\n    };\n    return MemoryRemoteDocumentCache;\n}());\n\n\n//# sourceMappingURL=memory_remote_document_cache.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/memory_persistence.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\nvar memory_persistence_LOG_TAG = 'MemoryPersistence';\n/**\n * A memory-backed instance of Persistence. Data is stored only in RAM and\n * not persisted across sessions.\n */\nvar memory_persistence_MemoryPersistence = /** @class */ (function () {\n    function MemoryPersistence() {\n        /**\n         * Note that these are retained here to make it easier to write tests\n         * affecting both the in-memory and IndexedDB-backed persistence layers. Tests\n         * can create a new LocalStore wrapping this Persistence instance and this\n         * will make the in-memory persistence layer behave as if it were actually\n         * persisting values.\n         */\n        this.mutationQueues = {};\n        this.remoteDocumentCache = new memory_remote_document_cache_MemoryRemoteDocumentCache();\n        this.queryCache = new memory_query_cache_MemoryQueryCache();\n        this.started = false;\n    }\n    MemoryPersistence.prototype.start = function () {\n        assert(!this.started, 'MemoryPersistence double-started!');\n        this.started = true;\n        // No durable state to read on startup.\n        return Promise.resolve();\n    };\n    MemoryPersistence.prototype.shutdown = function () {\n        // No durable state to ensure is closed on shutdown.\n        assert(this.started, 'MemoryPersistence shutdown without start!');\n        this.started = false;\n        return Promise.resolve();\n    };\n    MemoryPersistence.prototype.getMutationQueue = function (user) {\n        var queue = this.mutationQueues[user.toKey()];\n        if (!queue) {\n            queue = new memory_mutation_queue_MemoryMutationQueue();\n            this.mutationQueues[user.toKey()] = queue;\n        }\n        return queue;\n    };\n    MemoryPersistence.prototype.getQueryCache = function () {\n        return this.queryCache;\n    };\n    MemoryPersistence.prototype.getRemoteDocumentCache = function () {\n        return this.remoteDocumentCache;\n    };\n    MemoryPersistence.prototype.runTransaction = function (action, operation) {\n        debug(memory_persistence_LOG_TAG, 'Starting transaction:', action);\n        return operation(new MemoryPersistenceTransaction()).toPromise();\n    };\n    return MemoryPersistence;\n}());\n\n/** Dummy class since memory persistence doesn't actually use transactions. */\nvar MemoryPersistenceTransaction = /** @class */ (function () {\n    function MemoryPersistenceTransaction() {\n    }\n    return MemoryPersistenceTransaction;\n}());\n\n//# sourceMappingURL=memory_persistence.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/local/no_op_garbage_collector.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n/**\n * A garbage collector implementation that does absolutely nothing. It ignores\n * all addGarbageSource and addPotentialGarbageKey messages and and never\n * produces any garbage.\n */\nvar no_op_garbage_collector_NoOpGarbageCollector = /** @class */ (function () {\n    function NoOpGarbageCollector() {\n        this.isEager = false;\n    }\n    NoOpGarbageCollector.prototype.addGarbageSource = function (garbageSource) {\n        // Not tracking garbage so don't track sources.\n    };\n    NoOpGarbageCollector.prototype.removeGarbageSource = function (garbageSource) {\n        // Not tracking garbage so don't track sources.\n    };\n    NoOpGarbageCollector.prototype.addPotentialGarbageKey = function (key) {\n        // Not tracking garbage so ignore.\n    };\n    NoOpGarbageCollector.prototype.collectGarbage = function (txn) {\n        return persistence_promise_PersistencePromise.resolve(documentKeySet());\n    };\n    return NoOpGarbageCollector;\n}());\n\n\n//# sourceMappingURL=no_op_garbage_collector.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/promise.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar Deferred = /** @class */ (function () {\n    function Deferred() {\n        var _this = this;\n        this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n    }\n    return Deferred;\n}());\n\n/**\n * Takes an array of values and sequences them using the promise (or value)\n * returned by the supplied callback. The callback for each item is called\n * after the promise is resolved for the previous item.\n * The function returns a promise which is resolved after the promise for\n * the last item is resolved.\n */\nfunction sequence(values, fn, initialValue) {\n    var result = Promise.resolve(initialValue);\n    values.forEach(function (value) {\n        result = result.then(function (lastResult) { return fn(value, lastResult); });\n    });\n    return result;\n}\n\n//# sourceMappingURL=promise.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/async_queue.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n/**\n * Wellknown \"timer\" IDs used when scheduling delayed operations on the\n * AsyncQueue. These IDs can then be used from tests to check for the presence\n * of operations or to run them early.\n */\nvar TimerId;\n(function (TimerId) {\n    TimerId[TimerId[\"ListenStreamIdle\"] = 0] = \"ListenStreamIdle\";\n    TimerId[TimerId[\"ListenStreamConnection\"] = 1] = \"ListenStreamConnection\";\n    TimerId[TimerId[\"WriteStreamIdle\"] = 2] = \"WriteStreamIdle\";\n    TimerId[TimerId[\"WriteStreamConnection\"] = 3] = \"WriteStreamConnection\";\n})(TimerId || (TimerId = {}));\n/**\n * Represents an operation scheduled to be run in the future on an AsyncQueue.\n *\n * It is created via DelayedOperation.createAndSchedule().\n *\n * Supports cancellation (via cancel()) and early execution (via skipDelay()).\n */\nvar async_queue_DelayedOperation = /** @class */ (function () {\n    function DelayedOperation(asyncQueue, timerId, targetTimeMs, op, removalCallback) {\n        this.asyncQueue = asyncQueue;\n        this.timerId = timerId;\n        this.targetTimeMs = targetTimeMs;\n        this.op = op;\n        this.removalCallback = removalCallback;\n        this.deferred = new Deferred();\n        this.then = this.deferred.promise.then.bind(this.deferred.promise);\n        this.catch = this.deferred.promise.catch.bind(this.deferred.promise);\n    }\n    /**\n     * Creates and returns a DelayedOperation that has been scheduled to be\n     * executed on the provided asyncQueue after the provided delayMs.\n     *\n     * @param asyncQueue The queue to schedule the operation on.\n     * @param id A Timer ID identifying the type of operation this is.\n     * @param delayMs The delay (ms) before the operation should be scheduled.\n     * @param op The operation to run.\n     * @param removalCallback A callback to be called synchronously once the\n     *   operation is executed or canceled, notifying the AsyncQueue to remove it\n     *   from its delayedOperations list.\n     *   PORTING NOTE: This exists to prevent making removeDelayedOperation() and\n     *   the DelayedOperation class public.\n     */\n    DelayedOperation.createAndSchedule = function (asyncQueue, timerId, delayMs, op, removalCallback) {\n        var targetTime = Date.now() + delayMs;\n        var delayedOp = new DelayedOperation(asyncQueue, timerId, targetTime, op, removalCallback);\n        delayedOp.start(delayMs);\n        return delayedOp;\n    };\n    /**\n     * Starts the timer. This is called immediately after construction by\n     * createAndSchedule().\n     */\n    DelayedOperation.prototype.start = function (delayMs) {\n        var _this = this;\n        this.timerHandle = setTimeout(function () { return _this.handleDelayElapsed(); }, delayMs);\n    };\n    /**\n     * Queues the operation to run immediately (if it hasn't already been run or\n     * canceled).\n     */\n    DelayedOperation.prototype.skipDelay = function () {\n        return this.handleDelayElapsed();\n    };\n    /**\n     * Cancels the operation if it hasn't already been executed or canceled. The\n     * promise will be rejected.\n     *\n     * As long as the operation has not yet been run, calling cancel() provides a\n     * guarantee that the operation will not be run.\n     */\n    DelayedOperation.prototype.cancel = function (reason) {\n        if (this.timerHandle !== null) {\n            this.clearTimeout();\n            this.deferred.reject(new FirestoreError(Code.CANCELLED, 'Operation cancelled' + (reason ? ': ' + reason : '')));\n        }\n    };\n    DelayedOperation.prototype.handleDelayElapsed = function () {\n        var _this = this;\n        this.asyncQueue.enqueue(function () {\n            if (_this.timerHandle !== null) {\n                _this.clearTimeout();\n                return _this.op().then(function (result) {\n                    return _this.deferred.resolve(result);\n                });\n            }\n            else {\n                return Promise.resolve();\n            }\n        });\n    };\n    DelayedOperation.prototype.clearTimeout = function () {\n        if (this.timerHandle !== null) {\n            this.removalCallback(this);\n            clearTimeout(this.timerHandle);\n            this.timerHandle = null;\n        }\n    };\n    return DelayedOperation;\n}());\nvar async_queue_AsyncQueue = /** @class */ (function () {\n    function AsyncQueue() {\n        // The last promise in the queue.\n        this.tail = Promise.resolve();\n        // Operations scheduled to be queued in the future. Operations are\n        // automatically removed after they are run or canceled.\n        this.delayedOperations = [];\n        // Flag set while there's an outstanding AsyncQueue operation, used for\n        // assertion sanity-checks.\n        this.operationInProgress = false;\n    }\n    /**\n     * Adds a new operation to the queue. Returns a promise that will be resolved\n     * when the promise returned by the new operation is (with its value).\n     */\n    AsyncQueue.prototype.enqueue = function (op) {\n        var _this = this;\n        this.verifyNotFailed();\n        var newTail = this.tail.then(function () {\n            _this.operationInProgress = true;\n            return op()\n                .catch(function (error) {\n                _this.failure = error;\n                _this.operationInProgress = false;\n                var message = error.stack || error.message || '';\n                log_error('INTERNAL UNHANDLED ERROR: ', message);\n                // Escape the promise chain and throw the error globally so that\n                // e.g. any global crash reporting library detects and reports it.\n                // (but not for simulated errors in our tests since this breaks mocha)\n                if (message.indexOf('Firestore Test Simulated Error') < 0) {\n                    setTimeout(function () {\n                        throw error;\n                    }, 0);\n                }\n                // Re-throw the error so that this.tail becomes a rejected Promise and\n                // all further attempts to chain (via .then) will just short-circuit\n                // and return the rejected Promise.\n                throw error;\n            })\n                .then(function (result) {\n                _this.operationInProgress = false;\n                return result;\n            });\n        });\n        this.tail = newTail;\n        return newTail;\n    };\n    /**\n     * Schedules an operation to be queued on the AsyncQueue once the specified\n     * `delayMs` has elapsed. The returned CancelablePromise can be used to cancel\n     * the operation prior to its running.\n     */\n    AsyncQueue.prototype.enqueueAfterDelay = function (timerId, delayMs, op) {\n        var _this = this;\n        this.verifyNotFailed();\n        // While not necessarily harmful, we currently don't expect to have multiple\n        // ops with the same timer id in the queue, so defensively reject them.\n        assert(!this.containsDelayedOperation(timerId), \"Attempted to schedule multiple operations with timer id \" + TimerId[timerId] + \".\");\n        var delayedOp = async_queue_DelayedOperation.createAndSchedule(this, timerId, delayMs, op, function (op) { return _this.removeDelayedOperation(op); });\n        this.delayedOperations.push(delayedOp);\n        return delayedOp;\n    };\n    AsyncQueue.prototype.verifyNotFailed = function () {\n        if (this.failure) {\n            fail('AsyncQueue is already failed: ' +\n                (this.failure.stack || this.failure.message));\n        }\n    };\n    /**\n     * Verifies there's an operation currently in-progress on the AsyncQueue.\n     * Unfortunately we can't verify that the running code is in the promise chain\n     * of that operation, so this isn't a foolproof check, but it should be enough\n     * to catch some bugs.\n     */\n    AsyncQueue.prototype.verifyOperationInProgress = function () {\n        assert(this.operationInProgress, 'verifyOpInProgress() called when no op in progress on this queue.');\n    };\n    /**\n     * Waits until all currently queued tasks are finished executing. Delayed\n     * operations are not run.\n     */\n    AsyncQueue.prototype.drain = function () {\n        return this.enqueue(function () { return Promise.resolve(); });\n    };\n    /**\n     * For Tests: Determine if a delayed operation with a particular TimerId\n     * exists.\n     */\n    AsyncQueue.prototype.containsDelayedOperation = function (timerId) {\n        return this.delayedOperations.findIndex(function (op) { return op.timerId === timerId; }) >= 0;\n    };\n    /**\n     * For Tests: Runs some or all delayed operations early.\n     *\n     * @param lastTimerId If specified, only delayed operations up to and\n     *   including this TimerId will be drained. Throws if no such operation\n     *   exists.\n     * @returns a Promise that resolves once all operations have been run.\n     */\n    AsyncQueue.prototype.runDelayedOperationsEarly = function (lastTimerId) {\n        var _this = this;\n        // Note that draining may generate more delayed ops, so we do that first.\n        return this.drain().then(function () {\n            assert(lastTimerId === undefined || _this.containsDelayedOperation(lastTimerId), \"Attempted to drain to missing operation \" + lastTimerId);\n            // Run ops in the same order they'd run if they ran naturally.\n            _this.delayedOperations.sort(function (a, b) { return a.targetTimeMs - b.targetTimeMs; });\n            for (var _i = 0, _a = _this.delayedOperations; _i < _a.length; _i++) {\n                var op = _a[_i];\n                op.skipDelay();\n                if (lastTimerId !== undefined && op.timerId === lastTimerId) {\n                    break;\n                }\n            }\n            return _this.drain();\n        });\n    };\n    /** Called once a DelayedOperation is run or canceled. */\n    AsyncQueue.prototype.removeDelayedOperation = function (op) {\n        // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.\n        var index = this.delayedOperations.indexOf(op);\n        assert(index >= 0, 'Delayed operation not found.');\n        this.delayedOperations.splice(index, 1);\n    };\n    return AsyncQueue;\n}());\n\n\n//# sourceMappingURL=async_queue.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/backoff.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nvar backoff_LOG_TAG = 'ExponentialBackoff';\n/**\n * A helper for running delayed tasks following an exponential backoff curve\n * between attempts.\n *\n * Each delay is made up of a \"base\" delay which follows the exponential\n * backoff curve, and a +/- 50% \"jitter\" that is calculated and added to the\n * base delay. This prevents clients from accidentally synchronizing their\n * delays causing spikes of load to the backend.\n */\nvar backoff_ExponentialBackoff = /** @class */ (function () {\n    function ExponentialBackoff(\n        /**\n         * The AsyncQueue to run backoff operations on.\n         */\n        queue, \n        /**\n         * The ID to use when scheduling backoff operations on the AsyncQueue.\n         */\n        timerId, \n        /**\n         * The initial delay (used as the base delay on the first retry attempt).\n         * Note that jitter will still be applied, so the actual delay could be as\n         * little as 0.5*initialDelayMs.\n         */\n        initialDelayMs, \n        /**\n         * The multiplier to use to determine the extended base delay after each\n         * attempt.\n         */\n        backoffFactor, \n        /**\n         * The maximum base delay after which no further backoff is performed.\n         * Note that jitter will still be applied, so the actual delay could be as\n         * much as 1.5*maxDelayMs.\n         */\n        maxDelayMs) {\n        this.queue = queue;\n        this.timerId = timerId;\n        this.initialDelayMs = initialDelayMs;\n        this.backoffFactor = backoffFactor;\n        this.maxDelayMs = maxDelayMs;\n        this.timerPromise = null;\n        this.reset();\n    }\n    /**\n     * Resets the backoff delay.\n     *\n     * The very next backoffAndWait() will have no delay. If it is called again\n     * (i.e. due to an error), initialDelayMs (plus jitter) will be used, and\n     * subsequent ones will increase according to the backoffFactor.\n     */\n    ExponentialBackoff.prototype.reset = function () {\n        this.currentBaseMs = 0;\n    };\n    /**\n     * Resets the backoff delay to the maximum delay (e.g. for use after a\n     * RESOURCE_EXHAUSTED error).\n     */\n    ExponentialBackoff.prototype.resetToMax = function () {\n        this.currentBaseMs = this.maxDelayMs;\n    };\n    /**\n     * Returns a promise that resolves after currentDelayMs, and increases the\n     * delay for any subsequent attempts. If there was a pending backoff operation\n     * already, it will be canceled.\n     */\n    ExponentialBackoff.prototype.backoffAndRun = function (op) {\n        if (this.timerPromise !== null) {\n            this.timerPromise.cancel();\n        }\n        // First schedule using the current base (which may be 0 and should be\n        // honored as such).\n        var delayWithJitterMs = this.currentBaseMs + this.jitterDelayMs();\n        if (this.currentBaseMs > 0) {\n            debug(backoff_LOG_TAG, \"Backing off for \" + delayWithJitterMs + \" ms \" +\n                (\"(base delay: \" + this.currentBaseMs + \" ms)\"));\n        }\n        this.timerPromise = this.queue.enqueueAfterDelay(this.timerId, delayWithJitterMs, op);\n        // Apply backoff factor to determine next delay and ensure it is within\n        // bounds.\n        this.currentBaseMs *= this.backoffFactor;\n        if (this.currentBaseMs < this.initialDelayMs) {\n            this.currentBaseMs = this.initialDelayMs;\n        }\n        if (this.currentBaseMs > this.maxDelayMs) {\n            this.currentBaseMs = this.maxDelayMs;\n        }\n    };\n    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */\n    ExponentialBackoff.prototype.jitterDelayMs = function () {\n        return (Math.random() - 0.5) * this.currentBaseMs;\n    };\n    return ExponentialBackoff;\n}());\n\n\n//# sourceMappingURL=backoff.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/persistent_stream.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar persistent_stream___extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\n\n\nvar persistent_stream_LOG_TAG = 'PersistentStream';\nvar PersistentStreamState;\n(function (PersistentStreamState) {\n    /**\n     * The streaming RPC is not running and there's no error condition.\n     * Calling `start` will start the stream immediately without backoff.\n     * While in this state isStarted will return false.\n     */\n    PersistentStreamState[PersistentStreamState[\"Initial\"] = 0] = \"Initial\";\n    /**\n     * The stream is starting, and is waiting for an auth token to attach to\n     * the initial request. While in this state, isStarted will return\n     * true but isOpen will return false.\n     */\n    PersistentStreamState[PersistentStreamState[\"Auth\"] = 1] = \"Auth\";\n    /**\n     * The streaming RPC is up and running. Requests and responses can flow\n     * freely. Both isStarted and isOpen will return true.\n     */\n    PersistentStreamState[PersistentStreamState[\"Open\"] = 2] = \"Open\";\n    /**\n     * The stream encountered an error. The next start attempt will back off.\n     * While in this state isStarted() will return false.\n     *\n     */\n    PersistentStreamState[PersistentStreamState[\"Error\"] = 3] = \"Error\";\n    /**\n     * An in-between state after an error where the stream is waiting before\n     * re-starting. After\n     * waiting is complete, the stream will try to open. While in this\n     * state isStarted() will return YES but isOpen will return false.\n     */\n    PersistentStreamState[PersistentStreamState[\"Backoff\"] = 4] = \"Backoff\";\n    /**\n     * The stream has been explicitly stopped; no further events will be emitted.\n     */\n    PersistentStreamState[PersistentStreamState[\"Stopped\"] = 5] = \"Stopped\";\n})(PersistentStreamState || (PersistentStreamState = {}));\n/**\n * Initial backoff time in milliseconds after an error.\n * Set to 1s according to https://cloud.google.com/apis/design/errors.\n */\nvar BACKOFF_INITIAL_DELAY_MS = 1000;\n/** Maximum backoff time in milliseconds */\nvar BACKOFF_MAX_DELAY_MS = 60 * 1000;\nvar BACKOFF_FACTOR = 1.5;\n/** The time a stream stays open after it is marked idle. */\nvar IDLE_TIMEOUT_MS = 60 * 1000;\n/**\n * A PersistentStream is an abstract base class that represents a streaming RPC\n * to the Firestore backend. It's built on top of the connections own support\n * for streaming RPCs, and adds several critical features for our clients:\n *\n *   - Exponential backoff on failure\n *   - Authentication via CredentialsProvider\n *   - Dispatching all callbacks into the shared worker queue\n *\n * Subclasses of PersistentStream implement serialization of models to and\n * from the JSON representation of the protocol buffers for a specific\n * streaming RPC.\n *\n * ## Starting and Stopping\n *\n * Streaming RPCs are stateful and need to be `start`ed before messages can\n * be sent and received. The PersistentStream will call the onOpen function\n * of the listener once the stream is ready to accept requests.\n *\n * Should a `start` fail, PersistentStream will call the registered\n * onClose with a FirestoreError indicating what went wrong.\n *\n * A PersistentStream can be started and stopped repeatedly.\n *\n * Generic types:\n *  SendType: The type of the outgoing message of the underlying\n *    connection stream\n *  ReceiveType: The type of the incoming message of the underlying\n *    connection stream\n *  ListenerType: The type of the listener that will be used for callbacks\n */\nvar persistent_stream_PersistentStream = /** @class */ (function () {\n    function PersistentStream(queue, connectionTimerId, idleTimerId, connection, credentialsProvider) {\n        this.queue = queue;\n        this.idleTimerId = idleTimerId;\n        this.connection = connection;\n        this.credentialsProvider = credentialsProvider;\n        this.inactivityTimerPromise = null;\n        this.stream = null;\n        this.listener = null;\n        this.backoff = new backoff_ExponentialBackoff(queue, connectionTimerId, BACKOFF_INITIAL_DELAY_MS, BACKOFF_FACTOR, BACKOFF_MAX_DELAY_MS);\n        this.state = PersistentStreamState.Initial;\n    }\n    /**\n     * Returns true if `start` has been called and no error has occurred. True\n     * indicates the stream is open or in the process of opening (which\n     * encompasses respecting backoff, getting auth tokens, and starting the\n     * actual RPC). Use `isOpen` to determine if the stream is open and ready for\n     * outbound requests.\n     */\n    PersistentStream.prototype.isStarted = function () {\n        return (this.state === PersistentStreamState.Backoff ||\n            this.state === PersistentStreamState.Auth ||\n            this.state === PersistentStreamState.Open);\n    };\n    /**\n     * Returns true if the underlying RPC is open (the openHandler has been\n     * called) and the stream is ready for outbound requests.\n     */\n    PersistentStream.prototype.isOpen = function () {\n        return this.state === PersistentStreamState.Open;\n    };\n    /**\n     * Starts the RPC. Only allowed if isStarted returns false. The stream is\n     * not immediately ready for use: onOpen will be invoked when the RPC is ready\n     * for outbound requests, at which point isOpen will return true.\n     *\n     *  When start returns, isStarted will return true.\n     */\n    PersistentStream.prototype.start = function (listener) {\n        if (this.state === PersistentStreamState.Error) {\n            this.performBackoff(listener);\n            return;\n        }\n        assert(this.state === PersistentStreamState.Initial, 'Already started');\n        this.listener = listener;\n        this.auth();\n    };\n    /**\n     * Stops the RPC. This call is idempotent and allowed regardless of the\n     * current isStarted state.\n     *\n     * When stop returns, isStarted and isOpen will both return false.\n     */\n    PersistentStream.prototype.stop = function () {\n        if (this.isStarted()) {\n            this.close(PersistentStreamState.Stopped);\n        }\n    };\n    /**\n     * After an error the stream will usually back off on the next attempt to\n     * start it. If the error warrants an immediate restart of the stream, the\n     * sender can use this to indicate that the receiver should not back off.\n     *\n     * Each error will call the onClose function. That function can decide to\n     * inhibit backoff if required.\n     */\n    PersistentStream.prototype.inhibitBackoff = function () {\n        assert(!this.isStarted(), 'Can only inhibit backoff in a stopped state');\n        this.state = PersistentStreamState.Initial;\n        this.backoff.reset();\n    };\n    /**\n     * Marks this stream as idle. If no further actions are performed on the\n     * stream for one minute, the stream will automatically close itself and\n     * notify the stream's onClose() handler with Status.OK. The stream will then\n     * be in a !isStarted() state, requiring the caller to start the stream again\n     * before further use.\n     *\n     * Only streams that are in state 'Open' can be marked idle, as all other\n     * states imply pending network operations.\n     */\n    PersistentStream.prototype.markIdle = function () {\n        var _this = this;\n        // Starts the idle time if we are in state 'Open' and are not yet already\n        // running a timer (in which case the previous idle timeout still applies).\n        if (this.isOpen() && this.inactivityTimerPromise === null) {\n            this.inactivityTimerPromise = this.queue.enqueueAfterDelay(this.idleTimerId, IDLE_TIMEOUT_MS, function () { return _this.handleIdleCloseTimer(); });\n            this.inactivityTimerPromise.catch(function (err) {\n                // When the AsyncQueue gets drained during testing, pending Promises\n                // (including these idle checks) will get rejected. We special-case\n                // these cancelled idle checks to make sure that these specific Promise\n                // rejections are not considered unhandled.\n                assert(err.code === Code.CANCELLED, \"Received unexpected error in idle timeout closure. Expected CANCELLED, but was: \" + err);\n            });\n        }\n    };\n    /** Sends a message to the underlying stream. */\n    PersistentStream.prototype.sendRequest = function (msg) {\n        this.cancelIdleCheck();\n        this.stream.send(msg);\n    };\n    /** Called by the idle timer when the stream should close due to inactivity. */\n    PersistentStream.prototype.handleIdleCloseTimer = function () {\n        if (this.isOpen()) {\n            // When timing out an idle stream there's no reason to force the stream into backoff when\n            // it restarts so set the stream state to Initial instead of Error.\n            return this.close(PersistentStreamState.Initial);\n        }\n        return Promise.resolve();\n    };\n    /** Marks the stream as active again. */\n    PersistentStream.prototype.cancelIdleCheck = function () {\n        if (this.inactivityTimerPromise) {\n            this.inactivityTimerPromise.cancel();\n            this.inactivityTimerPromise = null;\n        }\n    };\n    /**\n     * Closes the stream and cleans up as necessary:\n     *\n     * * closes the underlying GRPC stream;\n     * * calls the onClose handler with the given 'error';\n     * * sets internal stream state to 'finalState';\n     * * adjusts the backoff timer based on the error\n     *\n     * A new stream can be opened by calling `start` unless `finalState` is set to\n     * `PersistentStreamState.Stopped`.\n     *\n     * @param finalState the intended state of the stream after closing.\n     * @param error the error the connection was closed with.\n     */\n    PersistentStream.prototype.close = function (finalState, error) {\n        assert(finalState === PersistentStreamState.Error || isNullOrUndefined(error), \"Can't provide an error when not in an error state.\");\n        this.cancelIdleCheck();\n        if (finalState !== PersistentStreamState.Error) {\n            // If this is an intentional close ensure we don't delay our next connection attempt.\n            this.backoff.reset();\n        }\n        else if (error && error.code === Code.RESOURCE_EXHAUSTED) {\n            // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)\n            log_error(error.toString());\n            log_error('Using maximum backoff delay to prevent overloading the backend.');\n            this.backoff.resetToMax();\n        }\n        // Clean up the underlying stream because we are no longer interested in events.\n        if (this.stream !== null) {\n            this.tearDown();\n            this.stream.close();\n            this.stream = null;\n        }\n        // This state must be assigned before calling onClose() to allow the callback to\n        // inhibit backoff or otherwise manipulate the state in its non-started state.\n        this.state = finalState;\n        var listener = this.listener;\n        // Clear the listener to avoid bleeding of events from the underlying streams.\n        this.listener = null;\n        // If the caller explicitly requested a stream stop, don't notify them of a closing stream (it\n        // could trigger undesirable recovery logic, etc.).\n        if (finalState !== PersistentStreamState.Stopped) {\n            return listener.onClose(error);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    /**\n     * Can be overridden to perform additional cleanup before the stream is closed.\n     * Calling super.tearDown() is not required.\n     */\n    PersistentStream.prototype.tearDown = function () { };\n    PersistentStream.prototype.auth = function () {\n        var _this = this;\n        assert(this.state === PersistentStreamState.Initial, 'Must be in initial state to auth');\n        this.state = PersistentStreamState.Auth;\n        this.credentialsProvider.getToken(/*forceRefresh=*/ false).then(function (token) {\n            // Normally we'd have to schedule the callback on the AsyncQueue.\n            // However, the following calls are safe to be called outside the\n            // AsyncQueue since they don't chain asynchronous calls\n            _this.startStream(token);\n        }, function (error) {\n            _this.queue.enqueue(function () {\n                if (_this.state !== PersistentStreamState.Stopped) {\n                    // Stream can be stopped while waiting for authorization.\n                    var rpcError = new FirestoreError(Code.UNKNOWN, 'Fetching auth token failed: ' + error.message);\n                    return _this.handleStreamClose(rpcError);\n                }\n                else {\n                    return Promise.resolve();\n                }\n            });\n        });\n    };\n    PersistentStream.prototype.startStream = function (token) {\n        var _this = this;\n        if (this.state === PersistentStreamState.Stopped) {\n            // Stream can be stopped while waiting for authorization.\n            return;\n        }\n        assert(this.state === PersistentStreamState.Auth, 'Trying to start stream in a non-auth state');\n        // Helper function to dispatch to AsyncQueue and make sure that any\n        // close will seem instantaneous and events are prevented from being\n        // raised after the close call\n        var dispatchIfStillActive = function (stream, fn) {\n            _this.queue.enqueue(function () {\n                // Only raise events if the stream instance has not changed\n                if (_this.stream === stream) {\n                    return fn();\n                }\n                else {\n                    return Promise.resolve();\n                }\n            });\n        };\n        // Only start stream if listener has not changed\n        if (this.listener !== null) {\n            var currentStream_1 = this.startRpc(token);\n            this.stream = currentStream_1;\n            this.stream.onOpen(function () {\n                dispatchIfStillActive(currentStream_1, function () {\n                    assert(_this.state === PersistentStreamState.Auth, 'Expected stream to be in state auth, but was ' + _this.state);\n                    _this.state = PersistentStreamState.Open;\n                    return _this.listener.onOpen();\n                });\n            });\n            this.stream.onClose(function (error) {\n                dispatchIfStillActive(currentStream_1, function () {\n                    return _this.handleStreamClose(error);\n                });\n            });\n            this.stream.onMessage(function (msg) {\n                dispatchIfStillActive(currentStream_1, function () {\n                    return _this.onMessage(msg);\n                });\n            });\n        }\n    };\n    PersistentStream.prototype.performBackoff = function (listener) {\n        var _this = this;\n        assert(this.state === PersistentStreamState.Error, 'Should only perform backoff in an error case');\n        this.state = PersistentStreamState.Backoff;\n        this.backoff.backoffAndRun(function () {\n            if (_this.state === PersistentStreamState.Stopped) {\n                // Stream can be stopped while waiting for backoff to complete.\n                return Promise.resolve();\n            }\n            _this.state = PersistentStreamState.Initial;\n            _this.start(listener);\n            assert(_this.isStarted(), 'PersistentStream should have started');\n            return Promise.resolve();\n        });\n    };\n    PersistentStream.prototype.handleStreamClose = function (error) {\n        assert(this.isStarted(), \"Can't handle server close on non-started stream\");\n        debug(persistent_stream_LOG_TAG, \"close with error: \" + error);\n        this.stream = null;\n        // In theory the stream could close cleanly, however, in our current model\n        // we never expect this to happen because if we stop a stream ourselves,\n        // this callback will never be called. To prevent cases where we retry\n        // without a backoff accidentally, we set the stream to error in all cases.\n        return this.close(PersistentStreamState.Error, error);\n    };\n    return PersistentStream;\n}());\n\n/**\n * A PersistentStream that implements the Listen RPC.\n *\n * Once the Listen stream has called the openHandler, any number of listen and\n * unlisten calls calls can be sent to control what changes will be sent from\n * the server for ListenResponses.\n */\nvar persistent_stream_PersistentListenStream = /** @class */ (function (_super) {\n    persistent_stream___extends(PersistentListenStream, _super);\n    function PersistentListenStream(queue, connection, credentials, serializer) {\n        var _this = _super.call(this, queue, TimerId.ListenStreamConnection, TimerId.ListenStreamIdle, connection, credentials) || this;\n        _this.serializer = serializer;\n        return _this;\n    }\n    PersistentListenStream.prototype.startRpc = function (token) {\n        return this.connection.openStream('Listen', token);\n    };\n    PersistentListenStream.prototype.onMessage = function (watchChangeProto) {\n        // A successful response means the stream is healthy\n        this.backoff.reset();\n        var watchChange = this.serializer.fromWatchChange(watchChangeProto);\n        var snapshot = this.serializer.versionFromListenResponse(watchChangeProto);\n        return this.listener.onWatchChange(watchChange, snapshot);\n    };\n    /**\n     * Registers interest in the results of the given query. If the query\n     * includes a resumeToken it will be included in the request. Results that\n     * affect the query will be streamed back as WatchChange messages that\n     * reference the targetId.\n     */\n    PersistentListenStream.prototype.watch = function (queryData) {\n        var request = {};\n        request.database = this.serializer.encodedDatabaseId;\n        request.addTarget = this.serializer.toTarget(queryData);\n        var labels = this.serializer.toListenRequestLabels(queryData);\n        if (labels) {\n            request.labels = labels;\n        }\n        this.sendRequest(request);\n    };\n    /**\n     * Unregisters interest in the results of the query associated with the\n     * given targetId.\n     */\n    PersistentListenStream.prototype.unwatch = function (targetId) {\n        var request = {};\n        request.database = this.serializer.encodedDatabaseId;\n        request.removeTarget = targetId;\n        this.sendRequest(request);\n    };\n    return PersistentListenStream;\n}(persistent_stream_PersistentStream));\n\n/**\n * A Stream that implements the Write RPC.\n *\n * The Write RPC requires the caller to maintain special streamToken\n * state in between calls, to help the server understand which responses the\n * client has processed by the time the next request is made. Every response\n * will contain a streamToken; this value must be passed to the next\n * request.\n *\n * After calling start() on this stream, the next request must be a handshake,\n * containing whatever streamToken is on hand. Once a response to this\n * request is received, all pending mutations may be submitted. When\n * submitting multiple batches of mutations at the same time, it's\n * okay to use the same streamToken for the calls to writeMutations.\n *\n * TODO(b/33271235): Use proto types\n */\nvar persistent_stream_PersistentWriteStream = /** @class */ (function (_super) {\n    persistent_stream___extends(PersistentWriteStream, _super);\n    function PersistentWriteStream(queue, connection, credentials, serializer) {\n        var _this = _super.call(this, queue, TimerId.WriteStreamConnection, TimerId.WriteStreamIdle, connection, credentials) || this;\n        _this.serializer = serializer;\n        _this.handshakeComplete_ = false;\n        return _this;\n    }\n    Object.defineProperty(PersistentWriteStream.prototype, \"handshakeComplete\", {\n        /**\n         * Tracks whether or not a handshake has been successfully exchanged and\n         * the stream is ready to accept mutations.\n         */\n        get: function () {\n            return this.handshakeComplete_;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // Override of PersistentStream.start\n    PersistentWriteStream.prototype.start = function (listener) {\n        this.handshakeComplete_ = false;\n        _super.prototype.start.call(this, listener);\n    };\n    PersistentWriteStream.prototype.tearDown = function () {\n        if (this.handshakeComplete_) {\n            this.writeMutations([]);\n        }\n    };\n    PersistentWriteStream.prototype.startRpc = function (token) {\n        return this.connection.openStream('Write', token);\n    };\n    PersistentWriteStream.prototype.onMessage = function (responseProto) {\n        // Always capture the last stream token.\n        assert(!!responseProto.streamToken, 'Got a write response without a stream token');\n        this.lastStreamToken = responseProto.streamToken;\n        if (!this.handshakeComplete_) {\n            // The first response is always the handshake response\n            assert(!responseProto.writeResults || responseProto.writeResults.length === 0, 'Got mutation results for handshake');\n            this.handshakeComplete_ = true;\n            return this.listener.onHandshakeComplete();\n        }\n        else {\n            // A successful first write response means the stream is healthy,\n            // Note, that we could consider a successful handshake healthy, however,\n            // the write itself might be causing an error we want to back off from.\n            this.backoff.reset();\n            var results = this.serializer.fromWriteResults(responseProto.writeResults);\n            var commitVersion = this.serializer.fromVersion(responseProto.commitTime);\n            return this.listener.onMutationResult(commitVersion, results);\n        }\n    };\n    /**\n     * Sends an initial streamToken to the server, performing the handshake\n     * required to make the StreamingWrite RPC work. Subsequent\n     * calls should wait until onHandshakeComplete was called.\n     */\n    PersistentWriteStream.prototype.writeHandshake = function () {\n        assert(this.isOpen(), 'Writing handshake requires an opened stream');\n        assert(!this.handshakeComplete_, 'Handshake already completed');\n        // TODO(dimond): Support stream resumption. We intentionally do not set the\n        // stream token on the handshake, ignoring any stream token we might have.\n        var request = {};\n        request.database = this.serializer.encodedDatabaseId;\n        this.sendRequest(request);\n    };\n    /** Sends a group of mutations to the Firestore backend to apply. */\n    PersistentWriteStream.prototype.writeMutations = function (mutations) {\n        var _this = this;\n        assert(this.isOpen(), 'Writing mutations requires an opened stream');\n        assert(this.handshakeComplete_, 'Handshake must be complete before writing mutations');\n        assert(this.lastStreamToken.length > 0, 'Trying to write mutation without a token');\n        var request = {\n            // Protos are typed with string, but we support UInt8Array on Node\n            // tslint:disable-next-line:no-any\n            streamToken: this.lastStreamToken,\n            writes: mutations.map(function (mutation) { return _this.serializer.toMutation(mutation); })\n        };\n        this.sendRequest(request);\n    };\n    return PersistentWriteStream;\n}(persistent_stream_PersistentStream));\n\n\n//# sourceMappingURL=persistent_stream.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/datastore.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n/**\n * Datastore is a wrapper around the external Google Cloud Datastore grpc API,\n * which provides an interface that is more convenient for the rest of the\n * client SDK architecture to consume.\n */\nvar datastore_Datastore = /** @class */ (function () {\n    function Datastore(queue, connection, credentials, serializer) {\n        this.queue = queue;\n        this.connection = connection;\n        this.credentials = credentials;\n        this.serializer = serializer;\n    }\n    Datastore.prototype.newPersistentWriteStream = function () {\n        return new persistent_stream_PersistentWriteStream(this.queue, this.connection, this.credentials, this.serializer);\n    };\n    Datastore.prototype.newPersistentWatchStream = function () {\n        return new persistent_stream_PersistentListenStream(this.queue, this.connection, this.credentials, this.serializer);\n    };\n    Datastore.prototype.commit = function (mutations) {\n        var _this = this;\n        var params = {\n            database: this.serializer.encodedDatabaseId,\n            writes: mutations.map(function (m) { return _this.serializer.toMutation(m); })\n        };\n        return this.invokeRPC('Commit', params).then(function (response) {\n            return _this.serializer.fromWriteResults(response.writeResults);\n        });\n    };\n    Datastore.prototype.lookup = function (keys) {\n        var _this = this;\n        var params = {\n            database: this.serializer.encodedDatabaseId,\n            documents: keys.map(function (k) { return _this.serializer.toName(k); })\n        };\n        return this.invokeStreamingRPC('BatchGetDocuments', params).then(function (response) {\n            var docs = maybeDocumentMap();\n            response.forEach(function (proto) {\n                var doc = _this.serializer.fromMaybeDocument(proto);\n                docs = docs.insert(doc.key, doc);\n            });\n            var result = [];\n            keys.forEach(function (key) {\n                var doc = docs.get(key);\n                assert(!!doc, 'Missing entity in write response for ' + key);\n                result.push(doc);\n            });\n            return result;\n        });\n    };\n    /** Gets an auth token and invokes the provided RPC. */\n    Datastore.prototype.invokeRPC = function (rpcName, request) {\n        var _this = this;\n        // TODO(mikelehen): Retry (with backoff) on token failures?\n        return this.credentials.getToken(/*forceRefresh=*/ false).then(function (token) {\n            return _this.connection.invokeRPC(rpcName, request, token);\n        });\n    };\n    /** Gets an auth token and invokes the provided RPC with streamed results. */\n    Datastore.prototype.invokeStreamingRPC = function (rpcName, request) {\n        var _this = this;\n        // TODO(mikelehen): Retry (with backoff) on token failures?\n        return this.credentials.getToken(/*forceRefresh=*/ false).then(function (token) {\n            return _this.connection.invokeStreamingRPC(rpcName, request, token);\n        });\n    };\n    return Datastore;\n}());\n\n\n//# sourceMappingURL=datastore.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/transaction.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n/**\n * Internal transaction object responsible for accumulating the mutations to\n * perform and the base versions for any documents read.\n */\nvar transaction_Transaction = /** @class */ (function () {\n    function Transaction(datastore) {\n        this.datastore = datastore;\n        // The version of each document that was read during this transaction.\n        this.readVersions = documentVersionMap();\n        this.mutations = [];\n        this.committed = false;\n    }\n    Transaction.prototype.recordVersion = function (doc) {\n        var docVersion = doc.version;\n        if (doc instanceof document_NoDocument) {\n            // For deleted docs, we must use baseVersion 0 when we overwrite them.\n            docVersion = snapshot_version_SnapshotVersion.forDeletedDoc();\n        }\n        var existingVersion = this.readVersions.get(doc.key);\n        if (existingVersion !== null) {\n            if (!docVersion.isEqual(existingVersion)) {\n                // This transaction will fail no matter what.\n                throw new FirestoreError(Code.ABORTED, 'Document version changed between two reads.');\n            }\n        }\n        else {\n            this.readVersions = this.readVersions.insert(doc.key, docVersion);\n        }\n    };\n    Transaction.prototype.lookup = function (keys) {\n        var _this = this;\n        if (this.committed) {\n            return Promise.reject('Transaction has already completed.');\n        }\n        if (this.mutations.length > 0) {\n            return Promise.reject('Transactions lookups are invalid after writes.');\n        }\n        return this.datastore.lookup(keys).then(function (docs) {\n            docs.forEach(function (doc) { return _this.recordVersion(doc); });\n            return docs;\n        });\n    };\n    Transaction.prototype.write = function (mutations) {\n        if (this.committed) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'Transaction has already completed.');\n        }\n        this.mutations = this.mutations.concat(mutations);\n    };\n    /**\n     * Returns the version of this document when it was read in this transaction,\n     * as a precondition, or no precondition if it was not read.\n     */\n    Transaction.prototype.precondition = function (key) {\n        var version = this.readVersions.get(key);\n        if (version) {\n            return mutation_Precondition.updateTime(version);\n        }\n        else {\n            return mutation_Precondition.NONE;\n        }\n    };\n    /**\n     * Returns the precondition for a document if the operation is an update.\n     */\n    Transaction.prototype.preconditionForUpdate = function (key) {\n        var version = this.readVersions.get(key);\n        if (version && version.isEqual(snapshot_version_SnapshotVersion.forDeletedDoc())) {\n            // The document doesn't exist, so fail the transaction.\n            throw new FirestoreError(Code.FAILED_PRECONDITION, \"Can't update a document that doesn't exist.\");\n        }\n        else if (version) {\n            // Document exists, base precondition on document update time.\n            return mutation_Precondition.updateTime(version);\n        }\n        else {\n            // Document was not read, so we just use the preconditions for a blind\n            // update.\n            return mutation_Precondition.exists(true);\n        }\n    };\n    Transaction.prototype.set = function (key, data) {\n        this.write(data.toMutations(key, this.precondition(key)));\n    };\n    Transaction.prototype.update = function (key, data) {\n        this.write(data.toMutations(key, this.preconditionForUpdate(key)));\n    };\n    Transaction.prototype.delete = function (key) {\n        this.write([new mutation_DeleteMutation(key, this.precondition(key))]);\n        // Since the delete will be applied before all following writes, we need to\n        // ensure that the precondition for the next write will be exists: false.\n        this.readVersions = this.readVersions.insert(key, snapshot_version_SnapshotVersion.forDeletedDoc());\n    };\n    Transaction.prototype.commit = function () {\n        var _this = this;\n        var unwritten = this.readVersions;\n        // For each mutation, note that the doc was written.\n        this.mutations.forEach(function (mutation) {\n            unwritten = unwritten.remove(mutation.key);\n        });\n        if (!unwritten.isEmpty()) {\n            return Promise.reject(Error('Every document read in a transaction must also be written.'));\n        }\n        return this.datastore.commit(this.mutations).then(function () {\n            _this.committed = true;\n        });\n    };\n    return Transaction;\n}());\n\n\n//# sourceMappingURL=transaction.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/remote/remote_store.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar remote_store_LOG_TAG = 'RemoteStore';\n// TODO(b/35853402): Negotiate this with the stream.\nvar MAX_PENDING_WRITES = 10;\n// The RemoteStore notifies an onlineStateHandler with OnlineState.Failed if we\n// fail to connect to the backend. This subsequently triggers get() requests to\n// fail or use cached data, etc. Unfortunately, our connections have\n// historically been subject to various transient failures. So we wait for\n// multiple failures before notifying the onlineStateHandler.\nvar ONLINE_ATTEMPTS_BEFORE_FAILURE = 2;\n/**\n * RemoteStore - An interface to remotely stored data, basically providing a\n * wrapper around the Datastore that is more reliable for the rest of the\n * system.\n *\n * RemoteStore is responsible for maintaining the connection to the server.\n * - maintaining a list of active listens.\n * - reconnecting when the connection is dropped.\n * - resuming all the active listens on reconnect.\n *\n * RemoteStore handles all incoming events from the Datastore.\n * - listening to the watch stream and repackaging the events as RemoteEvents\n * - notifying SyncEngine of any changes to the active listens.\n *\n * RemoteStore takes writes from other components and handles them reliably.\n * - pulling pending mutations from LocalStore and sending them to Datastore.\n * - retrying mutations that failed because of network problems.\n * - acking mutations to the SyncEngine once they are accepted or rejected.\n */\nvar remote_store_RemoteStore = /** @class */ (function () {\n    function RemoteStore(\n        /**\n         * The local store, used to fill the write pipeline with outbound\n         * mutations and resolve existence filter mismatches.\n         */\n        localStore, \n        /** The client-side proxy for interacting with the backend. */\n        datastore, onlineStateHandler) {\n        this.localStore = localStore;\n        this.datastore = datastore;\n        this.onlineStateHandler = onlineStateHandler;\n        this.pendingWrites = [];\n        this.lastBatchSeen = BATCHID_UNKNOWN;\n        /**\n         * A mapping of watched targets that the client cares about tracking and the\n         * user has explicitly called a 'listen' for this target.\n         *\n         * These targets may or may not have been sent to or acknowledged by the\n         * server. On re-establishing the listen stream, these targets should be sent\n         * to the server. The targets removed with unlistens are removed eagerly\n         * without waiting for confirmation from the listen stream.\n         */\n        this.listenTargets = {};\n        /**\n         * A mapping of targetId to pending acks needed.\n         *\n         * If a targetId is present in this map, then we're waiting for watch to\n         * acknowledge a removal or addition of the target. If a target is not in this\n         * mapping, and it's in the listenTargets map, then we consider the target to\n         * be active.\n         *\n         * We increment the count here every time we issue a request over the stream\n         * to watch or unwatch. We then decrement the count every time we get a target\n         * added or target removed message from the server. Once the count is equal to\n         * 0 we know that the client and server are in the same state (once this state\n         * is reached the targetId is removed from the map to free the memory).\n         */\n        this.pendingTargetResponses = {};\n        this.accumulatedWatchChanges = [];\n        this.watchStream = null;\n        this.writeStream = null;\n        /**\n         * The online state of the watch stream. The state is set to healthy if and\n         * only if there are messages received by the backend.\n         */\n        this.watchStreamOnlineState = OnlineState.Unknown;\n        /** A count of consecutive failures to open the stream. */\n        this.watchStreamFailures = 0;\n        /** Whether the client should fire offline warning. */\n        this.shouldWarnOffline = true;\n    }\n    /**\n     * Starts up the remote store, creating streams, restoring state from\n     * LocalStore, etc.\n     */\n    RemoteStore.prototype.start = function () {\n        return this.enableNetwork();\n    };\n    /**\n     * Updates our OnlineState to the new state, updating local state\n     * and notifying the onlineStateHandler as appropriate. Idempotent.\n     */\n    RemoteStore.prototype.updateOnlineState = function (newState) {\n        if (newState !== this.watchStreamOnlineState) {\n            if (newState === OnlineState.Healthy) {\n                // We've connected to watch at least once. Don't warn the developer about\n                // being offline going forward.\n                this.shouldWarnOffline = false;\n            }\n            else if (newState === OnlineState.Unknown) {\n                // The state is set to unknown when a healthy stream is closed (e.g. due to\n                // a token timeout) or when we have no active listens and therefore there's\n                // no need to start the stream. Assuming there is (possibly in the future)\n                // an active listen, then we will eventually move to state Online or Failed,\n                // but we always want to make at least ONLINE_ATTEMPTS_BEFORE_FAILURE\n                // attempts before failing, so we reset the count here.\n                this.watchStreamFailures = 0;\n            }\n            this.watchStreamOnlineState = newState;\n            this.onlineStateHandler(newState);\n        }\n    };\n    /**\n     * Updates our OnlineState as appropriate after the watch stream reports a\n     * failure. The first failure moves us to the 'Unknown' state. We then may\n     * allow multiple failures (based on ONLINE_ATTEMPTS_BEFORE_FAILURE) before we\n     * actually transition to OnlineState.Failed.\n     */\n    RemoteStore.prototype.updateOnlineStateAfterFailure = function () {\n        if (this.watchStreamOnlineState === OnlineState.Healthy) {\n            this.updateOnlineState(OnlineState.Unknown);\n        }\n        else {\n            this.watchStreamFailures++;\n            if (this.watchStreamFailures >= ONLINE_ATTEMPTS_BEFORE_FAILURE) {\n                if (this.shouldWarnOffline) {\n                    log_error('Could not reach Firestore backend.');\n                    this.shouldWarnOffline = false;\n                }\n                this.updateOnlineState(OnlineState.Failed);\n            }\n        }\n    };\n    RemoteStore.prototype.isNetworkEnabled = function () {\n        assert((this.watchStream == null) === (this.writeStream == null), 'WatchStream and WriteStream should both be null or non-null');\n        return this.watchStream != null;\n    };\n    /** Re-enables the network. Idempotent. */\n    RemoteStore.prototype.enableNetwork = function () {\n        var _this = this;\n        if (this.isNetworkEnabled()) {\n            return Promise.resolve();\n        }\n        // Create new streams (but note they're not started yet).\n        this.watchStream = this.datastore.newPersistentWatchStream();\n        this.writeStream = this.datastore.newPersistentWriteStream();\n        // Load any saved stream token from persistent storage\n        return this.localStore.getLastStreamToken().then(function (token) {\n            _this.writeStream.lastStreamToken = token;\n            if (_this.shouldStartWatchStream()) {\n                _this.startWatchStream();\n            }\n            _this.updateOnlineState(OnlineState.Unknown);\n            return _this.fillWritePipeline(); // This may start the writeStream.\n        });\n    };\n    /**\n     * Temporarily disables the network. The network can be re-enabled using\n     * enableNetwork().\n     */\n    RemoteStore.prototype.disableNetwork = function () {\n        this.disableNetworkInternal();\n        // Set the OnlineState to failed so get()'s return from cache, etc.\n        this.updateOnlineState(OnlineState.Failed);\n        return Promise.resolve();\n    };\n    /**\n     * Disables the network, if it is currently enabled.\n     */\n    RemoteStore.prototype.disableNetworkInternal = function () {\n        if (this.isNetworkEnabled()) {\n            // NOTE: We're guaranteed not to get any further events from these streams (not even a close\n            // event).\n            this.watchStream.stop();\n            this.writeStream.stop();\n            this.cleanUpWatchStreamState();\n            this.cleanUpWriteStreamState();\n            this.writeStream = null;\n            this.watchStream = null;\n        }\n    };\n    RemoteStore.prototype.shutdown = function () {\n        debug(remote_store_LOG_TAG, 'RemoteStore shutting down.');\n        this.disableNetworkInternal();\n        // Set the OnlineState to Unknown (rather than Failed) to avoid potentially\n        // triggering spurious listener events with cached data, etc.\n        this.updateOnlineState(OnlineState.Unknown);\n        return Promise.resolve();\n    };\n    /** Starts new listen for the given query. Uses resume token if provided */\n    RemoteStore.prototype.listen = function (queryData) {\n        assert(!contains(this.listenTargets, queryData.targetId), 'listen called with duplicate targetId!');\n        // Mark this as something the client is currently listening for.\n        this.listenTargets[queryData.targetId] = queryData;\n        if (this.shouldStartWatchStream()) {\n            // The listen will be sent in onWatchStreamOpen\n            this.startWatchStream();\n        }\n        else if (this.isNetworkEnabled() && this.watchStream.isOpen()) {\n            this.sendWatchRequest(queryData);\n        }\n    };\n    /** Removes the listen from server */\n    RemoteStore.prototype.unlisten = function (targetId) {\n        assert(contains(this.listenTargets, targetId), 'unlisten called without assigned target ID!');\n        delete this.listenTargets[targetId];\n        if (this.isNetworkEnabled() && this.watchStream.isOpen()) {\n            this.sendUnwatchRequest(targetId);\n            if (isEmpty(this.listenTargets)) {\n                this.watchStream.markIdle();\n            }\n        }\n    };\n    /**\n     * We need to increment the the expected number of pending responses we're due\n     * from watch so we wait for the ack to process any messages from this target.\n     */\n    RemoteStore.prototype.sendWatchRequest = function (queryData) {\n        this.recordPendingTargetRequest(queryData.targetId);\n        this.watchStream.watch(queryData);\n    };\n    /**\n     * We need to increment the expected number of pending responses we're due\n     * from watch so we wait for the removal on the server before we process any\n     * messages from this target.\n     */\n    RemoteStore.prototype.sendUnwatchRequest = function (targetId) {\n        this.recordPendingTargetRequest(targetId);\n        this.watchStream.unwatch(targetId);\n    };\n    /**\n     * Increment the mapping of how many acks are needed from watch before we can\n     * consider the server to be 'in-sync' with the client's active targets.\n     */\n    RemoteStore.prototype.recordPendingTargetRequest = function (targetId) {\n        // For each request we get we need to record we need a response for it.\n        this.pendingTargetResponses[targetId] =\n            (this.pendingTargetResponses[targetId] || 0) + 1;\n    };\n    RemoteStore.prototype.startWatchStream = function () {\n        assert(this.shouldStartWatchStream(), 'startWriteStream() called when shouldStartWatchStream() is false.');\n        this.watchStream.start({\n            onOpen: this.onWatchStreamOpen.bind(this),\n            onClose: this.onWatchStreamClose.bind(this),\n            onWatchChange: this.onWatchStreamChange.bind(this)\n        });\n    };\n    /**\n     * Returns whether the watch stream should be started because there are\n     * active targets trying to be listened too\n     */\n    RemoteStore.prototype.shouldStartWatchStream = function () {\n        return (this.isNetworkEnabled() &&\n            !this.watchStream.isStarted() &&\n            !isEmpty(this.listenTargets));\n    };\n    RemoteStore.prototype.cleanUpWatchStreamState = function () {\n        // If the connection is closed then we'll never get a snapshot version for\n        // the accumulated changes and so we'll never be able to complete the batch.\n        // When we start up again the server is going to resend these changes\n        // anyway, so just toss the accumulated state.\n        this.accumulatedWatchChanges = [];\n        this.pendingTargetResponses = {};\n    };\n    RemoteStore.prototype.onWatchStreamOpen = function () {\n        var _this = this;\n        // TODO(b/35852690): close the stream again (with some timeout?) if no watch\n        // targets are active\n        forEachNumber(this.listenTargets, function (targetId, queryData) {\n            _this.sendWatchRequest(queryData);\n        });\n        return Promise.resolve();\n    };\n    RemoteStore.prototype.onWatchStreamClose = function (error) {\n        assert(this.isNetworkEnabled(), 'onWatchStreamClose() should only be called when the network is enabled');\n        this.cleanUpWatchStreamState();\n        // If there was an error, retry the connection.\n        if (this.shouldStartWatchStream()) {\n            this.updateOnlineStateAfterFailure();\n            this.startWatchStream();\n        }\n        else {\n            // No need to restart watch stream because there are no active targets.\n            // The online state is set to unknown because there is no active attempt\n            // at establishing a connection\n            this.updateOnlineState(OnlineState.Unknown);\n        }\n        return Promise.resolve();\n    };\n    RemoteStore.prototype.onWatchStreamChange = function (watchChange, snapshotVersion) {\n        // Mark the connection as healthy because we got a message from the server\n        this.updateOnlineState(OnlineState.Healthy);\n        if (watchChange instanceof watch_change_WatchTargetChange &&\n            watchChange.state === WatchTargetChangeState.Removed &&\n            watchChange.cause) {\n            // There was an error on a target, don't wait for a consistent snapshot\n            // to raise events\n            return this.handleTargetError(watchChange);\n        }\n        // Accumulate watch changes but don't process them if there's no\n        // snapshotVersion or it's older than a previous snapshot we've processed\n        // (can happen after we resume a target using a resume token).\n        this.accumulatedWatchChanges.push(watchChange);\n        if (!snapshotVersion.isEqual(snapshot_version_SnapshotVersion.MIN) &&\n            snapshotVersion.compareTo(this.localStore.getLastRemoteSnapshotVersion()) >= 0) {\n            var changes = this.accumulatedWatchChanges;\n            this.accumulatedWatchChanges = [];\n            return this.handleWatchChangeBatch(snapshotVersion, changes);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    /**\n     * Takes a batch of changes from the Datastore, repackages them as a\n     * RemoteEvent, and passes that on to the listener, which is typically the\n     * SyncEngine.\n     */\n    RemoteStore.prototype.handleWatchChangeBatch = function (snapshotVersion, changes) {\n        var _this = this;\n        var aggregator = new watch_change_WatchChangeAggregator(snapshotVersion, this.listenTargets, this.pendingTargetResponses);\n        aggregator.addChanges(changes);\n        var remoteEvent = aggregator.createRemoteEvent();\n        // Get the new response counts from the aggregator\n        this.pendingTargetResponses = aggregator.pendingTargetResponses;\n        var promises = [];\n        // Handle existence filters and existence filter mismatches.\n        forEachNumber(aggregator.existenceFilters, function (targetId, filter) {\n            var queryData = _this.listenTargets[targetId];\n            if (!queryData) {\n                // A watched target might have been removed already.\n                return;\n            }\n            var query = queryData.query;\n            if (query.isDocumentQuery()) {\n                if (filter.count === 0) {\n                    // The existence filter told us the document does not exist.\n                    // We need to deduce that this document does not exist and apply\n                    // a deleted document to our updates. Without applying a deleted\n                    // document there might be another query that will raise this\n                    // document as part of a snapshot until it is resolved,\n                    // essentially exposing inconsistency between queries.\n                    var key = new document_key_DocumentKey(query.path);\n                    var deletedDoc = new document_NoDocument(key, snapshotVersion);\n                    remoteEvent.addDocumentUpdate(deletedDoc);\n                }\n                else {\n                    assert(filter.count === 1, 'Single document existence filter with count: ' + filter.count);\n                }\n            }\n            else {\n                // Not a document query.\n                var promise = _this.localStore\n                    .remoteDocumentKeys(targetId)\n                    .then(function (trackedRemote) {\n                    if (remoteEvent.targetChanges[targetId]) {\n                        var mapping = remoteEvent.targetChanges[targetId].mapping;\n                        if (mapping !== null) {\n                            if (mapping instanceof UpdateMapping) {\n                                trackedRemote = mapping.applyToKeySet(trackedRemote);\n                            }\n                            else {\n                                assert(mapping instanceof ResetMapping, 'Expected either reset or update mapping but got something else: ' +\n                                    mapping);\n                                trackedRemote = mapping.documents;\n                            }\n                        }\n                    }\n                    if (trackedRemote.size !== filter.count) {\n                        // Existence filter mismatch, resetting mapping.\n                        // Make sure the mismatch is exposed in the remote event.\n                        remoteEvent.handleExistenceFilterMismatch(targetId);\n                        // Clear the resume token for the query, since we're in a\n                        // known mismatch state.\n                        var newQueryData = new query_data_QueryData(query, targetId, queryData.purpose);\n                        _this.listenTargets[targetId] = newQueryData;\n                        // Cause a hard reset by unwatching and rewatching\n                        // immediately, but deliberately don't send a resume token\n                        // so that we get a full update.\n                        // Make sure we expect that this acks are going to happen.\n                        _this.sendUnwatchRequest(targetId);\n                        // Mark the query we send as being on behalf of an existence\n                        // filter mismatch, but don't actually retain that in\n                        // listenTargets. This ensures that we flag the first\n                        // re-listen this way without impacting future listens of\n                        // this target (that might happen e.g. on reconnect).\n                        var requestQueryData = new query_data_QueryData(query, targetId, QueryPurpose.ExistenceFilterMismatch);\n                        _this.sendWatchRequest(requestQueryData);\n                    }\n                });\n                promises.push(promise);\n            }\n        });\n        return Promise.all(promises).then(function () {\n            // Update in-memory resume tokens. LocalStore will update the\n            // persistent view of these when applying the completed RemoteEvent.\n            forEachNumber(remoteEvent.targetChanges, function (targetId, change) {\n                if (change.resumeToken.length > 0) {\n                    var queryData = _this.listenTargets[targetId];\n                    // A watched target might have been removed already.\n                    if (queryData) {\n                        _this.listenTargets[targetId] = queryData.update({\n                            resumeToken: change.resumeToken,\n                            snapshotVersion: change.snapshotVersion\n                        });\n                    }\n                }\n            });\n            // Finally handle remote event\n            return _this.syncEngine.applyRemoteEvent(remoteEvent);\n        });\n    };\n    /** Handles an error on a target */\n    RemoteStore.prototype.handleTargetError = function (watchChange) {\n        var _this = this;\n        assert(!!watchChange.cause, 'Handling target error without a cause');\n        var error = watchChange.cause;\n        var promiseChain = Promise.resolve();\n        watchChange.targetIds.forEach(function (targetId) {\n            promiseChain = promiseChain.then(function () {\n                if (contains(_this.listenTargets, targetId)) {\n                    delete _this.listenTargets[targetId];\n                    return _this.syncEngine.rejectListen(targetId, error);\n                }\n                else {\n                    // A watched target might have been removed already.\n                    return Promise.resolve();\n                }\n            });\n        });\n        return promiseChain;\n    };\n    RemoteStore.prototype.cleanUpWriteStreamState = function () {\n        this.lastBatchSeen = BATCHID_UNKNOWN;\n        debug(remote_store_LOG_TAG, 'Stopping write stream with ' +\n            this.pendingWrites.length +\n            ' pending writes');\n        this.pendingWrites = [];\n    };\n    /**\n     * Notifies that there are new mutations to process in the queue. This is\n     * typically called by SyncEngine after it has sent mutations to LocalStore.\n     */\n    RemoteStore.prototype.fillWritePipeline = function () {\n        var _this = this;\n        if (!this.canWriteMutations()) {\n            return Promise.resolve();\n        }\n        else {\n            return this.localStore\n                .nextMutationBatch(this.lastBatchSeen)\n                .then(function (batch) {\n                if (batch === null) {\n                    if (_this.pendingWrites.length === 0) {\n                        _this.writeStream.markIdle();\n                    }\n                    return Promise.resolve();\n                }\n                else {\n                    _this.commit(batch);\n                    return _this.fillWritePipeline();\n                }\n            });\n        }\n    };\n    /**\n     * Returns true if the backend can accept additional write requests.\n     *\n     * When sending mutations to the write stream (e.g. in fillWritePipeline),\n     * call this method first to check if more mutations can be sent.\n     *\n     * Currently the only thing that can prevent the backend from accepting\n     * write requests is if there are too many requests already outstanding. As\n     * writes complete the backend will be able to accept more.\n     */\n    RemoteStore.prototype.canWriteMutations = function () {\n        return (this.isNetworkEnabled() && this.pendingWrites.length < MAX_PENDING_WRITES);\n    };\n    // For testing\n    RemoteStore.prototype.outstandingWrites = function () {\n        return this.pendingWrites.length;\n    };\n    /**\n     * Given mutations to commit, actually commits them to the Datastore. Note\n     * that this does *not* return a Promise specifically because the AsyncQueue\n     * should not block operations for this.\n     */\n    RemoteStore.prototype.commit = function (batch) {\n        assert(this.canWriteMutations(), \"commit called when batches can't be written\");\n        this.lastBatchSeen = batch.batchId;\n        this.pendingWrites.push(batch);\n        if (this.shouldStartWriteStream()) {\n            this.startWriteStream();\n        }\n        else if (this.isNetworkEnabled() && this.writeStream.handshakeComplete) {\n            this.writeStream.writeMutations(batch.mutations);\n        }\n    };\n    RemoteStore.prototype.shouldStartWriteStream = function () {\n        return (this.isNetworkEnabled() &&\n            !this.writeStream.isStarted() &&\n            this.pendingWrites.length > 0);\n    };\n    RemoteStore.prototype.startWriteStream = function () {\n        assert(this.shouldStartWriteStream(), 'startWriteStream() called when shouldStartWriteStream() is false.');\n        this.writeStream.start({\n            onOpen: this.onWriteStreamOpen.bind(this),\n            onClose: this.onWriteStreamClose.bind(this),\n            onHandshakeComplete: this.onWriteHandshakeComplete.bind(this),\n            onMutationResult: this.onMutationResult.bind(this)\n        });\n    };\n    RemoteStore.prototype.onWriteStreamOpen = function () {\n        this.writeStream.writeHandshake();\n        return Promise.resolve();\n    };\n    RemoteStore.prototype.onWriteHandshakeComplete = function () {\n        var _this = this;\n        // Record the stream token.\n        return this.localStore\n            .setLastStreamToken(this.writeStream.lastStreamToken)\n            .then(function () {\n            // Drain any pending writes.\n            //\n            // Note that at this point pendingWrites contains mutations that\n            // have already been accepted by fillWritePipeline/commitBatch. If\n            // the pipeline is full, canWriteMutations will be false, despite\n            // the fact that we actually need to send mutations over.\n            //\n            // This also means that this method indirectly respects the limits\n            // imposed by canWriteMutations since writes can't be added to the\n            // pendingWrites array when canWriteMutations is false. If the\n            // limits imposed by canWriteMutations actually protect us from\n            // DOSing ourselves then those limits won't be exceeded here and\n            // we'll continue to make progress.\n            for (var _i = 0, _a = _this.pendingWrites; _i < _a.length; _i++) {\n                var batch = _a[_i];\n                _this.writeStream.writeMutations(batch.mutations);\n            }\n        });\n    };\n    RemoteStore.prototype.onMutationResult = function (commitVersion, results) {\n        var _this = this;\n        // This is a response to a write containing mutations and should be\n        // correlated to the first pending write.\n        assert(this.pendingWrites.length > 0, 'Got result for empty pending writes');\n        var batch = this.pendingWrites.shift();\n        var success = mutation_batch_MutationBatchResult.from(batch, commitVersion, results, this.writeStream.lastStreamToken);\n        return this.syncEngine.applySuccessfulWrite(success).then(function () {\n            // It's possible that with the completion of this mutation another\n            // slot has freed up.\n            return _this.fillWritePipeline();\n        });\n    };\n    RemoteStore.prototype.onWriteStreamClose = function (error) {\n        var _this = this;\n        assert(this.isNetworkEnabled(), 'onWriteStreamClose() should only be called when the network is enabled');\n        // If the write stream closed due to an error, invoke the error callbacks if\n        // there are pending writes.\n        if (error && this.pendingWrites.length > 0) {\n            assert(!!error, 'We have pending writes, but the write stream closed without an error');\n            // A promise that is resolved after we processed the error\n            var errorHandling = void 0;\n            if (this.writeStream.handshakeComplete) {\n                // This error affects the actual write.\n                errorHandling = this.handleWriteError(error);\n            }\n            else {\n                // If there was an error before the handshake has finished, it's\n                // possible that the server is unable to process the stream token\n                // we're sending. (Perhaps it's too old?)\n                errorHandling = this.handleHandshakeError(error);\n            }\n            return errorHandling.then(function () {\n                // The write stream might have been started by refilling the write\n                // pipeline for failed writes\n                if (_this.shouldStartWriteStream()) {\n                    _this.startWriteStream();\n                }\n            });\n        }\n        else {\n            // No pending writes, nothing to do\n            return Promise.resolve();\n        }\n    };\n    RemoteStore.prototype.handleHandshakeError = function (error) {\n        // Reset the token if it's a permanent error or the error code is\n        // ABORTED, signaling the write stream is no longer valid.\n        if (isPermanentError(error.code) || error.code === Code.ABORTED) {\n            debug(remote_store_LOG_TAG, 'RemoteStore error before completed handshake; resetting stream token: ', this.writeStream.lastStreamToken);\n            this.writeStream.lastStreamToken = emptyByteString();\n            return this.localStore.setLastStreamToken(emptyByteString());\n        }\n        else {\n            // Some other error, don't reset stream token. Our stream logic will\n            // just retry with exponential backoff.\n            return Promise.resolve();\n        }\n    };\n    RemoteStore.prototype.handleWriteError = function (error) {\n        var _this = this;\n        if (isPermanentError(error.code)) {\n            // This was a permanent error, the request itself was the problem\n            // so it's not going to succeed if we resend it.\n            var batch = this.pendingWrites.shift();\n            // In this case it's also unlikely that the server itself is melting\n            // down -- this was just a bad request so inhibit backoff on the next\n            // restart.\n            this.writeStream.inhibitBackoff();\n            return this.syncEngine\n                .rejectFailedWrite(batch.batchId, error)\n                .then(function () {\n                // It's possible that with the completion of this mutation\n                // another slot has freed up.\n                return _this.fillWritePipeline();\n            });\n        }\n        else {\n            // Transient error, just let the retry logic kick in.\n            return Promise.resolve();\n        }\n    };\n    RemoteStore.prototype.createTransaction = function () {\n        return new transaction_Transaction(this.datastore);\n    };\n    RemoteStore.prototype.handleUserChange = function (user) {\n        debug(remote_store_LOG_TAG, 'RemoteStore changing users: uid=', user.uid);\n        // If the network has been explicitly disabled, make sure we don't\n        // accidentally re-enable it.\n        if (this.isNetworkEnabled()) {\n            // Tear down and re-create our network streams. This will ensure we get a fresh auth token\n            // for the new user and re-fill the write pipeline with new mutations from the LocalStore\n            // (since mutations are per-user).\n            this.disableNetworkInternal();\n            this.updateOnlineState(OnlineState.Unknown);\n            return this.enableNetwork();\n        }\n    };\n    return RemoteStore;\n}());\n\n\n//# sourceMappingURL=remote_store.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/core/firestore_client.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar firestore_client_LOG_TAG = 'FirestoreClient';\n/**\n * FirestoreClient is a top-level class that constructs and owns all of the\n * pieces of the client SDK architecture. It is responsible for creating the\n * async queue that is shared by all of the other components in the system.\n */\nvar firestore_client_FirestoreClient = /** @class */ (function () {\n    function FirestoreClient(platform, databaseInfo, credentials, \n        /**\n         * Asynchronous queue responsible for all of our internal processing. When\n         * we get incoming work from the user (via public API) or the network\n         * (incoming GRPC messages), we should always schedule onto this queue.\n         * This ensures all of our work is properly serialized (e.g. we don't\n         * start processing a new operation while the previous one is waiting for\n         * an async I/O to complete).\n         */\n        asyncQueue) {\n        this.platform = platform;\n        this.databaseInfo = databaseInfo;\n        this.credentials = credentials;\n        this.asyncQueue = asyncQueue;\n    }\n    /**\n     * Starts up the FirestoreClient, returning only whether or not enabling\n     * persistence succeeded.\n     *\n     * The intent here is to \"do the right thing\" as far as users are concerned.\n     * Namely, in cases where offline persistence is requested and possible,\n     * enable it, but otherwise fall back to persistence disabled. For the most\n     * part we expect this to succeed one way or the other so we don't expect our\n     * users to actually wait on the firestore.enablePersistence Promise since\n     * they generally won't care.\n     *\n     * Of course some users actually do care about whether or not persistence\n     * was successfully enabled, so the Promise returned from this method\n     * indicates this outcome.\n     *\n     * This presents a problem though: even before enablePersistence resolves or\n     * rejects, users may have made calls to e.g. firestore.collection() which\n     * means that the FirestoreClient in there will be available and will be\n     * enqueuing actions on the async queue.\n     *\n     * Meanwhile any failure of an operation on the async queue causes it to\n     * panic and reject any further work, on the premise that unhandled errors\n     * are fatal.\n     *\n     * Consequently the fallback is handled internally here in start, and if the\n     * fallback succeeds we signal success to the async queue even though the\n     * start() itself signals failure.\n     *\n     * @param usePersistence Whether or not to attempt to enable persistence.\n     * @returns A deferred result indicating the user-visible result of enabling\n     *     offline persistence. This method will reject this if IndexedDB fails to\n     *     start for any reason. If usePersistence is false this is\n     *     unconditionally resolved.\n     */\n    FirestoreClient.prototype.start = function (usePersistence) {\n        var _this = this;\n        // We defer our initialization until we get the current user from\n        // setUserChangeListener(). We block the async queue until we got the\n        // initial user and the initialization is completed. This will prevent\n        // any scheduled work from happening before initialization is completed.\n        //\n        // If initializationDone resolved then the FirestoreClient is in a usable\n        // state.\n        var initializationDone = new Deferred();\n        // If usePersistence is true, certain classes of errors while starting are\n        // recoverable but only by falling back to persistence disabled.\n        //\n        // If there's an error in the first case but not in recovery we cannot\n        // reject the promise blocking the async queue because this will cause the\n        // async queue to panic.\n        var persistenceResult = new Deferred();\n        var initialized = false;\n        this.credentials.setUserChangeListener(function (user) {\n            if (!initialized) {\n                initialized = true;\n                _this.initializePersistence(usePersistence, persistenceResult)\n                    .then(function () { return _this.initializeRest(user); })\n                    .then(initializationDone.resolve, initializationDone.reject);\n            }\n            else {\n                _this.asyncQueue.enqueue(function () {\n                    return _this.handleUserChange(user);\n                });\n            }\n        });\n        // Block the async queue until initialization is done\n        this.asyncQueue.enqueue(function () {\n            return initializationDone.promise;\n        });\n        // Return only the result of enabling persistence. Note that this does not\n        // need to await the completion of initializationDone because the result of\n        // this method should not reflect any other kind of failure to start.\n        return persistenceResult.promise;\n    };\n    /** Enables the network connection and requeues all pending operations. */\n    FirestoreClient.prototype.enableNetwork = function () {\n        var _this = this;\n        return this.asyncQueue.enqueue(function () {\n            return _this.remoteStore.enableNetwork();\n        });\n    };\n    /**\n     * Initializes persistent storage, attempting to use IndexedDB if\n     * usePersistence is true or memory-only if false.\n     *\n     * If IndexedDB fails because it's already open in another tab or because the\n     * platform can't possibly support our implementation then this method rejects\n     * the persistenceResult and falls back on memory-only persistence.\n     *\n     * @param usePersistence indicates whether or not to use offline persistence\n     * @param persistenceResult A deferred result indicating the user-visible\n     *     result of enabling offline persistence. This method will reject this if\n     *     IndexedDB fails to start for any reason. If usePersistence is false\n     *     this is unconditionally resolved.\n     * @returns a Promise indicating whether or not initialization should\n     *     continue, i.e. that one of the persistence implementations actually\n     *     succeeded.\n     */\n    FirestoreClient.prototype.initializePersistence = function (usePersistence, persistenceResult) {\n        var _this = this;\n        if (usePersistence) {\n            return this.startIndexedDbPersistence()\n                .then(persistenceResult.resolve)\n                .catch(function (error) {\n                // Regardless of whether or not the retry succeeds, from an user\n                // perspective, offline persistence has failed.\n                persistenceResult.reject(error);\n                // An unknown failure on the first stage shuts everything down.\n                if (!_this.canFallback(error)) {\n                    return Promise.reject(error);\n                }\n                console.warn('Error enabling offline storage. Falling back to' +\n                    ' storage disabled: ' +\n                    error);\n                return _this.startMemoryPersistence();\n            });\n        }\n        else {\n            // When usePersistence == false, enabling offline persistence is defined\n            // to unconditionally succeed. This allows start() to have the same\n            // signature for both cases, despite the fact that the returned promise\n            // is only used in the enablePersistence call.\n            persistenceResult.resolve();\n            return this.startMemoryPersistence();\n        }\n    };\n    FirestoreClient.prototype.canFallback = function (error) {\n        return (error.code === Code.FAILED_PRECONDITION ||\n            error.code === Code.UNIMPLEMENTED);\n    };\n    /**\n     * Starts IndexedDB-based persistence.\n     *\n     * @returns A promise indicating success or failure.\n     */\n    FirestoreClient.prototype.startIndexedDbPersistence = function () {\n        // TODO(http://b/33384523): For now we just disable garbage collection\n        // when persistence is enabled.\n        this.garbageCollector = new no_op_garbage_collector_NoOpGarbageCollector();\n        var storagePrefix = indexeddb_persistence_IndexedDbPersistence.buildStoragePrefix(this.databaseInfo);\n        // Opt to use proto3 JSON in case the platform doesn't support Uint8Array.\n        var serializer = new serializer_JsonProtoSerializer(this.databaseInfo.databaseId, {\n            useProto3Json: true\n        });\n        this.persistence = new indexeddb_persistence_IndexedDbPersistence(storagePrefix, serializer);\n        return this.persistence.start();\n    };\n    /**\n     * Starts Memory-backed persistence. In practice this cannot fail.\n     *\n     * @returns A promise that will successfully resolve.\n     */\n    FirestoreClient.prototype.startMemoryPersistence = function () {\n        this.garbageCollector = new eager_garbage_collector_EagerGarbageCollector();\n        this.persistence = new memory_persistence_MemoryPersistence();\n        return this.persistence.start();\n    };\n    /**\n     * Initializes the rest of the FirestoreClient, assuming the initial user\n     * has been obtained from the credential provider and some persistence\n     * implementation is available in this.persistence.\n     */\n    FirestoreClient.prototype.initializeRest = function (user) {\n        var _this = this;\n        return this.platform\n            .loadConnection(this.databaseInfo)\n            .then(function (connection) {\n            _this.localStore = new local_store_LocalStore(_this.persistence, user, _this.garbageCollector);\n            var serializer = _this.platform.newSerializer(_this.databaseInfo.databaseId);\n            var datastore = new datastore_Datastore(_this.asyncQueue, connection, _this.credentials, serializer);\n            var onlineStateChangedHandler = function (onlineState) {\n                _this.syncEngine.applyOnlineStateChange(onlineState);\n                _this.eventMgr.applyOnlineStateChange(onlineState);\n            };\n            _this.remoteStore = new remote_store_RemoteStore(_this.localStore, datastore, onlineStateChangedHandler);\n            _this.syncEngine = new sync_engine_SyncEngine(_this.localStore, _this.remoteStore, user);\n            // Setup wiring between sync engine and remote store\n            _this.remoteStore.syncEngine = _this.syncEngine;\n            _this.eventMgr = new event_manager_EventManager(_this.syncEngine);\n            // NOTE: RemoteStore depends on LocalStore (for persisting stream\n            // tokens, refilling mutation queue, etc.) so must be started after\n            // LocalStore.\n            return _this.localStore.start();\n        })\n            .then(function () {\n            return _this.remoteStore.start();\n        });\n    };\n    FirestoreClient.prototype.handleUserChange = function (user) {\n        this.asyncQueue.verifyOperationInProgress();\n        debug(firestore_client_LOG_TAG, 'User Changed: ' + user.uid);\n        return this.syncEngine.handleUserChange(user);\n    };\n    /** Disables the network connection. Pending operations will not complete. */\n    FirestoreClient.prototype.disableNetwork = function () {\n        var _this = this;\n        return this.asyncQueue.enqueue(function () {\n            return _this.remoteStore.disableNetwork();\n        });\n    };\n    FirestoreClient.prototype.shutdown = function () {\n        var _this = this;\n        return this.asyncQueue\n            .enqueue(function () {\n            _this.credentials.removeUserChangeListener();\n            return _this.remoteStore.shutdown();\n        })\n            .then(function () {\n            // PORTING NOTE: LocalStore does not need an explicit shutdown on web.\n            return _this.persistence.shutdown();\n        });\n    };\n    FirestoreClient.prototype.listen = function (query, observer, options) {\n        var _this = this;\n        var listener = new event_manager_QueryListener(query, observer, options);\n        this.asyncQueue.enqueue(function () {\n            return _this.eventMgr.listen(listener);\n        });\n        return listener;\n    };\n    FirestoreClient.prototype.unlisten = function (listener) {\n        var _this = this;\n        this.asyncQueue.enqueue(function () {\n            return _this.eventMgr.unlisten(listener);\n        });\n    };\n    FirestoreClient.prototype.write = function (mutations) {\n        var _this = this;\n        var deferred = new Deferred();\n        this.asyncQueue.enqueue(function () { return _this.syncEngine.write(mutations, deferred); });\n        return deferred.promise;\n    };\n    FirestoreClient.prototype.databaseId = function () {\n        return this.databaseInfo.databaseId;\n    };\n    FirestoreClient.prototype.transaction = function (updateFunction) {\n        var _this = this;\n        // We have to wait for the async queue to be sure syncEngine is initialized.\n        return this.asyncQueue\n            .enqueue(function () {\n            return Promise.resolve();\n        })\n            .then(function () {\n            return _this.syncEngine.runTransaction(updateFunction);\n        });\n    };\n    return FirestoreClient;\n}());\n\n\n//# sourceMappingURL=firestore_client.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/util/async_observer.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/*\n * A wrapper implementation of Observer<T> that will dispatch events\n * asynchronously. To allow immediate silencing, a mute call is added which\n * causes events scheduled to no longer be raised.\n */\nvar AsyncObserver = /** @class */ (function () {\n    function AsyncObserver(observer) {\n        this.observer = observer;\n        /**\n         * When set to true, will not raise future events. Necessary to deal with\n         * async detachment of listener.\n         */\n        this.muted = false;\n    }\n    AsyncObserver.prototype.next = function (value) {\n        this.scheduleEvent(this.observer.next, value);\n    };\n    AsyncObserver.prototype.error = function (error) {\n        this.scheduleEvent(this.observer.error, error);\n    };\n    AsyncObserver.prototype.mute = function () {\n        this.muted = true;\n    };\n    AsyncObserver.prototype.scheduleEvent = function (eventHandler, event) {\n        var _this = this;\n        if (!this.muted) {\n            setTimeout(function () {\n                if (!_this.muted) {\n                    eventHandler(event);\n                }\n            }, 0);\n        }\n    };\n    return AsyncObserver;\n}());\n\n\n//# sourceMappingURL=async_observer.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/auth/user.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Simple wrapper around a nullable UID. Mostly exists to make code more\n * readable.\n */\nvar User = /** @class */ (function () {\n    function User(uid) {\n        this.uid = uid;\n    }\n    User.prototype.isAuthenticated = function () {\n        return this.uid != null;\n    };\n    /**\n     * Returns a key representing this user, suitable for inclusion in a\n     * dictionary.\n     */\n    User.prototype.toKey = function () {\n        if (this.isAuthenticated()) {\n            return 'uid:' + this.uid;\n        }\n        else {\n            return 'anonymous-user';\n        }\n    };\n    User.prototype.isEqual = function (otherUser) {\n        return otherUser.uid === this.uid;\n    };\n    /** A user with a null UID. */\n    User.UNAUTHENTICATED = new User(null);\n    // TODO(mikelehen): Look into getting a proper uid-equivalent for\n    // non-FirebaseAuth providers.\n    User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');\n    User.FIRST_PARTY = new User('first-party-uid');\n    return User;\n}());\n\n\n//# sourceMappingURL=user.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/credentials.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\nvar OAuthToken = /** @class */ (function () {\n    function OAuthToken(value, user) {\n        this.user = user;\n        this.type = 'OAuth';\n        this.authHeaders = { Authorization: \"Bearer \" + value };\n    }\n    return OAuthToken;\n}());\n\n/** A CredentialsProvider that always yields an empty token. */\nvar credentials_EmptyCredentialsProvider = /** @class */ (function () {\n    function EmptyCredentialsProvider() {\n        /**\n         * Stores the User listener registered with setUserChangeListener()\n         * This isn't actually necessary since the UID never changes, but we use this\n         * to verify the listen contract is adhered to in tests.\n         */\n        this.userListener = null;\n    }\n    EmptyCredentialsProvider.prototype.getToken = function (forceRefresh) {\n        return Promise.resolve(null);\n    };\n    EmptyCredentialsProvider.prototype.setUserChangeListener = function (listener) {\n        assert(!this.userListener, 'Can only call setUserChangeListener() once.');\n        this.userListener = listener;\n        // Fire with initial user.\n        listener(User.UNAUTHENTICATED);\n    };\n    EmptyCredentialsProvider.prototype.removeUserChangeListener = function () {\n        assert(this.userListener !== null, 'removeUserChangeListener() when no listener registered');\n        this.userListener = null;\n    };\n    return EmptyCredentialsProvider;\n}());\n\nvar credentials_FirebaseCredentialsProvider = /** @class */ (function () {\n    function FirebaseCredentialsProvider(app) {\n        var _this = this;\n        this.app = app;\n        /**\n         * The auth token listener registered with FirebaseApp, retained here so we\n         * can unregister it.\n         */\n        this.tokenListener = null;\n        /**\n         * Counter used to detect if the user changed while a getToken request was\n         * outstanding.\n         */\n        this.userCounter = 0;\n        /** The User listener registered with setUserChangeListener(). */\n        this.userListener = null;\n        // We listen for token changes but all we really care about is knowing when\n        // the uid may have changed.\n        this.tokenListener = function () {\n            var newUser = _this.getUser();\n            if (!_this.currentUser || !newUser.isEqual(_this.currentUser)) {\n                _this.currentUser = newUser;\n                _this.userCounter++;\n                if (_this.userListener) {\n                    _this.userListener(_this.currentUser);\n                }\n            }\n        };\n        this.userCounter = 0;\n        // Will fire at least once where we set this.currentUser\n        this.app.INTERNAL.addAuthTokenListener(this.tokenListener);\n    }\n    FirebaseCredentialsProvider.prototype.getToken = function (forceRefresh) {\n        var _this = this;\n        assert(this.tokenListener != null, 'getToken cannot be called after listener removed.');\n        // Take note of the current value of the userCounter so that this method can\n        // fail (with an ABORTED error) if there is a user change while the request\n        // is outstanding.\n        var initialUserCounter = this.userCounter;\n        return this.app.INTERNAL.getToken(forceRefresh).then(function (tokenData) {\n            // Cancel the request since the user changed while the request was\n            // outstanding so the response is likely for a previous user (which\n            // user, we can't be sure).\n            if (_this.userCounter !== initialUserCounter) {\n                throw new FirestoreError(Code.ABORTED, 'getToken aborted due to uid change.');\n            }\n            else {\n                if (tokenData) {\n                    assert(typeof tokenData.accessToken === 'string', 'Invalid tokenData returned from getToken():' + tokenData);\n                    return new OAuthToken(tokenData.accessToken, _this.currentUser);\n                }\n                else {\n                    return null;\n                }\n            }\n        });\n    };\n    FirebaseCredentialsProvider.prototype.setUserChangeListener = function (listener) {\n        assert(!this.userListener, 'Can only call setUserChangeListener() once.');\n        this.userListener = listener;\n        // Fire the initial event, but only if we received the initial user\n        if (this.currentUser) {\n            listener(this.currentUser);\n        }\n    };\n    FirebaseCredentialsProvider.prototype.removeUserChangeListener = function () {\n        assert(this.tokenListener != null, 'removeUserChangeListener() called twice');\n        assert(this.userListener !== null, 'removeUserChangeListener() called when no listener registered');\n        this.app.INTERNAL.removeAuthTokenListener(this.tokenListener);\n        this.tokenListener = null;\n        this.userListener = null;\n    };\n    FirebaseCredentialsProvider.prototype.getUser = function () {\n        // TODO(mikelehen): Remove this check once we're shipping with firebase.js.\n        if (typeof this.app.INTERNAL.getUid !== 'function') {\n            fail('This version of the Firestore SDK requires at least version' +\n                ' 3.7.0 of firebase.js.');\n        }\n        var currentUid = this.app.INTERNAL.getUid();\n        assert(currentUid === null || typeof currentUid === 'string', 'Received invalid UID: ' + currentUid);\n        return new User(currentUid);\n    };\n    return FirebaseCredentialsProvider;\n}());\n\n/*\n * FirstPartyToken provides a fresh token each time its value\n * is requested, because if the token is too old, requests will be rejected.\n * TODO(b/33147818) this implementation violates the current assumption that\n * tokens are immutable.  We need to either revisit this assumption or come\n * up with some way for FPA to use the listen/unlisten interface.\n */\nvar credentials_FirstPartyToken = /** @class */ (function () {\n    function FirstPartyToken(gapi, sessionIndex) {\n        this.gapi = gapi;\n        this.sessionIndex = sessionIndex;\n        this.type = 'FirstParty';\n        this.user = User.FIRST_PARTY;\n        assert(this.gapi &&\n            this.gapi['auth'] &&\n            this.gapi['auth']['getAuthHeaderValueForFirstParty'], 'unexpected gapi interface');\n    }\n    Object.defineProperty(FirstPartyToken.prototype, \"authHeaders\", {\n        get: function () {\n            return {\n                Authorization: this.gapi['auth']['getAuthHeaderValueForFirstParty']([]),\n                'X-Goog-AuthUser': this.sessionIndex\n            };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return FirstPartyToken;\n}());\n\n/*\n * Provides user credentials required for the Firestore JavaScript SDK\n * to authenticate the user, using technique that is only available\n * to applications hosted by Google.\n */\nvar credentials_FirstPartyCredentialsProvider = /** @class */ (function () {\n    function FirstPartyCredentialsProvider(gapi, sessionIndex) {\n        this.gapi = gapi;\n        this.sessionIndex = sessionIndex;\n        assert(this.gapi &&\n            this.gapi['auth'] &&\n            this.gapi['auth']['getAuthHeaderValueForFirstParty'], 'unexpected gapi interface');\n    }\n    FirstPartyCredentialsProvider.prototype.getToken = function (forceRefresh) {\n        return Promise.resolve(new credentials_FirstPartyToken(this.gapi, this.sessionIndex));\n    };\n    // TODO(33108925): can someone switch users w/o a page refresh?\n    // TODO(33110621): need to understand token/session lifecycle\n    FirstPartyCredentialsProvider.prototype.setUserChangeListener = function (listener) {\n        // Fire with initial uid.\n        listener(User.FIRST_PARTY);\n    };\n    FirstPartyCredentialsProvider.prototype.removeUserChangeListener = function () { };\n    return FirstPartyCredentialsProvider;\n}());\n\n/**\n * Builds a CredentialsProvider depending on the type of\n * the credentials passed in.\n */\nfunction makeCredentialsProvider(credentials) {\n    if (!credentials) {\n        return new credentials_EmptyCredentialsProvider();\n    }\n    switch (credentials.type) {\n        case 'gapi':\n            return new credentials_FirstPartyCredentialsProvider(credentials.client, credentials.sessionIndex || '0');\n        case 'provider':\n            return credentials.client;\n        default:\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'makeCredentialsProvider failed due to invalid credential type');\n    }\n}\n\n//# sourceMappingURL=credentials.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/observer.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nfunction isPartialObserver(obj) {\n    return implementsAnyMethods(obj, ['next', 'error', 'complete']);\n}\n/**\n * Returns true if obj is an object and contains at least one of the specified\n * methods.\n */\nfunction implementsAnyMethods(obj, methods) {\n    if (typeof obj !== 'object' || obj === null) {\n        return false;\n    }\n    var object = obj;\n    for (var _i = 0, methods_1 = methods; _i < methods_1.length; _i++) {\n        var method = methods_1[_i];\n        if (method in object && typeof object[method] === 'function') {\n            return true;\n        }\n    }\n    return false;\n}\n\n//# sourceMappingURL=observer.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/field_value.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar api_field_value___extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n/**\n * An opaque base class for FieldValue sentinel objects in our public API,\n * with public static methods for creating said sentinel objects.\n */\n// tslint:disable-next-line:class-as-namespace  We use this as a base class.\nvar FieldValueImpl = /** @class */ (function () {\n    function FieldValueImpl() {\n    }\n    FieldValueImpl.delete = function () {\n        return DeleteFieldValueImpl.instance;\n    };\n    FieldValueImpl.serverTimestamp = function () {\n        return ServerTimestampFieldValueImpl.instance;\n    };\n    FieldValueImpl.prototype.isEqual = function (other) {\n        return this === other;\n    };\n    return FieldValueImpl;\n}());\n\nvar DeleteFieldValueImpl = /** @class */ (function (_super) {\n    api_field_value___extends(DeleteFieldValueImpl, _super);\n    function DeleteFieldValueImpl() {\n        return _super.call(this) || this;\n    }\n    /** Singleton instance. */\n    DeleteFieldValueImpl.instance = new DeleteFieldValueImpl();\n    return DeleteFieldValueImpl;\n}(FieldValueImpl));\n\nvar ServerTimestampFieldValueImpl = /** @class */ (function (_super) {\n    api_field_value___extends(ServerTimestampFieldValueImpl, _super);\n    function ServerTimestampFieldValueImpl() {\n        return _super.call(this) || this;\n    }\n    /** Singleton instance. */\n    ServerTimestampFieldValueImpl.instance = new ServerTimestampFieldValueImpl();\n    return ServerTimestampFieldValueImpl;\n}(FieldValueImpl));\n\n// Public instance that disallows construction at runtime. This constructor is\n// used when exporting FieldValueImpl on firebase.firestore.FieldValue and will\n// be called FieldValue publicly. Internally we still use FieldValueImpl which\n// has a type-checked private constructor. Note that FieldValueImpl and\n// PublicFieldValue can be used interchangeably in instanceof checks.\n// For our internal TypeScript code PublicFieldValue doesn't exist as a type,\n// and so we need to use FieldValueImpl as type and export it too.\n// tslint:disable-next-line:variable-name  We treat this as a class name.\nvar PublicFieldValue = makeConstructorPrivate(FieldValueImpl, 'Use FieldValue.<field>() instead.');\n\n//# sourceMappingURL=field_value.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/user_data_converter.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nvar RESERVED_FIELD_REGEX = /^__.*__$/;\n/** The result of parsing document data (e.g. for a setData call). */\nvar user_data_converter_ParsedSetData = /** @class */ (function () {\n    function ParsedSetData(data, fieldMask, fieldTransforms) {\n        this.data = data;\n        this.fieldMask = fieldMask;\n        this.fieldTransforms = fieldTransforms;\n    }\n    ParsedSetData.prototype.toMutations = function (key, precondition) {\n        var mutations = [];\n        if (this.fieldMask !== null) {\n            mutations.push(new mutation_PatchMutation(key, this.data, this.fieldMask, precondition));\n        }\n        else {\n            mutations.push(new mutation_SetMutation(key, this.data, precondition));\n        }\n        if (this.fieldTransforms.length > 0) {\n            mutations.push(new mutation_TransformMutation(key, this.fieldTransforms));\n        }\n        return mutations;\n    };\n    return ParsedSetData;\n}());\n\n/** The result of parsing \"update\" data (i.e. for an updateData call). */\nvar user_data_converter_ParsedUpdateData = /** @class */ (function () {\n    function ParsedUpdateData(data, fieldMask, fieldTransforms) {\n        this.data = data;\n        this.fieldMask = fieldMask;\n        this.fieldTransforms = fieldTransforms;\n    }\n    ParsedUpdateData.prototype.toMutations = function (key, precondition) {\n        var mutations = [\n            new mutation_PatchMutation(key, this.data, this.fieldMask, precondition)\n        ];\n        if (this.fieldTransforms.length > 0) {\n            mutations.push(new mutation_TransformMutation(key, this.fieldTransforms));\n        }\n        return mutations;\n    };\n    return ParsedUpdateData;\n}());\n\n/*\n * Represents what type of API method provided the data being parsed; useful\n * for determining which error conditions apply during parsing and providing\n * better error messages.\n */\nvar UserDataSource;\n(function (UserDataSource) {\n    UserDataSource[UserDataSource[\"Set\"] = 0] = \"Set\";\n    UserDataSource[UserDataSource[\"Update\"] = 1] = \"Update\";\n    UserDataSource[UserDataSource[\"MergeSet\"] = 2] = \"MergeSet\";\n    UserDataSource[UserDataSource[\"QueryValue\"] = 3] = \"QueryValue\"; // from a where clause or cursor bound\n})(UserDataSource || (UserDataSource = {}));\nfunction isWrite(dataSource) {\n    switch (dataSource) {\n        case UserDataSource.Set: // fall through\n        case UserDataSource.MergeSet: // fall through\n        case UserDataSource.Update:\n            return true;\n        case UserDataSource.QueryValue:\n            return false;\n        default:\n            throw fail(\"Unexpected case for UserDataSource: \" + dataSource);\n    }\n}\n/** A \"context\" object passed around while parsing user data. */\nvar user_data_converter_ParseContext = /** @class */ (function () {\n    /**\n     * Initializes a ParseContext with the given source and path.\n     *\n     * @param dataSource Indicates what kind of API method this data came from.\n     * @param methodName The name of the method the user called to create this\n     *     ParseContext.\n     * @param path A path within the object being parsed. This could be an empty\n     *     path (in which case the context represents the root of the data being\n     *     parsed), or a nonempty path (indicating the context represents a nested\n     *     location within the data).\n     * @param arrayElement Whether or not this context corresponds to an element\n     *     of an array.\n     * @param fieldTransforms A mutable list of field transforms encountered while\n     *     parsing the data.\n     * @param fieldMask A mutable list of field paths encountered while parsing\n     *     the data.\n     *\n     * TODO(b/34871131): We don't support array paths right now, so path can be\n     * null to indicate the context represents any location within an array (in\n     * which case certain features will not work and errors will be somewhat\n     * compromised).\n     */\n    function ParseContext(dataSource, methodName, path, arrayElement, fieldTransforms, fieldMask) {\n        this.dataSource = dataSource;\n        this.methodName = methodName;\n        this.path = path;\n        this.arrayElement = arrayElement;\n        // Minor hack: If fieldTransforms is undefined, we assume this is an\n        // external call and we need to validate the entire path.\n        if (fieldTransforms === undefined) {\n            this.validatePath();\n        }\n        this.arrayElement = arrayElement !== undefined ? arrayElement : false;\n        this.fieldTransforms = fieldTransforms || [];\n        this.fieldMask = fieldMask || [];\n    }\n    ParseContext.prototype.childContextForField = function (field) {\n        var childPath = this.path == null ? null : this.path.child(field);\n        var context = new ParseContext(this.dataSource, this.methodName, childPath, \n        /*arrayElement=*/ false, this.fieldTransforms, this.fieldMask);\n        context.validatePathSegment(field);\n        return context;\n    };\n    ParseContext.prototype.childContextForFieldPath = function (field) {\n        var childPath = this.path == null ? null : this.path.child(field);\n        var context = new ParseContext(this.dataSource, this.methodName, childPath, \n        /*arrayElement=*/ false, this.fieldTransforms, this.fieldMask);\n        context.validatePath();\n        return context;\n    };\n    ParseContext.prototype.childContextForArray = function (index) {\n        // TODO(b/34871131): We don't support array paths right now; so make path\n        // null.\n        return new ParseContext(this.dataSource, this.methodName, \n        /*path=*/ null, \n        /*arrayElement=*/ true, this.fieldTransforms, this.fieldMask);\n    };\n    ParseContext.prototype.createError = function (reason) {\n        var fieldDescription = this.path === null || this.path.isEmpty()\n            ? ''\n            : \" (found in field \" + this.path.toString() + \")\";\n        return new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + this.methodName + \"() called with invalid data. \" +\n            reason +\n            fieldDescription);\n    };\n    ParseContext.prototype.validatePath = function () {\n        // TODO(b/34871131): Remove null check once we have proper paths for fields\n        // within arrays.\n        if (this.path === null) {\n            return;\n        }\n        for (var i = 0; i < this.path.length; i++) {\n            this.validatePathSegment(this.path.get(i));\n        }\n    };\n    ParseContext.prototype.validatePathSegment = function (segment) {\n        if (isWrite(this.dataSource) && RESERVED_FIELD_REGEX.test(segment)) {\n            throw this.createError('Document fields cannot begin and end with __');\n        }\n    };\n    return ParseContext;\n}());\n/**\n * A placeholder object for DocumentReferences in this file, in order to\n * avoid a circular dependency. See the comments for `DataPreConverter` for\n * the full context.\n */\nvar DocumentKeyReference = /** @class */ (function () {\n    function DocumentKeyReference(databaseId, key) {\n        this.databaseId = databaseId;\n        this.key = key;\n    }\n    return DocumentKeyReference;\n}());\n\n/**\n * Helper for parsing raw user input (provided via the API) into internal model\n * classes.\n */\nvar user_data_converter_UserDataConverter = /** @class */ (function () {\n    function UserDataConverter(preConverter) {\n        this.preConverter = preConverter;\n    }\n    /** Parse document data from a non-merge set() call. */\n    UserDataConverter.prototype.parseSetData = function (methodName, input) {\n        var context = new user_data_converter_ParseContext(UserDataSource.Set, methodName, path_FieldPath.EMPTY_PATH);\n        validatePlainObject('Data must be an object, but it was:', context, input);\n        var updateData = this.parseData(input, context);\n        return new user_data_converter_ParsedSetData(updateData, \n        /* fieldMask= */ null, context.fieldTransforms);\n    };\n    /** Parse document data from a set() call with '{merge:true}'. */\n    UserDataConverter.prototype.parseMergeData = function (methodName, input) {\n        var context = new user_data_converter_ParseContext(UserDataSource.MergeSet, methodName, path_FieldPath.EMPTY_PATH);\n        validatePlainObject('Data must be an object, but it was:', context, input);\n        var updateData = this.parseData(input, context);\n        var fieldMask = new mutation_FieldMask(context.fieldMask);\n        return new user_data_converter_ParsedSetData(updateData, fieldMask, context.fieldTransforms);\n    };\n    /** Parse update data from an update() call. */\n    UserDataConverter.prototype.parseUpdateData = function (methodName, input) {\n        var _this = this;\n        var context = new user_data_converter_ParseContext(UserDataSource.Update, methodName, path_FieldPath.EMPTY_PATH);\n        validatePlainObject('Data must be an object, but it was:', context, input);\n        var fieldMaskPaths = [];\n        var updateData = field_value_ObjectValue.EMPTY;\n        forEach(input, function (key, value) {\n            var path = fieldPathFromDotSeparatedString(methodName, key);\n            var childContext = context.childContextForFieldPath(path);\n            value = _this.runPreConverter(value, childContext);\n            if (value instanceof DeleteFieldValueImpl) {\n                // Add it to the field mask, but don't add anything to updateData.\n                fieldMaskPaths.push(path);\n            }\n            else {\n                var parsedValue = _this.parseData(value, childContext);\n                if (parsedValue != null) {\n                    fieldMaskPaths.push(path);\n                    updateData = updateData.set(path, parsedValue);\n                }\n            }\n        });\n        var mask = new mutation_FieldMask(fieldMaskPaths);\n        return new user_data_converter_ParsedUpdateData(updateData, mask, context.fieldTransforms);\n    };\n    /** Parse update data from a list of field/value arguments. */\n    UserDataConverter.prototype.parseUpdateVarargs = function (methodName, field, value, moreFieldsAndValues) {\n        var context = new user_data_converter_ParseContext(UserDataSource.Update, methodName, path_FieldPath.EMPTY_PATH);\n        var keys = [fieldPathFromArgument(methodName, field)];\n        var values = [value];\n        if (moreFieldsAndValues.length % 2 !== 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + methodName + \"() needs to be called with an even number \" +\n                'of arguments that alternate between field names and values.');\n        }\n        for (var i = 0; i < moreFieldsAndValues.length; i += 2) {\n            keys.push(fieldPathFromArgument(methodName, moreFieldsAndValues[i]));\n            values.push(moreFieldsAndValues[i + 1]);\n        }\n        var fieldMaskPaths = [];\n        var updateData = field_value_ObjectValue.EMPTY;\n        for (var i = 0; i < keys.length; ++i) {\n            var path = keys[i];\n            var childContext = context.childContextForFieldPath(path);\n            var value_1 = this.runPreConverter(values[i], childContext);\n            if (value_1 instanceof DeleteFieldValueImpl) {\n                // Add it to the field mask, but don't add anything to updateData.\n                fieldMaskPaths.push(path);\n            }\n            else {\n                var parsedValue = this.parseData(value_1, childContext);\n                if (parsedValue != null) {\n                    fieldMaskPaths.push(path);\n                    updateData = updateData.set(path, parsedValue);\n                }\n            }\n        }\n        var mask = new mutation_FieldMask(fieldMaskPaths);\n        return new user_data_converter_ParsedUpdateData(updateData, mask, context.fieldTransforms);\n    };\n    /**\n     * Parse a \"query value\" (e.g. value in a where filter or a value in a cursor\n     * bound).\n     */\n    UserDataConverter.prototype.parseQueryValue = function (methodName, input) {\n        var context = new user_data_converter_ParseContext(UserDataSource.QueryValue, methodName, path_FieldPath.EMPTY_PATH);\n        var parsed = this.parseData(input, context);\n        assert(parsed != null, 'Parsed data should not be null.');\n        assert(context.fieldTransforms.length === 0, 'Field transforms should have been disallowed.');\n        return parsed;\n    };\n    /** Sends data through this.preConverter, handling any thrown errors. */\n    UserDataConverter.prototype.runPreConverter = function (input, context) {\n        try {\n            return this.preConverter(input);\n        }\n        catch (e) {\n            var message = errorMessage(e);\n            throw context.createError(message);\n        }\n    };\n    /**\n     * Internal helper for parsing user data.\n     *\n     * @param input Data to be parsed.\n     * @param context A context object representing the current path being parsed,\n     * the source of the data being parsed, etc.\n     * @return The parsed value, or null if the value was a FieldValue sentinel\n     * that should not be included in the resulting parsed data.\n     */\n    UserDataConverter.prototype.parseData = function (input, context) {\n        input = this.runPreConverter(input, context);\n        if (input instanceof Array) {\n            // TODO(b/34871131): Include the path containing the array in the error\n            // message.\n            if (context.arrayElement) {\n                throw context.createError('Nested arrays are not supported');\n            }\n            // If context.path is null we are already inside an array and we don't\n            // support field mask paths more granular than the top-level array.\n            if (context.path) {\n                context.fieldMask.push(context.path);\n            }\n            return this.parseArray(input, context);\n        }\n        else if (looksLikeJsonObject(input)) {\n            validatePlainObject('Unsupported field value:', context, input);\n            return this.parseObject(input, context);\n        }\n        else {\n            // If context.path is null, we are inside an array and we should have\n            // already added the root of the array to the field mask.\n            if (context.path) {\n                context.fieldMask.push(context.path);\n            }\n            return this.parseScalarValue(input, context);\n        }\n    };\n    UserDataConverter.prototype.parseArray = function (array, context) {\n        var result = [];\n        var entryIndex = 0;\n        for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {\n            var entry = array_1[_i];\n            var parsedEntry = this.parseData(entry, context.childContextForArray(entryIndex));\n            if (parsedEntry == null) {\n                // Just include nulls in the array for fields being replaced with a\n                // sentinel.\n                parsedEntry = NullValue.INSTANCE;\n            }\n            result.push(parsedEntry);\n            entryIndex++;\n        }\n        return new field_value_ArrayValue(result);\n    };\n    UserDataConverter.prototype.parseObject = function (obj, context) {\n        var _this = this;\n        var result = new SortedMap(primitiveComparator);\n        forEach(obj, function (key, val) {\n            var parsedValue = _this.parseData(val, context.childContextForField(key));\n            if (parsedValue != null) {\n                result = result.insert(key, parsedValue);\n            }\n        });\n        return new field_value_ObjectValue(result);\n    };\n    /**\n     * Helper to parse a scalar value (i.e. not an Object or Array)\n     *\n     * @return The parsed value, or null if the value was a FieldValue sentinel\n     * that should not be included in the resulting parsed data.\n     */\n    UserDataConverter.prototype.parseScalarValue = function (value, context) {\n        if (value === null) {\n            return NullValue.INSTANCE;\n        }\n        else if (typeof value === 'number') {\n            if (isSafeInteger(value)) {\n                return new IntegerValue(value);\n            }\n            else {\n                return new DoubleValue(value);\n            }\n        }\n        else if (typeof value === 'boolean') {\n            return field_value_BooleanValue.of(value);\n        }\n        else if (typeof value === 'string') {\n            return new field_value_StringValue(value);\n        }\n        else if (value instanceof Date) {\n            return new TimestampValue(timestamp_Timestamp.fromDate(value));\n        }\n        else if (value instanceof geo_point_GeoPoint) {\n            return new GeoPointValue(value);\n        }\n        else if (value instanceof blob_Blob) {\n            return new BlobValue(value);\n        }\n        else if (value instanceof DocumentKeyReference) {\n            return new field_value_RefValue(value.databaseId, value.key);\n        }\n        else if (value instanceof FieldValueImpl) {\n            if (value instanceof DeleteFieldValueImpl) {\n                if (context.dataSource === UserDataSource.MergeSet) {\n                    return null;\n                }\n                else if (context.dataSource === UserDataSource.Update) {\n                    assert(context.path == null || context.path.length > 0, 'FieldValue.delete() at the top level should have already' +\n                        ' been handled.');\n                    throw context.createError('FieldValue.delete() can only appear at the top level ' +\n                        'of your update data');\n                }\n                else {\n                    // We shouldn't encounter delete sentinels for queries or non-merge set() calls.\n                    throw context.createError('FieldValue.delete() can only be used with update() and set() with {merge:true}');\n                }\n            }\n            else if (value instanceof ServerTimestampFieldValueImpl) {\n                if (!isWrite(context.dataSource)) {\n                    throw context.createError('FieldValue.serverTimestamp() can only be used with set()' +\n                        ' and update()');\n                }\n                if (context.path === null) {\n                    throw context.createError('FieldValue.serverTimestamp() is not currently' +\n                        ' supported inside arrays');\n                }\n                context.fieldTransforms.push(new FieldTransform(context.path, ServerTimestampTransform.instance));\n                // Return null so this value is omitted from the parsed result.\n                return null;\n            }\n            else {\n                return fail('Unknown FieldValue type: ' + value);\n            }\n        }\n        else {\n            throw context.createError(\"Unsupported field value: \" + valueDescription(value));\n        }\n    };\n    return UserDataConverter;\n}());\n\n/**\n * Checks whether an object looks like a JSON object that should be converted\n * into a struct. Normal class/prototype instances are considered to look like\n * JSON objects since they should be converted to a struct value. Arrays, Dates,\n * GeoPoints, etc. are not considered to look like JSON objects since they map\n * to specific FieldValue types other than ObjectValue.\n */\nfunction looksLikeJsonObject(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        !(input instanceof Array) &&\n        !(input instanceof Date) &&\n        !(input instanceof geo_point_GeoPoint) &&\n        !(input instanceof blob_Blob) &&\n        !(input instanceof DocumentKeyReference) &&\n        !(input instanceof FieldValueImpl));\n}\nfunction validatePlainObject(message, context, input) {\n    if (!looksLikeJsonObject(input) || !isPlainObject(input)) {\n        var description = valueDescription(input);\n        if (description === 'an object') {\n            // Massage the error if it was an object.\n            throw context.createError(message + ' a custom object');\n        }\n        else {\n            throw context.createError(message + ' ' + description);\n        }\n    }\n}\n/**\n * Helper that calls fromDotSeparatedString() but wraps any error thrown.\n */\nfunction fieldPathFromArgument(methodName, path) {\n    if (path instanceof field_path_FieldPath) {\n        return path._internalPath;\n    }\n    else if (typeof path === 'string') {\n        return fieldPathFromDotSeparatedString(methodName, path);\n    }\n    else {\n        var message = 'Field path arguments must be of type string or FieldPath.';\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + methodName + \"() called with invalid data. \" + message);\n    }\n}\n/**\n * Wraps fromDotSeparatedString with an error message about the method that\n * was thrown.\n * @param methodName The publicly visible method name\n * @param path The dot-separated string form of a field path which will be split\n * on dots.\n */\nfunction fieldPathFromDotSeparatedString(methodName, path) {\n    try {\n        return fromDotSeparatedString(path)._internalPath;\n    }\n    catch (e) {\n        var message = errorMessage(e);\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + methodName + \"() called with invalid data. \" + message);\n    }\n}\n/**\n * Extracts the message from a caught exception, which should be an Error object\n * though JS doesn't guarantee that.\n */\nfunction errorMessage(error) {\n    return error instanceof Error ? error.message : error.toString();\n}\n\n//# sourceMappingURL=user_data_converter.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/api/database.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar database___extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n// The objects that are a part of this API are exposed to third-parties as\n// compiled javascript so we want to flag our private members with a leading\n// underscore to discourage their use.\n// tslint:disable:strip-private-property-underscore\nvar DEFAULT_HOST = 'firestore.googleapis.com';\nvar DEFAULT_SSL = true;\n/**\n * A concrete type describing all the values that can be applied via a\n * user-supplied firestore.Settings object. This is a separate type so that\n * defaults can be supplied and the value can be checked for equality.\n */\nvar database_FirestoreSettings = /** @class */ (function () {\n    function FirestoreSettings(settings) {\n        if (settings.host === undefined) {\n            if (settings.ssl !== undefined) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Can't provide ssl option if host option is not set\");\n            }\n            this.host = DEFAULT_HOST;\n            this.ssl = DEFAULT_SSL;\n        }\n        else {\n            validateNamedType('settings', 'string', 'host', settings.host);\n            this.host = settings.host;\n            validateNamedOptionalType('settings', 'boolean', 'ssl', settings.ssl);\n            this.ssl = defaulted(settings.ssl, DEFAULT_SSL);\n        }\n        validateOptionNames('settings', settings, ['host', 'ssl', 'credentials']);\n        validateNamedOptionalType('settings', 'object', 'credentials', settings.credentials);\n        this.credentials = settings.credentials;\n    }\n    FirestoreSettings.prototype.isEqual = function (other) {\n        return (this.host === other.host &&\n            this.ssl === other.ssl &&\n            this.credentials === other.credentials);\n    };\n    return FirestoreSettings;\n}());\nvar FirestoreConfig = /** @class */ (function () {\n    function FirestoreConfig() {\n    }\n    return FirestoreConfig;\n}());\n/**\n * The root reference to the database.\n */\nvar database_Firestore = /** @class */ (function () {\n    function Firestore(databaseIdOrApp) {\n        var _this = this;\n        // Public for use in tests.\n        // TODO(mikelehen): Use modularized initialization instead.\n        this._queue = new async_queue_AsyncQueue();\n        this.INTERNAL = {\n            delete: function () {\n                if (_this._firestoreClient) {\n                    return _this._firestoreClient.shutdown();\n                }\n                else {\n                    return Promise.resolve();\n                }\n            }\n        };\n        var config = new FirestoreConfig();\n        if (typeof databaseIdOrApp.options === 'object') {\n            // This is very likely a Firebase app object\n            // TODO(b/34177605): Can we somehow use instanceof?\n            var app = databaseIdOrApp;\n            config.firebaseApp = app;\n            config.databaseId = Firestore.databaseIdFromApp(app);\n            config.persistenceKey = config.firebaseApp.name;\n            config.credentials = new credentials_FirebaseCredentialsProvider(app);\n        }\n        else {\n            var external_1 = databaseIdOrApp;\n            if (!external_1.projectId) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide projectId');\n            }\n            config.databaseId = new database_info_DatabaseId(external_1.projectId, external_1.database);\n            // Use a default persistenceKey that lines up with FirebaseApp.\n            config.persistenceKey = '[DEFAULT]';\n            config.credentials = new credentials_EmptyCredentialsProvider();\n        }\n        config.settings = new database_FirestoreSettings({});\n        this._config = config;\n        this._databaseId = config.databaseId;\n    }\n    Firestore.prototype.settings = function (settingsLiteral) {\n        validateExactNumberOfArgs('Firestore.settings', arguments, 1);\n        validateArgType('Firestore.settings', 'object', 1, settingsLiteral);\n        if (contains(settingsLiteral, 'persistence')) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, '\"persistence\" is now specified with a separate call to ' +\n                'firestore.enablePersistence().');\n        }\n        var newSettings = new database_FirestoreSettings(settingsLiteral);\n        if (this._firestoreClient && !this._config.settings.isEqual(newSettings)) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'Firestore has already been started and its settings can no longer ' +\n                'be changed. You can only call settings() before calling any other ' +\n                'methods on a Firestore object.');\n        }\n        this._config.settings = newSettings;\n        if (newSettings.credentials !== undefined) {\n            this._config.credentials = makeCredentialsProvider(newSettings.credentials);\n        }\n    };\n    Firestore.prototype.enableNetwork = function () {\n        this.ensureClientConfigured();\n        return this._firestoreClient.enableNetwork();\n    };\n    Firestore.prototype.disableNetwork = function () {\n        this.ensureClientConfigured();\n        return this._firestoreClient.disableNetwork();\n    };\n    Firestore.prototype.enablePersistence = function () {\n        if (this._firestoreClient) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'Firestore has already been started and persistence can no longer ' +\n                'be enabled. You can only call enablePersistence() before calling ' +\n                'any other methods on a Firestore object.');\n        }\n        return this.configureClient(/* persistence= */ true);\n    };\n    Firestore.prototype.ensureClientConfigured = function () {\n        if (!this._firestoreClient) {\n            this.configureClient(/* persistence= */ false);\n        }\n        return this._firestoreClient;\n    };\n    Firestore.prototype.configureClient = function (persistence) {\n        var _this = this;\n        assert(!!this._config.settings.host, 'FirestoreSettings.host cannot be falsey');\n        assert(!this._firestoreClient, 'configureClient() called multiple times');\n        var databaseInfo = new DatabaseInfo(this._config.databaseId, this._config.persistenceKey, this._config.settings.host, this._config.settings.ssl);\n        var preConverter = function (value) {\n            if (value instanceof database_DocumentReference) {\n                var thisDb = _this._config.databaseId;\n                var otherDb = value.firestore._config.databaseId;\n                if (!otherDb.isEqual(thisDb)) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Document reference is for database ' +\n                        (otherDb.projectId + \"/\" + otherDb.database + \" but should be \") +\n                        (\"for database \" + thisDb.projectId + \"/\" + thisDb.database));\n                }\n                return new DocumentKeyReference(_this._config.databaseId, value._key);\n            }\n            else {\n                return value;\n            }\n        };\n        this._dataConverter = new user_data_converter_UserDataConverter(preConverter);\n        this._firestoreClient = new firestore_client_FirestoreClient(platform_PlatformSupport.getPlatform(), databaseInfo, this._config.credentials, this._queue);\n        return this._firestoreClient.start(persistence);\n    };\n    Firestore.databaseIdFromApp = function (app) {\n        var options = app.options;\n        if (!contains(options, 'projectId')) {\n            // TODO(b/62673263): We can safely remove the special handling of\n            // 'firestoreId' once alpha testers have upgraded.\n            if (contains(options, 'firestoreId')) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, '\"firestoreId\" is now specified as \"projectId\" in ' +\n                    'firebase.initializeApp.');\n            }\n            throw new FirestoreError(Code.INVALID_ARGUMENT, '\"projectId\" not provided in firebase.initializeApp.');\n        }\n        if (contains(options, 'firestoreOptions')) {\n            // TODO(b/62673263): We can safely remove the special handling of\n            // 'firestoreOptions' once alpha testers have upgraded.\n            throw new FirestoreError(Code.INVALID_ARGUMENT, '\"firestoreOptions\" values are now specified with ' +\n                'Firestore.settings()');\n        }\n        var projectId = options['projectId'];\n        if (!projectId || typeof projectId !== 'string') {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'projectId must be a string in FirebaseApp.options');\n        }\n        return new database_info_DatabaseId(projectId);\n    };\n    Object.defineProperty(Firestore.prototype, \"app\", {\n        get: function () {\n            if (!this._config.firebaseApp) {\n                throw new FirestoreError(Code.FAILED_PRECONDITION, \"Firestore was not initialized using the Firebase SDK. 'app' is \" +\n                    'not available');\n            }\n            return this._config.firebaseApp;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Firestore.prototype.collection = function (pathString) {\n        validateExactNumberOfArgs('Firestore.collection', arguments, 1);\n        validateArgType('Firestore.collection', 'string', 1, pathString);\n        if (!pathString) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide a non-empty collection path to collection()');\n        }\n        this.ensureClientConfigured();\n        return new database_CollectionReference(path_ResourcePath.fromString(pathString), this);\n    };\n    Firestore.prototype.doc = function (pathString) {\n        validateExactNumberOfArgs('Firestore.doc', arguments, 1);\n        validateArgType('Firestore.doc', 'string', 1, pathString);\n        if (!pathString) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide a non-empty document path to doc()');\n        }\n        this.ensureClientConfigured();\n        return database_DocumentReference.forPath(path_ResourcePath.fromString(pathString), this);\n    };\n    Firestore.prototype.runTransaction = function (updateFunction) {\n        var _this = this;\n        validateExactNumberOfArgs('Firestore.runTransaction', arguments, 1);\n        validateArgType('Firestore.runTransaction', 'function', 1, updateFunction);\n        return this.ensureClientConfigured().transaction(function (transaction) {\n            return updateFunction(new database_Transaction(_this, transaction));\n        });\n    };\n    Firestore.prototype.batch = function () {\n        this.ensureClientConfigured();\n        return new database_WriteBatch(this);\n    };\n    Object.defineProperty(Firestore, \"logLevel\", {\n        get: function () {\n            switch (getLogLevel()) {\n                case LogLevel.DEBUG:\n                    return 'debug';\n                case LogLevel.ERROR:\n                    return 'error';\n                case LogLevel.SILENT:\n                    return 'silent';\n                default:\n                    return fail('Unknown log level: ' + getLogLevel());\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Firestore.setLogLevel = function (level) {\n        validateExactNumberOfArgs('Firestore.setLogLevel', arguments, 1);\n        validateArgType('Firestore.setLogLevel', 'string', 1, level);\n        switch (level) {\n            case 'debug':\n                setLogLevel(LogLevel.DEBUG);\n                break;\n            case 'error':\n                setLogLevel(LogLevel.ERROR);\n                break;\n            case 'silent':\n                setLogLevel(LogLevel.SILENT);\n                break;\n            default:\n                throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid log level: ' + level);\n        }\n    };\n    return Firestore;\n}());\n\n/**\n * A reference to a transaction.\n */\nvar database_Transaction = /** @class */ (function () {\n    function Transaction(_firestore, _transaction) {\n        this._firestore = _firestore;\n        this._transaction = _transaction;\n    }\n    Transaction.prototype.get = function (documentRef) {\n        var _this = this;\n        validateExactNumberOfArgs('Transaction.get', arguments, 1);\n        var ref = validateReference('Transaction.get', documentRef, this._firestore);\n        return this._transaction\n            .lookup([ref._key])\n            .then(function (docs) {\n            if (!docs || docs.length !== 1) {\n                return fail('Mismatch in docs returned from document lookup.');\n            }\n            var doc = docs[0];\n            if (doc instanceof document_NoDocument) {\n                return new database_DocumentSnapshot(_this._firestore, ref._key, null, false);\n            }\n            return new database_DocumentSnapshot(_this._firestore, ref._key, doc, false);\n        });\n    };\n    Transaction.prototype.set = function (documentRef, value, options) {\n        validateBetweenNumberOfArgs('Transaction.set', arguments, 2, 3);\n        var ref = validateReference('Transaction.set', documentRef, this._firestore);\n        options = validateSetOptions('Transaction.set', options);\n        var parsed = options.merge\n            ? this._firestore._dataConverter.parseMergeData('Transaction.set', value)\n            : this._firestore._dataConverter.parseSetData('Transaction.set', value);\n        this._transaction.set(ref._key, parsed);\n        return this;\n    };\n    Transaction.prototype.update = function (documentRef, fieldOrUpdateData, value) {\n        var moreFieldsAndValues = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            moreFieldsAndValues[_i - 3] = arguments[_i];\n        }\n        var ref;\n        var parsed;\n        if (typeof fieldOrUpdateData === 'string' ||\n            fieldOrUpdateData instanceof field_path_FieldPath) {\n            validateAtLeastNumberOfArgs('Transaction.update', arguments, 3);\n            ref = validateReference('Transaction.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateVarargs('Transaction.update', fieldOrUpdateData, value, moreFieldsAndValues);\n        }\n        else {\n            validateExactNumberOfArgs('Transaction.update', arguments, 2);\n            ref = validateReference('Transaction.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateData('Transaction.update', fieldOrUpdateData);\n        }\n        this._transaction.update(ref._key, parsed);\n        return this;\n    };\n    Transaction.prototype.delete = function (documentRef) {\n        validateExactNumberOfArgs('Transaction.delete', arguments, 1);\n        var ref = validateReference('Transaction.delete', documentRef, this._firestore);\n        this._transaction.delete(ref._key);\n        return this;\n    };\n    return Transaction;\n}());\n\nvar database_WriteBatch = /** @class */ (function () {\n    function WriteBatch(_firestore) {\n        this._firestore = _firestore;\n        this._mutations = [];\n        this._committed = false;\n    }\n    WriteBatch.prototype.set = function (documentRef, value, options) {\n        validateBetweenNumberOfArgs('WriteBatch.set', arguments, 2, 3);\n        this.verifyNotCommitted();\n        var ref = validateReference('WriteBatch.set', documentRef, this._firestore);\n        options = validateSetOptions('WriteBatch.set', options);\n        var parsed = options.merge\n            ? this._firestore._dataConverter.parseMergeData('WriteBatch.set', value)\n            : this._firestore._dataConverter.parseSetData('WriteBatch.set', value);\n        this._mutations = this._mutations.concat(parsed.toMutations(ref._key, mutation_Precondition.NONE));\n        return this;\n    };\n    WriteBatch.prototype.update = function (documentRef, fieldOrUpdateData, value) {\n        var moreFieldsAndValues = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            moreFieldsAndValues[_i - 3] = arguments[_i];\n        }\n        this.verifyNotCommitted();\n        var ref;\n        var parsed;\n        if (typeof fieldOrUpdateData === 'string' ||\n            fieldOrUpdateData instanceof field_path_FieldPath) {\n            validateAtLeastNumberOfArgs('WriteBatch.update', arguments, 3);\n            ref = validateReference('WriteBatch.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateVarargs('WriteBatch.update', fieldOrUpdateData, value, moreFieldsAndValues);\n        }\n        else {\n            validateExactNumberOfArgs('WriteBatch.update', arguments, 2);\n            ref = validateReference('WriteBatch.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateData('WriteBatch.update', fieldOrUpdateData);\n        }\n        this._mutations = this._mutations.concat(parsed.toMutations(ref._key, mutation_Precondition.exists(true)));\n        return this;\n    };\n    WriteBatch.prototype.delete = function (documentRef) {\n        validateExactNumberOfArgs('WriteBatch.delete', arguments, 1);\n        this.verifyNotCommitted();\n        var ref = validateReference('WriteBatch.delete', documentRef, this._firestore);\n        this._mutations = this._mutations.concat(new mutation_DeleteMutation(ref._key, mutation_Precondition.NONE));\n        return this;\n    };\n    WriteBatch.prototype.commit = function () {\n        this.verifyNotCommitted();\n        this._committed = true;\n        if (this._mutations.length > 0) {\n            return this._firestore.ensureClientConfigured().write(this._mutations);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    WriteBatch.prototype.verifyNotCommitted = function () {\n        if (this._committed) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'A write batch can no longer be used after commit() ' +\n                'has been called.');\n        }\n    };\n    return WriteBatch;\n}());\n\n/**\n * A reference to a particular document in a collection in the database.\n */\nvar database_DocumentReference = /** @class */ (function () {\n    function DocumentReference(_key, firestore) {\n        this._key = _key;\n        this.firestore = firestore;\n        this._firestoreClient = this.firestore.ensureClientConfigured();\n    }\n    DocumentReference.forPath = function (path, firestore) {\n        if (path.length % 2 !== 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid document reference. Document ' +\n                'references must have an even number of segments, but ' +\n                (path.canonicalString() + \" has \" + path.length));\n        }\n        return new DocumentReference(new document_key_DocumentKey(path), firestore);\n    };\n    Object.defineProperty(DocumentReference.prototype, \"id\", {\n        get: function () {\n            return this._key.path.lastSegment();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentReference.prototype, \"parent\", {\n        get: function () {\n            return new database_CollectionReference(this._key.path.popLast(), this.firestore);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentReference.prototype, \"path\", {\n        get: function () {\n            return this._key.path.canonicalString();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DocumentReference.prototype.collection = function (pathString) {\n        validateExactNumberOfArgs('DocumentReference.collection', arguments, 1);\n        validateArgType('DocumentReference.collection', 'string', 1, pathString);\n        if (!pathString) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide a non-empty collection name to collection()');\n        }\n        var path = path_ResourcePath.fromString(pathString);\n        return new database_CollectionReference(this._key.path.child(path), this.firestore);\n    };\n    DocumentReference.prototype.isEqual = function (other) {\n        if (!(other instanceof DocumentReference)) {\n            throw invalidClassError('isEqual', 'DocumentReference', 1, other);\n        }\n        return this.firestore === other.firestore && this._key.isEqual(other._key);\n    };\n    DocumentReference.prototype.set = function (value, options) {\n        validateBetweenNumberOfArgs('DocumentReference.set', arguments, 1, 2);\n        options = validateSetOptions('DocumentReference.set', options);\n        var parsed = options.merge\n            ? this.firestore._dataConverter.parseMergeData('DocumentReference.set', value)\n            : this.firestore._dataConverter.parseSetData('DocumentReference.set', value);\n        return this._firestoreClient.write(parsed.toMutations(this._key, mutation_Precondition.NONE));\n    };\n    DocumentReference.prototype.update = function (fieldOrUpdateData, value) {\n        var moreFieldsAndValues = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            moreFieldsAndValues[_i - 2] = arguments[_i];\n        }\n        var parsed;\n        if (typeof fieldOrUpdateData === 'string' ||\n            fieldOrUpdateData instanceof field_path_FieldPath) {\n            validateAtLeastNumberOfArgs('DocumentReference.update', arguments, 2);\n            parsed = this.firestore._dataConverter.parseUpdateVarargs('DocumentReference.update', fieldOrUpdateData, value, moreFieldsAndValues);\n        }\n        else {\n            validateExactNumberOfArgs('DocumentReference.update', arguments, 1);\n            parsed = this.firestore._dataConverter.parseUpdateData('DocumentReference.update', fieldOrUpdateData);\n        }\n        return this._firestoreClient.write(parsed.toMutations(this._key, mutation_Precondition.exists(true)));\n    };\n    DocumentReference.prototype.delete = function () {\n        validateExactNumberOfArgs('DocumentReference.delete', arguments, 0);\n        return this._firestoreClient.write([\n            new mutation_DeleteMutation(this._key, mutation_Precondition.NONE)\n        ]);\n    };\n    DocumentReference.prototype.onSnapshot = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        validateBetweenNumberOfArgs('DocumentReference.onSnapshot', arguments, 1, 4);\n        var options = {\n            includeMetadataChanges: false\n        };\n        var observer;\n        var currArg = 0;\n        if (typeof args[currArg] === 'object' &&\n            !isPartialObserver(args[currArg])) {\n            options = args[currArg];\n            validateOptionNames('DocumentReference.onSnapshot', options, [\n                'includeMetadataChanges'\n            ]);\n            validateNamedOptionalType('DocumentReference.onSnapshot', 'boolean', 'includeMetadataChanges', options.includeMetadataChanges);\n            currArg++;\n        }\n        var internalOptions = {\n            includeDocumentMetadataChanges: options.includeMetadataChanges,\n            includeQueryMetadataChanges: options.includeMetadataChanges\n        };\n        if (isPartialObserver(args[currArg])) {\n            observer = args[currArg];\n        }\n        else {\n            validateArgType('DocumentReference.onSnapshot', 'function', currArg, args[currArg]);\n            validateOptionalArgType('DocumentReference.onSnapshot', 'function', currArg + 1, args[currArg + 1]);\n            validateOptionalArgType('DocumentReference.onSnapshot', 'function', currArg + 2, args[currArg + 2]);\n            observer = {\n                next: args[currArg],\n                error: args[currArg + 1],\n                complete: args[currArg + 2]\n            };\n        }\n        return this.onSnapshotInternal(internalOptions, observer);\n    };\n    DocumentReference.prototype.onSnapshotInternal = function (options, observer) {\n        var _this = this;\n        var errHandler = function (err) {\n            console.error('Uncaught Error in onSnapshot:', err);\n        };\n        if (observer.error) {\n            errHandler = observer.error.bind(observer);\n        }\n        var asyncObserver = new AsyncObserver({\n            next: function (snapshot) {\n                if (observer.next) {\n                    assert(snapshot.docs.size <= 1, 'Too many documents returned on a document query');\n                    var doc = snapshot.docs.get(_this._key);\n                    observer.next(new database_DocumentSnapshot(_this.firestore, _this._key, doc, snapshot.fromCache));\n                }\n            },\n            error: errHandler\n        });\n        var internalListener = this._firestoreClient.listen(query_Query.atPath(this._key.path), asyncObserver, options);\n        return function () {\n            asyncObserver.mute();\n            _this._firestoreClient.unlisten(internalListener);\n        };\n    };\n    DocumentReference.prototype.get = function () {\n        var _this = this;\n        validateExactNumberOfArgs('DocumentReference.get', arguments, 0);\n        return new Promise(function (resolve, reject) {\n            var unlisten = _this.onSnapshotInternal({\n                includeQueryMetadataChanges: true,\n                includeDocumentMetadataChanges: true,\n                waitForSyncWhenOnline: true\n            }, {\n                next: function (snap) {\n                    // Remove query first before passing event to user to avoid\n                    // user actions affecting the now stale query.\n                    unlisten();\n                    if (!snap.exists && snap.metadata.fromCache) {\n                        // TODO(dimond): If we're online and the document doesn't\n                        // exist then we resolve with a doc.exists set to false. If\n                        // we're offline however, we reject the Promise in this\n                        // case. Two options: 1) Cache the negative response from\n                        // the server so we can deliver that even when you're\n                        // offline 2) Actually reject the Promise in the online case\n                        // if the document doesn't exist.\n                        reject(new FirestoreError(Code.ABORTED, 'Failed to get document because the client is ' + 'offline.'));\n                    }\n                    else {\n                        resolve(snap);\n                    }\n                },\n                error: reject\n            });\n        });\n    };\n    return DocumentReference;\n}());\n\nvar SnapshotMetadata = /** @class */ (function () {\n    function SnapshotMetadata(hasPendingWrites, fromCache) {\n        this.hasPendingWrites = hasPendingWrites;\n        this.fromCache = fromCache;\n    }\n    SnapshotMetadata.prototype.isEqual = function (other) {\n        return (this.hasPendingWrites === other.hasPendingWrites &&\n            this.fromCache === other.fromCache);\n    };\n    return SnapshotMetadata;\n}());\nvar database_DocumentSnapshot = /** @class */ (function () {\n    function DocumentSnapshot(_firestore, _key, _document, _fromCache) {\n        this._firestore = _firestore;\n        this._key = _key;\n        this._document = _document;\n        this._fromCache = _fromCache;\n    }\n    DocumentSnapshot.prototype.data = function (options) {\n        validateBetweenNumberOfArgs('DocumentSnapshot.data', arguments, 0, 1);\n        options = validateSnapshotOptions('DocumentSnapshot.data', options);\n        return !this._document\n            ? undefined\n            : this.convertObject(this._document.data, field_value_FieldValueOptions.fromSnapshotOptions(options));\n    };\n    DocumentSnapshot.prototype.get = function (fieldPath, options) {\n        validateBetweenNumberOfArgs('DocumentSnapshot.get', arguments, 1, 2);\n        options = validateSnapshotOptions('DocumentSnapshot.get', options);\n        if (this._document) {\n            var value = this._document.data.field(fieldPathFromArgument('DocumentSnapshot.get', fieldPath));\n            if (value !== undefined) {\n                return this.convertValue(value, field_value_FieldValueOptions.fromSnapshotOptions(options));\n            }\n        }\n        return undefined;\n    };\n    Object.defineProperty(DocumentSnapshot.prototype, \"id\", {\n        get: function () {\n            return this._key.path.lastSegment();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentSnapshot.prototype, \"ref\", {\n        get: function () {\n            return new database_DocumentReference(this._key, this._firestore);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentSnapshot.prototype, \"exists\", {\n        get: function () {\n            return this._document !== null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentSnapshot.prototype, \"metadata\", {\n        get: function () {\n            return new SnapshotMetadata(this._document !== null && this._document.hasLocalMutations, this._fromCache);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DocumentSnapshot.prototype.isEqual = function (other) {\n        if (!(other instanceof DocumentSnapshot)) {\n            throw invalidClassError('isEqual', 'DocumentSnapshot', 1, other);\n        }\n        return (this._firestore === other._firestore &&\n            this._fromCache === other._fromCache &&\n            this._key.isEqual(other._key) &&\n            (this._document === null\n                ? other._document === null\n                : this._document.isEqual(other._document)));\n    };\n    DocumentSnapshot.prototype.convertObject = function (data, options) {\n        var _this = this;\n        var result = {};\n        data.forEach(function (key, value) {\n            result[key] = _this.convertValue(value, options);\n        });\n        return result;\n    };\n    DocumentSnapshot.prototype.convertValue = function (value, options) {\n        if (value instanceof field_value_ObjectValue) {\n            return this.convertObject(value, options);\n        }\n        else if (value instanceof field_value_ArrayValue) {\n            return this.convertArray(value, options);\n        }\n        else if (value instanceof field_value_RefValue) {\n            var key = value.value(options);\n            var database = this._firestore.ensureClientConfigured().databaseId();\n            if (!value.databaseId.isEqual(database)) {\n                // TODO(b/64130202): Somehow support foreign references.\n                log_error(\"Document \" + this._key.path + \" contains a document \" +\n                    \"reference within a different database (\" +\n                    (value.databaseId.projectId + \"/\" + value.databaseId.database + \") which is not \") +\n                    \"supported. It will be treated as a reference in the current \" +\n                    (\"database (\" + database.projectId + \"/\" + database.database + \") \") +\n                    \"instead.\");\n            }\n            return new database_DocumentReference(key, this._firestore);\n        }\n        else {\n            return value.value(options);\n        }\n    };\n    DocumentSnapshot.prototype.convertArray = function (data, options) {\n        var _this = this;\n        return data.internalValue.map(function (value) {\n            return _this.convertValue(value, options);\n        });\n    };\n    return DocumentSnapshot;\n}());\n\nvar database_QueryDocumentSnapshot = /** @class */ (function (_super) {\n    database___extends(QueryDocumentSnapshot, _super);\n    function QueryDocumentSnapshot(firestore, key, document, fromCache) {\n        return _super.call(this, firestore, key, document, fromCache) || this;\n    }\n    QueryDocumentSnapshot.prototype.data = function (options) {\n        var data = _super.prototype.data.call(this, options);\n        assert(typeof data === 'object', 'Document in a QueryDocumentSnapshot should exist');\n        return data;\n    };\n    return QueryDocumentSnapshot;\n}(database_DocumentSnapshot));\n\nvar database_Query = /** @class */ (function () {\n    function Query(_query, firestore) {\n        this._query = _query;\n        this.firestore = firestore;\n    }\n    Query.prototype.where = function (field, opStr, value) {\n        validateExactNumberOfArgs('Query.where', arguments, 3);\n        validateArgType('Query.where', 'string', 2, opStr);\n        validateDefined('Query.where', 3, value);\n        var fieldValue;\n        var fieldPath = fieldPathFromArgument('Query.where', field);\n        if (fieldPath.isKeyField()) {\n            if (typeof value === 'string') {\n                if (value.indexOf('/') !== -1) {\n                    // TODO(dimond): Allow slashes once ancestor queries are supported\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Function Query.where() requires its third parameter to be a ' +\n                        'valid document ID if the first parameter is ' +\n                        'FieldPath.documentId(), but it contains a slash.');\n                }\n                if (value === '') {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Function Query.where() requires its third parameter to be a ' +\n                        'valid document ID if the first parameter is ' +\n                        'FieldPath.documentId(), but it was an empty string.');\n                }\n                var path = this._query.path.child(new path_ResourcePath([value]));\n                assert(path.length % 2 === 0, 'Path should be a document key');\n                fieldValue = new field_value_RefValue(this.firestore._databaseId, new document_key_DocumentKey(path));\n            }\n            else if (value instanceof database_DocumentReference) {\n                var ref = value;\n                fieldValue = new field_value_RefValue(this.firestore._databaseId, ref._key);\n            }\n            else {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function Query.where() requires its third parameter to be a \" +\n                    \"string or a DocumentReference if the first parameter is \" +\n                    \"FieldPath.documentId(), but it was: \" +\n                    (valueDescription(value) + \".\"));\n            }\n        }\n        else {\n            fieldValue = this.firestore._dataConverter.parseQueryValue('Query.where', value);\n        }\n        var filter = fieldFilter(fieldPath, query_RelationOp.fromString(opStr), fieldValue);\n        this.validateNewFilter(filter);\n        return new Query(this._query.addFilter(filter), this.firestore);\n    };\n    Query.prototype.orderBy = function (field, directionStr) {\n        validateBetweenNumberOfArgs('Query.orderBy', arguments, 1, 2);\n        validateOptionalArgType('Query.orderBy', 'string', 2, directionStr);\n        var direction;\n        if (directionStr === undefined || directionStr === 'asc') {\n            direction = Direction.ASCENDING;\n        }\n        else if (directionStr === 'desc') {\n            direction = Direction.DESCENDING;\n        }\n        else {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function Query.orderBy() has unknown direction '\" + directionStr + \"', \" +\n                \"expected 'asc' or 'desc'.\");\n        }\n        if (this._query.startAt !== null) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You must not call Query.startAt() or ' +\n                'Query.startAfter() before calling Query.orderBy().');\n        }\n        if (this._query.endAt !== null) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You must not call Query.endAt() or ' +\n                'Query.endBefore() before calling Query.orderBy().');\n        }\n        var fieldPath = fieldPathFromArgument('Query.orderBy', field);\n        var orderBy = new query_OrderBy(fieldPath, direction);\n        this.validateNewOrderBy(orderBy);\n        return new Query(this._query.addOrderBy(orderBy), this.firestore);\n    };\n    Query.prototype.limit = function (n) {\n        validateExactNumberOfArgs('Query.limit', arguments, 1);\n        validateArgType('Query.limit', 'number', 1, n);\n        if (n <= 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid Query. Query limit (\" + n + \") is invalid. Limit must be \" +\n                'positive.');\n        }\n        return new Query(this._query.withLimit(n), this.firestore);\n    };\n    Query.prototype.startAt = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.startAt', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.startAt', docOrField, fields, \n        /*before=*/ true);\n        return new Query(this._query.withStartAt(bound), this.firestore);\n    };\n    Query.prototype.startAfter = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.startAfter', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.startAfter', docOrField, fields, \n        /*before=*/ false);\n        return new Query(this._query.withStartAt(bound), this.firestore);\n    };\n    Query.prototype.endBefore = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.endBefore', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.endBefore', docOrField, fields, \n        /*before=*/ true);\n        return new Query(this._query.withEndAt(bound), this.firestore);\n    };\n    Query.prototype.endAt = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.endAt', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.endAt', docOrField, fields, \n        /*before=*/ false);\n        return new Query(this._query.withEndAt(bound), this.firestore);\n    };\n    Query.prototype.isEqual = function (other) {\n        if (!(other instanceof Query)) {\n            throw invalidClassError('isEqual', 'Query', 1, other);\n        }\n        return (this.firestore === other.firestore && this._query.isEqual(other._query));\n    };\n    /** Helper function to create a bound from a document or fields */\n    Query.prototype.boundFromDocOrFields = function (methodName, docOrField, fields, before) {\n        validateDefined(methodName, 1, docOrField);\n        if (docOrField instanceof database_DocumentSnapshot) {\n            if (fields.length > 0) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Too many arguments provided to \" + methodName + \"().\");\n            }\n            var snap = docOrField;\n            if (!snap.exists) {\n                throw new FirestoreError(Code.NOT_FOUND, \"Can't use a DocumentSnapshot that doesn't exist for \" +\n                    (methodName + \"().\"));\n            }\n            return this.boundFromDocument(methodName, snap._document, before);\n        }\n        else {\n            var allFields = [docOrField].concat(fields);\n            return this.boundFromFields(methodName, allFields, before);\n        }\n    };\n    /**\n     * Create a Bound from a query and a document.\n     *\n     * Note that the Bound will always include the key of the document\n     * and so only the provided document will compare equal to the returned\n     * position.\n     *\n     * Will throw if the document does not contain all fields of the order by\n     * of the query.\n     */\n    Query.prototype.boundFromDocument = function (methodName, doc, before) {\n        var components = [];\n        // Because people expect to continue/end a query at the exact document\n        // provided, we need to use the implicit sort order rather than the explicit\n        // sort order, because it's guaranteed to contain the document key. That way\n        // the position becomes unambiguous and the query continues/ends exactly at\n        // the provided document. Without the key (by using the explicit sort\n        // orders), multiple documents could match the position, yielding duplicate\n        // results.\n        for (var _i = 0, _a = this._query.orderBy; _i < _a.length; _i++) {\n            var orderBy = _a[_i];\n            if (orderBy.field.isKeyField()) {\n                components.push(new field_value_RefValue(this.firestore._databaseId, doc.key));\n            }\n            else {\n                var value = doc.field(orderBy.field);\n                if (value !== undefined) {\n                    components.push(value);\n                }\n                else {\n                    var field = orderBy.field.canonicalString();\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. You are trying to start or end a query using a \" +\n                        (\"document for which the field '\" + field + \"' (used as the \") +\n                        \"orderBy) does not exist.\");\n                }\n            }\n        }\n        return new query_Bound(components, before);\n    };\n    /**\n     * Converts a list of field values to a Bound for the given query.\n     */\n    Query.prototype.boundFromFields = function (methodName, values, before) {\n        // Use explicit order by's because it has to match the query the user made\n        var orderBy = this._query.explicitOrderBy;\n        if (values.length > orderBy.length) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Too many arguments provided to \" + methodName + \"(). \" +\n                \"The number of arguments must be less than or equal to the \" +\n                \"number of Query.orderBy() clauses\");\n        }\n        var components = [];\n        for (var i = 0; i < values.length; i++) {\n            var rawValue = values[i];\n            var orderByComponent = orderBy[i];\n            if (orderByComponent.field.isKeyField()) {\n                if (typeof rawValue !== 'string') {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. Expected a string for document ID in \" +\n                        (methodName + \"(), but got a \" + typeof rawValue));\n                }\n                if (rawValue.indexOf('/') !== -1) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. Document ID '\" + rawValue + \"' contains a slash in \" +\n                        (methodName + \"()\"));\n                }\n                var key = new document_key_DocumentKey(this._query.path.child(rawValue));\n                components.push(new field_value_RefValue(this.firestore._databaseId, key));\n            }\n            else {\n                var wrapped = this.firestore._dataConverter.parseQueryValue(methodName, rawValue);\n                components.push(wrapped);\n            }\n        }\n        return new query_Bound(components, before);\n    };\n    Query.prototype.onSnapshot = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        validateBetweenNumberOfArgs('Query.onSnapshot', arguments, 1, 4);\n        var options = {};\n        var observer;\n        var currArg = 0;\n        if (typeof args[currArg] === 'object' &&\n            !isPartialObserver(args[currArg])) {\n            options = args[currArg];\n            validateOptionNames('Query.onSnapshot', options, [\n                'includeQueryMetadataChanges',\n                'includeDocumentMetadataChanges'\n            ]);\n            validateNamedOptionalType('Query.onSnapshot', 'boolean', 'includeDocumentMetadataChanges', options.includeDocumentMetadataChanges);\n            validateNamedOptionalType('Query.onSnapshot', 'boolean', 'includeQueryMetadataChanges', options.includeQueryMetadataChanges);\n            currArg++;\n        }\n        if (isPartialObserver(args[currArg])) {\n            observer = args[currArg];\n        }\n        else {\n            validateArgType('Query.onSnapshot', 'function', currArg, args[currArg]);\n            validateOptionalArgType('Query.onSnapshot', 'function', currArg + 1, args[currArg + 1]);\n            validateOptionalArgType('Query.onSnapshot', 'function', currArg + 2, args[currArg + 2]);\n            observer = {\n                next: args[currArg],\n                error: args[currArg + 1],\n                complete: args[currArg + 2]\n            };\n        }\n        return this.onSnapshotInternal(options, observer);\n    };\n    Query.prototype.onSnapshotInternal = function (options, observer) {\n        var _this = this;\n        var errHandler = function (err) {\n            console.error('Uncaught Error in onSnapshot:', err);\n        };\n        if (observer.error) {\n            errHandler = observer.error.bind(observer);\n        }\n        var asyncObserver = new AsyncObserver({\n            next: function (result) {\n                if (observer.next) {\n                    observer.next(new database_QuerySnapshot(_this.firestore, _this._query, result));\n                }\n            },\n            error: errHandler\n        });\n        var firestoreClient = this.firestore.ensureClientConfigured();\n        var internalListener = firestoreClient.listen(this._query, asyncObserver, options);\n        return function () {\n            asyncObserver.mute();\n            firestoreClient.unlisten(internalListener);\n        };\n    };\n    Query.prototype.get = function () {\n        var _this = this;\n        validateExactNumberOfArgs('Query.get', arguments, 0);\n        return new Promise(function (resolve, reject) {\n            var unlisten = _this.onSnapshotInternal({\n                includeDocumentMetadataChanges: false,\n                includeQueryMetadataChanges: true,\n                waitForSyncWhenOnline: true\n            }, {\n                next: function (result) {\n                    // Remove query first before passing event to user to avoid\n                    // user actions affecting the now stale query.\n                    unlisten();\n                    resolve(result);\n                },\n                error: reject\n            });\n        });\n    };\n    Query.prototype.validateNewFilter = function (filter) {\n        if (filter instanceof query_RelationFilter && filter.isInequality()) {\n            var existingField = this._query.getInequalityFilterField();\n            if (existingField !== null && !existingField.isEqual(filter.field)) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. All where filters with an inequality' +\n                    ' (<, <=, >, or >=) must be on the same field. But you have' +\n                    (\" inequality filters on '\" + existingField.toString() + \"'\") +\n                    (\" and '\" + filter.field.toString() + \"'\"));\n            }\n            var firstOrderByField = this._query.getFirstOrderByField();\n            if (firstOrderByField !== null) {\n                this.validateOrderByAndInequalityMatch(filter.field, firstOrderByField);\n            }\n        }\n    };\n    Query.prototype.validateNewOrderBy = function (orderBy) {\n        if (this._query.getFirstOrderByField() === null) {\n            // This is the first order by. It must match any inequality.\n            var inequalityField = this._query.getInequalityFilterField();\n            if (inequalityField !== null) {\n                this.validateOrderByAndInequalityMatch(inequalityField, orderBy.field);\n            }\n        }\n    };\n    Query.prototype.validateOrderByAndInequalityMatch = function (inequality, orderBy) {\n        if (!orderBy.isEqual(inequality)) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. You have a where filter with an inequality \" +\n                (\"(<, <=, >, or >=) on field '\" + inequality.toString() + \"' \") +\n                (\"and so you must also use '\" + inequality.toString() + \"' \") +\n                \"as your first Query.orderBy(), but your first Query.orderBy() \" +\n                (\"is on field '\" + orderBy.toString() + \"' instead.\"));\n        }\n    };\n    return Query;\n}());\n\nvar database_QuerySnapshot = /** @class */ (function () {\n    function QuerySnapshot(_firestore, _originalQuery, _snapshot) {\n        this._firestore = _firestore;\n        this._originalQuery = _originalQuery;\n        this._snapshot = _snapshot;\n        this._cachedChanges = null;\n        this.metadata = new SnapshotMetadata(_snapshot.hasPendingWrites, _snapshot.fromCache);\n    }\n    Object.defineProperty(QuerySnapshot.prototype, \"docs\", {\n        get: function () {\n            var result = [];\n            this.forEach(function (doc) { return result.push(doc); });\n            return result;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySnapshot.prototype, \"empty\", {\n        get: function () {\n            return this._snapshot.docs.isEmpty();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySnapshot.prototype, \"size\", {\n        get: function () {\n            return this._snapshot.docs.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    QuerySnapshot.prototype.forEach = function (callback, thisArg) {\n        var _this = this;\n        validateBetweenNumberOfArgs('QuerySnapshot.forEach', arguments, 1, 2);\n        validateArgType('QuerySnapshot.forEach', 'function', 1, callback);\n        this._snapshot.docs.forEach(function (doc) {\n            callback.call(thisArg, _this.convertToDocumentImpl(doc));\n        });\n    };\n    Object.defineProperty(QuerySnapshot.prototype, \"query\", {\n        get: function () {\n            return new database_Query(this._originalQuery, this._firestore);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySnapshot.prototype, \"docChanges\", {\n        get: function () {\n            if (!this._cachedChanges) {\n                this._cachedChanges = changesFromSnapshot(this._firestore, this._snapshot);\n            }\n            return this._cachedChanges;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** Check the equality. The call can be very expensive. */\n    QuerySnapshot.prototype.isEqual = function (other) {\n        if (!(other instanceof QuerySnapshot)) {\n            throw invalidClassError('isEqual', 'QuerySnapshot', 1, other);\n        }\n        return (this._firestore === other._firestore &&\n            this._originalQuery.isEqual(other._originalQuery) &&\n            this._snapshot.isEqual(other._snapshot));\n    };\n    QuerySnapshot.prototype.convertToDocumentImpl = function (doc) {\n        return new database_QueryDocumentSnapshot(this._firestore, doc.key, doc, this.metadata.fromCache);\n    };\n    return QuerySnapshot;\n}());\n\nvar database_CollectionReference = /** @class */ (function (_super) {\n    database___extends(CollectionReference, _super);\n    function CollectionReference(path, firestore) {\n        var _this = _super.call(this, query_Query.atPath(path), firestore) || this;\n        if (path.length % 2 !== 1) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid collection reference. Collection ' +\n                'references must have an odd number of segments, but ' +\n                (path.canonicalString() + \" has \" + path.length));\n        }\n        return _this;\n    }\n    Object.defineProperty(CollectionReference.prototype, \"id\", {\n        get: function () {\n            return this._query.path.lastSegment();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CollectionReference.prototype, \"parent\", {\n        get: function () {\n            var parentPath = this._query.path.popLast();\n            if (parentPath.isEmpty()) {\n                return null;\n            }\n            else {\n                return new database_DocumentReference(new document_key_DocumentKey(parentPath), this.firestore);\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CollectionReference.prototype, \"path\", {\n        get: function () {\n            return this._query.path.canonicalString();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    CollectionReference.prototype.doc = function (pathString) {\n        validateBetweenNumberOfArgs('CollectionReference.doc', arguments, 0, 1);\n        // We allow omission of 'pathString' but explicitly prohibit passing in both\n        // 'undefined' and 'null'.\n        if (arguments.length === 0) {\n            pathString = misc_AutoId.newId();\n        }\n        validateArgType('CollectionReference.doc', 'string', 1, pathString);\n        if (pathString === '') {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Document path must be a non-empty string');\n        }\n        var path = path_ResourcePath.fromString(pathString);\n        return database_DocumentReference.forPath(this._query.path.child(path), this.firestore);\n    };\n    CollectionReference.prototype.add = function (value) {\n        validateExactNumberOfArgs('CollectionReference.add', arguments, 1);\n        validateArgType('CollectionReference.add', 'object', 1, value);\n        var docRef = this.doc();\n        return docRef.set(value).then(function () { return docRef; });\n    };\n    return CollectionReference;\n}(database_Query));\n\nfunction validateSetOptions(methodName, options) {\n    if (options === undefined) {\n        return {\n            merge: false\n        };\n    }\n    validateOptionNames(methodName, options, ['merge']);\n    validateNamedOptionalType(methodName, 'boolean', 'merge', options.merge);\n    return options;\n}\nfunction validateSnapshotOptions(methodName, options) {\n    if (options === undefined) {\n        return {};\n    }\n    validateOptionNames(methodName, options, ['serverTimestamps']);\n    validateNamedOptionalPropertyEquals(methodName, 'options', 'serverTimestamps', options.serverTimestamps, ['estimate', 'previous', 'none']);\n    return options;\n}\nfunction validateReference(methodName, documentRef, firestore) {\n    if (!(documentRef instanceof database_DocumentReference)) {\n        throw invalidClassError(methodName, 'DocumentReference', 1, documentRef);\n    }\n    else if (documentRef.firestore !== firestore) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Provided document reference is from a different Firestore instance.');\n    }\n    else {\n        return documentRef;\n    }\n}\n/**\n * Calculates the array of firestore.DocumentChange's for a given ViewSnapshot.\n *\n * Exported for testing.\n */\nfunction changesFromSnapshot(firestore, snapshot) {\n    if (snapshot.oldDocs.isEmpty()) {\n        // Special case the first snapshot because index calculation is easy and\n        // fast\n        var lastDoc_1;\n        var index_1 = 0;\n        return snapshot.docChanges.map(function (change) {\n            var doc = new database_QueryDocumentSnapshot(firestore, change.doc.key, change.doc, snapshot.fromCache);\n            assert(change.type === ChangeType.Added, 'Invalid event type for first snapshot');\n            assert(!lastDoc_1 || snapshot.query.docComparator(lastDoc_1, change.doc) < 0, 'Got added events in wrong order');\n            lastDoc_1 = change.doc;\n            return {\n                type: 'added',\n                doc: doc,\n                oldIndex: -1,\n                newIndex: index_1++\n            };\n        });\n    }\n    else {\n        // A DocumentSet that is updated incrementally as changes are applied to use\n        // to lookup the index of a document.\n        var indexTracker_1 = snapshot.oldDocs;\n        return snapshot.docChanges.map(function (change) {\n            var doc = new database_QueryDocumentSnapshot(firestore, change.doc.key, change.doc, snapshot.fromCache);\n            var oldIndex = -1;\n            var newIndex = -1;\n            if (change.type !== ChangeType.Added) {\n                oldIndex = indexTracker_1.indexOf(change.doc.key);\n                assert(oldIndex >= 0, 'Index for document not found');\n                indexTracker_1 = indexTracker_1.delete(change.doc.key);\n            }\n            if (change.type !== ChangeType.Removed) {\n                indexTracker_1 = indexTracker_1.add(change.doc);\n                newIndex = indexTracker_1.indexOf(change.doc.key);\n            }\n            return { type: resultChangeType(change.type), doc: doc, oldIndex: oldIndex, newIndex: newIndex };\n        });\n    }\n}\nfunction resultChangeType(type) {\n    switch (type) {\n        case ChangeType.Added:\n            return 'added';\n        case ChangeType.Modified:\n        case ChangeType.Metadata:\n            return 'modified';\n        case ChangeType.Removed:\n            return 'removed';\n        default:\n            return fail('Unknown change type: ' + type);\n    }\n}\n// Export the classes with a private constructor (it will fail if invoked\n// at runtime). Note that this still allows instanceof checks.\n// We're treating the variables as class names, so disable checking for lower\n// case variable names.\n// tslint:disable:variable-name\nvar PublicFirestore = makeConstructorPrivate(database_Firestore, 'Use firebase.firestore() instead.');\nvar PublicTransaction = makeConstructorPrivate(database_Transaction, 'Use firebase.firestore().runTransaction() instead.');\nvar PublicWriteBatch = makeConstructorPrivate(database_WriteBatch, 'Use firebase.firestore().batch() instead.');\nvar PublicDocumentReference = makeConstructorPrivate(database_DocumentReference, 'Use firebase.firestore().doc() instead.');\nvar PublicDocumentSnapshot = makeConstructorPrivate(database_DocumentSnapshot);\nvar PublicQueryDocumentSnapshot = makeConstructorPrivate(database_QueryDocumentSnapshot);\nvar PublicQuery = makeConstructorPrivate(database_Query);\nvar PublicQuerySnapshot = makeConstructorPrivate(database_QuerySnapshot);\nvar PublicCollectionReference = makeConstructorPrivate(database_CollectionReference, 'Use firebase.firestore().collection() instead.');\n// tslint:enable:variable-name\n\n//# sourceMappingURL=database.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/src/platform/config.js\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\n\n\n\nvar firestoreNamespace = {\n    Firestore: PublicFirestore,\n    GeoPoint: geo_point_GeoPoint,\n    Blob: PublicBlob,\n    Transaction: PublicTransaction,\n    WriteBatch: PublicWriteBatch,\n    DocumentReference: PublicDocumentReference,\n    DocumentSnapshot: PublicDocumentSnapshot,\n    Query: PublicQuery,\n    QueryDocumentSnapshot: PublicQueryDocumentSnapshot,\n    QuerySnapshot: PublicQuerySnapshot,\n    CollectionReference: PublicCollectionReference,\n    FieldPath: field_path_FieldPath,\n    FieldValue: PublicFieldValue,\n    setLogLevel: database_Firestore.setLogLevel\n};\n/**\n * Configures Firestore as part of the Firebase SDK by calling registerService.\n */\nfunction configureForFirebase(firebase) {\n    firebase.INTERNAL.registerService('firestore', function (app) { return new database_Firestore(app); }, shallowCopy(firestoreNamespace));\n}\n/**\n * Exports the Firestore namespace into the provided `exportObject` object under\n * the key 'firestore'. This is used for wrapped binary that exposes Firestore\n * as a goog module.\n */\nfunction configureForStandalone(exportObject) {\n    var copiedNamespace = shallowCopy(firestoreNamespace);\n    // Unlike the use with Firebase, the standalone allows the use of the\n    // constructor, so export it's internal class\n    copiedNamespace['Firestore'] = database_Firestore;\n    exportObject['firestore'] = copiedNamespace;\n}\n\n//# sourceMappingURL=config.js.map\n\n// CONCATENATED MODULE: ../firestore/dist/esm/index.js\n/* harmony export (immutable) */ __webpack_exports__[\"registerFirestore\"] = registerFirestore;\n/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n\n\nfunction registerFirestore(instance) {\n    configureForFirebase(instance);\n}\nregisterFirestore(esm[\"default\"]);\n\n//# sourceMappingURL=index.js.map\n\n\n/***/ }),\n\n/***/ 115:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {(function() {var g,goog=goog||{},k=this;function l(a){return\"string\"==typeof a}function aa(){}\nfunction ba(a){var b=typeof a;if(\"object\"==b)if(a){if(a instanceof Array)return\"array\";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if(\"[object Window]\"==c)return\"object\";if(\"[object Array]\"==c||\"number\"==typeof a.length&&\"undefined\"!=typeof a.splice&&\"undefined\"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable(\"splice\"))return\"array\";if(\"[object Function]\"==c||\"undefined\"!=typeof a.call&&\"undefined\"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable(\"call\"))return\"function\"}else return\"null\";\nelse if(\"function\"==b&&\"undefined\"==typeof a.call)return\"object\";return b}function n(a){return\"array\"==ba(a)}function ca(a){var b=ba(a);return\"array\"==b||\"object\"==b&&\"number\"==typeof a.length}function da(a){return\"function\"==ba(a)}function ea(a){var b=typeof a;return\"object\"==b&&null!=a||\"function\"==b}var p=\"closure_uid_\"+(1E9*Math.random()>>>0),fa=0;function ha(a,b,c){return a.call.apply(a.bind,arguments)}\nfunction ia(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}}function q(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf(\"native code\")?q=ha:q=ia;return q.apply(null,arguments)}\nfunction ja(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=c.slice();b.push.apply(b,arguments);return a.apply(this,b)}}var r=Date.now||function(){return+new Date};function t(a,b){function c(){}c.prototype=b.prototype;a.H=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.Db=function(a,c,f){for(var d=Array(arguments.length-2),e=2;e<arguments.length;e++)d[e-2]=arguments[e];return b.prototype[c].apply(a,d)}};function ka(a){if(Error.captureStackTrace)Error.captureStackTrace(this,ka);else{var b=Error().stack;b&&(this.stack=b)}a&&(this.message=String(a))}t(ka,Error);ka.prototype.name=\"CustomError\";function la(a,b){a=a.split(\"%s\");for(var c=\"\",d=a.length-1,e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:\"%s\");ka.call(this,c+a[d])}t(la,ka);la.prototype.name=\"AssertionError\";function ma(a,b){throw new la(\"Failure\"+(a?\": \"+a:\"\"),Array.prototype.slice.call(arguments,1));};function u(){0!=na&&(pa[this[p]||(this[p]=++fa)]=this);this.i=this.i;this.m=this.m}var na=0,pa={};u.prototype.i=!1;u.prototype.$=function(){if(!this.i&&(this.i=!0,this.w(),0!=na)){var a=this[p]||(this[p]=++fa);if(0!=na&&this.m&&0<this.m.length)throw Error(this+\" did not empty its onDisposeCallbacks queue. This probably means it overrode dispose() or disposeInternal() without calling the superclass' method.\");delete pa[a]}};u.prototype.w=function(){if(this.m)for(;this.m.length;)this.m.shift()()};var qa=Array.prototype.indexOf?function(a,b){return Array.prototype.indexOf.call(a,b,void 0)}:function(a,b){if(l(a))return l(b)&&1==b.length?a.indexOf(b,0):-1;for(var c=0;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},ra=Array.prototype.forEach?function(a,b,c){Array.prototype.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=l(a)?a.split(\"\"):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};\nfunction sa(a){a:{var b=ta;for(var c=a.length,d=l(a)?a.split(\"\"):a,e=0;e<c;e++)if(e in d&&b.call(void 0,d[e],e,a)){b=e;break a}b=-1}return 0>b?null:l(a)?a.charAt(b):a[b]}function ua(a){if(!n(a))for(var b=a.length-1;0<=b;b--)delete a[b];a.length=0}function va(a){return Array.prototype.concat.apply([],arguments)}function wa(a){var b=a.length;if(0<b){for(var c=Array(b),d=0;d<b;d++)c[d]=a[d];return c}return[]};function xa(a){return/^[\\s\\xa0]*$/.test(a)}var ya=String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(a)[1]};function za(a,b){return a<b?-1:a>b?1:0};var w;a:{var Aa=k.navigator;if(Aa){var Ba=Aa.userAgent;if(Ba){w=Ba;break a}}w=\"\"}function x(a){return-1!=w.indexOf(a)};function Ca(a,b,c){for(var d in a)b.call(c,a[d],d,a)}function Da(a){var b=[],c=0,d;for(d in a)b[c++]=a[d];return b}function Ea(a){var b=[],c=0,d;for(d in a)b[c++]=d;return b}function Fa(a){var b={},c;for(c in a)b[c]=a[c];return b}var Ga=\"constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf\".split(\" \");\nfunction Ha(a,b){for(var c,d,e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(var f=0;f<Ga.length;f++)c=Ga[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}};function Ia(a){Ia[\" \"](a);return a}Ia[\" \"]=aa;function Ja(a,b){var c=Ka;return Object.prototype.hasOwnProperty.call(c,a)?c[a]:c[a]=b(a)};var La=x(\"Opera\"),y=x(\"Trident\")||x(\"MSIE\"),Ma=x(\"Edge\"),Na=Ma||y,Oa=x(\"Gecko\")&&!(-1!=w.toLowerCase().indexOf(\"webkit\")&&!x(\"Edge\"))&&!(x(\"Trident\")||x(\"MSIE\"))&&!x(\"Edge\"),Pa=-1!=w.toLowerCase().indexOf(\"webkit\")&&!x(\"Edge\");function Qa(){var a=k.document;return a?a.documentMode:void 0}var Ra;\na:{var Sa=\"\",Ta=function(){var a=w;if(Oa)return/rv:([^\\);]+)(\\)|;)/.exec(a);if(Ma)return/Edge\\/([\\d\\.]+)/.exec(a);if(y)return/\\b(?:MSIE|rv)[: ]([^\\);]+)(\\)|;)/.exec(a);if(Pa)return/WebKit\\/(\\S+)/.exec(a);if(La)return/(?:Version)[ \\/]?(\\S+)/.exec(a)}();Ta&&(Sa=Ta?Ta[1]:\"\");if(y){var Ua=Qa();if(null!=Ua&&Ua>parseFloat(Sa)){Ra=String(Ua);break a}}Ra=Sa}var Ka={};\nfunction Va(a){return Ja(a,function(){for(var b=0,c=ya(String(Ra)).split(\".\"),d=ya(String(a)).split(\".\"),e=Math.max(c.length,d.length),f=0;0==b&&f<e;f++){var h=c[f]||\"\",m=d[f]||\"\";do{h=/(\\d*)(\\D*)(.*)/.exec(h)||[\"\",\"\",\"\",\"\"];m=/(\\d*)(\\D*)(.*)/.exec(m)||[\"\",\"\",\"\",\"\"];if(0==h[0].length&&0==m[0].length)break;b=za(0==h[1].length?0:parseInt(h[1],10),0==m[1].length?0:parseInt(m[1],10))||za(0==h[2].length,0==m[2].length)||za(h[2],m[2]);h=h[3];m=m[3]}while(0==b)}return 0<=b})}var Wa;var Xa=k.document;\nWa=Xa&&y?Qa()||(\"CSS1Compat\"==Xa.compatMode?parseInt(Ra,10):5):void 0;var Ya=Object.freeze||function(a){return a};var Za=!y||9<=Number(Wa),$a=y&&!Va(\"9\"),ab=function(){if(!k.addEventListener||!Object.defineProperty)return!1;var a=!1,b=Object.defineProperty({},\"passive\",{get:function(){a=!0}});k.addEventListener(\"test\",aa,b);k.removeEventListener(\"test\",aa,b);return a}();function z(a,b){this.type=a;this.a=this.target=b;this.Qa=!0}z.prototype.b=function(){this.Qa=!1};function bb(a,b){z.call(this,a?a.type:\"\");this.relatedTarget=this.a=this.target=null;this.button=this.screenY=this.screenX=this.clientY=this.clientX=0;this.key=\"\";this.metaKey=this.shiftKey=this.altKey=this.ctrlKey=!1;this.pointerId=0;this.pointerType=\"\";this.c=null;if(a){var c=this.type=a.type,d=a.changedTouches?a.changedTouches[0]:null;this.target=a.target||a.srcElement;this.a=b;if(b=a.relatedTarget){if(Oa){a:{try{Ia(b.nodeName);var e=!0;break a}catch(f){}e=!1}e||(b=null)}}else\"mouseover\"==c?b=\na.fromElement:\"mouseout\"==c&&(b=a.toElement);this.relatedTarget=b;null===d?(this.clientX=void 0!==a.clientX?a.clientX:a.pageX,this.clientY=void 0!==a.clientY?a.clientY:a.pageY,this.screenX=a.screenX||0,this.screenY=a.screenY||0):(this.clientX=void 0!==d.clientX?d.clientX:d.pageX,this.clientY=void 0!==d.clientY?d.clientY:d.pageY,this.screenX=d.screenX||0,this.screenY=d.screenY||0);this.button=a.button;this.key=a.key||\"\";this.ctrlKey=a.ctrlKey;this.altKey=a.altKey;this.shiftKey=a.shiftKey;this.metaKey=\na.metaKey;this.pointerId=a.pointerId||0;this.pointerType=l(a.pointerType)?a.pointerType:cb[a.pointerType]||\"\";this.c=a;a.defaultPrevented&&this.b()}}t(bb,z);var cb=Ya({2:\"touch\",3:\"pen\",4:\"mouse\"});bb.prototype.b=function(){bb.H.b.call(this);var a=this.c;if(a.preventDefault)a.preventDefault();else if(a.returnValue=!1,$a)try{if(a.ctrlKey||112<=a.keyCode&&123>=a.keyCode)a.keyCode=-1}catch(b){}};var db=\"closure_listenable_\"+(1E6*Math.random()|0),eb=0;function fb(a,b,c,d,e){this.listener=a;this.proxy=null;this.src=b;this.type=c;this.capture=!!d;this.ga=e;this.key=++eb;this.Z=this.ba=!1}function gb(a){a.Z=!0;a.listener=null;a.proxy=null;a.src=null;a.ga=null};function hb(a){this.src=a;this.a={};this.b=0}hb.prototype.add=function(a,b,c,d,e){var f=a.toString();a=this.a[f];a||(a=this.a[f]=[],this.b++);var h=ib(a,b,d,e);-1<h?(b=a[h],c||(b.ba=!1)):(b=new fb(b,this.src,f,!!d,e),b.ba=c,a.push(b));return b};function jb(a,b){var c=b.type;if(c in a.a){var d=a.a[c],e=qa(d,b),f;(f=0<=e)&&Array.prototype.splice.call(d,e,1);f&&(gb(b),0==a.a[c].length&&(delete a.a[c],a.b--))}}\nfunction ib(a,b,c,d){for(var e=0;e<a.length;++e){var f=a[e];if(!f.Z&&f.listener==b&&f.capture==!!c&&f.ga==d)return e}return-1};var kb=\"closure_lm_\"+(1E6*Math.random()|0),lb={},mb=0;function nb(a,b,c,d,e){if(d&&d.once)return ob(a,b,c,d,e);if(n(b)){for(var f=0;f<b.length;f++)nb(a,b[f],c,d,e);return null}c=pb(c);return a&&a[db]?a.Ha(b,c,ea(d)?!!d.capture:!!d,e):qb(a,b,c,!1,d,e)}\nfunction qb(a,b,c,d,e,f){if(!b)throw Error(\"Invalid event type\");var h=ea(e)?!!e.capture:!!e,m=rb(a);m||(a[kb]=m=new hb(a));c=m.add(b,c,d,h,f);if(c.proxy)return c;d=sb();c.proxy=d;d.src=a;d.listener=c;if(a.addEventListener)ab||(e=h),void 0===e&&(e=!1),a.addEventListener(b.toString(),d,e);else if(a.attachEvent)a.attachEvent(tb(b.toString()),d);else if(a.addListener&&a.removeListener)a.addListener(d);else throw Error(\"addEventListener and attachEvent are unavailable.\");mb++;return c}\nfunction sb(){var a=ub,b=Za?function(c){return a.call(b.src,b.listener,c)}:function(c){c=a.call(b.src,b.listener,c);if(!c)return c};return b}function ob(a,b,c,d,e){if(n(b)){for(var f=0;f<b.length;f++)ob(a,b[f],c,d,e);return null}c=pb(c);return a&&a[db]?a.Ia(b,c,ea(d)?!!d.capture:!!d,e):qb(a,b,c,!0,d,e)}\nfunction vb(a,b,c,d,e){if(n(b))for(var f=0;f<b.length;f++)vb(a,b[f],c,d,e);else(d=ea(d)?!!d.capture:!!d,c=pb(c),a&&a[db])?(a=a.f,b=String(b).toString(),b in a.a&&(f=a.a[b],c=ib(f,c,d,e),-1<c&&(gb(f[c]),Array.prototype.splice.call(f,c,1),0==f.length&&(delete a.a[b],a.b--)))):a&&(a=rb(a))&&(b=a.a[b.toString()],a=-1,b&&(a=ib(b,c,d,e)),(c=-1<a?b[a]:null)&&wb(c))}\nfunction wb(a){if(\"number\"!=typeof a&&a&&!a.Z){var b=a.src;if(b&&b[db])jb(b.f,a);else{var c=a.type,d=a.proxy;b.removeEventListener?b.removeEventListener(c,d,a.capture):b.detachEvent?b.detachEvent(tb(c),d):b.addListener&&b.removeListener&&b.removeListener(d);mb--;(c=rb(b))?(jb(c,a),0==c.b&&(c.src=null,b[kb]=null)):gb(a)}}}function tb(a){return a in lb?lb[a]:lb[a]=\"on\"+a}\nfunction xb(a,b,c,d){var e=!0;if(a=rb(a))if(b=a.a[b.toString()])for(b=b.concat(),a=0;a<b.length;a++){var f=b[a];f&&f.capture==c&&!f.Z&&(f=yb(f,d),e=e&&!1!==f)}return e}function yb(a,b){var c=a.listener,d=a.ga||a.src;a.ba&&wb(a);return c.call(d,b)}\nfunction ub(a,b){if(a.Z)return!0;if(!Za){if(!b)a:{b=[\"window\",\"event\"];for(var c=k,d=0;d<b.length;d++)if(c=c[b[d]],null==c){b=null;break a}b=c}d=b;b=new bb(d,this);c=!0;if(!(0>d.keyCode||void 0!=d.returnValue)){a:{var e=!1;if(0==d.keyCode)try{d.keyCode=-1;break a}catch(h){e=!0}if(e||void 0==d.returnValue)d.returnValue=!0}d=[];for(e=b.a;e;e=e.parentNode)d.push(e);a=a.type;for(e=d.length-1;0<=e;e--){b.a=d[e];var f=xb(d[e],a,!0,b);c=c&&f}for(e=0;e<d.length;e++)b.a=d[e],f=xb(d[e],a,!1,b),c=c&&f}return c}return yb(a,\nnew bb(b,this))}function rb(a){a=a[kb];return a instanceof hb?a:null}var zb=\"__closure_events_fn_\"+(1E9*Math.random()>>>0);function pb(a){if(da(a))return a;a[zb]||(a[zb]=function(b){return a.handleEvent(b)});return a[zb]};function A(){u.call(this);this.f=new hb(this);this.N=this;this.J=null}t(A,u);A.prototype[db]=!0;g=A.prototype;g.addEventListener=function(a,b,c,d){nb(this,a,b,c,d)};g.removeEventListener=function(a,b,c,d){vb(this,a,b,c,d)};\ng.dispatchEvent=function(a){var b,c=this.J;if(c)for(b=[];c;c=c.J)b.push(c);c=this.N;var d=a.type||a;if(l(a))a=new z(a,c);else if(a instanceof z)a.target=a.target||c;else{var e=a;a=new z(d,c);Ha(a,e)}e=!0;if(b)for(var f=b.length-1;0<=f;f--){var h=a.a=b[f];e=Ab(h,d,!0,a)&&e}h=a.a=c;e=Ab(h,d,!0,a)&&e;e=Ab(h,d,!1,a)&&e;if(b)for(f=0;f<b.length;f++)h=a.a=b[f],e=Ab(h,d,!1,a)&&e;return e};\ng.w=function(){A.H.w.call(this);if(this.f){var a=this.f,b=0,c;for(c in a.a){for(var d=a.a[c],e=0;e<d.length;e++)++b,gb(d[e]);delete a.a[c];a.b--}}this.J=null};g.Ha=function(a,b,c,d){return this.f.add(String(a),b,!1,c,d)};g.Ia=function(a,b,c,d){return this.f.add(String(a),b,!0,c,d)};\nfunction Ab(a,b,c,d){b=a.f.a[String(b)];if(!b)return!0;b=b.concat();for(var e=!0,f=0;f<b.length;++f){var h=b[f];if(h&&!h.Z&&h.capture==c){var m=h.listener,v=h.ga||h.src;h.ba&&jb(a.f,h);e=!1!==m.call(v,d)&&e}}return e&&0!=d.Qa};function Bb(a){return/^\\s*$/.test(a)?!1:/^[\\],:{}\\s\\u2028\\u2029]*$/.test(a.replace(/\\\\[\"\\\\\\/bfnrtu]/g,\"@\").replace(/(?:\"[^\"\\\\\\n\\r\\u2028\\u2029\\x00-\\x08\\x0a-\\x1f]*\"|true|false|null|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?)[\\s\\u2028\\u2029]*(?=:|,|]|}|$)/g,\"]\").replace(/(?:^|:|,)(?:[\\s\\u2028\\u2029]*\\[)+/g,\"\"))}function Cb(a){a=String(a);if(Bb(a))try{return eval(\"(\"+a+\")\")}catch(b){}throw Error(\"Invalid JSON string: \"+a);}function Db(a){var b=[];Eb(new Fb,a,b);return b.join(\"\")}function Fb(){}\nfunction Eb(a,b,c){if(null==b)c.push(\"null\");else{if(\"object\"==typeof b){if(n(b)){var d=b;b=d.length;c.push(\"[\");for(var e=\"\",f=0;f<b;f++)c.push(e),Eb(a,d[f],c),e=\",\";c.push(\"]\");return}if(b instanceof String||b instanceof Number||b instanceof Boolean)b=b.valueOf();else{c.push(\"{\");e=\"\";for(d in b)Object.prototype.hasOwnProperty.call(b,d)&&(f=b[d],\"function\"!=typeof f&&(c.push(e),Gb(d,c),c.push(\":\"),Eb(a,f,c),e=\",\"));c.push(\"}\");return}}switch(typeof b){case \"string\":Gb(b,c);break;case \"number\":c.push(isFinite(b)&&\n!isNaN(b)?String(b):\"null\");break;case \"boolean\":c.push(String(b));break;case \"function\":c.push(\"null\");break;default:throw Error(\"Unknown type: \"+typeof b);}}}var Hb={'\"':'\\\\\"',\"\\\\\":\"\\\\\\\\\",\"/\":\"\\\\/\",\"\\b\":\"\\\\b\",\"\\f\":\"\\\\f\",\"\\n\":\"\\\\n\",\"\\r\":\"\\\\r\",\"\\t\":\"\\\\t\",\"\\x0B\":\"\\\\u000b\"},Ib=/\\uffff/.test(\"\\uffff\")?/[\\\\\"\\x00-\\x1f\\x7f-\\uffff]/g:/[\\\\\"\\x00-\\x1f\\x7f-\\xff]/g;\nfunction Gb(a,b){b.push('\"',a.replace(Ib,function(a){var b=Hb[a];b||(b=\"\\\\u\"+(a.charCodeAt(0)|65536).toString(16).substr(1),Hb[a]=b);return b}),'\"')};function Jb(a,b){this.c=a;this.f=b;this.b=0;this.a=null}Jb.prototype.get=function(){if(0<this.b){this.b--;var a=this.a;this.a=a.next;a.next=null}else a=this.c();return a};function Kb(){this.b=this.a=null}var Nb=new Jb(function(){return new Mb},function(a){a.reset()});Kb.prototype.add=function(a,b){var c=Nb.get();c.set(a,b);this.b?this.b.next=c:this.a=c;this.b=c};function Ob(){var a=Pb,b=null;a.a&&(b=a.a,a.a=a.a.next,a.a||(a.b=null),b.next=null);return b}function Mb(){this.next=this.b=this.a=null}Mb.prototype.set=function(a,b){this.a=a;this.b=b;this.next=null};Mb.prototype.reset=function(){this.next=this.b=this.a=null};function Qb(a){k.setTimeout(function(){throw a;},0)}var Rb;\nfunction Sb(){var a=k.MessageChannel;\"undefined\"===typeof a&&\"undefined\"!==typeof window&&window.postMessage&&window.addEventListener&&!x(\"Presto\")&&(a=function(){var a=document.createElement(\"IFRAME\");a.style.display=\"none\";a.src=\"\";document.documentElement.appendChild(a);var b=a.contentWindow;a=b.document;a.open();a.write(\"\");a.close();var c=\"callImmediate\"+Math.random(),d=\"file:\"==b.location.protocol?\"*\":b.location.protocol+\"//\"+b.location.host;a=q(function(a){if((\"*\"==d||a.origin==d)&&a.data==\nc)this.port1.onmessage()},this);b.addEventListener(\"message\",a,!1);this.port1={};this.port2={postMessage:function(){b.postMessage(c,d)}}});if(\"undefined\"!==typeof a&&!x(\"Trident\")&&!x(\"MSIE\")){var b=new a,c={},d=c;b.port1.onmessage=function(){if(void 0!==c.next){c=c.next;var a=c.ya;c.ya=null;a()}};return function(a){d.next={ya:a};d=d.next;b.port2.postMessage(0)}}return\"undefined\"!==typeof document&&\"onreadystatechange\"in document.createElement(\"SCRIPT\")?function(a){var b=document.createElement(\"SCRIPT\");\nb.onreadystatechange=function(){b.onreadystatechange=null;b.parentNode.removeChild(b);b=null;a();a=null};document.documentElement.appendChild(b)}:function(a){k.setTimeout(a,0)}};var Tb;function Ub(){if(-1!=String(k.Promise).indexOf(\"[native code]\")){var a=k.Promise.resolve(void 0);Tb=function(){a.then(Vb)}}else Tb=function(){var a=Vb;!da(k.setImmediate)||k.Window&&k.Window.prototype&&!x(\"Edge\")&&k.Window.prototype.setImmediate==k.setImmediate?(Rb||(Rb=Sb()),Rb(a)):k.setImmediate(a)}}var Wb=!1,Pb=new Kb;function Vb(){for(var a;a=Ob();){try{a.a.call(a.b)}catch(c){Qb(c)}var b=Nb;b.f(a);100>b.b&&(b.b++,a.next=b.a,b.a=a)}Wb=!1};function Xb(a,b){A.call(this);this.b=a||1;this.a=b||k;this.c=q(this.lb,this);this.g=r()}t(Xb,A);g=Xb.prototype;g.ea=!1;g.O=null;g.lb=function(){if(this.ea){var a=r()-this.g;0<a&&a<.8*this.b?this.O=this.a.setTimeout(this.c,this.b-a):(this.O&&(this.a.clearTimeout(this.O),this.O=null),this.dispatchEvent(\"tick\"),this.ea&&(this.O=this.a.setTimeout(this.c,this.b),this.g=r()))}};g.start=function(){this.ea=!0;this.O||(this.O=this.a.setTimeout(this.c,this.b),this.g=r())};\nfunction Yb(a){a.ea=!1;a.O&&(a.a.clearTimeout(a.O),a.O=null)}g.w=function(){Xb.H.w.call(this);Yb(this);delete this.a};function Zb(a,b,c){if(da(a))c&&(a=q(a,c));else if(a&&\"function\"==typeof a.handleEvent)a=q(a.handleEvent,a);else throw Error(\"Invalid listener argument\");return 2147483647<Number(b)?-1:k.setTimeout(a,b||0)};function $b(a,b,c){u.call(this);this.f=null!=c?q(a,c):a;this.c=b;this.b=q(this.fb,this);this.a=[]}t($b,u);g=$b.prototype;g.ha=!1;g.Y=null;g.Ya=function(a){this.a=arguments;this.Y?this.ha=!0:ac(this)};g.w=function(){$b.H.w.call(this);this.Y&&(k.clearTimeout(this.Y),this.Y=null,this.ha=!1,this.a=[])};g.fb=function(){this.Y=null;this.ha&&(this.ha=!1,ac(this))};function ac(a){a.Y=Zb(a.b,a.c);a.f.apply(null,a.a)};function bc(a){u.call(this);this.b=a;this.a={}}t(bc,u);var cc=[];function dc(a,b,c,d){n(c)||(c&&(cc[0]=c.toString()),c=cc);for(var e=0;e<c.length;e++){var f=nb(b,c[e],d||a.handleEvent,!1,a.b||a);if(!f)break;a.a[f.key]=f}}function ec(a){Ca(a.a,function(a,c){this.a.hasOwnProperty(c)&&wb(a)},a);a.a={}}bc.prototype.w=function(){bc.H.w.call(this);ec(this)};bc.prototype.handleEvent=function(){throw Error(\"EventHandler.handleEvent not implemented\");};function fc(a,b,c){this.reset(a,b,c,void 0,void 0)}fc.prototype.a=null;var gc=0;fc.prototype.reset=function(a,b,c,d,e){\"number\"==typeof e||gc++;d||r();delete this.a};function hc(a){this.f=a;this.b=this.c=this.a=null}function B(a,b){this.name=a;this.value=b}B.prototype.toString=function(){return this.name};var ic=new B(\"SEVERE\",1E3),jc=new B(\"WARNING\",900),kc=new B(\"INFO\",800),lc=new B(\"CONFIG\",700),mc=new B(\"FINE\",500);function nc(a){if(a.c)return a.c;if(a.a)return nc(a.a);ma(\"Root logger has no level set.\");return null}hc.prototype.log=function(a,b,c){if(a.value>=nc(this).value)for(da(b)&&(b=b()),a=new fc(a,String(b),this.f),c&&(a.a=c),c=this;c;)c=c.a};\nvar oc={},pc=null;function qc(a){pc||(pc=new hc(\"\"),oc[\"\"]=pc,pc.c=lc);var b;if(!(b=oc[a])){b=new hc(a);var c=a.lastIndexOf(\".\"),d=a.substr(c+1);c=qc(a.substr(0,c));c.b||(c.b={});c.b[d]=b;b.a=c;oc[a]=b}return b};function C(a,b){a&&a.log(jc,b,void 0)}function rc(a,b){a&&a.log(kc,b,void 0)}function D(a,b){a&&a.log(mc,b,void 0)};function sc(){this.a=qc(\"goog.labs.net.webChannel.WebChannelDebug\");this.b=!0}sc.prototype.Ea=function(){this.b=!1};function tc(a,b,c,d,e,f){E(a,function(){if(a.b)if(f){var h=\"\";for(var m=f.split(\"&\"),v=0;v<m.length;v++){var I=m[v].split(\"=\");if(1<I.length){var W=I[0];I=I[1];var Lb=W.split(\"_\");h=2<=Lb.length&&\"type\"==Lb[1]?h+(W+\"=\"+I+\"&\"):h+(W+\"=redacted&\")}}}else h=null;else h=f;return\"XMLHTTP REQ (\"+d+\") [attempt \"+e+\"]: \"+b+\"\\n\"+c+\"\\n\"+h})}\nfunction uc(a,b,c,d,e,f,h){E(a,function(){return\"XMLHTTP RESP (\"+d+\") [ attempt \"+e+\"]: \"+b+\"\\n\"+c+\"\\n\"+f+\" \"+h})}function F(a,b,c,d){E(a,function(){return\"XMLHTTP TEXT (\"+b+\"): \"+vc(a,c)+(d?\" \"+d:\"\")})}function wc(a,b){E(a,function(){return\"TIMEOUT: \"+b})}function G(a,b){D(a.a,b)}function xc(a,b,c){(a=a.a)&&a.log(ic,c||\"Exception\",b)}function E(a,b){rc(a.a,b)}function H(a,b){(a=a.a)&&a.log(ic,b,void 0)}\nfunction vc(a,b){if(!a.b)return b;if(!b)return null;try{var c=JSON.parse(b);if(c)for(var d=0;d<c.length;d++)if(n(c[d])){var e=c[d];if(!(2>e.length)){var f=e[1];if(n(f)&&!(1>f.length)){var h=f[0];if(\"noop\"!=h&&\"stop\"!=h&&\"close\"!=h)for(var m=1;m<f.length;m++)f[m]=\"\"}}}return Db(c)}catch(v){return G(a,\"Exception parsing expected JS array - probably was not JS\"),b}};var J=new A;function yc(a){z.call(this,\"serverreachability\",a)}t(yc,z);function zc(a){J.dispatchEvent(new yc(J,a))}function Ac(a){z.call(this,\"statevent\",a)}t(Ac,z);function K(a){J.dispatchEvent(new Ac(J,a))}function Bc(a){z.call(this,\"timingevent\",a)}t(Bc,z);function Cc(a,b,c){J.dispatchEvent(new Bc(J,a,b,c))}function Dc(a,b){if(!da(a))throw Error(\"Fn must not be null and must be a function\");return k.setTimeout(function(){a()},b)};var Ec={NO_ERROR:0,mb:1,tb:2,sb:3,pb:4,rb:5,ub:6,Sa:7,TIMEOUT:8,xb:9};var Fc={ob:\"complete\",Bb:\"success\",Ta:\"error\",Sa:\"abort\",zb:\"ready\",Ab:\"readystatechange\",TIMEOUT:\"timeout\",vb:\"incrementaldata\",yb:\"progress\",qb:\"downloadprogress\",Cb:\"uploadprogress\"};function Gc(){}var Hc={OPEN:\"a\",nb:\"b\",Ta:\"c\",wb:\"d\"};function Ic(){z.call(this,\"d\")}t(Ic,z);function Jc(){z.call(this,\"c\")}t(Jc,z);function Kc(){}Kc.prototype.a=null;function Lc(a){var b;(b=a.a)||(b={},Mc(a)&&(b[0]=!0,b[1]=!0),b=a.a=b);return b};var Nc;function Oc(){}t(Oc,Kc);function Pc(a){return(a=Mc(a))?new ActiveXObject(a):new XMLHttpRequest}function Mc(a){if(!a.b&&\"undefined\"==typeof XMLHttpRequest&&\"undefined\"!=typeof ActiveXObject){for(var b=[\"MSXML2.XMLHTTP.6.0\",\"MSXML2.XMLHTTP.3.0\",\"MSXML2.XMLHTTP\",\"Microsoft.XMLHTTP\"],c=0;c<b.length;c++){var d=b[c];try{return new ActiveXObject(d),a.b=d}catch(e){}}throw Error(\"Could not create ActiveXObject. ActiveX might be disabled, or MSXML might not be installed\");}return a.b}Nc=new Oc;function L(a,b,c,d){this.i=a;this.b=b;this.c=c;this.T=d||1;this.L=new bc(this);this.R=Qc;a=Na?125:void 0;this.S=new Xb(a);this.j=null;this.f=!1;this.l=this.g=this.h=this.J=this.D=this.U=this.s=null;this.u=[];this.a=null;this.G=0;this.m=this.o=null;this.C=-1;this.B=!1;this.N=0;this.I=null;this.v=this.X=this.K=!1}var Qc=45E3;\nfunction Rc(a,b){switch(a){case 0:return\"Non-200 return code (\"+b+\")\";case 1:return\"XMLHTTP failure (no data)\";case 2:return\"HttpConnection timeout\";default:return\"Unknown error\"}}var Sc={},Tc={};g=L.prototype;g.setTimeout=function(a){this.R=a};function Uc(a,b,c){a.J=1;a.h=Vc(M(b));a.l=c;a.K=!0;Wc(a,null)}function Xc(a,b,c,d){a.J=1;a.h=Vc(M(b));a.l=null;a.K=c;Wc(a,d)}\nfunction Wc(a,b){a.D=r();Yc(a);a.g=M(a.h);Zc(a.g,\"t\",a.T);a.G=0;a.a=a.i.ca(a.i.ia()?b:null);0<a.N&&(a.I=new $b(q(a.Ra,a,a.a),a.N));dc(a.L,a.a,\"readystatechange\",a.ib);b=a.j?Fa(a.j):{};a.l?(a.o||(a.o=\"POST\"),b[\"Content-Type\"]=\"application/x-www-form-urlencoded\",a.a.fa(a.g,a.o,a.l,b)):(a.o=\"GET\",a.a.fa(a.g,a.o,null,b));zc(1);tc(a.b,a.o,a.g,a.c,a.T,a.l)}g.ib=function(a){a=a.target;var b=this.I;b&&3==N(a)?(G(this.b,\"Throttling readystatechange.\"),b.Ya()):this.Ra(a)};\ng.Ra=function(a){try{a==this.a?$c(this):C(this.b.a,\"Called back with an unexpected xmlhttp\")}catch(c){if(G(this.b,\"Failed call to OnXmlHttpReadyStateChanged_\"),this.a&&this.a.V()){var b=this;xc(this.b,c,function(){return\"ResponseText: \"+b.a.V()})}else xc(this.b,c,\"No response text\")}finally{}};\nfunction $c(a){var b=N(a.a),c=a.a.Fa(),d=a.a.W();if(!(3>b||3==b&&!Na&&!a.a.V())){a.B||4!=b||7==c||(8==c||0>=d?zc(3):zc(2));ad(a);var e=a.a.W();a.C=e;(c=a.a.V())||G(a.b,function(){return\"No response text for uri \"+a.g+\" status \"+e});a.f=200==e;uc(a.b,a.o,a.g,a.c,a.T,b,e);if(a.f){if(d=bd(a))F(a.b,a.c,d,\"Initial handshake response via X-HTTP-Initial-Response\"),a.v=!0,cd(a,d);a.K?(dd(a,b,c),Na&&a.f&&3==b&&ed(a)):(F(a.b,a.c,c,null),cd(a,c));4==b&&fd(a);a.f&&!a.B&&(4==b?a.i.ta(a):(a.f=!1,Yc(a)))}else 400==\ne&&0<c.indexOf(\"Unknown SID\")?(a.m=3,K(12),C(a.b.a,\"XMLHTTP Unknown SID (\"+a.c+\")\")):(a.m=0,K(13),C(a.b.a,\"XMLHTTP Bad status \"+e+\" (\"+a.c+\")\")),fd(a),gd(a)}}function bd(a){return!a.X||a.v?null:a.a&&(a=hd(a.a,\"X-HTTP-Initial-Response\"))&&!xa(a)?a:null}\nfunction dd(a,b,c){for(var d=!0;!a.B&&a.G<c.length;){var e=id(a,c);if(e==Tc){4==b&&(a.m=4,K(14),d=!1);F(a.b,a.c,null,\"[Incomplete Response]\");break}else if(e==Sc){a.m=4;K(15);F(a.b,a.c,c,\"[Invalid Chunk]\");d=!1;break}else F(a.b,a.c,e,null),cd(a,e)}4==b&&0==c.length&&(a.m=1,K(16),d=!1);a.f=a.f&&d;d||(F(a.b,a.c,c,\"[Invalid Chunked Response]\"),fd(a),gd(a))}g.hb=function(){if(this.a){var a=N(this.a),b=this.a.V();this.G<b.length&&(ad(this),dd(this,a,b),this.f&&4!=a&&Yc(this))}};\nfunction ed(a){dc(a.L,a.S,\"tick\",a.hb);a.S.start()}function id(a,b){var c=a.G,d=b.indexOf(\"\\n\",c);if(-1==d)return Tc;c=Number(b.substring(c,d));if(isNaN(c))return Sc;d+=1;if(d+c>b.length)return Tc;b=b.substr(d,c);a.G=d+c;return b}g.cancel=function(){this.B=!0;fd(this)};function Yc(a){a.U=r()+a.R;jd(a,a.R)}function jd(a,b){if(null!=a.s)throw Error(\"WatchDog timer not null\");a.s=Dc(q(a.gb,a),b)}function ad(a){a.s&&(k.clearTimeout(a.s),a.s=null)}\ng.gb=function(){this.s=null;var a=r();0<=a-this.U?(this.f&&H(this.b,\"Received watchdog timeout even though request loaded successfully\"),wc(this.b,this.g),2!=this.J&&(zc(3),K(17)),fd(this),this.m=2,gd(this)):(C(this.b.a,\"WatchDog timer called too early\"),jd(this,this.U-a))};function gd(a){a.i.Ka()||a.B||a.i.ta(a)}function fd(a){ad(a);var b=a.I;b&&\"function\"==typeof b.$&&b.$();a.I=null;Yb(a.S);ec(a.L);a.a&&(b=a.a,a.a=null,b.abort(),b.$())}\nfunction cd(a,b){try{a.i.Na(a,b),zc(4)}catch(c){xc(a.b,c,\"Error in httprequest callback\")}};function kd(a){if(a.A&&\"function\"==typeof a.A)return a.A();if(l(a))return a.split(\"\");if(ca(a)){for(var b=[],c=a.length,d=0;d<c;d++)b.push(a[d]);return b}return Da(a)}\nfunction ld(a,b){if(a.forEach&&\"function\"==typeof a.forEach)a.forEach(b,void 0);else if(ca(a)||l(a))ra(a,b,void 0);else{if(a.M&&\"function\"==typeof a.M)var c=a.M();else if(a.A&&\"function\"==typeof a.A)c=void 0;else if(ca(a)||l(a)){c=[];for(var d=a.length,e=0;e<d;e++)c.push(e)}else c=Ea(a);d=kd(a);e=d.length;for(var f=0;f<e;f++)b.call(void 0,d[f],c&&c[f],a)}};function O(a,b){this.b={};this.a=[];this.c=0;var c=arguments.length;if(1<c){if(c%2)throw Error(\"Uneven number of arguments\");for(var d=0;d<c;d+=2)this.set(arguments[d],arguments[d+1])}else if(a)if(a instanceof O)for(c=a.M(),d=0;d<c.length;d++)this.set(c[d],a.get(c[d]));else for(d in a)this.set(d,a[d])}g=O.prototype;g.A=function(){md(this);for(var a=[],b=0;b<this.a.length;b++)a.push(this.b[this.a[b]]);return a};g.M=function(){md(this);return this.a.concat()};\nfunction nd(a){a.b={};a.a.length=0;a.c=0}function od(a,b){return P(a.b,b)?(delete a.b[b],a.c--,a.a.length>2*a.c&&md(a),!0):!1}function md(a){if(a.c!=a.a.length){for(var b=0,c=0;b<a.a.length;){var d=a.a[b];P(a.b,d)&&(a.a[c++]=d);b++}a.a.length=c}if(a.c!=a.a.length){var e={};for(c=b=0;b<a.a.length;)d=a.a[b],P(e,d)||(a.a[c++]=d,e[d]=1),b++;a.a.length=c}}g.get=function(a,b){return P(this.b,a)?this.b[a]:b};g.set=function(a,b){P(this.b,a)||(this.c++,this.a.push(a));this.b[a]=b};\ng.forEach=function(a,b){for(var c=this.M(),d=0;d<c.length;d++){var e=c[d],f=this.get(e);a.call(b,f,e,this)}};function P(a,b){return Object.prototype.hasOwnProperty.call(a,b)};var pd=/^(?:([^:/?#.]+):)?(?:\\/\\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\\?([^#]*))?(?:#([\\s\\S]*))?$/;function qd(a,b){if(a){a=a.split(\"&\");for(var c=0;c<a.length;c++){var d=a[c].indexOf(\"=\"),e=null;if(0<=d){var f=a[c].substring(0,d);e=a[c].substring(d+1)}else f=a[c];b(f,e?decodeURIComponent(e.replace(/\\+/g,\" \")):\"\")}}};function Q(a,b){this.b=this.j=this.f=\"\";this.i=null;this.g=this.a=\"\";this.h=!1;var c;a instanceof Q?(this.h=void 0!==b?b:a.h,rd(this,a.f),this.j=a.j,sd(this,a.b),td(this,a.i),this.a=a.a,ud(this,vd(a.c)),this.g=a.g):a&&(c=String(a).match(pd))?(this.h=!!b,rd(this,c[1]||\"\",!0),this.j=wd(c[2]||\"\"),sd(this,c[3]||\"\",!0),td(this,c[4]),this.a=wd(c[5]||\"\",!0),ud(this,c[6]||\"\",!0),this.g=wd(c[7]||\"\")):(this.h=!!b,this.c=new xd(null,this.h))}\nQ.prototype.toString=function(){var a=[],b=this.f;b&&a.push(yd(b,zd,!0),\":\");var c=this.b;if(c||\"file\"==b)a.push(\"//\"),(b=this.j)&&a.push(yd(b,zd,!0),\"@\"),a.push(encodeURIComponent(String(c)).replace(/%25([0-9a-fA-F]{2})/g,\"%$1\")),c=this.i,null!=c&&a.push(\":\",String(c));if(c=this.a)this.b&&\"/\"!=c.charAt(0)&&a.push(\"/\"),a.push(yd(c,\"/\"==c.charAt(0)?Ad:Bd,!0));(c=this.c.toString())&&a.push(\"?\",c);(c=this.g)&&a.push(\"#\",yd(c,Cd));return a.join(\"\")};\nQ.prototype.resolve=function(a){var b=M(this),c=!!a.f;c?rd(b,a.f):c=!!a.j;c?b.j=a.j:c=!!a.b;c?sd(b,a.b):c=null!=a.i;var d=a.a;if(c)td(b,a.i);else if(c=!!a.a){if(\"/\"!=d.charAt(0))if(this.b&&!this.a)d=\"/\"+d;else{var e=b.a.lastIndexOf(\"/\");-1!=e&&(d=b.a.substr(0,e+1)+d)}e=d;if(\"..\"==e||\".\"==e)d=\"\";else if(-1!=e.indexOf(\"./\")||-1!=e.indexOf(\"/.\")){d=0==e.lastIndexOf(\"/\",0);e=e.split(\"/\");for(var f=[],h=0;h<e.length;){var m=e[h++];\".\"==m?d&&h==e.length&&f.push(\"\"):\"..\"==m?((1<f.length||1==f.length&&\"\"!=\nf[0])&&f.pop(),d&&h==e.length&&f.push(\"\")):(f.push(m),d=!0)}d=f.join(\"/\")}else d=e}c?b.a=d:c=\"\"!==a.c.toString();c?ud(b,vd(a.c)):c=!!a.g;c&&(b.g=a.g);return b};function M(a){return new Q(a)}function rd(a,b,c){a.f=c?wd(b,!0):b;a.f&&(a.f=a.f.replace(/:$/,\"\"))}function sd(a,b,c){a.b=c?wd(b,!0):b}function td(a,b){if(b){b=Number(b);if(isNaN(b)||0>b)throw Error(\"Bad port number \"+b);a.i=b}else a.i=null}function ud(a,b,c){b instanceof xd?(a.c=b,Dd(a.c,a.h)):(c||(b=yd(b,Ed)),a.c=new xd(b,a.h))}\nfunction R(a,b,c){a.c.set(b,c)}function Zc(a,b,c){n(c)||(c=[String(c)]);Fd(a.c,b,c)}function Vc(a){R(a,\"zx\",Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^r()).toString(36));return a}function Gd(a){return a instanceof Q?M(a):new Q(a,void 0)}function Hd(a,b,c,d){var e=new Q(null,void 0);a&&rd(e,a);b&&sd(e,b);c&&td(e,c);d&&(e.a=d);return e}function wd(a,b){return a?b?decodeURI(a.replace(/%25/g,\"%2525\")):decodeURIComponent(a):\"\"}\nfunction yd(a,b,c){return l(a)?(a=encodeURI(a).replace(b,Id),c&&(a=a.replace(/%25([0-9a-fA-F]{2})/g,\"%$1\")),a):null}function Id(a){a=a.charCodeAt(0);return\"%\"+(a>>4&15).toString(16)+(a&15).toString(16)}var zd=/[#\\/\\?@]/g,Bd=/[#\\?:]/g,Ad=/[#\\?]/g,Ed=/[#\\?@]/g,Cd=/#/g;function xd(a,b){this.b=this.a=null;this.c=a||null;this.f=!!b}function S(a){a.a||(a.a=new O,a.b=0,a.c&&qd(a.c,function(b,c){a.add(decodeURIComponent(b.replace(/\\+/g,\" \")),c)}))}g=xd.prototype;\ng.add=function(a,b){S(this);this.c=null;a=Jd(this,a);var c=this.a.get(a);c||this.a.set(a,c=[]);c.push(b);this.b+=1;return this};function Kd(a,b){S(a);b=Jd(a,b);P(a.a.b,b)&&(a.c=null,a.b-=a.a.get(b).length,od(a.a,b))}function Ld(a,b){S(a);b=Jd(a,b);return P(a.a.b,b)}g.forEach=function(a,b){S(this);this.a.forEach(function(c,d){ra(c,function(c){a.call(b,c,d,this)},this)},this)};\ng.M=function(){S(this);for(var a=this.a.A(),b=this.a.M(),c=[],d=0;d<b.length;d++)for(var e=a[d],f=0;f<e.length;f++)c.push(b[d]);return c};g.A=function(a){S(this);var b=[];if(l(a))Ld(this,a)&&(b=va(b,this.a.get(Jd(this,a))));else{a=this.a.A();for(var c=0;c<a.length;c++)b=va(b,a[c])}return b};g.set=function(a,b){S(this);this.c=null;a=Jd(this,a);Ld(this,a)&&(this.b-=this.a.get(a).length);this.a.set(a,[b]);this.b+=1;return this};g.get=function(a,b){a=a?this.A(a):[];return 0<a.length?String(a[0]):b};\nfunction Fd(a,b,c){Kd(a,b);0<c.length&&(a.c=null,a.a.set(Jd(a,b),wa(c)),a.b+=c.length)}g.toString=function(){if(this.c)return this.c;if(!this.a)return\"\";for(var a=[],b=this.a.M(),c=0;c<b.length;c++){var d=b[c],e=encodeURIComponent(String(d));d=this.A(d);for(var f=0;f<d.length;f++){var h=e;\"\"!==d[f]&&(h+=\"=\"+encodeURIComponent(String(d[f])));a.push(h)}}return this.c=a.join(\"&\")};function vd(a){var b=new xd;b.c=a.c;a.a&&(b.a=new O(a.a),b.b=a.b);return b}\nfunction Jd(a,b){b=String(b);a.f&&(b=b.toLowerCase());return b}function Dd(a,b){b&&!a.f&&(S(a),a.c=null,a.a.forEach(function(a,b){var c=b.toLowerCase();b!=c&&(Kd(this,b),Fd(this,c,a))},a));a.f=b};function Md(){this.a=r()}var Nd=null;Md.prototype.set=function(a){this.a=a};Md.prototype.reset=function(){this.set(r())};Md.prototype.get=function(){return this.a};function Od(){Nd||(Nd=new Md)}function Pd(){Nd||(Nd=new Md)}t(Pd,Od);function Qd(a,b){this.a=a;this.b=b;this.c=this.i=null;this.h=!1;this.m=null;this.f=-1;this.l=this.g=null}g=Qd.prototype;g.P=null;\nfunction Rd(a){G(a.b,\"TestConnection: starting stage 2\");var b=a.a.I.a;if(null!=b)G(a.b,function(){return true?\"Buffered\":\"Unbuffered\"}),K(4),b?(K(10),Sd(a.a,a,!1)):(K(11),Sd(a.a,a,!0));else{a.c=new L(a,a.b,void 0,void 0);a.c.j=a.i;var c=Td(a.a,a.g,a.m);K(4);Zc(c,\"TYPE\",\"xmlhttp\");var d=a.a.j,e=a.a.K;d&&e&&R(c,d,e);Xc(a.c,c,!1,a.g)}}g.ca=function(a){return this.a.ca(a)};g.abort=function(){this.c&&(this.c.cancel(),this.c=null);this.f=-1};\ng.Ka=function(){return!1};\ng.Na=function(a,b){this.f=a.C;if(0==this.P){G(this.b,\"TestConnection: Got data for stage 1\");if(!this.a.o&&(a=a.a)){var c=hd(a,\"X-Client-Wire-Protocol\");this.l=c?c:null;this.a.j&&((a=hd(a,\"X-HTTP-Session-Id\"))?this.a.K=a:C(this.b.a,\"Missing X_HTTP_SESSION_ID in the handshake response\"))}if(b){try{var d=this.a.la.a.parse(b)}catch(e){xc(this.b,e);Ud(this.a,this);return}this.g=d[0]}else G(this.b,\"TestConnection: Null responseText\"),Ud(this.a,this)}else if(1==this.P)if(this.h)K(6);else if(\"11111\"==b){if(K(5),\nthis.h=!0,!y||10<=Number(Wa))this.f=200,this.c.cancel(),G(this.b,\"Test connection succeeded; using streaming connection\"),K(11),Sd(this.a,this,!0)}else K(7),this.h=!1};\ng.ta=function(){this.f=this.c.C;this.c.f?0==this.P?(this.P=1,G(this.b,\"TestConnection: request complete for initial check\"),Rd(this)):1==this.P&&(G(this.b,\"TestConnection: request complete for stage 2\"),this.h?(G(this.b,\"Test connection succeeded; using streaming connection\"),K(11),Sd(this.a,this,!0)):(G(this.b,\"Test connection failed; not using streaming\"),K(10),Sd(this.a,this,!1))):(G(this.b,\"TestConnection: request failed, in state \"+this.P),0==this.P?K(8):1==this.P&&K(9),Ud(this.a,this))};\ng.ia=function(){return this.a.ia()};g.qa=function(){return this.a.qa()};function Vd(){this.a=this.b=null};function Wd(){this.a=new O}function Xd(a){var b=typeof a;return\"object\"==b&&a||\"function\"==b?\"o\"+(a[p]||(a[p]=++fa)):b.charAt(0)+a}Wd.prototype.add=function(a){this.a.set(Xd(a),a)};Wd.prototype.A=function(){return this.a.A()};function Yd(a,b){this.a=a;this.b=b};function Zd(a){this.g=a||$d;this.f=k.oa&&k.oa.La&&k.oa.La()&&k.oa.La().Fb?this.g:1;this.a=null;1<this.f&&(this.a=new Wd);this.b=null;this.c=[]}var $d=10;function ae(a,b){a.a||-1==b.indexOf(\"spdy\")&&-1==b.indexOf(\"quic\")&&-1==b.indexOf(\"h2\")||(a.f=a.g,a.a=new Wd,a.b&&(be(a,a.b),a.b=null))}function ce(a){return a.b?!0:a.a?a.a.a.c>=a.f:!1}function de(a,b){a.b?a=a.b==b:a.a?(b=Xd(b),a=P(a.a.a.b,b)):a=!1;return a}function be(a,b){a.a?a.a.add(b):a.b=b}\nfunction ee(a,b){if(a.b&&a.b==b)a.b=null;else{var c;if(c=a.a)c=Xd(b),c=P(a.a.a.b,c);c&&od(a.a.a,Xd(b))}}Zd.prototype.cancel=function(){this.c=fe(this);this.b?(this.b.cancel(),this.b=null):this.a&&0!=this.a.a.c&&(ra(this.a.A(),function(a){a.cancel()}),nd(this.a.a))};function fe(a){if(null!=a.b)return a.c.concat(a.b.u);if(null!=a.a&&0!=a.a.a.c){var b=a.c;ra(a.a.A(),function(a){b=b.concat(a.u)});return b}return wa(a.c)}function ge(a,b){a.c=a.c.concat(b)};function he(){}he.prototype.stringify=function(a){return k.JSON.stringify(a,void 0)};he.prototype.parse=function(a){return k.JSON.parse(a,void 0)};function ie(){this.a=new he}function je(a,b,c){var d=c||\"\";try{ld(a,function(a,c){var e=a;ea(a)&&(e=Db(a));b.push(d+c+\"=\"+encodeURIComponent(e))})}catch(e){throw b.push(d+\"type=\"+encodeURIComponent(\"_badmap\")),e;}};function ke(a,b){var c=new sc;G(c,\"TestLoadImage: loading \"+a);var d=new Image;d.onload=ja(le,c,d,\"TestLoadImage: loaded\",!0,b);d.onerror=ja(le,c,d,\"TestLoadImage: error\",!1,b);d.onabort=ja(le,c,d,\"TestLoadImage: abort\",!1,b);d.ontimeout=ja(le,c,d,\"TestLoadImage: timeout\",!1,b);k.setTimeout(function(){if(d.ontimeout)d.ontimeout()},1E4);d.src=a}function le(a,b,c,d,e){try{G(a,c),b.onload=null,b.onerror=null,b.onabort=null,b.ontimeout=null,e(d)}catch(f){xc(a,f)}};function T(a){A.call(this);this.headers=new O;this.D=a||null;this.c=!1;this.v=this.a=null;this.K=this.u=\"\";this.j=0;this.g=\"\";this.h=this.I=this.s=this.G=!1;this.l=0;this.B=null;this.L=me;this.C=this.o=!1}t(T,A);var me=\"\";T.prototype.b=qc(\"goog.net.XhrIo\");var ne=/^https?$/i,oe=[\"POST\",\"PUT\"];g=T.prototype;\ng.fa=function(a,b,c,d){if(this.a)throw Error(\"[goog.net.XhrIo] Object is active with another request=\"+this.u+\"; newUri=\"+a);b=b?b.toUpperCase():\"GET\";this.u=a;this.g=\"\";this.j=0;this.K=b;this.G=!1;this.c=!0;this.a=this.D?Pc(this.D):Pc(Nc);this.v=this.D?Lc(this.D):Lc(Nc);this.a.onreadystatechange=q(this.Ma,this);try{D(this.b,U(this,\"Opening Xhr\")),this.I=!0,this.a.open(b,String(a),!0),this.I=!1}catch(f){D(this.b,U(this,\"Error opening Xhr: \"+f.message));pe(this,f);return}a=c||\"\";var e=new O(this.headers);\nd&&ld(d,function(a,b){e.set(b,a)});d=sa(e.M());c=k.FormData&&a instanceof k.FormData;!(0<=qa(oe,b))||d||c||e.set(\"Content-Type\",\"application/x-www-form-urlencoded;charset=utf-8\");e.forEach(function(a,b){this.a.setRequestHeader(b,a)},this);this.L&&(this.a.responseType=this.L);\"withCredentials\"in this.a&&this.a.withCredentials!==this.o&&(this.a.withCredentials=this.o);try{qe(this),0<this.l&&(this.C=re(this.a),D(this.b,U(this,\"Will abort after \"+this.l+\"ms if incomplete, xhr2 \"+this.C)),this.C?(this.a.timeout=\nthis.l,this.a.ontimeout=q(this.Ja,this)):this.B=Zb(this.Ja,this.l,this)),D(this.b,U(this,\"Sending request\")),this.s=!0,this.a.send(a),this.s=!1}catch(f){D(this.b,U(this,\"Send error: \"+f.message)),pe(this,f)}};function re(a){return y&&Va(9)&&\"number\"==typeof a.timeout&&void 0!==a.ontimeout}function ta(a){return\"content-type\"==a.toLowerCase()}\ng.Ja=function(){\"undefined\"!=typeof goog&&this.a&&(this.g=\"Timed out after \"+this.l+\"ms, aborting\",this.j=8,D(this.b,U(this,this.g)),this.dispatchEvent(\"timeout\"),this.abort(8))};function pe(a,b){a.c=!1;a.a&&(a.h=!0,a.a.abort(),a.h=!1);a.g=b;a.j=5;se(a);te(a)}function se(a){a.G||(a.G=!0,a.dispatchEvent(\"complete\"),a.dispatchEvent(\"error\"))}\ng.abort=function(a){this.a&&this.c&&(D(this.b,U(this,\"Aborting\")),this.c=!1,this.h=!0,this.a.abort(),this.h=!1,this.j=a||7,this.dispatchEvent(\"complete\"),this.dispatchEvent(\"abort\"),te(this))};g.w=function(){this.a&&(this.c&&(this.c=!1,this.h=!0,this.a.abort(),this.h=!1),te(this,!0));T.H.w.call(this)};g.Ma=function(){this.i||(this.I||this.s||this.h?ue(this):this.eb())};g.eb=function(){ue(this)};\nfunction ue(a){if(a.c&&\"undefined\"!=typeof goog)if(a.v[1]&&4==N(a)&&2==a.W())D(a.b,U(a,\"Local request error detected and ignored\"));else if(a.s&&4==N(a))Zb(a.Ma,0,a);else if(a.dispatchEvent(\"readystatechange\"),4==N(a)){D(a.b,U(a,\"Request complete\"));a.c=!1;try{var b=a.W();a:switch(b){case 200:case 201:case 202:case 204:case 206:case 304:case 1223:var c=!0;break a;default:c=!1}var d;if(!(d=c)){var e;if(e=0===b){var f=String(a.u).match(pd)[1]||null;if(!f&&k.self&&k.self.location){var h=k.self.location.protocol;\nf=h.substr(0,h.length-1)}e=!ne.test(f?f.toLowerCase():\"\")}d=e}d?(a.dispatchEvent(\"complete\"),a.dispatchEvent(\"success\")):(a.j=6,a.g=a.Ga()+\" [\"+a.W()+\"]\",se(a))}finally{te(a)}}}function te(a,b){if(a.a){qe(a);var c=a.a,d=a.v[0]?aa:null;a.a=null;a.v=null;b||a.dispatchEvent(\"ready\");try{c.onreadystatechange=d}catch(e){(a=a.b)&&a.log(ic,\"Problem encountered resetting onreadystatechange: \"+e.message,void 0)}}}function qe(a){a.a&&a.C&&(a.a.ontimeout=null);a.B&&(k.clearTimeout(a.B),a.B=null)}\nfunction N(a){return a.a?a.a.readyState:0}g.W=function(){try{return 2<N(this)?this.a.status:-1}catch(a){return-1}};g.Ga=function(){try{return 2<N(this)?this.a.statusText:\"\"}catch(a){return D(this.b,\"Can not get status: \"+a.message),\"\"}};g.V=function(){try{return this.a?this.a.responseText:\"\"}catch(a){return D(this.b,\"Can not get responseText: \"+a.message),\"\"}};\ng.Za=function(a){if(this.a){var b=this.a.responseText;a&&0==b.indexOf(a)&&(b=b.substring(a.length));a:{a=b;if(k.JSON)try{var c=k.JSON.parse(a);break a}catch(d){}c=Cb(a)}return c}};function hd(a,b){return a.a?a.a.getResponseHeader(b):null}g.Fa=function(){return this.j};g.bb=function(){return l(this.g)?this.g:String(this.g)};function U(a,b){return b+\" [\"+a.K+\" \"+a.u+\" \"+a.W()+\"]\"};function ve(a){var b=\"\";Ca(a,function(a,d){b+=d;b+=\":\";b+=a;b+=\"\\r\\n\"});return b}function we(a,b,c){a:{for(d in c){var d=!1;break a}d=!0}if(d)return a;c=ve(c);if(l(a)){b=encodeURIComponent(String(b));c=null!=c?\"=\"+encodeURIComponent(String(c)):\"\";if(b+=c){c=a.indexOf(\"#\");0>c&&(c=a.length);d=a.indexOf(\"?\");if(0>d||d>c){d=c;var e=\"\"}else e=a.substring(d+1,c);a=[a.substr(0,d),e,a.substr(c)];c=a[1];a[1]=b?c?c+\"&\"+b:b:c;a=a[0]+(a[1]?\"?\"+a[1]:\"\")+a[2]}return a}R(a,b,c);return a};function xe(a){this.xa=0;this.g=[];this.a=new sc;this.I=new Vd;this.X=this.ua=this.D=this.ja=this.b=this.K=this.j=this.U=this.h=this.L=this.i=null;this.Va=this.R=0;this.Ua=a&&a.Eb||!1;this.ka=this.C=this.s=this.l=this.m=this.f=null;this.u=this.wa=this.N=-1;this.T=this.B=this.v=0;this.G=void 0;this.S=a&&a.supportsCrossDomainXhr||!1;this.J=\"\";this.c=new Zd(a&&a.concurrentRequestLimit);this.la=new ie;this.o=a&&void 0!==a.backgroundChannelTest?a.backgroundChannelTest:!0;(this.va=a&&a.fastHandshake||!1)&&\n!this.o&&(C(this.a.a,\"Force backgroundChannelTest when fastHandshake is enabled.\"),this.o=!0);a&&a.Ea&&this.a.Ea()}g=xe.prototype;g.na=8;g.F=1;\nfunction ye(a){G(a.a,\"disconnect()\");ze(a);if(3==a.F){var b=a.R++,c=M(a.D);R(c,\"SID\",a.J);R(c,\"RID\",b);R(c,\"TYPE\",\"terminate\");Ae(a,c);b=new L(a,a.a,b,void 0);b.J=2;b.h=Vc(M(c));c=!1;k.navigator&&k.navigator.sendBeacon&&(c=k.navigator.sendBeacon(b.h.toString(),\"\"));!c&&k.Image&&((new Image).src=b.h,c=!0);c||(b.a=b.i.ca(null),b.a.fa(b.h));b.D=r();Yc(b)}Be(a)}\nfunction ze(a){a.C&&(a.C.abort(),a.C=null);a.b&&(a.b.cancel(),a.b=null);a.l&&(k.clearTimeout(a.l),a.l=null);Ce(a);a.c.cancel();a.m&&(k.clearTimeout(a.m),a.m=null)}function De(a,b){1E3==a.g.length&&H(a.a,function(){return\"Already have 1000 queued maps upon queueing \"+Db(b)});a.g.push(new Yd(a.Va++,b));3==a.F&&Ee(a)}g.Ka=function(){return 0==this.F};function Ee(a){ce(a.c)||a.m||(a.m=Dc(q(a.Pa,a),0),a.v=0)}\nfunction Fe(a,b){var c=a.c;if((c.b?1:c.a?c.a.a.c:0)>=a.c.f-(a.m?1:0))return H(a.a,\"Unexpected retry request is scheduled.\"),!1;if(a.m)return G(a.a,\"Use the retry request that is already scheduled.\"),a.g=b.u.concat(a.g),!0;if(1==a.F||2==a.F||a.v>=(a.Ua?0:2))return!1;G(a.a,\"Going to retry POST\");a.m=Dc(q(a.Pa,a,b),Ge(a,a.v));a.v++;return!0}\ng.Pa=function(a){this.m=null;G(this.a,\"startForwardChannel_\");if(1==this.F)if(a)H(this.a,\"Not supposed to retry the open\");else{G(this.a,\"open_()\");this.R=Math.floor(1E5*Math.random());a=this.R++;var b=new L(this,this.a,a,void 0),c=this.i;this.L&&(c?(c=Fa(c),Ha(c,this.L)):c=this.L);null===this.h&&(b.j=c);var d=He(this,b),e=M(this.D);R(e,\"RID\",a);R(e,\"CVER\",22);this.o&&this.j&&R(e,\"X-HTTP-Session-Id\",this.j);Ae(this,e);this.h&&c&&we(e,this.h,c);be(this.c,b);this.va?(R(e,\"$req\",d),R(e,\"SID\",\"null\"),\nb.X=!0,Uc(b,e,null)):Uc(b,e,d);this.F=2}else 3==this.F&&(a?Ie(this,a):0==this.g.length?G(this.a,\"startForwardChannel_ returned: nothing to send\"):ce(this.c)?H(this.a,\"startForwardChannel_ returned: connection already in progress\"):(Ie(this),G(this.a,\"startForwardChannel_ finished, sent request\")))};\nfunction Ie(a,b){var c;b?c=b.c:c=a.R++;var d=M(a.D);R(d,\"SID\",a.J);R(d,\"RID\",c);R(d,\"AID\",a.N);Ae(a,d);a.h&&a.i&&we(d,a.h,a.i);c=new L(a,a.a,c,a.v+1);null===a.h&&(c.j=a.i);b&&(a.g=b.u.concat(a.g));b=He(a,c);c.setTimeout(1E4+Math.round(1E4*Math.random()));be(a.c,c);Uc(c,d,b)}function Ae(a,b){a.f&&ld({},function(a,d){R(b,d,a)})}\nfunction He(a,b){var c=Math.min(a.g.length,1E3),d=a.f?q(a.f.Wa,a.f,a):null;a:for(var e=a.g,f=-1;;){var h=[\"count=\"+c];-1==f?0<c?(f=e[0].a,h.push(\"ofs=\"+f)):f=0:h.push(\"ofs=\"+f);for(var m=!0,v=0;v<c;v++){var I=e[v].a,W=e[v].b;I-=f;if(0>I)f=Math.max(0,e[v].a-100),m=!1;else try{je(W,h,\"req\"+I+\"_\")}catch(Lb){d&&d(W)}}if(m){d=h.join(\"&\");break a}}a=a.g.splice(0,c);b.u=a;return d}function Je(a){if(!a.b&&!a.l){a.T=1;var b=a.Oa;Tb||Ub();Wb||(Tb(),Wb=!0);Pb.add(b,a);a.B=0}}\nfunction Ke(a){if(a.b||a.l)return H(a.a,\"Request already in progress\"),!1;if(3<=a.B)return!1;G(a.a,\"Going to retry GET\");a.T++;a.l=Dc(q(a.Oa,a),Ge(a,a.B));a.B++;return!0}\ng.Oa=function(){this.l=null;G(this.a,\"Creating new HttpRequest\");this.b=new L(this,this.a,\"rpc\",this.T);null===this.h&&(this.b.j=this.i);this.b.N=0;var a=M(this.ua);R(a,\"RID\",\"rpc\");R(a,\"SID\",this.J);R(a,\"CI\",this.ka?\"0\":\"1\");R(a,\"AID\",this.N);Ae(this,a);R(a,\"TYPE\",\"xmlhttp\");this.h&&this.i&&we(a,this.h,this.i);this.G&&this.b.setTimeout(this.G);Xc(this.b,a,!0,this.X);G(this.a,\"New Request created\")};\nfunction Sd(a,b,c){G(a.a,\"Test Connection Finished\");var d=b.l;d&&ae(a.c,d);a.ka=c;a.u=b.f;G(a.a,\"connectChannel_()\");a.D=Le(a,a.ja);Ee(a)}function Ud(a,b){G(a.a,\"Test Connection Failed\");a.u=b.f;V(a,2)}\ng.Na=function(a,b){if(0!=this.F&&(this.b==a||de(this.c,a)))if(this.u=a.C,!a.v&&de(this.c,a)&&3==this.F){try{var c=this.la.a.parse(b)}catch(f){c=null}if(n(c)&&3==c.length)if(b=c,0==b[0])a:if(G(this.a,\"Server claims our backchannel is missing.\"),this.l)G(this.a,\"But we are currently starting the request.\");else{if(this.b)if(this.b.D+3E3<a.D)Ce(this),this.b.cancel(),this.b=null;else break a;else C(this.a.a,\"We do not have a BackChannel established\");Ke(this);K(18)}else this.wa=b[1],a=this.wa-this.N,\n0<a&&(b=b[2],G(this.a,b+\" bytes (in \"+a+\" arrays) are outstanding on the BackChannel\"),37500>b&&this.ka&&0==this.B&&!this.s&&(this.s=Dc(q(this.cb,this),6E3)));else G(this.a,\"Bad POST response data returned\"),V(this,11)}else if((a.v||this.b==a)&&Ce(this),!xa(b))for(b=c=this.la.a.parse(b),c=0;c<b.length;c++){var d=b[c];this.N=d[0];d=d[1];if(2==this.F)if(\"c\"==d[0]){this.J=d[1];this.X=d[2];var e=d[3];null!=e&&(this.na=e,E(this.a,\"VER=\"+this.na));e=d[4];null!=e&&(this.xa=e,E(this.a,\"SVER=\"+this.xa));d=\nd[5];null!=d&&\"number\"==typeof d&&0<d&&(this.G=d*=1.5,E(this.a,\"backChannelRequestTimeoutMs_=\"+d));this.o&&(d=a.a)&&((e=hd(d,\"X-Client-Wire-Protocol\"))&&ae(this.c,e),this.j&&((d=hd(d,\"X-HTTP-Session-Id\"))?(this.K=d,R(this.D,this.j,d)):C(this.a.a,\"Missing X_HTTP_SESSION_ID in the handshake response\")));this.F=3;this.f&&this.f.Ca();d=a;this.ua=Td(this,this.X,this.ja);d.v?(G(this.a,\"Upgrade the handshake request to a backchannel.\"),ee(this.c,d),(e=this.G)&&d.setTimeout(e),d.s&&(ad(d),Yc(d)),this.b=d):\nJe(this)}else\"stop\"!=d[0]&&\"close\"!=d[0]||V(this,7);else 3==this.F&&(\"stop\"==d[0]||\"close\"==d[0]?\"stop\"==d[0]?V(this,7):ye(this):\"noop\"!=d[0]&&this.f&&this.f.Ba(d),this.B=0)}};g.cb=function(){null!=this.s&&(this.s=null,this.b.cancel(),this.b=null,Ke(this),K(19))};function Ce(a){null!=a.s&&(k.clearTimeout(a.s),a.s=null)}\ng.ta=function(a){G(this.a,\"Request complete\");var b=null;if(this.b==a){Ce(this);this.b=null;var c=2}else if(de(this.c,a))b=a.u,ee(this.c,a),c=1;else return;this.u=a.C;if(0!=this.F)if(a.f)1==c?(Cc(a.l?a.l.length:0,r()-a.D,this.v),Ee(this)):Je(this);else{var d=a.m;if(3==d||0==d&&0<this.u)G(this.a,\"Not retrying due to error type\");else{var e=this;G(this.a,function(){return\"Maybe retrying, last error: \"+Rc(d,e.u)});if(1==c&&Fe(this,a)||2==c&&Ke(this))return;G(this.a,\"Exceeded max number of retries\")}b&&\n0<b.length&&ge(this.c,b);G(this.a,\"Error: HTTP request failed\");switch(d){case 1:V(this,5);break;case 4:V(this,10);break;case 3:V(this,6);break;default:V(this,2)}}};function Ge(a,b){var c=5E3+Math.floor(1E4*Math.random());a.qa()||(G(a.a,\"Inactive channel\"),c*=2);return c*b}\nfunction V(a,b){E(a.a,\"Error code \"+b);if(2==b){var c=null;a.f&&(c=null);var d=q(a.kb,a);c||(c=new Q(\"//www.google.com/images/cleardot.gif\"),k.location&&\"http\"==k.location.protocol||rd(c,\"https\"),Vc(c));ke(c.toString(),d)}else K(2);G(a.a,\"HttpChannel: error - \"+b);a.F=0;a.f&&a.f.Aa(b);Be(a);ze(a)}g.kb=function(a){a?(E(this.a,\"Successfully pinged google.com\"),K(2)):(E(this.a,\"Failed to ping google.com\"),K(1))};\nfunction Be(a){a.F=0;a.u=-1;if(a.f){var b=fe(a.c);if(0!=b.length||0!=a.g.length)G(a.a,function(){return\"Number of undelivered maps, pending: \"+b.length+\", outgoing: \"+a.g.length}),a.c.c.length=0,wa(a.g),a.g.length=0;a.f.za()}}function Le(a,b){b=Me(a,null,b);G(a.a,\"GetForwardChannelUri: \"+b);return b}function Td(a,b,c){b=Me(a,a.ia()?b:null,c);G(a.a,\"GetBackChannelUri: \"+b);return b}\nfunction Me(a,b,c){var d=Gd(c);if(\"\"!=d.b)b&&sd(d,b+\".\"+d.b),td(d,d.i);else{var e=k.location,f;b?f=b+\".\"+e.hostname:f=e.hostname;d=Hd(e.protocol,f,e.port,c)}a.U&&Ca(a.U,function(a,b){R(d,b,a)});b=a.j;c=a.K;b&&c&&R(d,b,c);R(d,\"VER\",a.na);Ae(a,d);return d}g.ca=function(a){if(a&&!this.S)throw Error(\"Can't create secondary domain capable XhrIo object.\");a=new T;a.o=this.S;return a};g.qa=function(){return!!this.f&&!0};g.ia=function(){return this.S};new Pd;function Ne(){}g=Ne.prototype;g.Ca=function(){};\ng.Ba=function(){};g.Aa=function(){};g.za=function(){};g.Wa=function(){};function Oe(a){for(var b=arguments[0],c=1;c<arguments.length;c++){var d=arguments[c];if(0==d.lastIndexOf(\"/\",0))b=d;else{var e;(e=\"\"==b)||(e=b.length-1,e=0<=e&&b.indexOf(\"/\",e)==e);e?b+=d:b+=\"/\"+d}}return b};function Pe(){if(y&&!(10<=Number(Wa)))throw Error(\"Environmental error: no available transport.\");}Pe.prototype.a=function(a,b){return new X(a,b)};\nfunction X(a,b){A.call(this);this.a=new xe(b);this.b=a;this.o=b&&b.testUrl?b.testUrl:Oe(this.b,\"test\");this.c=qc(\"goog.labs.net.webChannel.WebChannelBaseTransport\");this.g=b&&b.messageUrlParams||null;a=b&&b.messageHeaders||null;b&&b.clientProtocolHeaderRequired&&(a?a[\"X-Client-Protocol\"]=\"webchannel\":a={\"X-Client-Protocol\":\"webchannel\"});this.a.i=a;a=b&&b.initMessageHeaders||null;b&&b.messageContentType&&(a?a[\"X-WebChannel-Content-Type\"]=b.messageContentType:a={\"X-WebChannel-Content-Type\":b.messageContentType});\nb&&b.Da&&(a?a[\"X-WebChannel-Client-Profile\"]=b.Da:a={\"X-WebChannel-Client-Profile\":b.Da});this.a.L=a;(a=b&&b.httpHeadersOverwriteParam)&&!xa(a)&&(this.a.h=a);this.l=b&&b.supportsCrossDomainXhr||!1;this.j=b&&b.sendRawJson||!1;(b=b&&b.httpSessionIdParam)&&!xa(b)&&(this.a.j=b,a=this.g,null!==a&&b in a&&(a=this.g,b in a&&delete a[b],C(this.c,\"Ignore httpSessionIdParam also specified with messageUrlParams: \"+b)));this.h=new Qe(this)}t(X,A);g=X.prototype;\ng.addEventListener=function(a,b,c,d){X.H.addEventListener.call(this,a,b,c,d)};g.removeEventListener=function(a,b,c,d){X.H.removeEventListener.call(this,a,b,c,d)};\ng.$a=function(){this.a.f=this.h;this.l&&(this.a.S=!0);var a=this.a,b=this.o,c=this.b,d=this.g||void 0;G(a.a,\"connect()\");K(0);a.ja=c;a.U=d||{};a.o&&(G(a.a,\"connect() bypassed channel-test.\"),a.I.b=[],a.I.a=!1);G(a.a,\"connectTest_()\");a.C=new Qd(a,a.a);null===a.h&&(a.C.i=a.i);c=b;a.h&&a.i&&(c=we(b,a.h,a.i));a=a.C;a.m=c;b=Le(a.a,a.m);K(3);c=a.a.I.b;null!=c?(a.g=c[0],a.P=1,Rd(a)):(Zc(b,\"MODE\",\"init\"),!a.a.o&&a.a.j&&Zc(b,\"X-HTTP-Session-Id\",a.a.j),a.c=new L(a,a.b,void 0,void 0),a.c.j=a.i,Xc(a.c,b,!1,\nnull),a.P=0)};g.close=function(){ye(this.a)};g.ab=function(a){if(l(a)){var b={};b.__data__=a;De(this.a,b)}else this.j?(b={},b.__data__=Db(a),De(this.a,b)):De(this.a,a)};g.w=function(){this.a.f=null;delete this.h;ye(this.a);delete this.a;X.H.w.call(this)};function Re(a){Ic.call(this);var b=a.__sm__;if(b){a:{for(var c in b){a=c;break a}a=void 0}(this.c=a)?(a=this.c,this.data=null!==b&&a in b?b[a]:void 0):this.data=b}else this.data=a}t(Re,Ic);function Se(){Jc.call(this);this.status=1}t(Se,Jc);\nfunction Qe(a){this.a=a}t(Qe,Ne);Qe.prototype.Ca=function(){rc(this.a.c,\"WebChannel opened on \"+this.a.b);this.a.dispatchEvent(\"a\")};Qe.prototype.Ba=function(a){this.a.dispatchEvent(new Re(a))};Qe.prototype.Aa=function(a){rc(this.a.c,\"WebChannel aborted on \"+this.a.b+\" due to channel error: \"+a);this.a.dispatchEvent(new Se(a))};Qe.prototype.za=function(){rc(this.a.c,\"WebChannel closed on \"+this.a.b);this.a.dispatchEvent(\"b\")};var Te=ja(function(a,b){function c(){}c.prototype=a.prototype;var d=new c;a.apply(d,Array.prototype.slice.call(arguments,1));return d},Pe);function Ue(){this.b=[];this.a=[]}function Ve(a){0==a.b.length&&(a.b=a.a,a.b.reverse(),a.a=[]);return a.b.pop()}function We(a){return a.b.length+a.a.length}Ue.prototype.A=function(){for(var a=[],b=this.b.length-1;0<=b;--b)a.push(this.b[b]);var c=this.a.length;for(b=0;b<c;++b)a.push(this.a[b]);return a};function Xe(a,b){u.call(this);this.h=a||0;this.c=b||10;if(this.h>this.c)throw Error(Ye);this.a=new Ue;this.b=new Wd;this.g=null;this.aa()}t(Xe,u);var Ye=\"[goog.structs.Pool] Min can not be greater than max\";g=Xe.prototype;g.da=function(){var a=r();if(!(null!=this.g&&0>a-this.g)){for(var b;0<We(this.a)&&(b=Ve(this.a),!this.sa(b));)this.aa();!b&&Ze(this)<this.c&&(b=this.pa());b&&(this.g=a,this.b.add(b));return b}};g.jb=function(a){return od(this.b.a,Xd(a))?(this.ma(a),!0):!1};\ng.ma=function(a){od(this.b.a,Xd(a));this.sa(a)&&Ze(this)<this.c?this.a.a.push(a):$e(a)};g.aa=function(){for(var a=this.a;Ze(this)<this.h;){var b=this.pa();a.a.push(b)}for(;Ze(this)>this.c&&0<We(this.a);)$e(Ve(a))};g.pa=function(){return{}};function $e(a){if(\"function\"==typeof a.$)a.$();else for(var b in a)a[b]=null}g.sa=function(a){return\"function\"==typeof a.Xa?a.Xa():!0};function Ze(a){return We(a.a)+a.b.a.c}\ng.w=function(){Xe.H.w.call(this);if(0<this.b.a.c)throw Error(\"[goog.structs.Pool] Objects not released\");delete this.b;for(var a=this.a;0!=a.b.length||0!=a.a.length;)$e(Ve(a));delete this.a};function af(a,b){this.a=a;this.b=b};function bf(a){this.a=[];if(a)a:{if(a instanceof bf){var b=a.M();a=a.A();if(0>=this.a.length){for(var c=this.a,d=0;d<b.length;d++)c.push(new af(b[d],a[d]));break a}}else b=Ea(a),a=Da(a);for(d=0;d<b.length;d++)cf(this,b[d],a[d])}}function cf(a,b,c){var d=a.a;d.push(new af(b,c));b=d.length-1;a=a.a;for(c=a[b];0<b;)if(d=b-1>>1,a[d].a>c.a)a[b]=a[d],b=d;else break;a[b]=c}bf.prototype.A=function(){for(var a=this.a,b=[],c=a.length,d=0;d<c;d++)b.push(a[d].b);return b};\nbf.prototype.M=function(){for(var a=this.a,b=[],c=a.length,d=0;d<c;d++)b.push(a[d].a);return b};function df(){bf.call(this)}t(df,bf);function Y(a,b){this.f=new df;Xe.call(this,a,b)}t(Y,Xe);g=Y.prototype;g.da=function(a,b){if(!a)return Y.H.da.call(this);cf(this.f,void 0!==b?b:100,a);this.ra()};g.ra=function(){for(var a=this.f;0<a.a.length;){var b=this.da();if(b){var c=a,d=c.a,e=d.length;var f=d[0];if(0>=e)f=void 0;else{if(1==e)ua(d);else{d[0]=d.pop();d=0;c=c.a;e=c.length;for(var h=c[d];d<e>>1;){var m=2*d+1,v=2*d+2;m=v<e&&c[v].a<c[m].a?v:m;if(c[m].a>h.a)break;c[d]=c[m];d=m}c[d]=h}f=f.b}f.apply(this,[b])}else break}};\ng.ma=function(a){Y.H.ma.call(this,a);this.ra()};g.aa=function(){Y.H.aa.call(this);this.ra()};g.w=function(){Y.H.w.call(this);k.clearTimeout(void 0);ua(this.f.a);this.f=null};function Z(a,b,c,d){this.l=a;this.j=!!d;Y.call(this,b,c)}t(Z,Y);Z.prototype.pa=function(){var a=new T,b=this.l;b&&b.forEach(function(b,d){a.headers.set(d,b)});this.j&&(a.o=!0);return a};Z.prototype.sa=function(a){return!a.i&&!a.a};Pe.prototype.createWebChannel=Pe.prototype.a;X.prototype.send=X.prototype.ab;X.prototype.open=X.prototype.$a;X.prototype.close=X.prototype.close;Ec.NO_ERROR=0;Ec.TIMEOUT=8;Ec.HTTP_ERROR=6;Fc.COMPLETE=\"complete\";Gc.EventType=Hc;Hc.OPEN=\"a\";Hc.CLOSE=\"b\";Hc.ERROR=\"c\";Hc.MESSAGE=\"d\";A.prototype.listen=A.prototype.Ha;Z.prototype.getObject=Z.prototype.da;Z.prototype.releaseObject=Z.prototype.jb;T.prototype.listenOnce=T.prototype.Ia;T.prototype.getLastError=T.prototype.bb;T.prototype.getLastErrorCode=T.prototype.Fa;\nT.prototype.getStatus=T.prototype.W;T.prototype.getStatusText=T.prototype.Ga;T.prototype.getResponseJson=T.prototype.Za;T.prototype.getResponseText=T.prototype.V;T.prototype.getResponseText=T.prototype.V;T.prototype.send=T.prototype.fa;module.exports={createWebChannelTransport:Te,ErrorCode:Ec,EventType:Fc,WebChannel:Gc,XhrIoPool:Z};}).call(typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(12)))\n\n/***/ })\n\n},[113]);\n        } catch(error) {\n          throw new Error(\n            'Cannot instantiate firebase-firestore.js - ' +\n            'be sure to load firebase-app.js first.'\n          )\n        }\n\n\n// WEBPACK FOOTER //\n// firebase-firestore.js","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nrequire('@firebase/firestore');\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./firestore/index.js\n// module id = 113\n// module chunks = 1","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* tslint:disable:no-console */\nimport { SDK_VERSION } from '../core/version';\nimport { PlatformSupport } from '../platform/platform';\nexport var LogLevel;\n(function (LogLevel) {\n    LogLevel[LogLevel[\"DEBUG\"] = 0] = \"DEBUG\";\n    LogLevel[LogLevel[\"ERROR\"] = 1] = \"ERROR\";\n    LogLevel[LogLevel[\"SILENT\"] = 2] = \"SILENT\";\n})(LogLevel || (LogLevel = {}));\nvar logLevel = LogLevel.ERROR;\n// Helper methods are needed because variables can't be exported as read/write\nexport function getLogLevel() {\n    return logLevel;\n}\nexport function setLogLevel(newLevel) {\n    logLevel = newLevel;\n}\nexport function debug(tag, msg) {\n    var obj = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        obj[_i - 2] = arguments[_i];\n    }\n    if (logLevel <= LogLevel.DEBUG) {\n        var time = new Date().toISOString();\n        var args = obj.map(argToString);\n        console.log.apply(console, [\"Firestore (\" + SDK_VERSION + \") \" + time + \" [\" + tag + \"]: \" + msg].concat(args));\n    }\n}\nexport function error(msg) {\n    var obj = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        obj[_i - 1] = arguments[_i];\n    }\n    if (logLevel <= LogLevel.ERROR) {\n        var time = new Date().toISOString();\n        var args = obj.map(argToString);\n        console.error.apply(console, [\"Firestore (\" + SDK_VERSION + \") \" + time + \": \" + msg].concat(args));\n    }\n}\n/**\n * Converts an additional log parameter to a string representation.\n */\nfunction argToString(obj) {\n    if (typeof obj === 'string') {\n        return obj;\n    }\n    else {\n        var platform = PlatformSupport.getPlatform();\n        try {\n            return platform.formatJSON(obj);\n        }\n        catch (e) {\n            // Converting to JSON failed, just log the object directly\n            return obj;\n        }\n    }\n}\n\n//# sourceMappingURL=log.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/log.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SDK_VERSION } from '../core/version';\nimport { error } from './log';\n/**\n * Unconditionally fails, throwing an Error with the given message.\n *\n * Returns any so it can be used in expressions:\n * @example\n * let futureVar = fail('not implemented yet');\n */\nexport function fail(failure) {\n    // Log the failure in addition to throw an exception, just in case the\n    // exception is swallowed.\n    var message = \"FIRESTORE (\" + SDK_VERSION + \") INTERNAL ASSERTION FAILED: \" + failure;\n    error(message);\n    // NOTE: We don't use FirestoreError here because these are internal failures\n    // that cannot be handled by the user. (Also it would create a circular\n    // dependency between the error and assert modules which doesn't work.)\n    throw new Error(message);\n}\n/**\n * Fails if the given assertion condition is false, throwing an Error with the\n * given message if it did.\n */\nexport function assert(assertion, message) {\n    if (!assertion) {\n        fail(message);\n    }\n}\n\n//# sourceMappingURL=assert.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/assert.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { fail } from '../util/assert';\n/**\n * Provides singleton helpers where setup code can inject a platform at runtime.\n * setPlatform needs to be set before Firestore is used and must be set exactly\n * once.\n */\nvar PlatformSupport = /** @class */ (function () {\n    function PlatformSupport() {\n    }\n    PlatformSupport.setPlatform = function (platform) {\n        if (PlatformSupport.platform) {\n            fail('Platform already defined');\n        }\n        PlatformSupport.platform = platform;\n    };\n    PlatformSupport.getPlatform = function () {\n        if (!PlatformSupport.platform) {\n            fail('Platform not set');\n        }\n        return PlatformSupport.platform;\n    };\n    return PlatformSupport;\n}());\nexport { PlatformSupport };\n/**\n * Returns the representation of an empty \"proto\" byte string for the\n * platform.\n */\nexport function emptyByteString() {\n    return PlatformSupport.getPlatform().emptyByteString;\n}\n\n//# sourceMappingURL=platform.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/platform/platform.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// We are doing some heavy reflective stuff, lots of any casting necessary\n/* tslint:disable:no-any */\nimport { Code, FirestoreError } from './error';\n/**\n * Helper function to prevent instantiation through the constructor.\n *\n * This method creates a new constructor that throws when it's invoked.\n * The prototype of that constructor is then set to the prototype of the hidden\n * \"class\" to expose all the prototype methods and allow for instanceof\n * checks.\n *\n * To also make all the static methods available, all properties of the\n * original constructor are copied to the new constructor.\n */\nexport function makeConstructorPrivate(cls, optionalMessage) {\n    function PublicConstructor() {\n        var error = 'This constructor is private.';\n        if (optionalMessage) {\n            error += ' ';\n            error += optionalMessage;\n        }\n        throw new FirestoreError(Code.INVALID_ARGUMENT, error);\n    }\n    // Make sure instanceof checks work and all methods are exposed on the public\n    // constructor\n    PublicConstructor.prototype = cls.prototype;\n    // Copy any static methods/members\n    for (var staticProperty in cls) {\n        if (cls.hasOwnProperty(staticProperty)) {\n            PublicConstructor[staticProperty] = cls[staticProperty];\n        }\n    }\n    return PublicConstructor;\n}\n\n//# sourceMappingURL=api.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/api.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from './assert';\nexport function contains(obj, key) {\n    return Object.prototype.hasOwnProperty.call(obj, key);\n}\nexport function get(obj, key) {\n    return Object.prototype.hasOwnProperty.call(obj, key) ? obj[key] : null;\n}\nexport function size(obj) {\n    var count = 0;\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            count++;\n        }\n    }\n    return count;\n}\n/** Returns the given value if it's defined or the defaultValue otherwise. */\nexport function defaulted(value, defaultValue) {\n    return value !== undefined ? value : defaultValue;\n}\nexport function forEachNumber(obj, fn) {\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            var num = Number(key);\n            if (!isNaN(num)) {\n                fn(num, obj[key]);\n            }\n        }\n    }\n}\nexport function forEach(obj, fn) {\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            fn(key, obj[key]);\n        }\n    }\n}\nexport function lookupOrInsert(obj, key, valFn) {\n    if (!contains(obj, key)) {\n        obj[key] = valFn();\n    }\n    return obj[key];\n}\nexport function isEmpty(obj) {\n    assert(obj != null && typeof obj === 'object', 'isEmpty() expects object parameter.');\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function shallowCopy(obj) {\n    assert(obj && typeof obj === 'object', 'shallowCopy() expects object parameter.');\n    var result = {};\n    for (var key in obj) {\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\n            result[key] = obj[key];\n        }\n    }\n    return result;\n}\n\n//# sourceMappingURL=obj.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/obj.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { fail } from './assert';\nimport { Code, FirestoreError } from './error';\nimport * as obj from './obj';\n/**\n * Validates the invocation of functionName has the exact number of arguments.\n *\n * Forward the magic \"arguments\" variable as second parameter on which the\n * parameter validation is performed:\n * validateExactNumberOfArgs('myFunction', arguments, 2);\n */\nexport function validateExactNumberOfArgs(functionName, args, numberOfArgs) {\n    if (args.length !== numberOfArgs) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires \" +\n            formatPlural(numberOfArgs, 'argument') +\n            ', but was called with ' +\n            formatPlural(args.length, 'argument') +\n            '.');\n    }\n}\n/**\n * Validates the invocation of functionName has at least the provided number of\n * arguments (but can have many more).\n *\n * Forward the magic \"arguments\" variable as second parameter on which the\n * parameter validation is performed:\n * validateAtLeastNumberOfArgs('myFunction', arguments, 2);\n */\nexport function validateAtLeastNumberOfArgs(functionName, args, minNumberOfArgs) {\n    if (args.length < minNumberOfArgs) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires at least \" +\n            formatPlural(minNumberOfArgs, 'argument') +\n            ', but was called with ' +\n            formatPlural(args.length, 'argument') +\n            '.');\n    }\n}\n/**\n * Validates the invocation of functionName has number of arguments between\n * the values provided.\n *\n * Forward the magic \"arguments\" variable as second parameter on which the\n * parameter validation is performed:\n * validateBetweenNumberOfArgs('myFunction', arguments, 2, 3);\n */\nexport function validateBetweenNumberOfArgs(functionName, args, minNumberOfArgs, maxNumberOfArgs) {\n    if (args.length < minNumberOfArgs || args.length > maxNumberOfArgs) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires between \" + minNumberOfArgs + \" and \" +\n            (maxNumberOfArgs + \" arguments, but was called with \") +\n            formatPlural(args.length, 'argument') +\n            '.');\n    }\n}\n/**\n * Validates the provided argument is an array and has as least the expected\n * number of elements.\n */\nexport function validateNamedArrayAtLeastNumberOfElements(functionName, value, name, minNumberOfElements) {\n    if (!(value instanceof Array) || value.length < minNumberOfElements) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires its \" + name + \" argument to be an \" +\n            'array with at least ' +\n            (formatPlural(minNumberOfElements, 'element') + \".\"));\n    }\n}\n/**\n * Validates the provided positional argument has the native JavaScript type\n * using typeof checks.\n */\nexport function validateArgType(functionName, type, position, argument) {\n    validateType(functionName, type, ordinal(position) + \" argument\", argument);\n}\n/**\n * Validates the provided argument has the native JavaScript type using\n * typeof checks or is undefined.\n */\nexport function validateOptionalArgType(functionName, type, position, argument) {\n    if (argument !== undefined) {\n        validateArgType(functionName, type, position, argument);\n    }\n}\n/**\n * Validates the provided named option has the native JavaScript type using\n * typeof checks.\n */\nexport function validateNamedType(functionName, type, optionName, argument) {\n    validateType(functionName, type, optionName + \" option\", argument);\n}\n/**\n * Validates the provided named option has the native JavaScript type using\n * typeof checks or is undefined.\n */\nexport function validateNamedOptionalType(functionName, type, optionName, argument) {\n    if (argument !== undefined) {\n        validateNamedType(functionName, type, optionName, argument);\n    }\n}\n/**\n * Validates that the provided named option equals one of the expected values.\n */\nexport function validateNamedPropertyEquals(functionName, inputName, optionName, input, expected) {\n    var expectedDescription = [];\n    for (var _i = 0, expected_1 = expected; _i < expected_1.length; _i++) {\n        var val = expected_1[_i];\n        if (val === input) {\n            return;\n        }\n        expectedDescription.push(valueDescription(val));\n    }\n    var actualDescription = valueDescription(input);\n    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid value \" + actualDescription + \" provided to function \" + functionName + \"() for option \\\"\" + optionName + \"\\\". Acceptable values: \" + expectedDescription.join(', '));\n}\n/**\n * Validates that the provided named option equals one of the expected values or\n * is undefined.\n */\nexport function validateNamedOptionalPropertyEquals(functionName, inputName, optionName, input, expected) {\n    if (input !== undefined) {\n        validateNamedPropertyEquals(functionName, inputName, optionName, input, expected);\n    }\n}\n/** Helper to validate the type of a provided input. */\nfunction validateType(functionName, type, inputName, input) {\n    if (typeof input !== type || (type === 'object' && !isPlainObject(input))) {\n        var description = valueDescription(input);\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires its \" + inputName + \" \" +\n            (\"to be of type \" + type + \", but it was: \" + description));\n    }\n}\n/**\n * Returns true iff it's a non-null object without a custom prototype\n * (i.e. excludes Array, Date, etc.).\n */\nexport function isPlainObject(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        Object.getPrototypeOf(input) === Object.prototype);\n}\n/** Returns a string describing the type / value of the provided input. */\nexport function valueDescription(input) {\n    if (input === undefined) {\n        return 'undefined';\n    }\n    else if (input === null) {\n        return 'null';\n    }\n    else if (typeof input === 'string') {\n        if (input.length > 20) {\n            input = input.substring(0, 20) + \"...\";\n        }\n        return JSON.stringify(input);\n    }\n    else if (typeof input === 'number' || typeof input === 'boolean') {\n        return '' + input;\n    }\n    else if (typeof input === 'object') {\n        if (input instanceof Array) {\n            return 'an array';\n        }\n        else {\n            var customObjectName = tryGetCustomObjectType(input);\n            if (customObjectName) {\n                return \"a custom \" + customObjectName + \" object\";\n            }\n            else {\n                return 'an object';\n            }\n        }\n    }\n    else if (typeof input === 'function') {\n        return 'a function';\n    }\n    else {\n        return fail('Unknown wrong type: ' + typeof input);\n    }\n}\n/** Hacky method to try to get the constructor name for an object. */\nexport function tryGetCustomObjectType(input) {\n    if (input.constructor) {\n        var funcNameRegex = /function\\s+([^\\s(]+)\\s*\\(/;\n        var results = funcNameRegex.exec(input.constructor.toString());\n        if (results && results.length > 1) {\n            return results[1];\n        }\n    }\n    return null;\n}\n/** Validates the provided argument is defined. */\nexport function validateDefined(functionName, position, argument) {\n    if (argument === undefined) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires a valid \" + ordinal(position) + \" \" +\n            \"argument, but it was undefined.\");\n    }\n}\n/**\n * Validates the provided positional argument is an object, and its keys and\n * values match the expected keys and types provided in optionTypes.\n */\nexport function validateOptionNames(functionName, options, optionNames) {\n    obj.forEach(options, function (key, _) {\n        if (optionNames.indexOf(key) < 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Unknown option '\" + key + \"' passed to function \" + functionName + \"(). \" +\n                'Available options: ' +\n                optionNames.join(', '));\n        }\n    });\n}\n/**\n * Helper method to throw an error that the provided argument did not pass\n * an instanceof check.\n */\nexport function invalidClassError(functionName, type, position, argument) {\n    var description = valueDescription(argument);\n    return new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + functionName + \"() requires its \" + ordinal(position) + \" \" +\n        (\"argument to be a \" + type + \", but it was: \" + description));\n}\n/** Converts a number to its english word representation */\nfunction ordinal(num) {\n    switch (num) {\n        case 1:\n            return 'first';\n        case 2:\n            return 'second';\n        case 3:\n            return 'third';\n        default:\n            return num + 'th';\n    }\n}\n/**\n * Formats the given word as plural conditionally given the preceding number.\n */\nfunction formatPlural(num, str) {\n    return num + \" \" + str + (num === 1 ? '' : 's');\n}\n\n//# sourceMappingURL=input_validation.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/input_validation.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from './assert';\n// tslint:disable-next-line:class-as-namespace\nvar AutoId = /** @class */ (function () {\n    function AutoId() {\n    }\n    AutoId.newId = function () {\n        // Alphanumeric characters\n        var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';\n        var autoId = '';\n        for (var i = 0; i < 20; i++) {\n            autoId += chars.charAt(Math.floor(Math.random() * chars.length));\n        }\n        assert(autoId.length === 20, 'Invalid auto ID: ' + autoId);\n        return autoId;\n    };\n    return AutoId;\n}());\nexport { AutoId };\nexport function primitiveComparator(left, right) {\n    if (left < right)\n        return -1;\n    if (left > right)\n        return 1;\n    return 0;\n}\n/** Helper to compare nullable (or undefined-able) objects using isEqual(). */\nexport function equals(left, right) {\n    if (left !== null && left !== undefined) {\n        return !!(right && left.isEqual(right));\n    }\n    else {\n        // HACK: Explicitly cast since TypeScript's type narrowing apparently isn't\n        // smart enough.\n        return left === right;\n    }\n}\n/** Helper to compare arrays using isEqual(). */\nexport function arrayEquals(left, right) {\n    if (left.length !== right.length) {\n        return false;\n    }\n    for (var i = 0; i < left.length; i++) {\n        if (!left[i].isEqual(right[i])) {\n            return false;\n        }\n    }\n    return true;\n}\n/**\n * Returns the largest lexicographically smaller string of equal or smaller\n * length. Returns an empty string if there is no such predecessor (if the input\n * is empty).\n *\n * Strings returned from this method can be invalid UTF-16 but this is sufficent\n * in use for indexeddb because that depends on lexicographical ordering but\n * shouldn't be used elsewhere.\n */\nexport function immediatePredecessor(s) {\n    // We can decrement the last character in the string and be done\n    // unless that character is 0 (0x0000), in which case we have to erase the\n    // last character.\n    var lastIndex = s.length - 1;\n    if (s.length === 0) {\n        // Special case the empty string.\n        return '';\n    }\n    else if (s.charAt(lastIndex) === '\\0') {\n        return s.substring(0, lastIndex);\n    }\n    else {\n        return (s.substring(0, lastIndex) +\n            String.fromCharCode(s.charCodeAt(lastIndex) - 1));\n    }\n}\n/**\n * Returns the immediate lexicographically-following string. This is useful to\n * construct an inclusive range for indexeddb iterators.\n */\nexport function immediateSuccessor(s) {\n    // Return the input string, with an additional NUL byte appended.\n    return s + '\\0';\n}\n\n//# sourceMappingURL=misc.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/misc.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { PlatformSupport } from '../platform/platform';\nimport { makeConstructorPrivate } from '../util/api';\nimport { Code, FirestoreError } from '../util/error';\nimport { invalidClassError, validateArgType, validateExactNumberOfArgs } from '../util/input_validation';\nimport { primitiveComparator } from '../util/misc';\n/** Helper function to assert Uint8Array is available at runtime. */\nfunction assertUint8ArrayAvailable() {\n    if (typeof Uint8Array === 'undefined') {\n        throw new FirestoreError(Code.UNIMPLEMENTED, 'Uint8Arrays are not available in this environment.');\n    }\n}\n/** Helper function to assert Base64 functions are available at runtime. */\nfunction assertBase64Available() {\n    if (!PlatformSupport.getPlatform().base64Available) {\n        throw new FirestoreError(Code.UNIMPLEMENTED, 'Blobs are unavailable in Firestore in this environment.');\n    }\n}\n/**\n * Immutable class holding a blob (binary data).\n * This class is directly exposed in the public API.\n *\n * Note that while you can't hide the constructor in JavaScript code, we are\n * using the hack above to make sure no-one outside this module can call it.\n */\nvar Blob = /** @class */ (function () {\n    function Blob(binaryString) {\n        assertBase64Available();\n        this._binaryString = binaryString;\n    }\n    Blob.fromBase64String = function (base64) {\n        validateExactNumberOfArgs('Blob.fromBase64String', arguments, 1);\n        validateArgType('Blob.fromBase64String', 'string', 1, base64);\n        assertBase64Available();\n        try {\n            var binaryString = PlatformSupport.getPlatform().atob(base64);\n            return new Blob(binaryString);\n        }\n        catch (e) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Failed to construct Blob from Base64 string: ' + e);\n        }\n    };\n    Blob.fromUint8Array = function (array) {\n        validateExactNumberOfArgs('Blob.fromUint8Array', arguments, 1);\n        assertUint8ArrayAvailable();\n        if (!(array instanceof Uint8Array)) {\n            throw invalidClassError('Blob.fromUint8Array', 'Uint8Array', 1, array);\n        }\n        // We can't call array.map directly because it expects the return type to\n        // be a Uint8Array, whereas we can convert it to a regular array by invoking\n        // map on the Array prototype.\n        var binaryString = Array.prototype.map\n            .call(array, function (char) {\n            return String.fromCharCode(char);\n        })\n            .join('');\n        return new Blob(binaryString);\n    };\n    Blob.prototype.toBase64 = function () {\n        validateExactNumberOfArgs('Blob.toBase64', arguments, 0);\n        assertBase64Available();\n        return PlatformSupport.getPlatform().btoa(this._binaryString);\n    };\n    Blob.prototype.toUint8Array = function () {\n        validateExactNumberOfArgs('Blob.toUint8Array', arguments, 0);\n        assertUint8ArrayAvailable();\n        var buffer = new Uint8Array(this._binaryString.length);\n        for (var i = 0; i < this._binaryString.length; i++) {\n            buffer[i] = this._binaryString.charCodeAt(i);\n        }\n        return buffer;\n    };\n    Blob.prototype.toString = function () {\n        return 'Blob(base64: ' + this.toBase64() + ')';\n    };\n    Blob.prototype.isEqual = function (other) {\n        return this._binaryString === other._binaryString;\n    };\n    /**\n     * Actually private to JS consumers of our API, so this function is prefixed\n     * with an underscore.\n     */\n    Blob.prototype._compareTo = function (other) {\n        return primitiveComparator(this._binaryString, other._binaryString);\n    };\n    return Blob;\n}());\nexport { Blob };\n// Public instance that disallows construction at runtime. This constructor is\n// used when exporting Blob on firebase.firestore.Blob and will be called Blob\n// publicly. Internally we still use Blob which has a type checked private\n// constructor. Note that Blob and PublicBlob can be used interchangeably in\n// instanceof checks.\n// For our internal TypeScript code PublicBlob doesn't exist as a type, and so\n// we need to use Blob as type and export it too.\n// tslint:disable-next-line:variable-name We're treating this as a class name.\nexport var PublicBlob = makeConstructorPrivate(Blob, 'Use Blob.fromUint8Array() or Blob.fromBase64String() instead.');\n\n//# sourceMappingURL=blob.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/blob.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { assert, fail } from '../util/assert';\nimport { primitiveComparator } from '../util/misc';\nimport { SortedMap } from '../util/sorted_map';\nimport { DocumentKey } from './document_key';\nexport var TypeOrder;\n(function (TypeOrder) {\n    // This order is defined by the backend.\n    TypeOrder[TypeOrder[\"NullValue\"] = 0] = \"NullValue\";\n    TypeOrder[TypeOrder[\"BooleanValue\"] = 1] = \"BooleanValue\";\n    TypeOrder[TypeOrder[\"NumberValue\"] = 2] = \"NumberValue\";\n    TypeOrder[TypeOrder[\"TimestampValue\"] = 3] = \"TimestampValue\";\n    TypeOrder[TypeOrder[\"StringValue\"] = 4] = \"StringValue\";\n    TypeOrder[TypeOrder[\"BlobValue\"] = 5] = \"BlobValue\";\n    TypeOrder[TypeOrder[\"RefValue\"] = 6] = \"RefValue\";\n    TypeOrder[TypeOrder[\"GeoPointValue\"] = 7] = \"GeoPointValue\";\n    TypeOrder[TypeOrder[\"ArrayValue\"] = 8] = \"ArrayValue\";\n    TypeOrder[TypeOrder[\"ObjectValue\"] = 9] = \"ObjectValue\";\n})(TypeOrder || (TypeOrder = {}));\n/** Defines the return value for pending server timestamps. */\nexport var ServerTimestampBehavior;\n(function (ServerTimestampBehavior) {\n    ServerTimestampBehavior[ServerTimestampBehavior[\"Default\"] = 0] = \"Default\";\n    ServerTimestampBehavior[ServerTimestampBehavior[\"Estimate\"] = 1] = \"Estimate\";\n    ServerTimestampBehavior[ServerTimestampBehavior[\"Previous\"] = 2] = \"Previous\";\n})(ServerTimestampBehavior || (ServerTimestampBehavior = {}));\n/** Holds properties that define field value deserialization options. */\nvar FieldValueOptions = /** @class */ (function () {\n    function FieldValueOptions(serverTimestampBehavior) {\n        this.serverTimestampBehavior = serverTimestampBehavior;\n    }\n    FieldValueOptions.fromSnapshotOptions = function (options) {\n        switch (options.serverTimestamps) {\n            case 'estimate':\n                return new FieldValueOptions(ServerTimestampBehavior.Estimate);\n            case 'previous':\n                return new FieldValueOptions(ServerTimestampBehavior.Previous);\n            case 'none': // Fall-through intended.\n            case undefined:\n                return FieldValueOptions.defaultOptions;\n            default:\n                return fail('fromSnapshotOptions() called with invalid options.');\n        }\n    };\n    FieldValueOptions.defaultOptions = new FieldValueOptions(ServerTimestampBehavior.Default);\n    return FieldValueOptions;\n}());\nexport { FieldValueOptions };\n/**\n * A field value represents a datatype as stored by Firestore.\n */\nvar FieldValue = /** @class */ (function () {\n    function FieldValue() {\n    }\n    FieldValue.prototype.toString = function () {\n        var val = this.value();\n        return val === null ? 'null' : val.toString();\n    };\n    FieldValue.prototype.defaultCompareTo = function (other) {\n        assert(this.typeOrder !== other.typeOrder, 'Default compareTo should not be used for values of same type.');\n        var cmp = primitiveComparator(this.typeOrder, other.typeOrder);\n        return cmp;\n    };\n    return FieldValue;\n}());\nexport { FieldValue };\nvar NullValue = /** @class */ (function (_super) {\n    __extends(NullValue, _super);\n    function NullValue() {\n        var _this = _super.call(this) || this;\n        _this.typeOrder = TypeOrder.NullValue;\n        // internalValue is unused but we add it to work around\n        // https://github.com/Microsoft/TypeScript/issues/15585\n        _this.internalValue = null;\n        return _this;\n    }\n    NullValue.prototype.value = function (options) {\n        return null;\n    };\n    NullValue.prototype.isEqual = function (other) {\n        return other instanceof NullValue;\n    };\n    NullValue.prototype.compareTo = function (other) {\n        if (other instanceof NullValue) {\n            return 0;\n        }\n        return this.defaultCompareTo(other);\n    };\n    NullValue.INSTANCE = new NullValue();\n    return NullValue;\n}(FieldValue));\nexport { NullValue };\nvar BooleanValue = /** @class */ (function (_super) {\n    __extends(BooleanValue, _super);\n    function BooleanValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.BooleanValue;\n        return _this;\n    }\n    BooleanValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    BooleanValue.prototype.isEqual = function (other) {\n        return (other instanceof BooleanValue &&\n            this.internalValue === other.internalValue);\n    };\n    BooleanValue.prototype.compareTo = function (other) {\n        if (other instanceof BooleanValue) {\n            return primitiveComparator(this, other);\n        }\n        return this.defaultCompareTo(other);\n    };\n    BooleanValue.of = function (value) {\n        return value ? BooleanValue.TRUE : BooleanValue.FALSE;\n    };\n    BooleanValue.TRUE = new BooleanValue(true);\n    BooleanValue.FALSE = new BooleanValue(false);\n    return BooleanValue;\n}(FieldValue));\nexport { BooleanValue };\n/** Base class for IntegerValue and DoubleValue. */\nvar NumberValue = /** @class */ (function (_super) {\n    __extends(NumberValue, _super);\n    function NumberValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.NumberValue;\n        return _this;\n    }\n    NumberValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    NumberValue.prototype.compareTo = function (other) {\n        if (other instanceof NumberValue) {\n            return numericComparator(this.internalValue, other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return NumberValue;\n}(FieldValue));\nexport { NumberValue };\n/** Utility function to compare doubles (using Firestore semantics for NaN). */\nfunction numericComparator(left, right) {\n    if (left < right) {\n        return -1;\n    }\n    else if (left > right) {\n        return 1;\n    }\n    else if (left === right) {\n        return 0;\n    }\n    else {\n        // one or both are NaN.\n        if (isNaN(left)) {\n            return isNaN(right) ? 0 : -1;\n        }\n        else {\n            return 1;\n        }\n    }\n}\n/**\n * Utility function to check numbers for equality using Firestore semantics\n * (NaN === NaN, -0.0 !== 0.0).\n */\nfunction numericEquals(left, right) {\n    // Implemented based on Object.is() polyfill from\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is\n    if (left === right) {\n        // +0 != -0\n        return left !== 0 || 1 / left === 1 / right;\n    }\n    else {\n        // NaN == NaN\n        return left !== left && right !== right;\n    }\n}\nvar IntegerValue = /** @class */ (function (_super) {\n    __extends(IntegerValue, _super);\n    function IntegerValue(internalValue) {\n        return _super.call(this, internalValue) || this;\n    }\n    IntegerValue.prototype.isEqual = function (other) {\n        // NOTE: DoubleValue and IntegerValue instances may compareTo() the same,\n        // but that doesn't make them equal via isEqual().\n        if (other instanceof IntegerValue) {\n            return numericEquals(this.internalValue, other.internalValue);\n        }\n        else {\n            return false;\n        }\n    };\n    return IntegerValue;\n}(NumberValue));\nexport { IntegerValue };\nvar DoubleValue = /** @class */ (function (_super) {\n    __extends(DoubleValue, _super);\n    function DoubleValue(internalValue) {\n        var _this = _super.call(this, internalValue) || this;\n        _this.internalValue = internalValue;\n        return _this;\n    }\n    DoubleValue.prototype.isEqual = function (other) {\n        // NOTE: DoubleValue and IntegerValue instances may compareTo() the same,\n        // but that doesn't make them equal via isEqual().\n        if (other instanceof DoubleValue) {\n            return numericEquals(this.internalValue, other.internalValue);\n        }\n        else {\n            return false;\n        }\n    };\n    DoubleValue.NAN = new DoubleValue(NaN);\n    DoubleValue.POSITIVE_INFINITY = new DoubleValue(Infinity);\n    DoubleValue.NEGATIVE_INFINITY = new DoubleValue(-Infinity);\n    return DoubleValue;\n}(NumberValue));\nexport { DoubleValue };\n// TODO(b/37267885): Add truncation support\nvar StringValue = /** @class */ (function (_super) {\n    __extends(StringValue, _super);\n    function StringValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.StringValue;\n        return _this;\n    }\n    StringValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    StringValue.prototype.isEqual = function (other) {\n        return (other instanceof StringValue && this.internalValue === other.internalValue);\n    };\n    StringValue.prototype.compareTo = function (other) {\n        if (other instanceof StringValue) {\n            return primitiveComparator(this.internalValue, other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return StringValue;\n}(FieldValue));\nexport { StringValue };\nvar TimestampValue = /** @class */ (function (_super) {\n    __extends(TimestampValue, _super);\n    function TimestampValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.TimestampValue;\n        return _this;\n    }\n    TimestampValue.prototype.value = function (options) {\n        return this.internalValue.toDate();\n    };\n    TimestampValue.prototype.isEqual = function (other) {\n        return (other instanceof TimestampValue &&\n            this.internalValue.isEqual(other.internalValue));\n    };\n    TimestampValue.prototype.compareTo = function (other) {\n        if (other instanceof TimestampValue) {\n            return this.internalValue.compareTo(other.internalValue);\n        }\n        else if (other instanceof ServerTimestampValue) {\n            // Concrete timestamps come before server timestamps.\n            return -1;\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    return TimestampValue;\n}(FieldValue));\nexport { TimestampValue };\n/**\n * Represents a locally-applied ServerTimestamp.\n *\n * Notes:\n * - ServerTimestampValue instances are created as the result of applying a\n *   TransformMutation (see TransformMutation.applyTo()). They can only exist in\n *   the local view of a document. Therefore they do not need to be parsed or\n *   serialized.\n * - When evaluated locally (e.g. for snapshot.data()), they by default\n *   evaluate to `null`. This behavior can be configured by passing custom\n *   FieldValueOptions to value().\n * - With respect to other ServerTimestampValues, they sort by their\n *   localWriteTime.\n */\nvar ServerTimestampValue = /** @class */ (function (_super) {\n    __extends(ServerTimestampValue, _super);\n    function ServerTimestampValue(localWriteTime, previousValue) {\n        var _this = _super.call(this) || this;\n        _this.localWriteTime = localWriteTime;\n        _this.previousValue = previousValue;\n        _this.typeOrder = TypeOrder.TimestampValue;\n        return _this;\n    }\n    ServerTimestampValue.prototype.value = function (options) {\n        if (options &&\n            options.serverTimestampBehavior === ServerTimestampBehavior.Estimate) {\n            return this.localWriteTime.toDate();\n        }\n        else if (options &&\n            options.serverTimestampBehavior === ServerTimestampBehavior.Previous) {\n            return this.previousValue ? this.previousValue.value(options) : null;\n        }\n        else {\n            return null;\n        }\n    };\n    ServerTimestampValue.prototype.isEqual = function (other) {\n        return (other instanceof ServerTimestampValue &&\n            this.localWriteTime.isEqual(other.localWriteTime));\n    };\n    ServerTimestampValue.prototype.compareTo = function (other) {\n        if (other instanceof ServerTimestampValue) {\n            return this.localWriteTime.compareTo(other.localWriteTime);\n        }\n        else if (other instanceof TimestampValue) {\n            // Server timestamps come after all concrete timestamps.\n            return 1;\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    ServerTimestampValue.prototype.toString = function () {\n        return '<ServerTimestamp localTime=' + this.localWriteTime.toString() + '>';\n    };\n    return ServerTimestampValue;\n}(FieldValue));\nexport { ServerTimestampValue };\nvar BlobValue = /** @class */ (function (_super) {\n    __extends(BlobValue, _super);\n    function BlobValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.BlobValue;\n        return _this;\n    }\n    BlobValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    BlobValue.prototype.isEqual = function (other) {\n        return (other instanceof BlobValue &&\n            this.internalValue.isEqual(other.internalValue));\n    };\n    BlobValue.prototype.compareTo = function (other) {\n        if (other instanceof BlobValue) {\n            return this.internalValue._compareTo(other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return BlobValue;\n}(FieldValue));\nexport { BlobValue };\nvar RefValue = /** @class */ (function (_super) {\n    __extends(RefValue, _super);\n    function RefValue(databaseId, key) {\n        var _this = _super.call(this) || this;\n        _this.databaseId = databaseId;\n        _this.key = key;\n        _this.typeOrder = TypeOrder.RefValue;\n        return _this;\n    }\n    RefValue.prototype.value = function (options) {\n        return this.key;\n    };\n    RefValue.prototype.isEqual = function (other) {\n        if (other instanceof RefValue) {\n            return (this.key.isEqual(other.key) && this.databaseId.isEqual(other.databaseId));\n        }\n        else {\n            return false;\n        }\n    };\n    RefValue.prototype.compareTo = function (other) {\n        if (other instanceof RefValue) {\n            var cmp = this.databaseId.compareTo(other.databaseId);\n            return cmp !== 0 ? cmp : DocumentKey.comparator(this.key, other.key);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return RefValue;\n}(FieldValue));\nexport { RefValue };\nvar GeoPointValue = /** @class */ (function (_super) {\n    __extends(GeoPointValue, _super);\n    function GeoPointValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.GeoPointValue;\n        return _this;\n    }\n    GeoPointValue.prototype.value = function (options) {\n        return this.internalValue;\n    };\n    GeoPointValue.prototype.isEqual = function (other) {\n        return (other instanceof GeoPointValue &&\n            this.internalValue.isEqual(other.internalValue));\n    };\n    GeoPointValue.prototype.compareTo = function (other) {\n        if (other instanceof GeoPointValue) {\n            return this.internalValue._compareTo(other.internalValue);\n        }\n        return this.defaultCompareTo(other);\n    };\n    return GeoPointValue;\n}(FieldValue));\nexport { GeoPointValue };\nvar ObjectValue = /** @class */ (function (_super) {\n    __extends(ObjectValue, _super);\n    function ObjectValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.ObjectValue;\n        return _this;\n    }\n    ObjectValue.prototype.value = function (options) {\n        var result = {};\n        this.internalValue.inorderTraversal(function (key, val) {\n            result[key] = val.value(options);\n        });\n        return result;\n    };\n    ObjectValue.prototype.forEach = function (action) {\n        this.internalValue.inorderTraversal(action);\n    };\n    ObjectValue.prototype.isEqual = function (other) {\n        if (other instanceof ObjectValue) {\n            var it1 = this.internalValue.getIterator();\n            var it2 = other.internalValue.getIterator();\n            while (it1.hasNext() && it2.hasNext()) {\n                var next1 = it1.getNext();\n                var next2 = it2.getNext();\n                if (next1.key !== next2.key || !next1.value.isEqual(next2.value)) {\n                    return false;\n                }\n            }\n            return !it1.hasNext() && !it2.hasNext();\n        }\n        return false;\n    };\n    ObjectValue.prototype.compareTo = function (other) {\n        if (other instanceof ObjectValue) {\n            var it1 = this.internalValue.getIterator();\n            var it2 = other.internalValue.getIterator();\n            while (it1.hasNext() && it2.hasNext()) {\n                var next1 = it1.getNext();\n                var next2 = it2.getNext();\n                var cmp = primitiveComparator(next1.key, next2.key) ||\n                    next1.value.compareTo(next2.value);\n                if (cmp) {\n                    return cmp;\n                }\n            }\n            // Only equal if both iterators are exhausted\n            return primitiveComparator(it1.hasNext(), it2.hasNext());\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    ObjectValue.prototype.set = function (path, to) {\n        assert(!path.isEmpty(), 'Cannot set field for empty path on ObjectValue');\n        if (path.length === 1) {\n            return this.setChild(path.firstSegment(), to);\n        }\n        else {\n            var child = this.child(path.firstSegment());\n            if (!(child instanceof ObjectValue)) {\n                child = ObjectValue.EMPTY;\n            }\n            var newChild = child.set(path.popFirst(), to);\n            return this.setChild(path.firstSegment(), newChild);\n        }\n    };\n    ObjectValue.prototype.delete = function (path) {\n        assert(!path.isEmpty(), 'Cannot delete field for empty path on ObjectValue');\n        if (path.length === 1) {\n            return new ObjectValue(this.internalValue.remove(path.firstSegment()));\n        }\n        else {\n            // nested field\n            var child = this.child(path.firstSegment());\n            if (child instanceof ObjectValue) {\n                var newChild = child.delete(path.popFirst());\n                return new ObjectValue(this.internalValue.insert(path.firstSegment(), newChild));\n            }\n            else {\n                // Don't actually change a primitive value to an object for a delete\n                return this;\n            }\n        }\n    };\n    ObjectValue.prototype.contains = function (path) {\n        return this.field(path) !== undefined;\n    };\n    ObjectValue.prototype.field = function (path) {\n        assert(!path.isEmpty(), \"Can't get field of empty path\");\n        var field = this;\n        path.forEach(function (pathSegment) {\n            if (field instanceof ObjectValue) {\n                field = field.internalValue.get(pathSegment) || undefined;\n            }\n            else {\n                field = undefined;\n            }\n        });\n        return field;\n    };\n    ObjectValue.prototype.toString = function () {\n        return JSON.stringify(this.value());\n    };\n    ObjectValue.prototype.child = function (childName) {\n        return this.internalValue.get(childName) || undefined;\n    };\n    ObjectValue.prototype.setChild = function (childName, value) {\n        return new ObjectValue(this.internalValue.insert(childName, value));\n    };\n    ObjectValue.EMPTY = new ObjectValue(new SortedMap(primitiveComparator));\n    return ObjectValue;\n}(FieldValue));\nexport { ObjectValue };\nvar ArrayValue = /** @class */ (function (_super) {\n    __extends(ArrayValue, _super);\n    function ArrayValue(internalValue) {\n        var _this = _super.call(this) || this;\n        _this.internalValue = internalValue;\n        _this.typeOrder = TypeOrder.ArrayValue;\n        return _this;\n    }\n    ArrayValue.prototype.value = function (options) {\n        return this.internalValue.map(function (v) { return v.value(options); });\n    };\n    ArrayValue.prototype.forEach = function (action) {\n        this.internalValue.forEach(action);\n    };\n    ArrayValue.prototype.isEqual = function (other) {\n        if (other instanceof ArrayValue) {\n            if (this.internalValue.length !== other.internalValue.length) {\n                return false;\n            }\n            for (var i = 0; i < this.internalValue.length; i++) {\n                if (!this.internalValue[i].isEqual(other.internalValue[i])) {\n                    return false;\n                }\n            }\n            return true;\n        }\n        return false;\n    };\n    ArrayValue.prototype.compareTo = function (other) {\n        if (other instanceof ArrayValue) {\n            var minLength = Math.min(this.internalValue.length, other.internalValue.length);\n            for (var i = 0; i < minLength; i++) {\n                var cmp = this.internalValue[i].compareTo(other.internalValue[i]);\n                if (cmp) {\n                    return cmp;\n                }\n            }\n            return primitiveComparator(this.internalValue.length, other.internalValue.length);\n        }\n        else {\n            return this.defaultCompareTo(other);\n        }\n    };\n    ArrayValue.prototype.toString = function () {\n        return JSON.stringify(this.value());\n    };\n    return ArrayValue;\n}(FieldValue));\nexport { ArrayValue };\n\n//# sourceMappingURL=field_value.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/field_value.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n// Untyped Number alias we can use to check for ES6 methods / properties.\n// tslint:disable-next-line:no-any variable-name\nvar NumberAsAny = Number;\n/**\n * Minimum safe integer in Javascript because of floating point precision.\n * Added to not rely on ES6 features.\n */\nexport var MIN_SAFE_INTEGER = NumberAsAny.MIN_SAFE_INTEGER || -(Math.pow(2, 53) - 1);\n/**\n * Maximum safe integer in Javascript because of floating point precision.\n * Added to not rely on ES6 features.\n */\nexport var MAX_SAFE_INTEGER = NumberAsAny.MAX_SAFE_INTEGER || Math.pow(2, 53) - 1;\n/**\n * Returns whether an number is an integer, uses native implementation if\n * available.\n * Added to not rely on ES6 features.\n * @param value The value to test for being an integer\n */\nexport var isInteger = NumberAsAny.isInteger ||\n    (function (value) {\n        return typeof value === 'number' &&\n            isFinite(value) &&\n            Math.floor(value) === value;\n    });\n/**\n * Returns whether a variable is either undefined or null.\n */\nexport function isNullOrUndefined(value) {\n    return value === null || value === undefined;\n}\n/**\n * Returns whether a value is an integer and in the safe integer range\n * @param value The value to test for being an integer and in the safe range\n */\nexport function isSafeInteger(value) {\n    return (isInteger(value) &&\n        value <= MAX_SAFE_INTEGER &&\n        value >= MIN_SAFE_INTEGER);\n}\n/**\n * Safely checks if the number is NaN.\n */\nexport function safeIsNaN(value) {\n    if (NumberAsAny.IsNaN) {\n        return NumberAsAny.IsNaN(value);\n    }\n    else {\n        return typeof value === 'number' && isNaN(value);\n    }\n}\n\n//# sourceMappingURL=types.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/types.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Document } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { DoubleValue, NullValue, RefValue } from '../model/field_value';\nimport { FieldPath } from '../model/path';\nimport { assert, fail } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nimport { isNullOrUndefined } from '../util/types';\nvar Query = /** @class */ (function () {\n    function Query(path, explicitOrderBy, filters, limit, startAt, endAt) {\n        if (explicitOrderBy === void 0) { explicitOrderBy = []; }\n        if (filters === void 0) { filters = []; }\n        if (limit === void 0) { limit = null; }\n        if (startAt === void 0) { startAt = null; }\n        if (endAt === void 0) { endAt = null; }\n        this.path = path;\n        this.explicitOrderBy = explicitOrderBy;\n        this.filters = filters;\n        this.limit = limit;\n        this.startAt = startAt;\n        this.endAt = endAt;\n        this.memoizedCanonicalId = null;\n        this.memoizedOrderBy = null;\n        if (this.startAt) {\n            this.assertValidBound(this.startAt);\n        }\n        if (this.endAt) {\n            this.assertValidBound(this.endAt);\n        }\n    }\n    Query.atPath = function (path) {\n        return new Query(path);\n    };\n    Object.defineProperty(Query.prototype, \"orderBy\", {\n        get: function () {\n            if (this.memoizedOrderBy === null) {\n                var inequalityField = this.getInequalityFilterField();\n                var firstOrderByField = this.getFirstOrderByField();\n                if (inequalityField !== null && firstOrderByField === null) {\n                    // In order to implicitly add key ordering, we must also add the\n                    // inequality filter field for it to be a valid query.\n                    // Note that the default inequality field and key ordering is ascending.\n                    if (inequalityField.isKeyField()) {\n                        this.memoizedOrderBy = [KEY_ORDERING_ASC];\n                    }\n                    else {\n                        this.memoizedOrderBy = [\n                            new OrderBy(inequalityField),\n                            KEY_ORDERING_ASC\n                        ];\n                    }\n                }\n                else {\n                    assert(inequalityField === null ||\n                        (firstOrderByField !== null &&\n                            inequalityField.isEqual(firstOrderByField)), 'First orderBy should match inequality field.');\n                    this.memoizedOrderBy = [];\n                    var foundKeyOrdering = false;\n                    for (var _i = 0, _a = this.explicitOrderBy; _i < _a.length; _i++) {\n                        var orderBy = _a[_i];\n                        this.memoizedOrderBy.push(orderBy);\n                        if (orderBy.field.isKeyField()) {\n                            foundKeyOrdering = true;\n                        }\n                    }\n                    if (!foundKeyOrdering) {\n                        // The order of the implicit key ordering always matches the last\n                        // explicit order by\n                        var lastDirection = this.explicitOrderBy.length > 0\n                            ? this.explicitOrderBy[this.explicitOrderBy.length - 1].dir\n                            : Direction.ASCENDING;\n                        this.memoizedOrderBy.push(lastDirection === Direction.ASCENDING\n                            ? KEY_ORDERING_ASC\n                            : KEY_ORDERING_DESC);\n                    }\n                }\n            }\n            return this.memoizedOrderBy;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Query.prototype.addFilter = function (filter) {\n        assert(this.getInequalityFilterField() == null ||\n            !(filter instanceof RelationFilter) ||\n            !filter.isInequality() ||\n            filter.field.isEqual(this.getInequalityFilterField()), 'Query must only have one inequality field.');\n        assert(!DocumentKey.isDocumentKey(this.path), 'No filtering allowed for document query');\n        var newFilters = this.filters.concat([filter]);\n        return new Query(this.path, this.explicitOrderBy.slice(), newFilters, this.limit, this.startAt, this.endAt);\n    };\n    Query.prototype.addOrderBy = function (orderBy) {\n        assert(!DocumentKey.isDocumentKey(this.path), 'No ordering allowed for document query');\n        assert(!this.startAt && !this.endAt, 'Bounds must be set after orderBy');\n        // TODO(dimond): validate that orderBy does not list the same key twice.\n        var newOrderBy = this.explicitOrderBy.concat([orderBy]);\n        return new Query(this.path, newOrderBy, this.filters.slice(), this.limit, this.startAt, this.endAt);\n    };\n    Query.prototype.withLimit = function (limit) {\n        return new Query(this.path, this.explicitOrderBy.slice(), this.filters.slice(), limit, this.startAt, this.endAt);\n    };\n    Query.prototype.withStartAt = function (bound) {\n        return new Query(this.path, this.explicitOrderBy.slice(), this.filters.slice(), this.limit, bound, this.endAt);\n    };\n    Query.prototype.withEndAt = function (bound) {\n        return new Query(this.path, this.explicitOrderBy.slice(), this.filters.slice(), this.limit, this.startAt, bound);\n    };\n    // TODO(b/29183165): This is used to get a unique string from a query to, for\n    // example, use as a dictionary key, but the implementation is subject to\n    // collisions. Make it collision-free.\n    Query.prototype.canonicalId = function () {\n        if (this.memoizedCanonicalId === null) {\n            var canonicalId = this.path.canonicalString();\n            canonicalId += '|f:';\n            for (var _i = 0, _a = this.filters; _i < _a.length; _i++) {\n                var filter = _a[_i];\n                canonicalId += filter.canonicalId();\n                canonicalId += ',';\n            }\n            canonicalId += '|ob:';\n            // TODO(dimond): make this collision resistant\n            for (var _b = 0, _c = this.orderBy; _b < _c.length; _b++) {\n                var orderBy = _c[_b];\n                canonicalId += orderBy.canonicalId();\n                canonicalId += ',';\n            }\n            if (!isNullOrUndefined(this.limit)) {\n                canonicalId += '|l:';\n                canonicalId += this.limit;\n            }\n            if (this.startAt) {\n                canonicalId += '|lb:';\n                canonicalId += this.startAt.canonicalId();\n            }\n            if (this.endAt) {\n                canonicalId += '|ub:';\n                canonicalId += this.endAt.canonicalId();\n            }\n            this.memoizedCanonicalId = canonicalId;\n        }\n        return this.memoizedCanonicalId;\n    };\n    Query.prototype.toString = function () {\n        var str = 'Query(' + this.path.canonicalString();\n        if (this.filters.length > 0) {\n            str += \", filters: [\" + this.filters.join(', ') + \"]\";\n        }\n        if (!isNullOrUndefined(this.limit)) {\n            str += ', limit: ' + this.limit;\n        }\n        if (this.explicitOrderBy.length > 0) {\n            str += \", orderBy: [\" + this.explicitOrderBy.join(', ') + \"]\";\n        }\n        if (this.startAt) {\n            str += ', startAt: ' + this.startAt.canonicalId();\n        }\n        if (this.endAt) {\n            str += ', endAt: ' + this.endAt.canonicalId();\n        }\n        return str + ')';\n    };\n    Query.prototype.isEqual = function (other) {\n        if (this.limit !== other.limit) {\n            return false;\n        }\n        if (this.orderBy.length !== other.orderBy.length) {\n            return false;\n        }\n        for (var i = 0; i < this.orderBy.length; i++) {\n            if (!this.orderBy[i].isEqual(other.orderBy[i])) {\n                return false;\n            }\n        }\n        if (this.filters.length !== other.filters.length) {\n            return false;\n        }\n        for (var i = 0; i < this.filters.length; i++) {\n            if (!this.filters[i].isEqual(other.filters[i])) {\n                return false;\n            }\n        }\n        if (!this.path.isEqual(other.path)) {\n            return false;\n        }\n        if (this.startAt !== null\n            ? !this.startAt.isEqual(other.startAt)\n            : other.startAt !== null) {\n            return false;\n        }\n        return this.endAt !== null\n            ? this.endAt.isEqual(other.endAt)\n            : other.endAt === null;\n    };\n    Query.prototype.docComparator = function (d1, d2) {\n        var comparedOnKeyField = false;\n        for (var _i = 0, _a = this.orderBy; _i < _a.length; _i++) {\n            var orderBy = _a[_i];\n            var comp = orderBy.compare(d1, d2);\n            if (comp !== 0)\n                return comp;\n            comparedOnKeyField = comparedOnKeyField || orderBy.field.isKeyField();\n        }\n        // Assert that we actually compared by key\n        assert(comparedOnKeyField, \"orderBy used that doesn't compare on key field\");\n        return 0;\n    };\n    Query.prototype.matches = function (doc) {\n        return (this.matchesAncestor(doc) &&\n            this.matchesOrderBy(doc) &&\n            this.matchesFilters(doc) &&\n            this.matchesBounds(doc));\n    };\n    Query.prototype.hasLimit = function () {\n        return !isNullOrUndefined(this.limit);\n    };\n    Query.prototype.getFirstOrderByField = function () {\n        return this.explicitOrderBy.length > 0\n            ? this.explicitOrderBy[0].field\n            : null;\n    };\n    Query.prototype.getInequalityFilterField = function () {\n        for (var _i = 0, _a = this.filters; _i < _a.length; _i++) {\n            var filter = _a[_i];\n            if (filter instanceof RelationFilter && filter.isInequality()) {\n                return filter.field;\n            }\n        }\n        return null;\n    };\n    Query.prototype.isDocumentQuery = function () {\n        return DocumentKey.isDocumentKey(this.path) && this.filters.length === 0;\n    };\n    Query.prototype.matchesAncestor = function (doc) {\n        var docPath = doc.key.path;\n        if (DocumentKey.isDocumentKey(this.path)) {\n            // exact match for document queries\n            return this.path.isEqual(docPath);\n        }\n        else {\n            // shallow ancestor queries by default\n            return (this.path.isPrefixOf(docPath) && this.path.length === docPath.length - 1);\n        }\n    };\n    /**\n     * A document must have a value for every ordering clause in order to show up\n     * in the results.\n     */\n    Query.prototype.matchesOrderBy = function (doc) {\n        for (var _i = 0, _a = this.explicitOrderBy; _i < _a.length; _i++) {\n            var orderBy = _a[_i];\n            // order by key always matches\n            if (!orderBy.field.isKeyField() &&\n                doc.field(orderBy.field) === undefined) {\n                return false;\n            }\n        }\n        return true;\n    };\n    Query.prototype.matchesFilters = function (doc) {\n        for (var _i = 0, _a = this.filters; _i < _a.length; _i++) {\n            var filter = _a[_i];\n            if (!filter.matches(doc)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    /**\n     * Makes sure a document is within the bounds, if provided.\n     */\n    Query.prototype.matchesBounds = function (doc) {\n        if (this.startAt && !this.startAt.sortsBeforeDocument(this.orderBy, doc)) {\n            return false;\n        }\n        if (this.endAt && this.endAt.sortsBeforeDocument(this.orderBy, doc)) {\n            return false;\n        }\n        return true;\n    };\n    Query.prototype.assertValidBound = function (bound) {\n        assert(bound.position.length <= this.orderBy.length, 'Bound is longer than orderBy');\n    };\n    return Query;\n}());\nexport { Query };\nvar RelationOp = /** @class */ (function () {\n    function RelationOp(name) {\n        this.name = name;\n    }\n    RelationOp.fromString = function (op) {\n        switch (op) {\n            case '<':\n                return RelationOp.LESS_THAN;\n            case '<=':\n                return RelationOp.LESS_THAN_OR_EQUAL;\n            case '==':\n                return RelationOp.EQUAL;\n            case '>=':\n                return RelationOp.GREATER_THAN_OR_EQUAL;\n            case '>':\n                return RelationOp.GREATER_THAN;\n            default:\n                return fail('Unknown relation: ' + op);\n        }\n    };\n    RelationOp.prototype.toString = function () {\n        return this.name;\n    };\n    RelationOp.prototype.isEqual = function (other) {\n        return this.name === other.name;\n    };\n    RelationOp.LESS_THAN = new RelationOp('<');\n    RelationOp.LESS_THAN_OR_EQUAL = new RelationOp('<=');\n    RelationOp.EQUAL = new RelationOp('==');\n    RelationOp.GREATER_THAN = new RelationOp('>');\n    RelationOp.GREATER_THAN_OR_EQUAL = new RelationOp('>=');\n    return RelationOp;\n}());\nexport { RelationOp };\nvar RelationFilter = /** @class */ (function () {\n    function RelationFilter(field, op, value) {\n        this.field = field;\n        this.op = op;\n        this.value = value;\n    }\n    RelationFilter.prototype.matches = function (doc) {\n        if (this.field.isKeyField()) {\n            assert(this.value instanceof RefValue, 'Comparing on key, but filter value not a RefValue');\n            var refValue = this.value;\n            var comparison = DocumentKey.comparator(doc.key, refValue.key);\n            return this.matchesComparison(comparison);\n        }\n        else {\n            var val = doc.field(this.field);\n            return val !== undefined && this.matchesValue(val);\n        }\n    };\n    RelationFilter.prototype.matchesValue = function (value) {\n        // Only compare types with matching backend order (such as double and int).\n        if (this.value.typeOrder !== value.typeOrder) {\n            return false;\n        }\n        return this.matchesComparison(value.compareTo(this.value));\n    };\n    RelationFilter.prototype.matchesComparison = function (comparison) {\n        switch (this.op) {\n            case RelationOp.LESS_THAN:\n                return comparison < 0;\n            case RelationOp.LESS_THAN_OR_EQUAL:\n                return comparison <= 0;\n            case RelationOp.EQUAL:\n                return comparison === 0;\n            case RelationOp.GREATER_THAN:\n                return comparison > 0;\n            case RelationOp.GREATER_THAN_OR_EQUAL:\n                return comparison >= 0;\n            default:\n                return fail('Unknown relation op' + this.op);\n        }\n    };\n    RelationFilter.prototype.isInequality = function () {\n        return this.op !== RelationOp.EQUAL;\n    };\n    RelationFilter.prototype.canonicalId = function () {\n        // TODO(b/29183165): Technically, this won't be unique if two values have\n        // the same description, such as the int 3 and the string \"3\". So we should\n        // add the types in here somehow, too.\n        return (this.field.canonicalString() + this.op.toString() + this.value.toString());\n    };\n    RelationFilter.prototype.isEqual = function (other) {\n        if (other instanceof RelationFilter) {\n            return (this.op.isEqual(other.op) &&\n                this.field.isEqual(other.field) &&\n                this.value.isEqual(other.value));\n        }\n        else {\n            return false;\n        }\n    };\n    RelationFilter.prototype.toString = function () {\n        return this.field.canonicalString() + \" \" + this.op + \" \" + this.value.value();\n    };\n    return RelationFilter;\n}());\nexport { RelationFilter };\n/**\n * Filter that matches 'null' values.\n */\nvar NullFilter = /** @class */ (function () {\n    function NullFilter(field) {\n        this.field = field;\n    }\n    NullFilter.prototype.matches = function (doc) {\n        var val = doc.field(this.field);\n        return val !== undefined && val.value() === null;\n    };\n    NullFilter.prototype.canonicalId = function () {\n        return this.field.canonicalString() + ' IS null';\n    };\n    NullFilter.prototype.toString = function () {\n        return this.field.canonicalString() + \" IS null\";\n    };\n    NullFilter.prototype.isEqual = function (other) {\n        if (other instanceof NullFilter) {\n            return this.field.isEqual(other.field);\n        }\n        else {\n            return false;\n        }\n    };\n    return NullFilter;\n}());\nexport { NullFilter };\n/**\n * Filter that matches 'NaN' values.\n */\nvar NanFilter = /** @class */ (function () {\n    function NanFilter(field) {\n        this.field = field;\n    }\n    NanFilter.prototype.matches = function (doc) {\n        var val = doc.field(this.field).value();\n        return typeof val === 'number' && isNaN(val);\n    };\n    NanFilter.prototype.canonicalId = function () {\n        return this.field.canonicalString() + ' IS NaN';\n    };\n    NanFilter.prototype.toString = function () {\n        return this.field.canonicalString() + \" IS NaN\";\n    };\n    NanFilter.prototype.isEqual = function (other) {\n        if (other instanceof NanFilter) {\n            return this.field.isEqual(other.field);\n        }\n        else {\n            return false;\n        }\n    };\n    return NanFilter;\n}());\nexport { NanFilter };\n/**\n * Creates a filter based on the provided arguments.\n */\nexport function fieldFilter(field, op, value) {\n    if (value.isEqual(NullValue.INSTANCE)) {\n        if (op !== RelationOp.EQUAL) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You can only perform equals ' + 'comparisons on null.');\n        }\n        return new NullFilter(field);\n    }\n    else if (value.isEqual(DoubleValue.NAN)) {\n        if (op !== RelationOp.EQUAL) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You can only perform equals ' + 'comparisons on NaN.');\n        }\n        return new NanFilter(field);\n    }\n    else {\n        return new RelationFilter(field, op, value);\n    }\n}\n/**\n * The direction of sorting in an order by.\n */\nvar Direction = /** @class */ (function () {\n    function Direction(name) {\n        this.name = name;\n    }\n    Direction.prototype.toString = function () {\n        return this.name;\n    };\n    Direction.ASCENDING = new Direction('asc');\n    Direction.DESCENDING = new Direction('desc');\n    return Direction;\n}());\nexport { Direction };\n/**\n * Represents a bound of a query.\n *\n * The bound is specified with the given components representing a position and\n * whether it's just before or just after the position (relative to whatever the\n * query order is).\n *\n * The position represents a logical index position for a query. It's a prefix\n * of values for the (potentially implicit) order by clauses of a query.\n *\n * Bound provides a function to determine whether a document comes before or\n * after a bound. This is influenced by whether the position is just before or\n * just after the provided values.\n */\nvar Bound = /** @class */ (function () {\n    function Bound(position, before) {\n        this.position = position;\n        this.before = before;\n    }\n    Bound.prototype.canonicalId = function () {\n        // TODO(b/29183165): Make this collision robust.\n        var canonicalId = this.before ? 'b:' : 'a:';\n        for (var _i = 0, _a = this.position; _i < _a.length; _i++) {\n            var component = _a[_i];\n            canonicalId += component.toString();\n        }\n        return canonicalId;\n    };\n    /**\n     * Returns true if a document sorts before a bound using the provided sort\n     * order.\n     */\n    Bound.prototype.sortsBeforeDocument = function (orderBy, doc) {\n        assert(this.position.length <= orderBy.length, \"Bound has more components than query's orderBy\");\n        var comparison = 0;\n        for (var i = 0; i < this.position.length; i++) {\n            var orderByComponent = orderBy[i];\n            var component = this.position[i];\n            if (orderByComponent.field.isKeyField()) {\n                assert(component instanceof RefValue, 'Bound has a non-key value where the key path is being used.');\n                comparison = DocumentKey.comparator(component.key, doc.key);\n            }\n            else {\n                var docValue = doc.field(orderByComponent.field);\n                assert(docValue !== undefined, 'Field should exist since document matched the orderBy already.');\n                comparison = component.compareTo(docValue);\n            }\n            if (orderByComponent.dir === Direction.DESCENDING) {\n                comparison = comparison * -1;\n            }\n            if (comparison !== 0) {\n                break;\n            }\n        }\n        return this.before ? comparison <= 0 : comparison < 0;\n    };\n    Bound.prototype.isEqual = function (other) {\n        if (other === null) {\n            return false;\n        }\n        if (this.before !== other.before ||\n            this.position.length !== other.position.length) {\n            return false;\n        }\n        for (var i = 0; i < this.position.length; i++) {\n            var thisPosition = this.position[i];\n            var otherPosition = other.position[i];\n            return thisPosition.isEqual(otherPosition);\n        }\n        return true;\n    };\n    return Bound;\n}());\nexport { Bound };\n/**\n * An ordering on a field, in some Direction. Direction defaults to ASCENDING.\n */\nvar OrderBy = /** @class */ (function () {\n    function OrderBy(field, dir) {\n        this.field = field;\n        if (dir === undefined) {\n            dir = Direction.ASCENDING;\n        }\n        this.dir = dir;\n        this.isKeyOrderBy = field.isKeyField();\n    }\n    OrderBy.prototype.compare = function (d1, d2) {\n        var comparison = this.isKeyOrderBy\n            ? Document.compareByKey(d1, d2)\n            : Document.compareByField(this.field, d1, d2);\n        switch (this.dir) {\n            case Direction.ASCENDING:\n                return comparison;\n            case Direction.DESCENDING:\n                return -1 * comparison;\n            default:\n                return fail('Unknown direction: ' + this.dir);\n        }\n    };\n    OrderBy.prototype.canonicalId = function () {\n        // TODO(b/29183165): Make this collision robust.\n        return this.field.canonicalString() + this.dir.toString();\n    };\n    OrderBy.prototype.toString = function () {\n        return this.field.canonicalString() + \" (\" + this.dir + \")\";\n    };\n    OrderBy.prototype.isEqual = function (other) {\n        return this.dir === other.dir && this.field.isEqual(other.field);\n    };\n    return OrderBy;\n}());\nexport { OrderBy };\nvar KEY_ORDERING_ASC = new OrderBy(FieldPath.keyField(), Direction.ASCENDING);\nvar KEY_ORDERING_DESC = new OrderBy(FieldPath.keyField(), Direction.DESCENDING);\n\n//# sourceMappingURL=query.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/query.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { fail } from '../util/assert';\nimport { Code } from '../util/error';\nimport * as log from '../util/log';\n/**\n * Error Codes describing the different ways GRPC can fail. These are copied\n * directly from GRPC's sources here:\n *\n * https://github.com/grpc/grpc/blob/bceec94ea4fc5f0085d81235d8e1c06798dc341a/include/grpc%2B%2B/impl/codegen/status_code_enum.h\n *\n * Important! The names of these identifiers matter because the string forms\n * are used for reverse lookups from the webchannel stream. Do NOT change the\n * names of these identifiers.\n */\nvar RpcCode;\n(function (RpcCode) {\n    RpcCode[RpcCode[\"OK\"] = 0] = \"OK\";\n    RpcCode[RpcCode[\"CANCELLED\"] = 1] = \"CANCELLED\";\n    RpcCode[RpcCode[\"UNKNOWN\"] = 2] = \"UNKNOWN\";\n    RpcCode[RpcCode[\"INVALID_ARGUMENT\"] = 3] = \"INVALID_ARGUMENT\";\n    RpcCode[RpcCode[\"DEADLINE_EXCEEDED\"] = 4] = \"DEADLINE_EXCEEDED\";\n    RpcCode[RpcCode[\"NOT_FOUND\"] = 5] = \"NOT_FOUND\";\n    RpcCode[RpcCode[\"ALREADY_EXISTS\"] = 6] = \"ALREADY_EXISTS\";\n    RpcCode[RpcCode[\"PERMISSION_DENIED\"] = 7] = \"PERMISSION_DENIED\";\n    RpcCode[RpcCode[\"UNAUTHENTICATED\"] = 16] = \"UNAUTHENTICATED\";\n    RpcCode[RpcCode[\"RESOURCE_EXHAUSTED\"] = 8] = \"RESOURCE_EXHAUSTED\";\n    RpcCode[RpcCode[\"FAILED_PRECONDITION\"] = 9] = \"FAILED_PRECONDITION\";\n    RpcCode[RpcCode[\"ABORTED\"] = 10] = \"ABORTED\";\n    RpcCode[RpcCode[\"OUT_OF_RANGE\"] = 11] = \"OUT_OF_RANGE\";\n    RpcCode[RpcCode[\"UNIMPLEMENTED\"] = 12] = \"UNIMPLEMENTED\";\n    RpcCode[RpcCode[\"INTERNAL\"] = 13] = \"INTERNAL\";\n    RpcCode[RpcCode[\"UNAVAILABLE\"] = 14] = \"UNAVAILABLE\";\n    RpcCode[RpcCode[\"DATA_LOSS\"] = 15] = \"DATA_LOSS\";\n})(RpcCode || (RpcCode = {}));\nexport function isPermanentError(code) {\n    switch (code) {\n        case Code.OK:\n            return fail('Treated status OK as error');\n        case Code.CANCELLED:\n        case Code.UNKNOWN:\n        case Code.DEADLINE_EXCEEDED:\n        case Code.RESOURCE_EXHAUSTED:\n        case Code.INTERNAL:\n        case Code.UNAVAILABLE:\n        // Unauthenticated means something went wrong with our token and we need\n        // to retry with new credentials which will happen automatically.\n        // TODO(b/37325376): Give up after second unauthenticated error.\n        case Code.UNAUTHENTICATED:\n            return false;\n        case Code.INVALID_ARGUMENT:\n        case Code.NOT_FOUND:\n        case Code.ALREADY_EXISTS:\n        case Code.PERMISSION_DENIED:\n        case Code.FAILED_PRECONDITION:\n        // Aborted might be retried in some scenarios, but that is dependant on\n        // the context and should handled individually by the calling code.\n        // See https://cloud.google.com/apis/design/errors.\n        case Code.ABORTED:\n        case Code.OUT_OF_RANGE:\n        case Code.UNIMPLEMENTED:\n        case Code.DATA_LOSS:\n            return true;\n        default:\n            return fail('Unknown status code: ' + code);\n    }\n}\n/**\n * Maps an error Code from a GRPC status identifier like 'NOT_FOUND'.\n *\n * @returns The Code equivalent to the given status string or undefined if\n *     there is no match.\n */\nexport function mapCodeFromRpcStatus(status) {\n    // tslint:disable-next-line:no-any lookup by string\n    var code = RpcCode[status];\n    if (code === undefined) {\n        return undefined;\n    }\n    return mapCodeFromRpcCode(code);\n}\n/**\n * Maps an error Code from GRPC status code number, like 0, 1, or 14. These\n * are not the same as HTTP status codes.\n *\n * @returns The Code equivalent to the given GRPC status code. Fails if there\n *     is no match.\n */\nexport function mapCodeFromRpcCode(code) {\n    if (code === undefined) {\n        // This shouldn't normally happen, but in certain error cases (like trying\n        // to send invalid proto messages) we may get an error with no GRPC code.\n        log.error('GRPC error has no .code');\n        return Code.UNKNOWN;\n    }\n    switch (code) {\n        case RpcCode.OK:\n            return Code.OK;\n        case RpcCode.CANCELLED:\n            return Code.CANCELLED;\n        case RpcCode.UNKNOWN:\n            return Code.UNKNOWN;\n        case RpcCode.DEADLINE_EXCEEDED:\n            return Code.DEADLINE_EXCEEDED;\n        case RpcCode.RESOURCE_EXHAUSTED:\n            return Code.RESOURCE_EXHAUSTED;\n        case RpcCode.INTERNAL:\n            return Code.INTERNAL;\n        case RpcCode.UNAVAILABLE:\n            return Code.UNAVAILABLE;\n        case RpcCode.UNAUTHENTICATED:\n            return Code.UNAUTHENTICATED;\n        case RpcCode.INVALID_ARGUMENT:\n            return Code.INVALID_ARGUMENT;\n        case RpcCode.NOT_FOUND:\n            return Code.NOT_FOUND;\n        case RpcCode.ALREADY_EXISTS:\n            return Code.ALREADY_EXISTS;\n        case RpcCode.PERMISSION_DENIED:\n            return Code.PERMISSION_DENIED;\n        case RpcCode.FAILED_PRECONDITION:\n            return Code.FAILED_PRECONDITION;\n        case RpcCode.ABORTED:\n            return Code.ABORTED;\n        case RpcCode.OUT_OF_RANGE:\n            return Code.OUT_OF_RANGE;\n        case RpcCode.UNIMPLEMENTED:\n            return Code.UNIMPLEMENTED;\n        case RpcCode.DATA_LOSS:\n            return Code.DATA_LOSS;\n        default:\n            return fail('Unknown status code: ' + code);\n    }\n}\n/**\n * Maps an RPC code from a Code. This is the reverse operation from\n * mapCodeFromRpcCode and should really only be used in tests.\n */\nexport function mapRpcCodeFromCode(code) {\n    if (code === undefined) {\n        return RpcCode.OK;\n    }\n    switch (code) {\n        case Code.OK:\n            return RpcCode.OK;\n        case Code.CANCELLED:\n            return RpcCode.CANCELLED;\n        case Code.UNKNOWN:\n            return RpcCode.UNKNOWN;\n        case Code.DEADLINE_EXCEEDED:\n            return RpcCode.DEADLINE_EXCEEDED;\n        case Code.RESOURCE_EXHAUSTED:\n            return RpcCode.RESOURCE_EXHAUSTED;\n        case Code.INTERNAL:\n            return RpcCode.INTERNAL;\n        case Code.UNAVAILABLE:\n            return RpcCode.UNAVAILABLE;\n        case Code.UNAUTHENTICATED:\n            return RpcCode.UNAUTHENTICATED;\n        case Code.INVALID_ARGUMENT:\n            return RpcCode.INVALID_ARGUMENT;\n        case Code.NOT_FOUND:\n            return RpcCode.NOT_FOUND;\n        case Code.ALREADY_EXISTS:\n            return RpcCode.ALREADY_EXISTS;\n        case Code.PERMISSION_DENIED:\n            return RpcCode.PERMISSION_DENIED;\n        case Code.FAILED_PRECONDITION:\n            return RpcCode.FAILED_PRECONDITION;\n        case Code.ABORTED:\n            return RpcCode.ABORTED;\n        case Code.OUT_OF_RANGE:\n            return RpcCode.OUT_OF_RANGE;\n        case Code.UNIMPLEMENTED:\n            return RpcCode.UNIMPLEMENTED;\n        case Code.DATA_LOSS:\n            return RpcCode.DATA_LOSS;\n        default:\n            return fail('Unknown status code: ' + code);\n    }\n}\n/**\n * Converts an HTTP Status Code to the equivalent error code.\n *\n * @param status An HTTP Status Code, like 200, 404, 503, etc.\n * @returns The equivalent Code. Unknown status codes are mapped to\n *     Code.UNKNOWN.\n */\nexport function mapCodeFromHttpStatus(status) {\n    // The canonical error codes for Google APIs [1] specify mapping onto HTTP\n    // status codes but the mapping is not bijective. In each case of ambiguity\n    // this function chooses a primary error.\n    //\n    // [1]\n    // https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto\n    switch (status) {\n        case 200:// OK\n            return Code.OK;\n        case 400:// Bad Request\n            return Code.INVALID_ARGUMENT;\n        // Other possibilities based on the forward mapping\n        // return Code.FAILED_PRECONDITION;\n        // return Code.OUT_OF_RANGE;\n        case 401:// Unauthorized\n            return Code.UNAUTHENTICATED;\n        case 403:// Forbidden\n            return Code.PERMISSION_DENIED;\n        case 404:// Not Found\n            return Code.NOT_FOUND;\n        case 409:// Conflict\n            return Code.ABORTED;\n        // Other possibilities:\n        // return Code.ALREADY_EXISTS;\n        case 416:// Range Not Satisfiable\n            return Code.OUT_OF_RANGE;\n        case 429:// Too Many Requests\n            return Code.RESOURCE_EXHAUSTED;\n        case 499:// Client Closed Request\n            return Code.CANCELLED;\n        case 500:// Internal Server Error\n            return Code.UNKNOWN;\n        // Other possibilities:\n        // return Code.INTERNAL;\n        // return Code.DATA_LOSS;\n        case 501:// Unimplemented\n            return Code.UNIMPLEMENTED;\n        case 503:// Service Unavailable\n            return Code.UNAVAILABLE;\n        case 504:// Gateway Timeout\n            return Code.DEADLINE_EXCEEDED;\n        default:\n            if (status >= 200 && status < 300)\n                return Code.OK;\n            if (status >= 400 && status < 500)\n                return Code.FAILED_PRECONDITION;\n            if (status >= 500 && status < 600)\n                return Code.INTERNAL;\n            return Code.UNKNOWN;\n    }\n}\n\n//# sourceMappingURL=rpc_error.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/rpc_error.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SortedMap } from '../util/sorted_map';\nimport { SortedSet } from '../util/sorted_set';\nimport { DocumentKey } from './document_key';\nvar EMPTY_MAYBE_DOCUMENT_MAP = new SortedMap(DocumentKey.comparator);\nexport function maybeDocumentMap() {\n    return EMPTY_MAYBE_DOCUMENT_MAP;\n}\nvar EMPTY_DOCUMENT_MAP = new SortedMap(DocumentKey.comparator);\nexport function documentMap() {\n    return EMPTY_DOCUMENT_MAP;\n}\nvar EMPTY_DOCUMENT_VERSION_MAP = new SortedMap(DocumentKey.comparator);\nexport function documentVersionMap() {\n    return EMPTY_DOCUMENT_VERSION_MAP;\n}\nvar EMPTY_DOCUMENT_KEY_SET = new SortedSet(DocumentKey.comparator);\nexport function documentKeySet() {\n    return EMPTY_DOCUMENT_KEY_SET;\n}\n\n//# sourceMappingURL=collections.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/collections.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { maybeDocumentMap } from '../model/collections';\nimport { emptyByteString } from '../platform/platform';\nimport { assert, fail } from '../util/assert';\nimport * as objUtils from '../util/obj';\nimport { CurrentStatusUpdate, RemoteEvent, ResetMapping, UpdateMapping } from './remote_event';\n/**\n * Represents a changed document and a list of target ids to which this change\n * applies.\n *\n * If document has been deleted NoDocument will be provided.\n */\nvar DocumentWatchChange = /** @class */ (function () {\n    function DocumentWatchChange(\n        /** The new document applies to all of these targets. */\n        updatedTargetIds, \n        /** The new document is removed from all of these targets. */\n        removedTargetIds, \n        /** The key of the document for this change. */\n        key, \n        /**\n         * The new document or NoDocument if it was deleted. Is null if the\n         * document went out of view without the server sending a new document.\n         */\n        newDoc) {\n        this.updatedTargetIds = updatedTargetIds;\n        this.removedTargetIds = removedTargetIds;\n        this.key = key;\n        this.newDoc = newDoc;\n    }\n    return DocumentWatchChange;\n}());\nexport { DocumentWatchChange };\nvar ExistenceFilterChange = /** @class */ (function () {\n    function ExistenceFilterChange(targetId, existenceFilter) {\n        this.targetId = targetId;\n        this.existenceFilter = existenceFilter;\n    }\n    return ExistenceFilterChange;\n}());\nexport { ExistenceFilterChange };\nexport var WatchTargetChangeState;\n(function (WatchTargetChangeState) {\n    WatchTargetChangeState[WatchTargetChangeState[\"NoChange\"] = 0] = \"NoChange\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Added\"] = 1] = \"Added\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Removed\"] = 2] = \"Removed\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Current\"] = 3] = \"Current\";\n    WatchTargetChangeState[WatchTargetChangeState[\"Reset\"] = 4] = \"Reset\";\n})(WatchTargetChangeState || (WatchTargetChangeState = {}));\nvar WatchTargetChange = /** @class */ (function () {\n    function WatchTargetChange(\n        /** What kind of change occurred to the watch target. */\n        state, \n        /** The target IDs that were added/removed/set. */\n        targetIds, \n        /**\n         * An opaque, server-assigned token that allows watching a query to be\n         * resumed after disconnecting without retransmitting all the data that\n         * matches the query. The resume token essentially identifies a point in\n         * time from which the server should resume sending results.\n         */\n        resumeToken, \n        /** An RPC error indicating why the watch failed. */\n        cause) {\n        if (resumeToken === void 0) { resumeToken = emptyByteString(); }\n        if (cause === void 0) { cause = null; }\n        this.state = state;\n        this.targetIds = targetIds;\n        this.resumeToken = resumeToken;\n        this.cause = cause;\n    }\n    return WatchTargetChange;\n}());\nexport { WatchTargetChange };\n/**\n * A helper class to accumulate watch changes into a RemoteEvent and other\n * target information.\n */\nvar WatchChangeAggregator = /** @class */ (function () {\n    function WatchChangeAggregator(snapshotVersion, listenTargets, pendingTargetResponses) {\n        this.snapshotVersion = snapshotVersion;\n        this.listenTargets = listenTargets;\n        /** The existence filter - if any - for the given target IDs. */\n        this.existenceFilters = {};\n        /** Keeps track of the current target mappings */\n        this.targetChanges = {};\n        /** Keeps track of document to update */\n        this.documentUpdates = maybeDocumentMap();\n        /** Whether this aggregator was frozen and can no longer be modified */\n        this.frozen = false;\n        this.pendingTargetResponses = objUtils.shallowCopy(pendingTargetResponses);\n    }\n    /** Aggregates a watch change into the current state */\n    WatchChangeAggregator.prototype.add = function (watchChange) {\n        assert(!this.frozen, 'Trying to modify frozen WatchChangeAggregator.');\n        if (watchChange instanceof DocumentWatchChange) {\n            this.addDocumentChange(watchChange);\n        }\n        else if (watchChange instanceof WatchTargetChange) {\n            this.addTargetChange(watchChange);\n        }\n        else if (watchChange instanceof ExistenceFilterChange) {\n            this.addExistenceFilterChange(watchChange);\n        }\n        else {\n            fail('Unknown watch change: ' + watchChange);\n        }\n    };\n    /** Aggregates all provided watch changes to the current state in order */\n    WatchChangeAggregator.prototype.addChanges = function (watchChanges) {\n        var _this = this;\n        assert(!this.frozen, 'Trying to modify frozen WatchChangeAggregator.');\n        watchChanges.forEach(function (change) { return _this.add(change); });\n    };\n    /**\n     * Converts the current state into a remote event with the snapshot version\n     * provided via the constructor.\n     */\n    WatchChangeAggregator.prototype.createRemoteEvent = function () {\n        var _this = this;\n        var targetChanges = this.targetChanges;\n        // Remove all the non-active targets from the remote event.\n        objUtils.forEachNumber(this.targetChanges, function (targetId) {\n            if (!_this.isActiveTarget(targetId)) {\n                delete targetChanges[targetId];\n            }\n        });\n        // Mark this aggregator as frozen so no further modifications are made\n        this.frozen = true;\n        return new RemoteEvent(this.snapshotVersion, targetChanges, this.documentUpdates);\n    };\n    WatchChangeAggregator.prototype.ensureTargetChange = function (targetId) {\n        var change = this.targetChanges[targetId];\n        if (!change) {\n            // Create an UpdateMapping by default, since resets are always explicit.\n            change = {\n                currentStatusUpdate: CurrentStatusUpdate.None,\n                snapshotVersion: this.snapshotVersion,\n                mapping: new UpdateMapping(),\n                resumeToken: emptyByteString()\n            };\n            this.targetChanges[targetId] = change;\n        }\n        return change;\n    };\n    /**\n     * We need to wait for watch to ack targets before we process those events,\n     * so to know if a target is active, there must be no pending acks we're\n     * waiting for and it must be in the current list of targets that the client\n     * cares about.\n     *\n     * This method is visible for testing.\n     */\n    WatchChangeAggregator.prototype.isActiveTarget = function (targetId) {\n        return (!objUtils.contains(this.pendingTargetResponses, targetId) &&\n            objUtils.contains(this.listenTargets, targetId));\n    };\n    WatchChangeAggregator.prototype.addDocumentChange = function (docChange) {\n        var relevant = false;\n        for (var _i = 0, _a = docChange.updatedTargetIds; _i < _a.length; _i++) {\n            var targetId = _a[_i];\n            if (this.isActiveTarget(targetId)) {\n                var change = this.ensureTargetChange(targetId);\n                change.mapping.add(docChange.key);\n                relevant = true;\n            }\n        }\n        for (var _b = 0, _c = docChange.removedTargetIds; _b < _c.length; _b++) {\n            var targetId = _c[_b];\n            if (this.isActiveTarget(targetId)) {\n                var change = this.ensureTargetChange(targetId);\n                change.mapping.delete(docChange.key);\n                relevant = true;\n            }\n        }\n        // Only update the document if there is a new document to replace to an\n        // active target that is being listened to, this might be just a target\n        // update instead.\n        if (docChange.newDoc && relevant) {\n            this.documentUpdates = this.documentUpdates.insert(docChange.key, docChange.newDoc);\n        }\n    };\n    WatchChangeAggregator.prototype.addTargetChange = function (targetChange) {\n        var _this = this;\n        targetChange.targetIds.forEach(function (targetId) {\n            var change = _this.ensureTargetChange(targetId);\n            switch (targetChange.state) {\n                case WatchTargetChangeState.NoChange:\n                    if (_this.isActiveTarget(targetId)) {\n                        // Creating the change above satisfies the semantics of no-change.\n                        applyResumeToken(change, targetChange.resumeToken);\n                    }\n                    break;\n                case WatchTargetChangeState.Added:\n                    // We need to decrement the number of pending acks needed from watch\n                    // for this targetId.\n                    _this.recordTargetResponse(targetId);\n                    if (!objUtils.contains(_this.pendingTargetResponses, targetId)) {\n                        // We have a freshly added target, so we need to reset any state\n                        // that we had previously This can happen e.g. when remove and add\n                        // back a target for existence filter mismatches.\n                        change.mapping = new UpdateMapping();\n                        change.currentStatusUpdate = CurrentStatusUpdate.None;\n                        delete _this.existenceFilters[targetId];\n                    }\n                    applyResumeToken(change, targetChange.resumeToken);\n                    break;\n                case WatchTargetChangeState.Removed:\n                    // We need to keep track of removed targets to we can\n                    // post-filter and remove any target changes.\n                    // We need to decrement the number of pending acks needed from watch\n                    // for this targetId.\n                    _this.recordTargetResponse(targetId);\n                    assert(!targetChange.cause, 'WatchChangeAggregator does not handle errored targets');\n                    break;\n                case WatchTargetChangeState.Current:\n                    if (_this.isActiveTarget(targetId)) {\n                        change.currentStatusUpdate = CurrentStatusUpdate.MarkCurrent;\n                        applyResumeToken(change, targetChange.resumeToken);\n                    }\n                    break;\n                case WatchTargetChangeState.Reset:\n                    if (_this.isActiveTarget(targetId)) {\n                        // Overwrite any existing target mapping with a reset\n                        // mapping. Every subsequent update will modify the reset\n                        // mapping, not an update mapping.\n                        change.mapping = new ResetMapping();\n                        applyResumeToken(change, targetChange.resumeToken);\n                    }\n                    break;\n                default:\n                    fail('Unknown target watch change state: ' + targetChange.state);\n            }\n        });\n    };\n    /**\n     * Record that we get a watch target add/remove by decrementing the number of\n     * pending target responses that we have.\n     */\n    WatchChangeAggregator.prototype.recordTargetResponse = function (targetId) {\n        var newCount = (this.pendingTargetResponses[targetId] || 0) - 1;\n        if (newCount === 0) {\n            delete this.pendingTargetResponses[targetId];\n        }\n        else {\n            this.pendingTargetResponses[targetId] = newCount;\n        }\n    };\n    WatchChangeAggregator.prototype.addExistenceFilterChange = function (change) {\n        if (this.isActiveTarget(change.targetId)) {\n            this.existenceFilters[change.targetId] = change.existenceFilter;\n        }\n    };\n    return WatchChangeAggregator;\n}());\nexport { WatchChangeAggregator };\n/**\n * Applies the resume token to the TargetChange, but only when it has a new\n * value. null and empty resumeTokens are discarded.\n */\nfunction applyResumeToken(change, resumeToken) {\n    if (resumeToken.length > 0) {\n        change.resumeToken = resumeToken;\n    }\n}\n\n//# sourceMappingURL=watch_change.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/watch_change.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Blob } from '../api/blob';\nimport { GeoPoint } from '../api/geo_point';\nimport { DatabaseId } from '../core/database_info';\nimport { Bound, Direction, NanFilter, NullFilter, OrderBy, Query, RelationFilter, RelationOp } from '../core/query';\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { Timestamp } from '../core/timestamp';\nimport { QueryPurpose } from '../local/query_data';\nimport { Document, NoDocument } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport * as fieldValue from '../model/field_value';\nimport { DeleteMutation, FieldMask, FieldTransform, MutationResult, PatchMutation, Precondition, ServerTimestampTransform, SetMutation, TransformMutation } from '../model/mutation';\nimport { FieldPath, ResourcePath } from '../model/path';\nimport { assert, fail } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nimport * as obj from '../util/obj';\nimport * as typeUtils from '../util/types';\nimport { ExistenceFilter } from './existence_filter';\nimport { mapCodeFromRpcCode, mapRpcCodeFromCode } from './rpc_error';\nimport { DocumentWatchChange, ExistenceFilterChange, WatchTargetChange, WatchTargetChangeState } from './watch_change';\nvar DIRECTIONS = (function () {\n    var dirs = {};\n    dirs[Direction.ASCENDING.name] = 'ASCENDING';\n    dirs[Direction.DESCENDING.name] = 'DESCENDING';\n    return dirs;\n})();\nvar OPERATORS = (function () {\n    var ops = {};\n    ops[RelationOp.LESS_THAN.name] = 'LESS_THAN';\n    ops[RelationOp.LESS_THAN_OR_EQUAL.name] = 'LESS_THAN_OR_EQUAL';\n    ops[RelationOp.GREATER_THAN.name] = 'GREATER_THAN';\n    ops[RelationOp.GREATER_THAN_OR_EQUAL.name] = 'GREATER_THAN_OR_EQUAL';\n    ops[RelationOp.EQUAL.name] = 'EQUAL';\n    return ops;\n})();\nfunction assertPresent(value, description) {\n    assert(!typeUtils.isNullOrUndefined(value), description + ' is missing');\n}\nfunction parseInt64(value) {\n    // TODO(bjornick): Handle int64 greater than 53 bits.\n    if (typeof value === 'number') {\n        return value;\n    }\n    else if (typeof value === 'string') {\n        return Number(value);\n    }\n    else {\n        return fail(\"can't parse \" + value);\n    }\n}\n/**\n * Generates JsonObject values for the Datastore API suitable for sending to\n * either GRPC stub methods or via the JSON/HTTP REST API.\n * TODO(klimt): We can remove the databaseId argument if we keep the full\n * resource name in documents.\n */\nvar JsonProtoSerializer = /** @class */ (function () {\n    function JsonProtoSerializer(databaseId, options) {\n        this.databaseId = databaseId;\n        this.options = options;\n    }\n    JsonProtoSerializer.prototype.emptyByteString = function () {\n        if (this.options.useProto3Json) {\n            return '';\n        }\n        else {\n            return new Uint8Array(0);\n        }\n    };\n    JsonProtoSerializer.prototype.unsafeCastProtoByteString = function (byteString) {\n        // byteStrings can be either string or UInt8Array, but the typings say\n        // it's always a string. Cast as string to avoid type check failing\n        return byteString;\n    };\n    JsonProtoSerializer.prototype.fromRpcStatus = function (status) {\n        var code = status.code === undefined\n            ? Code.UNKNOWN\n            : mapCodeFromRpcCode(status.code);\n        return new FirestoreError(code, status.message || '');\n    };\n    /**\n     * Returns a value for a number (or undefined) that's appropriate to put into\n     * a google.protobuf.Int32Value proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as returning \"number\" because that's what\n     * our generated proto interfaces say Int32Value must be. But GRPC actually\n     * expects a { value: <number> } struct.\n     */\n    JsonProtoSerializer.prototype.toInt32Value = function (val) {\n        if (!typeUtils.isNullOrUndefined(val)) {\n            // tslint:disable-next-line:no-any We need to match generated Proto types.\n            return { value: val };\n        }\n        else {\n            return undefined;\n        }\n    };\n    /**\n     * Returns a number (or null) from a google.protobuf.Int32Value proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as accepting \"number\" because that's what\n     * our generated proto interfaces say Int32Value must be, but it actually\n     * accepts { value: number } to match our serialization in toInt32Value().\n     */\n    JsonProtoSerializer.prototype.fromInt32Value = function (val) {\n        var result;\n        if (typeof val === 'object') {\n            // tslint:disable-next-line:no-any We need to match generated Proto types.\n            result = val.value;\n        }\n        else {\n            // We accept raw numbers (without the {value: ... } wrapper) for\n            // compatibility with legacy persisted data.\n            result = val;\n        }\n        return typeUtils.isNullOrUndefined(result) ? null : result;\n    };\n    /**\n     * Returns a value for a Date that's appropriate to put into a proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as returning \"string\" because that's what\n     * our generated proto interfaces say dates must be. But it's easier and safer\n     * to actually return a Timestamp proto.\n     */\n    JsonProtoSerializer.prototype.toTimestamp = function (timestamp) {\n        return {\n            seconds: timestamp.seconds,\n            nanos: timestamp.nanos\n            // tslint:disable-next-line:no-any\n        };\n    };\n    JsonProtoSerializer.prototype.fromTimestamp = function (date) {\n        // The json interface (for the browser) will return an iso timestamp string,\n        // while the proto js library (for node) will return a\n        // google.protobuf.Timestamp instance.\n        if (typeof date === 'string') {\n            // TODO(b/37282237): Use strings for Proto3 timestamps\n            // assert(this.options.useProto3Json,\n            //   'The timestamp string format requires Proto3.');\n            return Timestamp.fromISOString(date);\n        }\n        else {\n            assert(!!date, 'Cannot deserialize null or undefined timestamp.');\n            // TODO(b/37282237): Use strings for Proto3 timestamps\n            // assert(!this.options.useProto3Json,\n            //   'The timestamp instance format requires Proto JS.');\n            var seconds = parseInt64(date.seconds || '0');\n            var nanos = date.nanos || 0;\n            return new Timestamp(seconds, nanos);\n        }\n    };\n    /**\n     * Returns a value for bytes that's appropriate to put in a proto.\n     * DO NOT USE THIS FOR ANYTHING ELSE.\n     * This method cheats. It's typed as returning \"string\" because that's what\n     * our generated proto interfaces say bytes must be. But it should return\n     * an Uint8Array in Node.\n     */\n    JsonProtoSerializer.prototype.toBytes = function (bytes) {\n        if (this.options.useProto3Json) {\n            return bytes.toBase64();\n        }\n        else {\n            // The typings say it's a string, but it needs to be a Uint8Array in Node.\n            return this.unsafeCastProtoByteString(bytes.toUint8Array());\n        }\n    };\n    /**\n     * Parse the blob from the protos into the internal Blob class. Note that the\n     * typings assume all blobs are strings, but they are actually Uint8Arrays\n     * on Node.\n     */\n    JsonProtoSerializer.prototype.fromBlob = function (blob) {\n        if (typeof blob === 'string') {\n            assert(this.options.useProto3Json, 'Expected bytes to be passed in as Uint8Array, but got a string instead.');\n            return Blob.fromBase64String(blob);\n        }\n        else {\n            assert(!this.options.useProto3Json, 'Expected bytes to be passed in as string, but got something else instead.');\n            return Blob.fromUint8Array(blob);\n        }\n    };\n    JsonProtoSerializer.prototype.toVersion = function (version) {\n        return this.toTimestamp(version.toTimestamp());\n    };\n    JsonProtoSerializer.prototype.fromVersion = function (version) {\n        assert(!!version, \"Trying to deserialize version that isn't set\");\n        return SnapshotVersion.fromTimestamp(this.fromTimestamp(version));\n    };\n    JsonProtoSerializer.prototype.toResourceName = function (databaseId, path) {\n        return this.fullyQualifiedPrefixPath(databaseId)\n            .child('documents')\n            .child(path)\n            .canonicalString();\n    };\n    JsonProtoSerializer.prototype.fromResourceName = function (name) {\n        var resource = ResourcePath.fromString(name);\n        assert(this.isValidResourceName(resource), 'Tried to deserialize invalid key ' + resource.toString());\n        return resource;\n    };\n    JsonProtoSerializer.prototype.toName = function (key) {\n        return this.toResourceName(this.databaseId, key.path);\n    };\n    JsonProtoSerializer.prototype.fromName = function (name) {\n        var resource = this.fromResourceName(name);\n        assert(resource.get(1) === this.databaseId.projectId, 'Tried to deserialize key from different project: ' +\n            resource.get(1) +\n            ' vs ' +\n            this.databaseId.projectId);\n        assert((!resource.get(3) && !this.databaseId.database) ||\n            resource.get(3) === this.databaseId.database, 'Tried to deserialize key from different database: ' +\n            resource.get(3) +\n            ' vs ' +\n            this.databaseId.database);\n        return new DocumentKey(this.extractLocalPathFromResourceName(resource));\n    };\n    JsonProtoSerializer.prototype.toQueryPath = function (path) {\n        if (path.length === 0) {\n            // If the path is empty, the backend requires we leave off the /documents\n            // at the end.\n            return this.encodedDatabaseId;\n        }\n        return this.toResourceName(this.databaseId, path);\n    };\n    JsonProtoSerializer.prototype.fromQueryPath = function (name) {\n        var resourceName = this.fromResourceName(name);\n        if (resourceName.length === 4) {\n            return ResourcePath.EMPTY_PATH;\n        }\n        return this.extractLocalPathFromResourceName(resourceName);\n    };\n    Object.defineProperty(JsonProtoSerializer.prototype, \"encodedDatabaseId\", {\n        get: function () {\n            var path = new ResourcePath([\n                'projects',\n                this.databaseId.projectId,\n                'databases',\n                this.databaseId.database\n            ]);\n            return path.canonicalString();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    JsonProtoSerializer.prototype.fullyQualifiedPrefixPath = function (databaseId) {\n        return new ResourcePath([\n            'projects',\n            databaseId.projectId,\n            'databases',\n            databaseId.database\n        ]);\n    };\n    JsonProtoSerializer.prototype.extractLocalPathFromResourceName = function (resourceName) {\n        assert(resourceName.length > 4 && resourceName.get(4) === 'documents', 'tried to deserialize invalid key ' + resourceName.toString());\n        return resourceName.popFirst(5);\n    };\n    JsonProtoSerializer.prototype.isValidResourceName = function (path) {\n        // Resource names have at least 4 components (project ID, database ID)\n        return (path.length >= 4 &&\n            path.get(0) === 'projects' &&\n            path.get(2) === 'databases');\n    };\n    JsonProtoSerializer.prototype.toValue = function (val) {\n        if (val instanceof fieldValue.NullValue) {\n            return { nullValue: 'NULL_VALUE' };\n        }\n        else if (val instanceof fieldValue.BooleanValue) {\n            return { booleanValue: val.value() };\n        }\n        else if (val instanceof fieldValue.IntegerValue) {\n            return { integerValue: '' + val.value() };\n        }\n        else if (val instanceof fieldValue.DoubleValue) {\n            var doubleValue = val.value();\n            if (this.options.useProto3Json) {\n                // Proto 3 let's us encode NaN and Infinity as string values as\n                // expected by the backend. This is currently not checked by our unit\n                // tests because they rely on protobuf.js.\n                if (isNaN(doubleValue)) {\n                    return { doubleValue: 'NaN' };\n                }\n                else if (doubleValue === Infinity) {\n                    return { doubleValue: 'Infinity' };\n                }\n                else if (doubleValue === -Infinity) {\n                    return { doubleValue: '-Infinity' };\n                }\n            }\n            return { doubleValue: val.value() };\n        }\n        else if (val instanceof fieldValue.StringValue) {\n            return { stringValue: val.value() };\n        }\n        else if (val instanceof fieldValue.ObjectValue) {\n            return { mapValue: this.toMapValue(val) };\n        }\n        else if (val instanceof fieldValue.ArrayValue) {\n            return { arrayValue: this.toArrayValue(val) };\n        }\n        else if (val instanceof fieldValue.TimestampValue) {\n            return {\n                timestampValue: this.toTimestamp(val.internalValue)\n            };\n        }\n        else if (val instanceof fieldValue.GeoPointValue) {\n            return {\n                geoPointValue: {\n                    latitude: val.value().latitude,\n                    longitude: val.value().longitude\n                }\n            };\n        }\n        else if (val instanceof fieldValue.BlobValue) {\n            return {\n                bytesValue: this.toBytes(val.value())\n            };\n        }\n        else if (val instanceof fieldValue.RefValue) {\n            return {\n                referenceValue: this.toResourceName(val.databaseId, val.key.path)\n            };\n        }\n        else {\n            return fail('Unknown FieldValue ' + JSON.stringify(val));\n        }\n    };\n    JsonProtoSerializer.prototype.fromValue = function (obj) {\n        var _this = this;\n        // tslint:disable-next-line:no-any\n        var type = obj['value_type'];\n        if (hasTag(obj, type, 'nullValue')) {\n            return fieldValue.NullValue.INSTANCE;\n        }\n        else if (hasTag(obj, type, 'booleanValue')) {\n            return fieldValue.BooleanValue.of(obj.booleanValue);\n        }\n        else if (hasTag(obj, type, 'integerValue')) {\n            return new fieldValue.IntegerValue(parseInt64(obj.integerValue));\n        }\n        else if (hasTag(obj, type, 'doubleValue')) {\n            if (this.options.useProto3Json) {\n                // Proto 3 uses the string values 'NaN' and 'Infinity'.\n                if (obj.doubleValue === 'NaN') {\n                    return fieldValue.DoubleValue.NAN;\n                }\n                else if (obj.doubleValue === 'Infinity') {\n                    return fieldValue.DoubleValue.POSITIVE_INFINITY;\n                }\n                else if (obj.doubleValue === '-Infinity') {\n                    return fieldValue.DoubleValue.NEGATIVE_INFINITY;\n                }\n            }\n            return new fieldValue.DoubleValue(obj.doubleValue);\n        }\n        else if (hasTag(obj, type, 'stringValue')) {\n            return new fieldValue.StringValue(obj.stringValue);\n        }\n        else if (hasTag(obj, type, 'mapValue')) {\n            return this.fromFields(obj.mapValue.fields || {});\n        }\n        else if (hasTag(obj, type, 'arrayValue')) {\n            // \"values\" is not present if the array is empty\n            assertPresent(obj.arrayValue, 'arrayValue');\n            var values = obj.arrayValue.values || [];\n            return new fieldValue.ArrayValue(values.map(function (v) { return _this.fromValue(v); }));\n        }\n        else if (hasTag(obj, type, 'timestampValue')) {\n            assertPresent(obj.timestampValue, 'timestampValue');\n            return new fieldValue.TimestampValue(this.fromTimestamp(obj.timestampValue));\n        }\n        else if (hasTag(obj, type, 'geoPointValue')) {\n            assertPresent(obj.geoPointValue, 'geoPointValue');\n            var latitude = obj.geoPointValue.latitude || 0;\n            var longitude = obj.geoPointValue.longitude || 0;\n            return new fieldValue.GeoPointValue(new GeoPoint(latitude, longitude));\n        }\n        else if (hasTag(obj, type, 'bytesValue')) {\n            assertPresent(obj.bytesValue, 'bytesValue');\n            var blob = this.fromBlob(obj.bytesValue);\n            return new fieldValue.BlobValue(blob);\n        }\n        else if (hasTag(obj, type, 'referenceValue')) {\n            assertPresent(obj.referenceValue, 'referenceValue');\n            var resourceName = this.fromResourceName(obj.referenceValue);\n            var dbId = new DatabaseId(resourceName.get(1), resourceName.get(3));\n            var key = new DocumentKey(this.extractLocalPathFromResourceName(resourceName));\n            return new fieldValue.RefValue(dbId, key);\n        }\n        else {\n            return fail('Unknown Value proto ' + JSON.stringify(obj));\n        }\n    };\n    /** Creates an api.Document from key and fields (but no create/update time) */\n    JsonProtoSerializer.prototype.toMutationDocument = function (key, fields) {\n        return {\n            name: this.toName(key),\n            fields: this.toFields(fields)\n        };\n    };\n    JsonProtoSerializer.prototype.toDocument = function (document) {\n        assert(!document.hasLocalMutations, \"Can't serialize documents with mutations.\");\n        return {\n            name: this.toName(document.key),\n            fields: this.toFields(document.data),\n            updateTime: this.toTimestamp(document.version.toTimestamp())\n        };\n    };\n    JsonProtoSerializer.prototype.fromDocument = function (document) {\n        return new Document(this.fromName(document.name), this.fromVersion(document.updateTime), this.fromFields(document.fields || {}), { hasLocalMutations: false });\n    };\n    JsonProtoSerializer.prototype.toFields = function (fields) {\n        var _this = this;\n        var result = {};\n        fields.forEach(function (key, value) {\n            result[key] = _this.toValue(value);\n        });\n        return result;\n    };\n    JsonProtoSerializer.prototype.fromFields = function (object) {\n        var _this = this;\n        // Proto map<string, Value> gets mapped to Object, so cast it.\n        var map = object;\n        var result = fieldValue.ObjectValue.EMPTY;\n        obj.forEach(map, function (key, value) {\n            result = result.set(new FieldPath([key]), _this.fromValue(value));\n        });\n        return result;\n    };\n    JsonProtoSerializer.prototype.toMapValue = function (map) {\n        return {\n            fields: this.toFields(map)\n        };\n    };\n    JsonProtoSerializer.prototype.toArrayValue = function (array) {\n        var _this = this;\n        var result = [];\n        array.forEach(function (value) {\n            result.push(_this.toValue(value));\n        });\n        return { values: result };\n    };\n    JsonProtoSerializer.prototype.fromFound = function (doc) {\n        assert(!!doc.found, 'Tried to deserialize a found document from a missing document.');\n        assertPresent(doc.found.name, 'doc.found.name');\n        assertPresent(doc.found.updateTime, 'doc.found.updateTime');\n        var key = this.fromName(doc.found.name);\n        var version = this.fromVersion(doc.found.updateTime);\n        var fields = this.fromFields(doc.found.fields || {});\n        return new Document(key, version, fields, { hasLocalMutations: false });\n    };\n    JsonProtoSerializer.prototype.fromMissing = function (result) {\n        assert(!!result.missing, 'Tried to deserialize a missing document from a found document.');\n        assert(!!result.readTime, 'Tried to deserialize a missing document without a read time.');\n        var key = this.fromName(result.missing);\n        var version = this.fromVersion(result.readTime);\n        return new NoDocument(key, version);\n    };\n    JsonProtoSerializer.prototype.fromMaybeDocument = function (result) {\n        // tslint:disable-next-line:no-any\n        var type = result['result'];\n        if (hasTag(result, type, 'found')) {\n            return this.fromFound(result);\n        }\n        else if (hasTag(result, type, 'missing')) {\n            return this.fromMissing(result);\n        }\n        return fail('invalid batch get response: ' + JSON.stringify(result));\n    };\n    JsonProtoSerializer.prototype.toWatchTargetChangeState = function (state) {\n        switch (state) {\n            case WatchTargetChangeState.Added:\n                return 'ADD';\n            case WatchTargetChangeState.Current:\n                return 'CURRENT';\n            case WatchTargetChangeState.NoChange:\n                return 'NO_CHANGE';\n            case WatchTargetChangeState.Removed:\n                return 'REMOVE';\n            case WatchTargetChangeState.Reset:\n                return 'RESET';\n            default:\n                return fail('Unknown WatchTargetChangeState: ' + state);\n        }\n    };\n    JsonProtoSerializer.prototype.toTestWatchChange = function (watchChange) {\n        if (watchChange instanceof ExistenceFilterChange) {\n            return {\n                filter: {\n                    count: watchChange.existenceFilter.count,\n                    targetId: watchChange.targetId\n                }\n            };\n        }\n        if (watchChange instanceof DocumentWatchChange) {\n            if (watchChange.newDoc instanceof Document) {\n                var doc = watchChange.newDoc;\n                return {\n                    documentChange: {\n                        document: {\n                            name: this.toName(doc.key),\n                            fields: this.toFields(doc.data),\n                            updateTime: this.toVersion(doc.version)\n                        },\n                        targetIds: watchChange.updatedTargetIds,\n                        removedTargetIds: watchChange.removedTargetIds\n                    }\n                };\n            }\n            else if (watchChange.newDoc instanceof NoDocument) {\n                var doc = watchChange.newDoc;\n                return {\n                    documentDelete: {\n                        document: this.toName(doc.key),\n                        readTime: this.toVersion(doc.version),\n                        removedTargetIds: watchChange.removedTargetIds\n                    }\n                };\n            }\n            else if (watchChange.newDoc === null) {\n                return {\n                    documentRemove: {\n                        document: this.toName(watchChange.key),\n                        removedTargetIds: watchChange.removedTargetIds\n                    }\n                };\n            }\n        }\n        if (watchChange instanceof WatchTargetChange) {\n            var cause = undefined;\n            if (watchChange.cause) {\n                cause = {\n                    code: mapRpcCodeFromCode(watchChange.cause.code),\n                    message: watchChange.cause.message\n                };\n            }\n            return {\n                targetChange: {\n                    targetChangeType: this.toWatchTargetChangeState(watchChange.state),\n                    targetIds: watchChange.targetIds,\n                    resumeToken: this.unsafeCastProtoByteString(watchChange.resumeToken),\n                    cause: cause\n                }\n            };\n        }\n        return fail('Unrecognized watch change: ' + JSON.stringify(watchChange));\n    };\n    JsonProtoSerializer.prototype.fromWatchChange = function (change) {\n        // tslint:disable-next-line:no-any\n        var type = change['response_type'];\n        var watchChange;\n        if (hasTag(change, type, 'targetChange')) {\n            assertPresent(change.targetChange, 'targetChange');\n            // proto3 default value is unset in JSON (undefined), so use 'NO_CHANGE'\n            // if unset\n            var state = this.fromWatchTargetChangeState(change.targetChange.targetChangeType || 'NO_CHANGE');\n            var targetIds = change.targetChange.targetIds || [];\n            var resumeToken = change.targetChange.resumeToken || this.emptyByteString();\n            var causeProto = change.targetChange.cause;\n            var cause = causeProto && this.fromRpcStatus(causeProto);\n            watchChange = new WatchTargetChange(state, targetIds, resumeToken, cause || null);\n        }\n        else if (hasTag(change, type, 'documentChange')) {\n            assertPresent(change.documentChange, 'documentChange');\n            assertPresent(change.documentChange.document, 'documentChange.name');\n            assertPresent(change.documentChange.document.name, 'documentChange.document.name');\n            assertPresent(change.documentChange.document.updateTime, 'documentChange.document.updateTime');\n            var entityChange = change.documentChange;\n            var key = this.fromName(entityChange.document.name);\n            var version = this.fromVersion(entityChange.document.updateTime);\n            var fields = this.fromFields(entityChange.document.fields || {});\n            var doc = new Document(key, version, fields, {\n                hasLocalMutations: false\n            });\n            var updatedTargetIds = entityChange.targetIds || [];\n            var removedTargetIds = entityChange.removedTargetIds || [];\n            watchChange = new DocumentWatchChange(updatedTargetIds, removedTargetIds, doc.key, doc);\n        }\n        else if (hasTag(change, type, 'documentDelete')) {\n            assertPresent(change.documentDelete, 'documentDelete');\n            assertPresent(change.documentDelete.document, 'documentDelete.document');\n            var docDelete = change.documentDelete;\n            var key = this.fromName(docDelete.document);\n            var version = docDelete.readTime\n                ? this.fromVersion(docDelete.readTime)\n                : SnapshotVersion.forDeletedDoc();\n            var doc = new NoDocument(key, version);\n            var removedTargetIds = docDelete.removedTargetIds || [];\n            watchChange = new DocumentWatchChange([], removedTargetIds, doc.key, doc);\n        }\n        else if (hasTag(change, type, 'documentRemove')) {\n            assertPresent(change.documentRemove, 'documentRemove');\n            assertPresent(change.documentRemove.document, 'documentRemove');\n            var docRemove = change.documentRemove;\n            var key = this.fromName(docRemove.document);\n            var removedTargetIds = docRemove.removedTargetIds || [];\n            watchChange = new DocumentWatchChange([], removedTargetIds, key, null);\n        }\n        else if (hasTag(change, type, 'filter')) {\n            // TODO(dimond): implement existence filter parsing with strategy.\n            assertPresent(change.filter, 'filter');\n            assertPresent(change.filter.targetId, 'filter.targetId');\n            var filter = change.filter;\n            var count = filter.count || 0;\n            var existenceFilter = new ExistenceFilter(count);\n            var targetId = filter.targetId;\n            watchChange = new ExistenceFilterChange(targetId, existenceFilter);\n        }\n        else {\n            return fail('Unknown change type ' + JSON.stringify(change));\n        }\n        return watchChange;\n    };\n    JsonProtoSerializer.prototype.fromWatchTargetChangeState = function (state) {\n        if (state === 'NO_CHANGE') {\n            return WatchTargetChangeState.NoChange;\n        }\n        else if (state === 'ADD') {\n            return WatchTargetChangeState.Added;\n        }\n        else if (state === 'REMOVE') {\n            return WatchTargetChangeState.Removed;\n        }\n        else if (state === 'CURRENT') {\n            return WatchTargetChangeState.Current;\n        }\n        else if (state === 'RESET') {\n            return WatchTargetChangeState.Reset;\n        }\n        else {\n            return fail('Got unexpected TargetChange.state: ' + state);\n        }\n    };\n    JsonProtoSerializer.prototype.versionFromListenResponse = function (change) {\n        // We have only reached a consistent snapshot for the entire stream if there\n        // is a read_time set and it applies to all targets (i.e. the list of\n        // targets is empty). The backend is guaranteed to send such responses.\n        // tslint:disable-next-line:no-any\n        var type = change['response_type'];\n        if (!hasTag(change, type, 'targetChange')) {\n            return SnapshotVersion.MIN;\n        }\n        var targetChange = change.targetChange;\n        if (targetChange.targetIds && targetChange.targetIds.length) {\n            return SnapshotVersion.MIN;\n        }\n        if (!targetChange.readTime) {\n            return SnapshotVersion.MIN;\n        }\n        return this.fromVersion(targetChange.readTime);\n    };\n    JsonProtoSerializer.prototype.toMutation = function (mutation) {\n        var _this = this;\n        var result;\n        if (mutation instanceof SetMutation) {\n            result = {\n                update: this.toMutationDocument(mutation.key, mutation.value)\n            };\n        }\n        else if (mutation instanceof DeleteMutation) {\n            result = { delete: this.toName(mutation.key) };\n        }\n        else if (mutation instanceof PatchMutation) {\n            result = {\n                update: this.toMutationDocument(mutation.key, mutation.data),\n                updateMask: this.toDocumentMask(mutation.fieldMask)\n            };\n        }\n        else if (mutation instanceof TransformMutation) {\n            result = {\n                transform: {\n                    document: this.toName(mutation.key),\n                    fieldTransforms: mutation.fieldTransforms.map(function (transform) {\n                        return _this.toFieldTransform(transform);\n                    })\n                }\n            };\n        }\n        else {\n            return fail('Unknown mutation type ' + mutation.type);\n        }\n        if (!mutation.precondition.isNone) {\n            result.currentDocument = this.toPrecondition(mutation.precondition);\n        }\n        return result;\n    };\n    JsonProtoSerializer.prototype.fromMutation = function (proto) {\n        var _this = this;\n        var precondition = proto.currentDocument\n            ? this.fromPrecondition(proto.currentDocument)\n            : Precondition.NONE;\n        if (proto.update) {\n            assertPresent(proto.update.name, 'name');\n            var key = this.fromName(proto.update.name);\n            var value = this.fromFields(proto.update.fields || {});\n            if (proto.updateMask) {\n                var fieldMask = this.fromDocumentMask(proto.updateMask);\n                return new PatchMutation(key, value, fieldMask, precondition);\n            }\n            else {\n                return new SetMutation(key, value, precondition);\n            }\n        }\n        else if (proto.delete) {\n            var key = this.fromName(proto.delete);\n            return new DeleteMutation(key, precondition);\n        }\n        else if (proto.transform) {\n            var key = this.fromName(proto.transform.document);\n            var fieldTransforms = proto.transform.fieldTransforms.map(function (transform) {\n                return _this.fromFieldTransform(transform);\n            });\n            assert(precondition.exists === true, 'Transforms only support precondition \"exists == true\"');\n            return new TransformMutation(key, fieldTransforms);\n        }\n        else {\n            return fail('unknown mutation proto: ' + JSON.stringify(proto));\n        }\n    };\n    JsonProtoSerializer.prototype.toPrecondition = function (precondition) {\n        assert(!precondition.isNone, \"Can't serialize an empty precondition\");\n        if (precondition.updateTime !== undefined) {\n            return {\n                updateTime: this.toVersion(precondition.updateTime)\n            };\n        }\n        else if (precondition.exists !== undefined) {\n            return { exists: precondition.exists };\n        }\n        else {\n            return fail('Unknown precondition');\n        }\n    };\n    JsonProtoSerializer.prototype.fromPrecondition = function (precondition) {\n        if (precondition.updateTime !== undefined) {\n            return Precondition.updateTime(this.fromVersion(precondition.updateTime));\n        }\n        else if (precondition.exists !== undefined) {\n            return Precondition.exists(precondition.exists);\n        }\n        else {\n            return Precondition.NONE;\n        }\n    };\n    JsonProtoSerializer.prototype.fromWriteResult = function (proto) {\n        var _this = this;\n        // NOTE: Deletes don't have an updateTime.\n        var version = proto.updateTime\n            ? this.fromVersion(proto.updateTime)\n            : null;\n        var transformResults = null;\n        if (proto.transformResults && proto.transformResults.length > 0) {\n            transformResults = proto.transformResults.map(function (result) {\n                return _this.fromValue(result);\n            });\n        }\n        return new MutationResult(version, transformResults);\n    };\n    JsonProtoSerializer.prototype.fromWriteResults = function (protos) {\n        var _this = this;\n        return (protos || []).map(function (proto) { return _this.fromWriteResult(proto); });\n    };\n    JsonProtoSerializer.prototype.toFieldTransform = function (fieldTransform) {\n        assert(fieldTransform.transform instanceof ServerTimestampTransform, 'Unknown transform: ' + fieldTransform.transform);\n        return {\n            fieldPath: fieldTransform.field.canonicalString(),\n            setToServerValue: 'REQUEST_TIME'\n        };\n    };\n    JsonProtoSerializer.prototype.fromFieldTransform = function (proto) {\n        assert(proto.setToServerValue === 'REQUEST_TIME', 'Unknown transform proto: ' + JSON.stringify(proto));\n        var fieldPath = FieldPath.fromServerFormat(proto.fieldPath);\n        return new FieldTransform(fieldPath, ServerTimestampTransform.instance);\n    };\n    JsonProtoSerializer.prototype.toDocumentsTarget = function (query) {\n        return { documents: [this.toQueryPath(query.path)] };\n    };\n    JsonProtoSerializer.prototype.fromDocumentsTarget = function (documentsTarget) {\n        var count = documentsTarget.documents.length;\n        assert(count === 1, 'DocumentsTarget contained other than 1 document: ' + count);\n        var name = documentsTarget.documents[0];\n        return Query.atPath(this.fromQueryPath(name));\n    };\n    JsonProtoSerializer.prototype.toQueryTarget = function (query) {\n        // Dissect the path into parent, collectionId, and optional key filter.\n        var result = { structuredQuery: {} };\n        if (query.path.isEmpty()) {\n            result.parent = this.toQueryPath(ResourcePath.EMPTY_PATH);\n        }\n        else {\n            var path = query.path;\n            assert(path.length % 2 !== 0, 'Document queries with filters are not supported.');\n            result.parent = this.toQueryPath(path.popLast());\n            result.structuredQuery.from = [{ collectionId: path.lastSegment() }];\n        }\n        var where = this.toFilter(query.filters);\n        if (where) {\n            result.structuredQuery.where = where;\n        }\n        var orderBy = this.toOrder(query.orderBy);\n        if (orderBy) {\n            result.structuredQuery.orderBy = orderBy;\n        }\n        var limit = this.toInt32Value(query.limit);\n        if (limit !== undefined) {\n            result.structuredQuery.limit = limit;\n        }\n        if (query.startAt) {\n            result.structuredQuery.startAt = this.toCursor(query.startAt);\n        }\n        if (query.endAt) {\n            result.structuredQuery.endAt = this.toCursor(query.endAt);\n        }\n        return result;\n    };\n    JsonProtoSerializer.prototype.fromQueryTarget = function (target) {\n        var path = this.fromQueryPath(target.parent);\n        var query = target.structuredQuery;\n        var fromCount = query.from ? query.from.length : 0;\n        if (fromCount > 0) {\n            assert(fromCount === 1, 'StructuredQuery.from with more than one collection is not supported.');\n            var from = query.from[0];\n            path = path.child(from.collectionId);\n        }\n        var filterBy = [];\n        if (query.where) {\n            filterBy = this.fromFilter(query.where);\n        }\n        var orderBy = [];\n        if (query.orderBy) {\n            orderBy = this.fromOrder(query.orderBy);\n        }\n        var limit = null;\n        if (query.limit) {\n            limit = this.fromInt32Value(query.limit);\n        }\n        var startAt = null;\n        if (query.startAt) {\n            startAt = this.fromCursor(query.startAt);\n        }\n        var endAt = null;\n        if (query.endAt) {\n            endAt = this.fromCursor(query.endAt);\n        }\n        return new Query(path, orderBy, filterBy, limit, startAt, endAt);\n    };\n    JsonProtoSerializer.prototype.toListenRequestLabels = function (queryData) {\n        var value = this.toLabel(queryData.purpose);\n        if (value == null) {\n            return null;\n        }\n        else {\n            return {\n                'goog-listen-tags': value\n            };\n        }\n    };\n    JsonProtoSerializer.prototype.toLabel = function (purpose) {\n        switch (purpose) {\n            case QueryPurpose.Listen:\n                return null;\n            case QueryPurpose.ExistenceFilterMismatch:\n                return 'existence-filter-mismatch';\n            case QueryPurpose.LimboResolution:\n                return 'limbo-document';\n            default:\n                return fail('Unrecognized query purpose: ' + purpose);\n        }\n    };\n    JsonProtoSerializer.prototype.toTarget = function (queryData) {\n        var result;\n        var query = queryData.query;\n        if (query.isDocumentQuery()) {\n            result = { documents: this.toDocumentsTarget(query) };\n        }\n        else {\n            result = { query: this.toQueryTarget(query) };\n        }\n        result.targetId = queryData.targetId;\n        if (queryData.resumeToken.length > 0) {\n            result.resumeToken = this.unsafeCastProtoByteString(queryData.resumeToken);\n        }\n        return result;\n    };\n    JsonProtoSerializer.prototype.toFilter = function (filters) {\n        var _this = this;\n        if (filters.length === 0)\n            return;\n        var protos = filters.map(function (filter) {\n            return filter instanceof RelationFilter\n                ? _this.toRelationFilter(filter)\n                : _this.toUnaryFilter(filter);\n        });\n        if (protos.length === 1) {\n            return protos[0];\n        }\n        return { compositeFilter: { op: 'AND', filters: protos } };\n    };\n    JsonProtoSerializer.prototype.fromFilter = function (filter) {\n        var _this = this;\n        if (!filter) {\n            return [];\n        }\n        else if (filter.unaryFilter !== undefined) {\n            return [this.fromUnaryFilter(filter)];\n        }\n        else if (filter.fieldFilter !== undefined) {\n            return [this.fromRelationFilter(filter)];\n        }\n        else if (filter.compositeFilter !== undefined) {\n            return filter.compositeFilter.filters\n                .map(function (f) { return _this.fromFilter(f); })\n                .reduce(function (accum, current) { return accum.concat(current); });\n        }\n        else {\n            return fail('Unknown filter: ' + JSON.stringify(filter));\n        }\n    };\n    JsonProtoSerializer.prototype.toOrder = function (orderBys) {\n        var _this = this;\n        if (orderBys.length === 0)\n            return;\n        return orderBys.map(function (order) { return _this.toPropertyOrder(order); });\n    };\n    JsonProtoSerializer.prototype.fromOrder = function (orderBys) {\n        var _this = this;\n        return orderBys.map(function (order) { return _this.fromPropertyOrder(order); });\n    };\n    JsonProtoSerializer.prototype.toCursor = function (cursor) {\n        var _this = this;\n        return {\n            before: cursor.before,\n            values: cursor.position.map(function (component) { return _this.toValue(component); })\n        };\n    };\n    JsonProtoSerializer.prototype.fromCursor = function (cursor) {\n        var _this = this;\n        var before = !!cursor.before;\n        var position = cursor.values.map(function (component) { return _this.fromValue(component); });\n        return new Bound(position, before);\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toDirection = function (dir) {\n        return DIRECTIONS[dir.name];\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.fromDirection = function (dir) {\n        switch (dir) {\n            case 'ASCENDING':\n                return Direction.ASCENDING;\n            case 'DESCENDING':\n                return Direction.DESCENDING;\n            default:\n                return undefined;\n        }\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toOperatorName = function (op) {\n        return OPERATORS[op.name];\n    };\n    JsonProtoSerializer.prototype.fromOperatorName = function (op) {\n        switch (op) {\n            case 'EQUAL':\n                return RelationOp.EQUAL;\n            case 'GREATER_THAN':\n                return RelationOp.GREATER_THAN;\n            case 'GREATER_THAN_OR_EQUAL':\n                return RelationOp.GREATER_THAN_OR_EQUAL;\n            case 'LESS_THAN':\n                return RelationOp.LESS_THAN;\n            case 'LESS_THAN_OR_EQUAL':\n                return RelationOp.LESS_THAN_OR_EQUAL;\n            case 'OPERATOR_UNSPECIFIED':\n                return fail('Unspecified relation');\n            default:\n                return fail('Unknown relation');\n        }\n    };\n    JsonProtoSerializer.prototype.toFieldPathReference = function (path) {\n        return { fieldPath: path.canonicalString() };\n    };\n    JsonProtoSerializer.prototype.fromFieldPathReference = function (fieldReference) {\n        return FieldPath.fromServerFormat(fieldReference.fieldPath);\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toPropertyOrder = function (orderBy) {\n        return {\n            field: this.toFieldPathReference(orderBy.field),\n            direction: this.toDirection(orderBy.dir)\n        };\n    };\n    JsonProtoSerializer.prototype.fromPropertyOrder = function (orderBy) {\n        return new OrderBy(this.fromFieldPathReference(orderBy.field), this.fromDirection(orderBy.direction));\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toRelationFilter = function (filter) {\n        if (filter instanceof RelationFilter) {\n            return {\n                fieldFilter: {\n                    field: this.toFieldPathReference(filter.field),\n                    op: this.toOperatorName(filter.op),\n                    value: this.toValue(filter.value)\n                }\n            };\n        }\n        else {\n            return fail('Unrecognized filter: ' + JSON.stringify(filter));\n        }\n    };\n    JsonProtoSerializer.prototype.fromRelationFilter = function (filter) {\n        return new RelationFilter(this.fromFieldPathReference(filter.fieldFilter.field), this.fromOperatorName(filter.fieldFilter.op), this.fromValue(filter.fieldFilter.value));\n    };\n    // visible for testing\n    JsonProtoSerializer.prototype.toUnaryFilter = function (filter) {\n        if (filter instanceof NanFilter) {\n            return {\n                unaryFilter: {\n                    field: this.toFieldPathReference(filter.field),\n                    op: 'IS_NAN'\n                }\n            };\n        }\n        else if (filter instanceof NullFilter) {\n            return {\n                unaryFilter: {\n                    field: this.toFieldPathReference(filter.field),\n                    op: 'IS_NULL'\n                }\n            };\n        }\n        else {\n            return fail('Unrecognized filter: ' + JSON.stringify(filter));\n        }\n    };\n    JsonProtoSerializer.prototype.fromUnaryFilter = function (filter) {\n        switch (filter.unaryFilter.op) {\n            case 'IS_NAN':\n                var nanField = this.fromFieldPathReference(filter.unaryFilter.field);\n                return new NanFilter(nanField);\n            case 'IS_NULL':\n                var nullField = this.fromFieldPathReference(filter.unaryFilter.field);\n                return new NullFilter(nullField);\n            case 'OPERATOR_UNSPECIFIED':\n                return fail('Unspecified filter');\n            default:\n                return fail('Unknown filter');\n        }\n    };\n    JsonProtoSerializer.prototype.toDocumentMask = function (fieldMask) {\n        return {\n            fieldPaths: fieldMask.fields.map(function (field) { return field.canonicalString(); })\n        };\n    };\n    JsonProtoSerializer.prototype.fromDocumentMask = function (proto) {\n        var paths = proto.fieldPaths || [];\n        var fields = paths.map(function (path) { return FieldPath.fromServerFormat(path); });\n        return new FieldMask(fields);\n    };\n    return JsonProtoSerializer;\n}());\nexport { JsonProtoSerializer };\n/**\n * Checks for a specific oneof tag in a protocol buffer message.\n *\n * This intentionally accommodates two distinct cases:\n *\n * 1) Messages containing a type tag: these are the format produced by GRPC in\n * return values. These may contain default-value mappings for all tags in the\n * oneof but the type tag specifies which one was actually set.\n *\n * 2) Messages that don't contain a type tag: these are the format required by\n * GRPC as inputs. If we emitted objects with type tags, ProtoBuf.js would\n * choke claiming that the tags aren't fields in the Message.\n *\n * Allowing both formats here makes the serializer able to consume the outputs\n * it produces: for all messages it supports, fromX(toX(value)) == value.\n *\n * Note that case 2 suffers from ambiguity: if multiple tags are present\n * without a type tag then the callers are structured in such a way that the\n * first invocation will win. Since we only parse in this mode when parsing\n * the output of a serialize method this works, but it's not a general\n * solution.\n *\n * Unfortunately there is no general solution here because proto3 makes it\n * impossible to distinguish unset from explicitly set fields: both have the\n * default value for the type. Without the type tag but multiple value tags\n * it's possible to have default values for each tag in the oneof and not be\n * able to know which was actually in effect.\n */\nfunction hasTag(obj, type, tag) {\n    return type === tag || (!type && tag in obj);\n}\n\n//# sourceMappingURL=serializer.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/serializer.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { FieldPath as InternalFieldPath } from '../model/path';\nimport { Code, FirestoreError } from '../util/error';\nimport { invalidClassError, validateArgType, validateNamedArrayAtLeastNumberOfElements } from '../util/input_validation';\n// The objects that are a part of this API are exposed to third-parties as\n// compiled javascript so we want to flag our private members with a leading\n// underscore to discourage their use.\n// tslint:disable:strip-private-property-underscore\n/**\n * A FieldPath refers to a field in a document. The path may consist of a single\n * field name (referring to a top-level field in the document), or a list of\n * field names (referring to a nested field in the document).\n */\nvar FieldPath = /** @class */ (function () {\n    /**\n     * Creates a FieldPath from the provided field names. If more than one field\n     * name is provided, the path will point to a nested field in a document.\n     *\n     * @param fieldNames A list of field names.\n     */\n    function FieldPath() {\n        var fieldNames = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            fieldNames[_i] = arguments[_i];\n        }\n        validateNamedArrayAtLeastNumberOfElements('FieldPath', fieldNames, 'fieldNames', 1);\n        for (var i = 0; i < fieldNames.length; ++i) {\n            validateArgType('FieldPath', 'string', i, fieldNames[i]);\n            if (fieldNames[i].length === 0) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field name at argument $(i + 1). \" +\n                    'Field names must not be empty.');\n            }\n        }\n        this._internalPath = new InternalFieldPath(fieldNames);\n    }\n    FieldPath.documentId = function () {\n        return FieldPath._DOCUMENT_ID;\n    };\n    FieldPath.prototype.isEqual = function (other) {\n        if (!(other instanceof FieldPath)) {\n            throw invalidClassError('isEqual', 'FieldPath', 1, other);\n        }\n        return this._internalPath.isEqual(other._internalPath);\n    };\n    /**\n     * Internal Note: The backend doesn't technically support querying by\n     * document ID. Instead it queries by the entire document name (full path\n     * included), but in the cases we currently support documentId(), the net\n     * effect is the same.\n     */\n    FieldPath._DOCUMENT_ID = new FieldPath(InternalFieldPath.keyField().canonicalString());\n    return FieldPath;\n}());\nexport { FieldPath };\n/**\n * Matches any characters in a field path string that are reserved.\n */\nvar RESERVED = new RegExp('[~\\\\*/\\\\[\\\\]]');\n/**\n * Parses a field path string into a FieldPath, treating dots as separators.\n */\nexport function fromDotSeparatedString(path) {\n    var found = path.search(RESERVED);\n    if (found >= 0) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field path (\" + path + \"). Paths must not contain \" +\n            \"'~', '*', '/', '[', or ']'\");\n    }\n    try {\n        return new (FieldPath.bind.apply(FieldPath, [void 0].concat(path.split('.'))))();\n    }\n    catch (e) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field path (\" + path + \"). Paths must not be empty, \" +\n            \"begin with '.', end with '.', or contain '..'\");\n    }\n}\n\n//# sourceMappingURL=field_path.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/field_path.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentKeySet } from '../model/collections';\nimport { Document } from '../model/document';\nimport { DocumentSet } from '../model/document_set';\nimport { CurrentStatusUpdate, ResetMapping, UpdateMapping } from '../remote/remote_event';\nimport { assert, fail } from '../util/assert';\nimport { OnlineState } from './types';\nimport { ChangeType, DocumentChangeSet, SyncState, ViewSnapshot } from './view_snapshot';\nvar AddedLimboDocument = /** @class */ (function () {\n    function AddedLimboDocument(key) {\n        this.key = key;\n    }\n    return AddedLimboDocument;\n}());\nexport { AddedLimboDocument };\nvar RemovedLimboDocument = /** @class */ (function () {\n    function RemovedLimboDocument(key) {\n        this.key = key;\n    }\n    return RemovedLimboDocument;\n}());\nexport { RemovedLimboDocument };\n/**\n * View is responsible for computing the final merged truth of what docs are in\n * a query. It gets notified of local and remote changes to docs, and applies\n * the query filters and limits to determine the most correct possible results.\n */\nvar View = /** @class */ (function () {\n    function View(query, \n        /** Documents included in the remote target */\n        syncedDocuments) {\n        this.query = query;\n        this.syncedDocuments = syncedDocuments;\n        this.syncState = null;\n        /**\n         * A flag whether the view is current with the backend. A view is considered\n         * current after it has seen the current flag from the backend and did not\n         * lose consistency within the watch stream (e.g. because of an existence\n         * filter mismatch).\n         */\n        this.current = false;\n        /** Documents in the view but not in the remote target */\n        this.limboDocuments = documentKeySet();\n        /** Document Keys that have local changes */\n        this.mutatedKeys = documentKeySet();\n        this.documentSet = new DocumentSet(query.docComparator.bind(query));\n    }\n    /**\n     * Iterates over a set of doc changes, applies the query limit, and computes\n     * what the new results should be, what the changes were, and whether we may\n     * need to go back to the local cache for more results. Does not make any\n     * changes to the view.\n     * @param docChanges The doc changes to apply to this view.\n     * @param previousChanges If this is being called with a refill, then start\n     *        with this set of docs and changes instead of the current view.\n     * @return a new set of docs, changes, and refill flag.\n     */\n    View.prototype.computeDocChanges = function (docChanges, previousChanges) {\n        var _this = this;\n        var changeSet = previousChanges\n            ? previousChanges.changeSet\n            : new DocumentChangeSet();\n        var oldDocumentSet = previousChanges\n            ? previousChanges.documentSet\n            : this.documentSet;\n        var newMutatedKeys = previousChanges\n            ? previousChanges.mutatedKeys\n            : this.mutatedKeys;\n        var newDocumentSet = oldDocumentSet;\n        var needsRefill = false;\n        // Track the last doc in a (full) limit. This is necessary, because some\n        // update (a delete, or an update moving a doc past the old limit) might\n        // mean there is some other document in the local cache that either should\n        // come (1) between the old last limit doc and the new last document, in the\n        // case of updates, or (2) after the new last document, in the case of\n        // deletes. So we keep this doc at the old limit to compare the updates to.\n        //\n        // Note that this should never get used in a refill (when previousChanges is\n        // set), because there will only be adds -- no deletes or updates.\n        var lastDocInLimit = this.query.hasLimit() && oldDocumentSet.size === this.query.limit\n            ? oldDocumentSet.last()\n            : null;\n        docChanges.inorderTraversal(function (key, newMaybeDoc) {\n            var oldDoc = oldDocumentSet.get(key);\n            var newDoc = newMaybeDoc instanceof Document ? newMaybeDoc : null;\n            if (newDoc) {\n                assert(key.isEqual(newDoc.key), 'Mismatching keys found in document changes: ' +\n                    key +\n                    ' != ' +\n                    newDoc.key);\n                newDoc = _this.query.matches(newDoc) ? newDoc : null;\n            }\n            if (newDoc) {\n                newDocumentSet = newDocumentSet.add(newDoc);\n                if (newDoc.hasLocalMutations) {\n                    newMutatedKeys = newMutatedKeys.add(key);\n                }\n                else {\n                    newMutatedKeys = newMutatedKeys.delete(key);\n                }\n            }\n            else {\n                newDocumentSet = newDocumentSet.delete(key);\n                newMutatedKeys = newMutatedKeys.delete(key);\n            }\n            // Calculate change\n            if (oldDoc && newDoc) {\n                var docsEqual = oldDoc.data.isEqual(newDoc.data);\n                if (!docsEqual ||\n                    oldDoc.hasLocalMutations !== newDoc.hasLocalMutations) {\n                    // only report a change if document actually changed\n                    if (docsEqual) {\n                        changeSet.track({ type: ChangeType.Metadata, doc: newDoc });\n                    }\n                    else {\n                        changeSet.track({ type: ChangeType.Modified, doc: newDoc });\n                    }\n                    if (lastDocInLimit &&\n                        _this.query.docComparator(newDoc, lastDocInLimit) > 0) {\n                        // This doc moved from inside the limit to after the limit.\n                        // That means there may be some doc in the local cache that's\n                        // actually less than this one.\n                        needsRefill = true;\n                    }\n                }\n            }\n            else if (!oldDoc && newDoc) {\n                changeSet.track({ type: ChangeType.Added, doc: newDoc });\n            }\n            else if (oldDoc && !newDoc) {\n                changeSet.track({ type: ChangeType.Removed, doc: oldDoc });\n                if (lastDocInLimit) {\n                    // A doc was removed from a full limit query. We'll need to\n                    // requery from the local cache to see if we know about some other\n                    // doc that should be in the results.\n                    needsRefill = true;\n                }\n            }\n        });\n        if (this.query.hasLimit()) {\n            // TODO(klimt): Make DocumentSet size be constant time.\n            while (newDocumentSet.size > this.query.limit) {\n                var oldDoc = newDocumentSet.last();\n                newDocumentSet = newDocumentSet.delete(oldDoc.key);\n                changeSet.track({ type: ChangeType.Removed, doc: oldDoc });\n            }\n        }\n        assert(!needsRefill || !previousChanges, 'View was refilled using docs that themselves needed refilling.');\n        return {\n            documentSet: newDocumentSet,\n            changeSet: changeSet,\n            needsRefill: needsRefill,\n            mutatedKeys: newMutatedKeys\n        };\n    };\n    /**\n     * Updates the view with the given ViewDocumentChanges and updates limbo docs\n     * and sync state from the given (optional) target change.\n     * @param docChanges The set of changes to make to the view's docs.\n     * @param targetChange A target change to apply for computing limbo docs and\n     *        sync state.\n     * @return A new ViewChange with the given docs, changes, and sync state.\n     */\n    View.prototype.applyChanges = function (docChanges, targetChange) {\n        var _this = this;\n        assert(!docChanges.needsRefill, 'Cannot apply changes that need a refill');\n        var oldDocs = this.documentSet;\n        this.documentSet = docChanges.documentSet;\n        this.mutatedKeys = docChanges.mutatedKeys;\n        // Sort changes based on type and query comparator\n        var changes = docChanges.changeSet.getChanges();\n        changes.sort(function (c1, c2) {\n            return (compareChangeType(c1.type, c2.type) ||\n                _this.query.docComparator(c1.doc, c2.doc));\n        });\n        this.applyTargetChange(targetChange);\n        var limboChanges = this.updateLimboDocuments();\n        var synced = this.limboDocuments.size === 0 && this.current;\n        var newSyncState = synced ? SyncState.Synced : SyncState.Local;\n        var syncStateChanged = newSyncState !== this.syncState;\n        this.syncState = newSyncState;\n        if (changes.length === 0 && !syncStateChanged) {\n            // no changes\n            return { limboChanges: limboChanges };\n        }\n        else {\n            var snap = new ViewSnapshot(this.query, docChanges.documentSet, oldDocs, changes, newSyncState === SyncState.Local, !docChanges.mutatedKeys.isEmpty(), syncStateChanged);\n            return {\n                snapshot: snap,\n                limboChanges: limboChanges\n            };\n        }\n    };\n    /**\n     * Applies an OnlineState change to the view, potentially generating a\n     * ViewChange if the view's syncState changes as a result.\n     */\n    View.prototype.applyOnlineStateChange = function (onlineState) {\n        if (this.current && onlineState === OnlineState.Failed) {\n            // If we're offline, set `current` to false and then call applyChanges()\n            // to refresh our syncState and generate a ViewChange as appropriate. We\n            // are guaranteed to get a new TargetChange that sets `current` back to\n            // true once the client is back online.\n            this.current = false;\n            return this.applyChanges({\n                documentSet: this.documentSet,\n                changeSet: new DocumentChangeSet(),\n                mutatedKeys: this.mutatedKeys,\n                needsRefill: false\n            });\n        }\n        else {\n            // No effect, just return a no-op ViewChange.\n            return { limboChanges: [] };\n        }\n    };\n    /**\n     * Returns whether the doc for the given key should be in limbo.\n     */\n    View.prototype.shouldBeInLimbo = function (key) {\n        // If the remote end says it's part of this query, it's not in limbo.\n        if (this.syncedDocuments.has(key)) {\n            return false;\n        }\n        // The local store doesn't think it's a result, so it shouldn't be in limbo.\n        if (!this.documentSet.has(key)) {\n            return false;\n        }\n        // If there are local changes to the doc, they might explain why the server\n        // doesn't know that it's part of the query. So don't put it in limbo.\n        // TODO(klimt): Ideally, we would only consider changes that might actually\n        // affect this specific query.\n        if (this.documentSet.get(key).hasLocalMutations) {\n            return false;\n        }\n        // Everything else is in limbo.\n        return true;\n    };\n    /**\n     * Updates syncedDocuments, current, and limbo docs based on the given change.\n     * Returns the list of changes to which docs are in limbo.\n     */\n    View.prototype.applyTargetChange = function (targetChange) {\n        if (targetChange) {\n            var targetMapping = targetChange.mapping;\n            if (targetMapping instanceof ResetMapping) {\n                this.syncedDocuments = targetMapping.documents;\n            }\n            else if (targetMapping instanceof UpdateMapping) {\n                this.syncedDocuments = targetMapping.applyToKeySet(this.syncedDocuments);\n            }\n            switch (targetChange.currentStatusUpdate) {\n                case CurrentStatusUpdate.MarkCurrent:\n                    this.current = true;\n                    break;\n                case CurrentStatusUpdate.MarkNotCurrent:\n                    this.current = false;\n                    break;\n                case CurrentStatusUpdate.None:\n                    break;\n                default:\n                    fail('Unknown current status update: ' + targetChange.currentStatusUpdate);\n            }\n        }\n    };\n    View.prototype.updateLimboDocuments = function () {\n        var _this = this;\n        // We can only determine limbo documents when we're in-sync with the server.\n        if (!this.current) {\n            return [];\n        }\n        // TODO(klimt): Do this incrementally so that it's not quadratic when\n        // updating many documents.\n        var oldLimboDocuments = this.limboDocuments;\n        this.limboDocuments = documentKeySet();\n        this.documentSet.forEach(function (doc) {\n            if (_this.shouldBeInLimbo(doc.key)) {\n                _this.limboDocuments = _this.limboDocuments.add(doc.key);\n            }\n        });\n        // Diff the new limbo docs with the old limbo docs.\n        var changes = [];\n        oldLimboDocuments.forEach(function (key) {\n            if (!_this.limboDocuments.has(key)) {\n                changes.push(new RemovedLimboDocument(key));\n            }\n        });\n        this.limboDocuments.forEach(function (key) {\n            if (!oldLimboDocuments.has(key)) {\n                changes.push(new AddedLimboDocument(key));\n            }\n        });\n        return changes;\n    };\n    return View;\n}());\nexport { View };\nfunction compareChangeType(c1, c2) {\n    var order = function (change) {\n        switch (change) {\n            case ChangeType.Added:\n                return 1;\n            case ChangeType.Modified:\n                return 2;\n            case ChangeType.Metadata:\n                // A metadata change is converted to a modified change at the public\n                // api layer.  Since we sort by document key and then change type,\n                // metadata and modified changes must be sorted equivalently.\n                return 2;\n            case ChangeType.Removed:\n                return 0;\n            default:\n                return fail('Unknown ChangeType: ' + change);\n        }\n    };\n    return order(c1) - order(c2);\n}\n\n//# sourceMappingURL=view.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/view.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ResourcePath } from '../model/path';\nimport { assert, fail } from '../util/assert';\nvar escapeChar = '\\u0001';\nvar encodedSeparatorChar = '\\u0001';\nvar encodedNul = '\\u0010';\nvar encodedEscape = '\\u0011';\n/**\n * Encodes a resource path into a IndexedDb-compatible string form.\n */\nexport function encode(path) {\n    var result = '';\n    for (var i = 0; i < path.length; i++) {\n        if (result.length > 0) {\n            result = encodeSeparator(result);\n        }\n        result = encodeSegment(path.get(i), result);\n    }\n    return encodeSeparator(result);\n}\n/** Encodes a single segment of a resource path into the given result */\nfunction encodeSegment(segment, resultBuf) {\n    var result = resultBuf;\n    var length = segment.length;\n    for (var i = 0; i < length; i++) {\n        var c = segment.charAt(i);\n        switch (c) {\n            case '\\0':\n                result += escapeChar + encodedNul;\n                break;\n            case escapeChar:\n                result += escapeChar + encodedEscape;\n                break;\n            default:\n                result += c;\n        }\n    }\n    return result;\n}\n/** Encodes a path separator into the given result */\nfunction encodeSeparator(result) {\n    return result + escapeChar + encodedSeparatorChar;\n}\n/**\n * Decodes the given IndexedDb-compatible string form of a resource path into\n * a ResourcePath instance. Note that this method is not suitable for use with\n * decoding resource names from the server; those are One Platform format\n * strings.\n */\nexport function decode(path) {\n    // Event the empty path must encode as a path of at least length 2. A path\n    // with exactly 2 must be the empty path.\n    var length = path.length;\n    assert(length >= 2, 'Invalid path ' + path);\n    if (length === 2) {\n        assert(path.charAt(0) === escapeChar && path.charAt(1) === encodedSeparatorChar, 'Non-empty path ' + path + ' had length 2');\n        return ResourcePath.EMPTY_PATH;\n    }\n    // Escape characters cannot exist past the second-to-last position in the\n    // source value.\n    var lastReasonableEscapeIndex = length - 2;\n    var segments = [];\n    var segmentBuilder = '';\n    for (var start = 0; start < length;) {\n        // The last two characters of a valid encoded path must be a separator, so\n        // there must be an end to this segment.\n        var end = path.indexOf(escapeChar, start);\n        if (end < 0 || end > lastReasonableEscapeIndex) {\n            fail('Invalid encoded resource path: \"' + path + '\"');\n        }\n        var next = path.charAt(end + 1);\n        switch (next) {\n            case encodedSeparatorChar:\n                var currentPiece = path.substring(start, end);\n                var segment = void 0;\n                if (segmentBuilder.length === 0) {\n                    // Avoid copying for the common case of a segment that excludes \\0\n                    // and \\001\n                    segment = currentPiece;\n                }\n                else {\n                    segmentBuilder += currentPiece;\n                    segment = segmentBuilder;\n                    segmentBuilder = '';\n                }\n                segments.push(segment);\n                break;\n            case encodedNul:\n                segmentBuilder += path.substring(start, end);\n                segmentBuilder += '\\0';\n                break;\n            case encodedEscape:\n                // The escape character can be used in the output to encode itself.\n                segmentBuilder += path.substring(start, end + 1);\n                break;\n            default:\n                fail('Invalid encoded resource path: \"' + path + '\"');\n        }\n        start = end + 2;\n    }\n    return new ResourcePath(segments);\n}\n/**\n * Computes the prefix successor of the given path, computed by encode above.\n * A prefix successor is the first key that cannot be prefixed by the given\n * path. It's useful for defining the end of a prefix scan such that all keys\n * in the scan have the same prefix.\n *\n * Note that this is not a general prefix successor implementation, which is\n * tricky to get right with Strings, given that they encode down to UTF-8.\n * Instead this relies on the fact that all paths encoded by this class are\n * always terminated with a separator, and so a successor can always be\n * cheaply computed by incrementing the last character of the path.\n */\nexport function prefixSuccessor(path) {\n    var c = path.charCodeAt(path.length - 1);\n    // TODO(mcg): this really should be a general thing, but not worth it right\n    // now\n    assert(c === 1, 'successor may only operate on paths generated by encode');\n    return path.substring(0, path.length - 1) + String.fromCharCode(c + 1);\n}\n\n//# sourceMappingURL=encoded_resource_path.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/encoded_resource_path.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\nimport { encode } from './encoded_resource_path';\nexport var SCHEMA_VERSION = 1;\n/** Performs database creation and (in the future) upgrades between versions. */\nexport function createOrUpgradeDb(db, oldVersion) {\n    assert(oldVersion === 0, 'Unexpected upgrade from version ' + oldVersion);\n    db.createObjectStore(DbMutationQueue.store, {\n        keyPath: DbMutationQueue.keyPath\n    });\n    // TODO(mikelehen): Get rid of \"as any\" if/when TypeScript fixes their\n    // types. https://github.com/Microsoft/TypeScript/issues/14322\n    db.createObjectStore(DbMutationBatch.store, \n    // tslint:disable-next-line:no-any\n    { keyPath: DbMutationBatch.keyPath });\n    var targetDocumentsStore = db.createObjectStore(DbTargetDocument.store, \n    // tslint:disable-next-line:no-any\n    { keyPath: DbTargetDocument.keyPath });\n    targetDocumentsStore.createIndex(DbTargetDocument.documentTargetsIndex, DbTargetDocument.documentTargetsKeyPath, { unique: true });\n    var targetStore = db.createObjectStore(DbTarget.store, {\n        keyPath: DbTarget.keyPath\n    });\n    // NOTE: This is unique only because the TargetId is the suffix.\n    targetStore.createIndex(DbTarget.queryTargetsIndexName, DbTarget.queryTargetsKeyPath, { unique: true });\n    // NOTE: keys for these stores are specified explicitly rather than using a\n    // keyPath.\n    db.createObjectStore(DbDocumentMutation.store);\n    db.createObjectStore(DbRemoteDocument.store);\n    db.createObjectStore(DbOwner.store);\n    db.createObjectStore(DbTargetGlobal.store);\n}\n/**\n * Wrapper class to store timestamps (seconds and nanos) in IndexedDb objects.\n */\nvar DbTimestamp = /** @class */ (function () {\n    function DbTimestamp(seconds, nanos) {\n        this.seconds = seconds;\n        this.nanos = nanos;\n    }\n    return DbTimestamp;\n}());\nexport { DbTimestamp };\n/**\n * A singleton object to be stored in the 'owner' store in IndexedDb.\n *\n * A given database can be owned by a single tab at a given time. That tab\n * must validate that it is still the owner before every write operation and\n * should regularly write an updated timestamp to prevent other tabs from\n * \"stealing\" ownership of the db.\n */\nvar DbOwner = /** @class */ (function () {\n    function DbOwner(ownerId, leaseTimestampMs) {\n        this.ownerId = ownerId;\n        this.leaseTimestampMs = leaseTimestampMs;\n    }\n    /** Name of the IndexedDb object store. */\n    DbOwner.store = 'owner';\n    return DbOwner;\n}());\nexport { DbOwner };\n/**\n * An object to be stored in the 'mutationQueues' store in IndexedDb.\n *\n * Each user gets a single queue of MutationBatches to apply to the server.\n * DbMutationQueue tracks the metadata about the queue.\n */\nvar DbMutationQueue = /** @class */ (function () {\n    function DbMutationQueue(\n        /**\n         * The normalized user ID to which this queue belongs.\n         */\n        userId, \n        /**\n         * An identifier for the highest numbered batch that has been acknowledged\n         * by the server. All MutationBatches in this queue with batchIds less\n         * than or equal to this value are considered to have been acknowledged by\n         * the server.\n         */\n        lastAcknowledgedBatchId, \n        /**\n         * A stream token that was previously sent by the server.\n         *\n         * See StreamingWriteRequest in datastore.proto for more details about\n         * usage.\n         *\n         * After sending this token, earlier tokens may not be used anymore so\n         * only a single stream token is retained.\n         */\n        lastStreamToken) {\n        this.userId = userId;\n        this.lastAcknowledgedBatchId = lastAcknowledgedBatchId;\n        this.lastStreamToken = lastStreamToken;\n    }\n    /** Name of the IndexedDb object store.  */\n    DbMutationQueue.store = 'mutationQueues';\n    /** Keys are automatically assigned via the userId property. */\n    DbMutationQueue.keyPath = 'userId';\n    return DbMutationQueue;\n}());\nexport { DbMutationQueue };\n/**\n * An object to be stored in the 'mutations' store in IndexedDb.\n *\n * Represents a batch of user-level mutations intended to be sent to the server\n * in a single write. Each user-level batch gets a separate DbMutationBatch\n * with a new batchId.\n */\nvar DbMutationBatch = /** @class */ (function () {\n    function DbMutationBatch(\n        /**\n         * The normalized user ID to which this batch belongs.\n         */\n        userId, \n        /**\n         * An identifier for this batch, allocated by the mutation queue in a\n         * monotonically increasing manner.\n         */\n        batchId, \n        /**\n         * The local write time of the batch, stored as milliseconds since the\n         * epoch.\n         */\n        localWriteTimeMs, \n        /**\n         * A list of mutations to apply. All mutations will be applied atomically.\n         *\n         * Mutations are serialized via JsonProtoSerializer.toMutation().\n         */\n        mutations) {\n        this.userId = userId;\n        this.batchId = batchId;\n        this.localWriteTimeMs = localWriteTimeMs;\n        this.mutations = mutations;\n    }\n    /** Name of the IndexedDb object store.  */\n    DbMutationBatch.store = 'mutations';\n    /** Keys are automatically assigned via the userId, batchId properties. */\n    DbMutationBatch.keyPath = ['userId', 'batchId'];\n    return DbMutationBatch;\n}());\nexport { DbMutationBatch };\n/**\n * An object to be stored in the 'documentMutations' store in IndexedDb.\n *\n * A manually maintained index of all the mutation batches that affect a given\n * document key. The rows in this table are references based on the contents of\n * DbMutationBatch.mutations.\n */\nvar DbDocumentMutation = /** @class */ (function () {\n    function DbDocumentMutation() {\n    }\n    /**\n     * Creates a [userId] key for use in the DbDocumentMutations index to iterate\n     * over all of a user's document mutations.\n     */\n    DbDocumentMutation.prefixForUser = function (userId) {\n        return [userId];\n    };\n    /**\n     * Creates a [userId, encodedPath] key for use in the DbDocumentMutations\n     * index to iterate over all at document mutations for a given path or lower.\n     */\n    DbDocumentMutation.prefixForPath = function (userId, path) {\n        return [userId, encode(path)];\n    };\n    /**\n     * Creates a full index key of [userId, encodedPath, batchId] for inserting\n     * and deleting into the DbDocumentMutations index.\n     */\n    DbDocumentMutation.key = function (userId, path, batchId) {\n        return [userId, encode(path), batchId];\n    };\n    DbDocumentMutation.store = 'documentMutations';\n    /**\n     * Because we store all the useful information for this store in the key,\n     * there is no useful information to store as the value. The raw (unencoded)\n     * path cannot be stored because IndexedDb doesn't store prototype\n     * information.\n     */\n    DbDocumentMutation.PLACEHOLDER = new DbDocumentMutation();\n    return DbDocumentMutation;\n}());\nexport { DbDocumentMutation };\n/**\n * Represents the known absence of a document at a particular version.\n * Stored in IndexedDb as part of a DbRemoteDocument object.\n */\nvar DbNoDocument = /** @class */ (function () {\n    function DbNoDocument(path, readTime) {\n        this.path = path;\n        this.readTime = readTime;\n    }\n    return DbNoDocument;\n}());\nexport { DbNoDocument };\n/**\n * An object to be stored in the 'remoteDocuments' store in IndexedDb. It\n * represents either a cached document (if it exists) or a cached \"no-document\"\n * (if it is known to not exist).\n *\n * Note: This is the persisted equivalent of a MaybeDocument and could perhaps\n * be made more general if necessary.\n */\nvar DbRemoteDocument = /** @class */ (function () {\n    function DbRemoteDocument(\n        /**\n         * Set to an instance of a DbNoDocument if it is known that no document\n         * exists.\n         */\n        noDocument, \n        /**\n         * Set to an instance of a Document if there's a cached version of the\n         * document.\n         */\n        document) {\n        this.noDocument = noDocument;\n        this.document = document;\n    }\n    DbRemoteDocument.store = 'remoteDocuments';\n    return DbRemoteDocument;\n}());\nexport { DbRemoteDocument };\n/**\n * An object to be stored in the 'targets' store in IndexedDb.\n *\n * This is based on and should be kept in sync with the proto used in the iOS\n * client.\n *\n * Each query the client listens to against the server is tracked on disk so\n * that the query can be efficiently resumed on restart.\n */\nvar DbTarget = /** @class */ (function () {\n    function DbTarget(\n        /**\n         * An auto-generated sequential numeric identifier for the query.\n         *\n         * Queries are stored using their canonicalId as the key, but these\n         * canonicalIds can be quite long so we additionally assign a unique\n         * queryId which can be used by referenced data structures (e.g.\n         * indexes) to minimize the on-disk cost.\n         */\n        targetId, \n        /**\n         * The canonical string representing this query. This is not unique.\n         */\n        canonicalId, \n        /**\n         * The last readTime received from the Watch Service for this query.\n         *\n         * This is the same value as TargetChange.read_time in the protos.\n         */\n        readTime, \n        /**\n         * An opaque, server-assigned token that allows watching a query to be\n         * resumed after disconnecting without retransmitting all the data\n         * that matches the query. The resume token essentially identifies a\n         * point in time from which the server should resume sending results.\n         *\n         * This is related to the snapshotVersion in that the resumeToken\n         * effectively also encodes that value, but the resumeToken is opaque\n         * and sometimes encodes additional information.\n         *\n         * A consequence of this is that the resumeToken should be used when\n         * asking the server to reason about where this client is in the watch\n         * stream, but the client should use the snapshotVersion for its own\n         * purposes.\n         *\n         * This is the same value as TargetChange.resume_token in the protos.\n         */\n        resumeToken, \n        /**\n         * A sequence number representing the last time this query was\n         * listened to, used for garbage collection purposes.\n         *\n         * Conventionally this would be a timestamp value, but device-local\n         * clocks are unreliable and they must be able to create new listens\n         * even while disconnected. Instead this should be a monotonically\n         * increasing number that's incremented on each listen call.\n         *\n         * This is different from the queryId since the queryId is an\n         * immutable identifier assigned to the Query on first use while\n         * lastListenSequenceNumber is updated every time the query is\n         * listened to.\n         */\n        lastListenSequenceNumber, \n        /**\n         * The query for this target.\n         *\n         * Because canonical ids are not unique we must store the actual query. We\n         * use the proto to have an object we can persist without having to\n         * duplicate translation logic to and from a `Query` object.\n         */\n        query) {\n        this.targetId = targetId;\n        this.canonicalId = canonicalId;\n        this.readTime = readTime;\n        this.resumeToken = resumeToken;\n        this.lastListenSequenceNumber = lastListenSequenceNumber;\n        this.query = query;\n    }\n    DbTarget.store = 'targets';\n    /** Keys are automatically assigned via the targetId property. */\n    DbTarget.keyPath = 'targetId';\n    /** The name of the queryTargets index. */\n    DbTarget.queryTargetsIndexName = 'queryTargetsIndex';\n    /**\n     * The index of all canonicalIds to the targets that they match. This is not\n     * a unique mapping because canonicalId does not promise a unique name for all\n     * possible queries, so we append the targetId to make the mapping unique.\n     */\n    DbTarget.queryTargetsKeyPath = ['canonicalId', 'targetId'];\n    return DbTarget;\n}());\nexport { DbTarget };\n/**\n * An object representing an association between a target and a document.\n * Stored in the targetDocument object store to store the documents tracked by a\n * particular target.\n */\nvar DbTargetDocument = /** @class */ (function () {\n    function DbTargetDocument(\n        /**\n         * The targetId identifying a target.\n         */\n        targetId, \n        /**\n         * The path to the document, as encoded in the key.\n         */\n        path) {\n        this.targetId = targetId;\n        this.path = path;\n    }\n    /** Name of the IndexedDb object store.  */\n    DbTargetDocument.store = 'targetDocuments';\n    /** Keys are automatically assigned via the targetId, path properties. */\n    DbTargetDocument.keyPath = ['targetId', 'path'];\n    /** The index name for the reverse index. */\n    DbTargetDocument.documentTargetsIndex = 'documentTargetsIndex';\n    /** We also need to create the reverse index for these properties. */\n    DbTargetDocument.documentTargetsKeyPath = ['path', 'targetId'];\n    return DbTargetDocument;\n}());\nexport { DbTargetDocument };\n/**\n * A record of global state tracked across all Targets, tracked separately\n * to avoid the need for extra indexes.\n *\n * This should be kept in-sync with the proto used in the iOS client.\n */\nvar DbTargetGlobal = /** @class */ (function () {\n    function DbTargetGlobal(\n        /**\n         * The highest numbered target id across all targets.\n         *\n         * See DbTarget.targetId.\n         */\n        highestTargetId, \n        /**\n         * The highest numbered lastListenSequenceNumber across all targets.\n         *\n         * See DbTarget.lastListenSequenceNumber.\n         */\n        highestListenSequenceNumber, \n        /**\n         * A global snapshot version representing the last consistent snapshot we\n         * received from the backend. This is monotonically increasing and any\n         * snapshots received from the backend prior to this version (e.g. for\n         * targets resumed with a resumeToken) should be suppressed (buffered)\n         * until the backend has caught up to this snapshot version again. This\n         * prevents our cache from ever going backwards in time.\n         */\n        lastRemoteSnapshotVersion) {\n        this.highestTargetId = highestTargetId;\n        this.highestListenSequenceNumber = highestListenSequenceNumber;\n        this.lastRemoteSnapshotVersion = lastRemoteSnapshotVersion;\n    }\n    /**\n     * The key string used for the single object that exists in the\n     * DbTargetGlobal store.\n     */\n    DbTargetGlobal.key = 'targetGlobalKey';\n    DbTargetGlobal.store = 'targetGlobal';\n    return DbTargetGlobal;\n}());\nexport { DbTargetGlobal };\n/**\n * The list of all IndexedDB stored used by the SDK. This is used when creating\n * transactions so that access across all stores is done atomically.\n */\nexport var ALL_STORES = [\n    DbMutationQueue.store,\n    DbMutationBatch.store,\n    DbDocumentMutation.store,\n    DbRemoteDocument.store,\n    DbTarget.store,\n    DbOwner.store,\n    DbTargetGlobal.store,\n    DbTargetDocument.store\n];\n\n//# sourceMappingURL=indexeddb_schema.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/indexeddb_schema.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\nimport { debug } from '../util/log';\nimport { PersistencePromise } from './persistence_promise';\nvar LOG_TAG = 'SimpleDb';\n/**\n * Provides a wrapper around IndexedDb with a simplified interface that uses\n * Promise-like return values to chain operations. Real promises cannot be used\n * since .then() continuations are executed asynchronously (e.g. via\n * .setImmediate), which would cause IndexedDB to end the transaction.\n * See PersistencePromise for more details.\n */\nvar SimpleDb = /** @class */ (function () {\n    function SimpleDb(db) {\n        this.db = db;\n    }\n    /** Opens the specified database, creating or upgrading it if necessary. */\n    SimpleDb.openOrCreate = function (name, version, runUpgrade) {\n        assert(SimpleDb.isAvailable(), 'IndexedDB not supported in current environment.');\n        debug(LOG_TAG, 'Opening database:', name);\n        return new PersistencePromise(function (resolve, reject) {\n            // TODO(mikelehen): Investigate browser compatibility.\n            // https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API/Using_IndexedDB\n            // suggests IE9 and older WebKit browsers handle upgrade\n            // differently.\n            var request = window.indexedDB.open(name, version);\n            request.onsuccess = function (event) {\n                var db = event.target.result;\n                resolve(new SimpleDb(db));\n            };\n            request.onerror = function (event) {\n                reject(event.target.error);\n            };\n            request.onupgradeneeded = function (event) {\n                debug(LOG_TAG, 'Database \"' + name + '\" requires upgrade from version:', event.oldVersion);\n                // TODO(mikelehen): If/when we need to do an actual data\n                // migration, we'll want to wrap db in a SimpleDb and have the\n                // runUpgrade function return a PersistencePromise, since we'll\n                // likely need to do async reads and writes. For now we're\n                // cheating and just passing the raw IndexedDB in, since\n                // createObjectStore(), etc. are synchronous.\n                var db = event.target.result;\n                runUpgrade(db, event.oldVersion);\n            };\n        }).toPromise();\n    };\n    /** Deletes the specified database. */\n    SimpleDb.delete = function (name) {\n        debug(LOG_TAG, 'Removing database:', name);\n        return wrapRequest(window.indexedDB.deleteDatabase(name)).toPromise();\n    };\n    /** Returns true if IndexedDB is available in the current environment. */\n    SimpleDb.isAvailable = function () {\n        if (typeof window === 'undefined' || window.indexedDB == null) {\n            return false;\n        }\n        // We extensively use indexed array values and compound keys,\n        // which IE and Edge do not support. However, they still have indexedDB\n        // defined on the window, so we need to check for them here and make sure\n        // to return that persistence is not enabled for those browsers.\n        // For tracking support of this feature, see here:\n        // https://developer.microsoft.com/en-us/microsoft-edge/platform/status/indexeddbarraysandmultientrysupport/\n        // Check the UA string to find out the browser.\n        var ua = window.navigator.userAgent;\n        // IE 10\n        // ua = 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.2; Trident/6.0)';\n        // IE 11\n        // ua = 'Mozilla/5.0 (Windows NT 6.3; Trident/7.0; rv:11.0) like Gecko';\n        // Edge\n        // ua = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML,\n        // like Gecko) Chrome/39.0.2171.71 Safari/537.36 Edge/12.0';\n        if (ua.indexOf('MSIE ') > 0 ||\n            ua.indexOf('Trident/') > 0 ||\n            ua.indexOf('Edge/') > 0) {\n            return false;\n        }\n        else {\n            return true;\n        }\n    };\n    SimpleDb.prototype.runTransaction = function (mode, objectStores, transactionFn) {\n        var transaction = new SimpleDbTransaction(this.db, mode, objectStores);\n        var transactionFnResult = transactionFn(transaction)\n            .catch(function (error) {\n            // Abort the transaction if there was an\n            // error.\n            transaction.abort();\n            return PersistencePromise.reject(error);\n        })\n            .toPromise();\n        // Wait for the transaction to complete (i.e. IndexedDb's onsuccess event to\n        // fire), but still return the original transactionFnResult back to the\n        // caller.\n        return transaction.completionPromise.then(function () { return transactionFnResult; });\n    };\n    SimpleDb.prototype.close = function () {\n        this.db.close();\n    };\n    return SimpleDb;\n}());\nexport { SimpleDb };\n/**\n * A controller for iterating over a key range or index. It allows an iterate\n * callback to delete the currently-referenced object, or jump to a new key\n * within the key range or index.\n */\nvar IterationController = /** @class */ (function () {\n    function IterationController(dbCursor) {\n        this.dbCursor = dbCursor;\n        this.shouldStop = false;\n        this.nextKey = null;\n    }\n    Object.defineProperty(IterationController.prototype, \"isDone\", {\n        get: function () {\n            return this.shouldStop;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(IterationController.prototype, \"skipToKey\", {\n        get: function () {\n            return this.nextKey;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(IterationController.prototype, \"cursor\", {\n        set: function (value) {\n            this.dbCursor = value;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * This function can be called to stop iteration at any point.\n     */\n    IterationController.prototype.done = function () {\n        this.shouldStop = true;\n    };\n    /**\n     * This function can be called to skip to that next key, which could be\n     * an index or a primary key.\n     */\n    IterationController.prototype.skip = function (key) {\n        this.nextKey = key;\n    };\n    /**\n     * Delete the current cursor value from the object store.\n     *\n     * NOTE: You CANNOT do this with a keysOnly query.\n     */\n    IterationController.prototype.delete = function () {\n        return wrapRequest(this.dbCursor.delete());\n    };\n    return IterationController;\n}());\nexport { IterationController };\n/**\n * Wraps an IDBTransaction and exposes a store() method to get a handle to a\n * specific object store.\n */\nvar SimpleDbTransaction = /** @class */ (function () {\n    function SimpleDbTransaction(db, mode, objectStoresNames) {\n        var _this = this;\n        this.aborted = false;\n        this.transaction = db.transaction(objectStoresNames, mode);\n        this.completionPromise = new Promise(function (resolve, reject) {\n            // We consider aborting to be \"normal\" and just resolve the promise.\n            // May need to revisit if/when we actually need to abort transactions.\n            _this.transaction.onabort = _this.transaction.oncomplete = function (event) {\n                resolve();\n            };\n            _this.transaction.onerror = function (event) {\n                reject(event.target.error);\n            };\n        });\n    }\n    SimpleDbTransaction.prototype.abort = function () {\n        if (!this.aborted) {\n            debug(LOG_TAG, 'Aborting transaction.');\n            this.aborted = true;\n            this.transaction.abort();\n        }\n    };\n    /**\n     * Returns a SimpleDbStore<KeyType, ValueType> for the specified store. All\n     * operations performed on the SimpleDbStore happen within the context of this\n     * transaction and it cannot be used anymore once the transaction is\n     * completed.\n     *\n     * Note that we can't actually enforce that the KeyType and ValueType are\n     * correct, but they allow type safety through the rest of the consuming code.\n     */\n    SimpleDbTransaction.prototype.store = function (storeName) {\n        var store = this.transaction.objectStore(storeName);\n        assert(!!store, 'Object store not part of transaction: ' + storeName);\n        return new SimpleDbStore(store);\n    };\n    return SimpleDbTransaction;\n}());\nexport { SimpleDbTransaction };\n/**\n * A wrapper around an IDBObjectStore providing an API that:\n *\n * 1) Has generic KeyType / ValueType parameters to provide strongly-typed\n * methods for acting against the object store.\n * 2) Deals with IndexedDB's onsuccess / onerror event callbacks, making every\n * method return a PersistencePromise instead.\n * 3) Provides a higher-level API to avoid needing to do excessive wrapping of\n * intermediate IndexedDB types (IDBCursorWithValue, etc.)\n */\nvar SimpleDbStore = /** @class */ (function () {\n    function SimpleDbStore(store) {\n        this.store = store;\n    }\n    SimpleDbStore.prototype.put = function (keyOrValue, value) {\n        var request;\n        if (value !== undefined) {\n            debug(LOG_TAG, 'PUT', this.store.name, keyOrValue, value);\n            request = this.store.put(value, keyOrValue);\n        }\n        else {\n            debug(LOG_TAG, 'PUT', this.store.name, '<auto-key>', keyOrValue);\n            request = this.store.put(keyOrValue);\n        }\n        return wrapRequest(request);\n    };\n    /**\n     * Gets the object with the specified key from the specified store, or null\n     * if no object exists with the specified key.\n     *\n     * @key The key of the object to get.\n     * @return The object with the specified key or null if no object exists.\n     */\n    SimpleDbStore.prototype.get = function (key) {\n        var _this = this;\n        var request = this.store.get(key);\n        // tslint:disable-next-line:no-any We're doing an unsafe cast to ValueType.\n        return wrapRequest(request).next(function (result) {\n            // Normalize nonexistence to null.\n            if (result === undefined) {\n                result = null;\n            }\n            debug(LOG_TAG, 'GET', _this.store.name, key, result);\n            return result;\n        });\n    };\n    SimpleDbStore.prototype.delete = function (key) {\n        debug(LOG_TAG, 'DELETE', this.store.name, key);\n        var request = this.store.delete(key);\n        return wrapRequest(request);\n    };\n    SimpleDbStore.prototype.loadAll = function (indexOrRange, range) {\n        var cursor = this.cursor(this.options(indexOrRange, range));\n        var results = [];\n        return this.iterateCursor(cursor, function (key, value) {\n            results.push(value);\n        }).next(function () {\n            return results;\n        });\n    };\n    SimpleDbStore.prototype.deleteAll = function (indexOrRange, range) {\n        debug(LOG_TAG, 'DELETE ALL', this.store.name);\n        var options = this.options(indexOrRange, range);\n        options.keysOnly = false;\n        var cursor = this.cursor(options);\n        return this.iterateCursor(cursor, function (key, value, control) {\n            // NOTE: Calling delete() on a cursor is documented as more efficient than\n            // calling delete() on an object store with a single key\n            // (https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore/delete),\n            // however, this requires us *not* to use a keysOnly cursor\n            // (https://developer.mozilla.org/en-US/docs/Web/API/IDBCursor/delete). We\n            // may want to compare the performance of each method.\n            return control.delete();\n        });\n    };\n    SimpleDbStore.prototype.iterate = function (optionsOrCallback, callback) {\n        var options;\n        if (!callback) {\n            options = {};\n            callback = optionsOrCallback;\n        }\n        else {\n            options = optionsOrCallback;\n        }\n        var cursor = this.cursor(options);\n        return this.iterateCursor(cursor, callback);\n    };\n    SimpleDbStore.prototype.iterateCursor = function (cursorRequest, fn) {\n        var results = [];\n        return new PersistencePromise(function (resolve, reject) {\n            cursorRequest.onerror = function (event) {\n                reject(event.target.error);\n            };\n            cursorRequest.onsuccess = function (event) {\n                var cursor = event.target.result;\n                if (!cursor) {\n                    resolve();\n                    return;\n                }\n                var controller = new IterationController(cursor);\n                var userResult = fn(cursor.primaryKey, cursor.value, controller);\n                if (userResult instanceof PersistencePromise) {\n                    results.push(userResult);\n                }\n                if (controller.isDone) {\n                    resolve();\n                }\n                else if (controller.skipToKey === null) {\n                    cursor.continue();\n                }\n                else {\n                    cursor.continue(controller.skipToKey);\n                }\n            };\n        }).next(function () {\n            return PersistencePromise.waitFor(results);\n        });\n    };\n    SimpleDbStore.prototype.options = function (indexOrRange, range) {\n        var indexName = undefined;\n        if (indexOrRange !== undefined) {\n            if (typeof indexOrRange === 'string') {\n                indexName = indexOrRange;\n            }\n            else {\n                assert(range === undefined, '3rd argument must not be defined if 2nd is a range.');\n                range = indexOrRange;\n            }\n        }\n        return { index: indexName, range: range };\n    };\n    SimpleDbStore.prototype.cursor = function (options) {\n        var direction = 'next';\n        if (options.reverse) {\n            direction = 'prev';\n        }\n        if (options.index) {\n            var index = this.store.index(options.index);\n            if (options.keysOnly) {\n                return index.openKeyCursor(options.range, direction);\n            }\n            else {\n                return index.openCursor(options.range, direction);\n            }\n        }\n        else {\n            return this.store.openCursor(options.range, direction);\n        }\n    };\n    return SimpleDbStore;\n}());\nexport { SimpleDbStore };\n/**\n * Wraps an IDBRequest in a PersistencePromise, using the onsuccess / onerror\n * handlers to resolve / reject the PersistencePromise as appropriate.\n */\nfunction wrapRequest(request) {\n    return new PersistencePromise(function (resolve, reject) {\n        request.onsuccess = function (event) {\n            var result = event.target.result;\n            resolve(result);\n        };\n        request.onerror = function (event) {\n            reject(event.target.error);\n        };\n    });\n}\n\n//# sourceMappingURL=simple_db.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/simple_db.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { BATCHID_UNKNOWN, MutationBatch } from '../model/mutation_batch';\nimport { assert, fail } from '../util/assert';\nimport { immediatePredecessor, primitiveComparator } from '../util/misc';\nimport { SortedSet } from '../util/sorted_set';\nimport * as EncodedResourcePath from './encoded_resource_path';\nimport { DbDocumentMutation, DbMutationBatch, DbMutationQueue } from './indexeddb_schema';\nimport { PersistencePromise } from './persistence_promise';\nimport { SimpleDbTransaction } from './simple_db';\n/** A mutation queue for a specific user, backed by IndexedDB. */\nvar IndexedDbMutationQueue = /** @class */ (function () {\n    function IndexedDbMutationQueue(\n        /**\n         * The normalized userId (e.g. null UID => \"\" userId) used to store /\n         * retrieve mutations.\n         */\n        userId, serializer) {\n        this.userId = userId;\n        this.serializer = serializer;\n        this.garbageCollector = null;\n    }\n    /**\n     * Creates a new mutation queue for the given user.\n     * @param user The user for which to create a mutation queue.\n     * @param serializer The serializer to use when persisting to IndexedDb.\n     */\n    IndexedDbMutationQueue.forUser = function (user, serializer) {\n        // TODO(mcg): Figure out what constraints there are on userIDs\n        // In particular, are there any reserved characters? are empty ids allowed?\n        // For the moment store these together in the same mutations table assuming\n        // that empty userIDs aren't allowed.\n        assert(user.uid !== '', 'UserID must not be an empty string.');\n        var userId = user.isAuthenticated() ? user.uid : '';\n        return new IndexedDbMutationQueue(userId, serializer);\n    };\n    IndexedDbMutationQueue.prototype.start = function (transaction) {\n        var _this = this;\n        return IndexedDbMutationQueue.loadNextBatchIdFromDb(transaction)\n            .next(function (nextBatchId) {\n            _this.nextBatchId = nextBatchId;\n            return mutationQueuesStore(transaction).get(_this.userId);\n        })\n            .next(function (metadata) {\n            if (!metadata) {\n                metadata = new DbMutationQueue(_this.userId, BATCHID_UNKNOWN, \n                /*lastStreamToken=*/ '');\n            }\n            _this.metadata = metadata;\n            // On restart, nextBatchId may end up lower than\n            // lastAcknowledgedBatchId since it's computed from the queue\n            // contents, and there may be no mutations in the queue. In this\n            // case, we need to reset lastAcknowledgedBatchId (which is safe\n            // since the queue must be empty).\n            if (_this.metadata.lastAcknowledgedBatchId >= _this.nextBatchId) {\n                return _this.checkEmpty(transaction).next(function (empty) {\n                    assert(empty, 'Reset nextBatchID is only possible when the queue is empty');\n                    _this.metadata.lastAcknowledgedBatchId = BATCHID_UNKNOWN;\n                    return mutationQueuesStore(transaction).put(_this.metadata);\n                });\n            }\n            else {\n                return PersistencePromise.resolve();\n            }\n        });\n    };\n    /**\n     * Returns one larger than the largest batch ID that has been stored. If there\n     * are no mutations returns 0. Note that batch IDs are global.\n     */\n    IndexedDbMutationQueue.loadNextBatchIdFromDb = function (txn) {\n        var maxBatchId = BATCHID_UNKNOWN;\n        return mutationsStore(txn)\n            .iterate({ reverse: true }, function (key, batch, control) {\n            var userId = key[0], batchId = key[1];\n            if (batchId > maxBatchId) {\n                maxBatchId = batch.batchId;\n            }\n            if (userId === '') {\n                // We can't compute a predecessor for the empty string, since it\n                // is lexographically first. That also means that no other\n                // userIds can come before this one, so we can just exit early.\n                control.done();\n            }\n            else {\n                var nextUser = immediatePredecessor(userId);\n                control.skip([nextUser]);\n            }\n        })\n            .next(function () { return maxBatchId + 1; });\n    };\n    IndexedDbMutationQueue.prototype.checkEmpty = function (transaction) {\n        var empty = true;\n        var range = IDBKeyRange.bound(this.keyForBatchId(Number.NEGATIVE_INFINITY), this.keyForBatchId(Number.POSITIVE_INFINITY));\n        return mutationsStore(transaction)\n            .iterate({ range: range }, function (key, value, control) {\n            empty = false;\n            control.done();\n        })\n            .next(function () { return empty; });\n    };\n    IndexedDbMutationQueue.prototype.getNextBatchId = function (transaction) {\n        return PersistencePromise.resolve(this.nextBatchId);\n    };\n    IndexedDbMutationQueue.prototype.getHighestAcknowledgedBatchId = function (transaction) {\n        return PersistencePromise.resolve(this.metadata.lastAcknowledgedBatchId);\n    };\n    IndexedDbMutationQueue.prototype.acknowledgeBatch = function (transaction, batch, streamToken) {\n        var batchId = batch.batchId;\n        assert(batchId > this.metadata.lastAcknowledgedBatchId, 'Mutation batchIDs must be acknowledged in order');\n        this.metadata.lastAcknowledgedBatchId = batchId;\n        this.metadata.lastStreamToken = validateStreamToken(streamToken);\n        return mutationQueuesStore(transaction).put(this.metadata);\n    };\n    IndexedDbMutationQueue.prototype.getLastStreamToken = function (transaction) {\n        return PersistencePromise.resolve(this.metadata.lastStreamToken);\n    };\n    IndexedDbMutationQueue.prototype.setLastStreamToken = function (transaction, streamToken) {\n        this.metadata.lastStreamToken = validateStreamToken(streamToken);\n        return mutationQueuesStore(transaction).put(this.metadata);\n    };\n    IndexedDbMutationQueue.prototype.addMutationBatch = function (transaction, localWriteTime, mutations) {\n        var _this = this;\n        var batchId = this.nextBatchId;\n        this.nextBatchId++;\n        var batch = new MutationBatch(batchId, localWriteTime, mutations);\n        var dbBatch = this.serializer.toDbMutationBatch(this.userId, batch);\n        return mutationsStore(transaction)\n            .put(dbBatch)\n            .next(function () {\n            var promises = [];\n            for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n                var mutation = mutations_1[_i];\n                var indexKey = DbDocumentMutation.key(_this.userId, mutation.key.path, batchId);\n                documentMutationsStore(transaction).put(indexKey, DbDocumentMutation.PLACEHOLDER);\n            }\n            return PersistencePromise.waitFor(promises);\n        })\n            .next(function () {\n            return batch;\n        });\n    };\n    IndexedDbMutationQueue.prototype.lookupMutationBatch = function (transaction, batchId) {\n        var _this = this;\n        return mutationsStore(transaction)\n            .get(this.keyForBatchId(batchId))\n            .next(function (dbBatch) {\n            return dbBatch ? _this.serializer.fromDbMutationBatch(dbBatch) : null;\n        });\n    };\n    IndexedDbMutationQueue.prototype.getNextMutationBatchAfterBatchId = function (transaction, batchId) {\n        var _this = this;\n        var range = IDBKeyRange.lowerBound(this.keyForBatchId(batchId + 1));\n        var foundBatch = null;\n        return mutationsStore(transaction)\n            .iterate({ range: range }, function (key, dbBatch, control) {\n            if (dbBatch.userId === _this.userId) {\n                assert(dbBatch.batchId > batchId, 'Should have found mutation after ' + batchId);\n                foundBatch = _this.serializer.fromDbMutationBatch(dbBatch);\n            }\n            control.done();\n        })\n            .next(function () { return foundBatch; });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatches = function (transaction) {\n        var _this = this;\n        var range = IDBKeyRange.bound(this.keyForBatchId(BATCHID_UNKNOWN), this.keyForBatchId(Number.POSITIVE_INFINITY));\n        return mutationsStore(transaction)\n            .loadAll(range)\n            .next(function (dbBatches) {\n            return dbBatches.map(function (dbBatch) { return _this.serializer.fromDbMutationBatch(dbBatch); });\n        });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatchesThroughBatchId = function (transaction, batchId) {\n        var _this = this;\n        var range = IDBKeyRange.bound(this.keyForBatchId(BATCHID_UNKNOWN), this.keyForBatchId(batchId));\n        return mutationsStore(transaction)\n            .loadAll(range)\n            .next(function (dbBatches) {\n            return dbBatches.map(function (dbBatch) { return _this.serializer.fromDbMutationBatch(dbBatch); });\n        });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatchesAffectingDocumentKey = function (transaction, documentKey) {\n        var _this = this;\n        // Scan the document-mutation index starting with a prefix starting with\n        // the given documentKey.\n        var indexPrefix = DbDocumentMutation.prefixForPath(this.userId, documentKey.path);\n        var indexStart = IDBKeyRange.lowerBound(indexPrefix);\n        var results = [];\n        return documentMutationsStore(transaction)\n            .iterate({ range: indexStart }, function (indexKey, _, control) {\n            var userID = indexKey[0], encodedPath = indexKey[1], batchID = indexKey[2];\n            // Only consider rows matching exactly the specific key of\n            // interest. Note that because we order by path first, and we\n            // order terminators before path separators, we'll encounter all\n            // the index rows for documentKey contiguously. In particular, all\n            // the rows for documentKey will occur before any rows for\n            // documents nested in a subcollection beneath documentKey so we\n            // can stop as soon as we hit any such row.\n            var path = EncodedResourcePath.decode(encodedPath);\n            if (userID !== _this.userId || !documentKey.path.isEqual(path)) {\n                control.done();\n                return;\n            }\n            var mutationKey = _this.keyForBatchId(batchID);\n            // Look up the mutation batch in the store.\n            // PORTING NOTE: because iteration is callback driven in the web,\n            // we just look up the key instead of keeping an open iterator\n            // like iOS.\n            return mutationsStore(transaction)\n                .get(mutationKey)\n                .next(function (dbBatch) {\n                if (dbBatch === null) {\n                    fail('Dangling document-mutation reference found: ' +\n                        indexKey +\n                        ' which points to ' +\n                        mutationKey);\n                }\n                results.push(_this.serializer.fromDbMutationBatch(dbBatch));\n            });\n        })\n            .next(function () { return results; });\n    };\n    IndexedDbMutationQueue.prototype.getAllMutationBatchesAffectingQuery = function (transaction, query) {\n        var _this = this;\n        assert(!query.isDocumentQuery(), \"Document queries shouldn't go down this path\");\n        var queryPath = query.path;\n        var immediateChildrenLength = queryPath.length + 1;\n        // TODO(mcg): Actually implement a single-collection query\n        //\n        // This is actually executing an ancestor query, traversing the whole\n        // subtree below the collection which can be horrifically inefficient for\n        // some structures. The right way to solve this is to implement the full\n        // value index, but that's not in the cards in the near future so this is\n        // the best we can do for the moment.\n        //\n        // Since we don't yet index the actual properties in the mutations, our\n        // current approach is to just return all mutation batches that affect\n        // documents in the collection being queried.\n        var indexPrefix = DbDocumentMutation.prefixForPath(this.userId, queryPath);\n        var indexStart = IDBKeyRange.lowerBound(indexPrefix);\n        // Collect up unique batchIDs encountered during a scan of the index. Use a\n        // SortedSet to accumulate batch IDs so they can be traversed in order in a\n        // scan of the main table.\n        var uniqueBatchIDs = new SortedSet(primitiveComparator);\n        return documentMutationsStore(transaction)\n            .iterate({ range: indexStart }, function (indexKey, _, control) {\n            var userID = indexKey[0], encodedPath = indexKey[1], batchID = indexKey[2];\n            var path = EncodedResourcePath.decode(encodedPath);\n            if (userID !== _this.userId || !queryPath.isPrefixOf(path)) {\n                control.done();\n                return;\n            }\n            // Rows with document keys more than one segment longer than the\n            // query path can't be matches. For example, a query on 'rooms'\n            // can't match the document /rooms/abc/messages/xyx.\n            // TODO(mcg): we'll need a different scanner when we implement\n            // ancestor queries.\n            if (path.length !== immediateChildrenLength) {\n                return;\n            }\n            uniqueBatchIDs = uniqueBatchIDs.add(batchID);\n        })\n            .next(function () {\n            var results = [];\n            var promises = [];\n            // TODO(rockwood): Implement this using iterate.\n            uniqueBatchIDs.forEach(function (batchID) {\n                var mutationKey = _this.keyForBatchId(batchID);\n                promises.push(mutationsStore(transaction)\n                    .get(mutationKey)\n                    .next(function (mutation) {\n                    if (mutation === null) {\n                        fail('Dangling document-mutation reference found, ' +\n                            'which points to ' +\n                            mutationKey);\n                    }\n                    results.push(_this.serializer.fromDbMutationBatch(mutation));\n                }));\n            });\n            return PersistencePromise.waitFor(promises).next(function () { return results; });\n        });\n    };\n    IndexedDbMutationQueue.prototype.removeMutationBatches = function (transaction, batches) {\n        var txn = mutationsStore(transaction);\n        var indexTxn = documentMutationsStore(transaction);\n        var promises = [];\n        var _loop_1 = function (batch) {\n            var range = IDBKeyRange.only(this_1.keyForBatchId(batch.batchId));\n            var numDeleted = 0;\n            var removePromise = txn.iterate({ range: range }, function (key, value, control) {\n                numDeleted++;\n                return control.delete();\n            });\n            promises.push(removePromise.next(function () {\n                assert(numDeleted === 1, 'Dangling document-mutation reference found: Missing batch ' +\n                    batch.batchId);\n            }));\n            for (var _i = 0, _a = batch.mutations; _i < _a.length; _i++) {\n                var mutation = _a[_i];\n                var indexKey = DbDocumentMutation.key(this_1.userId, mutation.key.path, batch.batchId);\n                promises.push(indexTxn.delete(indexKey));\n                if (this_1.garbageCollector !== null) {\n                    this_1.garbageCollector.addPotentialGarbageKey(mutation.key);\n                }\n            }\n        };\n        var this_1 = this;\n        for (var _i = 0, batches_1 = batches; _i < batches_1.length; _i++) {\n            var batch = batches_1[_i];\n            _loop_1(batch);\n        }\n        return PersistencePromise.waitFor(promises);\n    };\n    IndexedDbMutationQueue.prototype.performConsistencyCheck = function (txn) {\n        var _this = this;\n        return this.checkEmpty(txn).next(function (empty) {\n            if (!empty) {\n                return PersistencePromise.resolve();\n            }\n            // Verify that there are no entries in the documentMutations index if\n            // the queue is empty.\n            var startRange = IDBKeyRange.lowerBound(DbDocumentMutation.prefixForUser(_this.userId));\n            var danglingMutationReferences = [];\n            return documentMutationsStore(txn)\n                .iterate({ range: startRange }, function (key, _, control) {\n                var userID = key[0];\n                if (userID !== _this.userId) {\n                    control.done();\n                    return;\n                }\n                else {\n                    var path = EncodedResourcePath.decode(key[1]);\n                    danglingMutationReferences.push(path);\n                }\n            })\n                .next(function () {\n                assert(danglingMutationReferences.length === 0, 'Document leak -- detected dangling mutation references when queue is empty. Dangling keys: ' +\n                    danglingMutationReferences.map(function (p) { return p.canonicalString(); }));\n            });\n        });\n    };\n    IndexedDbMutationQueue.prototype.setGarbageCollector = function (gc) {\n        this.garbageCollector = gc;\n    };\n    IndexedDbMutationQueue.prototype.containsKey = function (txn, key) {\n        var _this = this;\n        var indexKey = DbDocumentMutation.prefixForPath(this.userId, key.path);\n        var encodedPath = indexKey[1];\n        var startRange = IDBKeyRange.lowerBound(indexKey);\n        var containsKey = false;\n        return documentMutationsStore(txn)\n            .iterate({ range: startRange, keysOnly: true }, function (key, value, control) {\n            var userID = key[0], keyPath = key[1], /*batchID*/ _ = key[2];\n            if (userID === _this.userId && keyPath === encodedPath) {\n                containsKey = true;\n            }\n            control.done();\n        })\n            .next(function () { return containsKey; });\n    };\n    /**\n     * Creates a [userId, batchId] key for use with the DbMutationQueue object\n     * store.\n     */\n    IndexedDbMutationQueue.prototype.keyForBatchId = function (batchId) {\n        return [this.userId, batchId];\n    };\n    return IndexedDbMutationQueue;\n}());\nexport { IndexedDbMutationQueue };\nfunction validateStreamToken(token) {\n    assert(typeof token === 'string', 'Persisting non-string stream token not supported.');\n    return token;\n}\n/**\n * Helper to get a typed SimpleDbStore for the mutations object store.\n */\nfunction mutationsStore(txn) {\n    return getStore(txn, DbMutationBatch.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the mutationQueues object store.\n */\nfunction documentMutationsStore(txn) {\n    return getStore(txn, DbDocumentMutation.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the mutationQueues object store.\n */\nfunction mutationQueuesStore(txn) {\n    return getStore(txn, DbMutationQueue.store);\n}\n/**\n * Helper to get a typed SimpleDbStore from a transaction.\n */\nfunction getStore(txn, store) {\n    if (txn instanceof SimpleDbTransaction) {\n        return txn.store(store);\n    }\n    else {\n        return fail('Invalid transaction object provided!');\n    }\n}\n\n//# sourceMappingURL=indexeddb_mutation_queue.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/indexeddb_mutation_queue.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { Timestamp } from '../core/timestamp';\nimport { documentKeySet } from '../model/collections';\nimport { DocumentKey } from '../model/document_key';\nimport { assert, fail } from '../util/assert';\nimport { immediateSuccessor } from '../util/misc';\nimport * as EncodedResourcePath from './encoded_resource_path';\nimport { DbTarget, DbTargetDocument, DbTargetGlobal } from './indexeddb_schema';\nimport { PersistencePromise } from './persistence_promise';\nimport { SimpleDbTransaction } from './simple_db';\nvar IndexedDbQueryCache = /** @class */ (function () {\n    function IndexedDbQueryCache(serializer) {\n        this.serializer = serializer;\n        /**\n         * The last received snapshot version. We store this seperately from the\n         * metadata to avoid the extra conversion to/from DbTimestamp.\n         */\n        this.lastRemoteSnapshotVersion = SnapshotVersion.MIN;\n        /**\n         * A cached copy of the metadata for the query cache.\n         */\n        this.metadata = new DbTargetGlobal(\n        /*highestTargetId=*/ 0, \n        /*lastListenSequenceNumber=*/ 0, SnapshotVersion.MIN.toTimestamp());\n        /** The garbage collector to notify about potential garbage keys. */\n        this.garbageCollector = null;\n    }\n    IndexedDbQueryCache.prototype.start = function (transaction) {\n        var _this = this;\n        return globalTargetStore(transaction)\n            .get(DbTargetGlobal.key)\n            .next(function (metadata) {\n            if (metadata !== null) {\n                _this.metadata = metadata;\n                var lastSavedVersion = metadata.lastRemoteSnapshotVersion;\n                _this.lastRemoteSnapshotVersion = SnapshotVersion.fromTimestamp(new Timestamp(lastSavedVersion.seconds, lastSavedVersion.nanos));\n            }\n            return PersistencePromise.resolve();\n        });\n    };\n    IndexedDbQueryCache.prototype.getHighestTargetId = function () {\n        return this.metadata.highestTargetId;\n    };\n    IndexedDbQueryCache.prototype.getLastRemoteSnapshotVersion = function () {\n        return this.lastRemoteSnapshotVersion;\n    };\n    IndexedDbQueryCache.prototype.setLastRemoteSnapshotVersion = function (transaction, snapshotVersion) {\n        this.lastRemoteSnapshotVersion = snapshotVersion;\n        this.metadata.lastRemoteSnapshotVersion = snapshotVersion.toTimestamp();\n        return globalTargetStore(transaction).put(DbTargetGlobal.key, this.metadata);\n    };\n    IndexedDbQueryCache.prototype.addQueryData = function (transaction, queryData) {\n        var _this = this;\n        var targetId = queryData.targetId;\n        var addedQueryPromise = targetsStore(transaction).put(this.serializer.toDbTarget(queryData));\n        if (targetId > this.metadata.highestTargetId) {\n            this.metadata.highestTargetId = targetId;\n            return addedQueryPromise.next(function () {\n                return globalTargetStore(transaction).put(DbTargetGlobal.key, _this.metadata);\n            });\n        }\n        else {\n            return addedQueryPromise;\n        }\n    };\n    IndexedDbQueryCache.prototype.removeQueryData = function (transaction, queryData) {\n        return this.removeMatchingKeysForTargetId(transaction, queryData.targetId).next(function () {\n            targetsStore(transaction).delete(queryData.targetId);\n        });\n    };\n    IndexedDbQueryCache.prototype.getQueryData = function (transaction, query) {\n        var _this = this;\n        // Iterating by the canonicalId may yield more than one result because\n        // canonicalId values are not required to be unique per target. This query\n        // depends on the queryTargets index to be efficent.\n        var canonicalId = query.canonicalId();\n        var range = IDBKeyRange.bound([canonicalId, Number.NEGATIVE_INFINITY], [canonicalId, Number.POSITIVE_INFINITY]);\n        var result = null;\n        return targetsStore(transaction)\n            .iterate({ range: range, index: DbTarget.queryTargetsIndexName }, function (key, value, control) {\n            var found = _this.serializer.fromDbTarget(value);\n            // After finding a potential match, check that the query is\n            // actually equal to the requested query.\n            if (query.isEqual(found.query)) {\n                result = found;\n                control.done();\n            }\n        })\n            .next(function () { return result; });\n    };\n    IndexedDbQueryCache.prototype.addMatchingKeys = function (txn, keys, targetId) {\n        // PORTING NOTE: The reverse index (documentsTargets) is maintained by\n        // Indexeddb.\n        var promises = [];\n        var store = documentTargetStore(txn);\n        keys.forEach(function (key) {\n            var path = EncodedResourcePath.encode(key.path);\n            promises.push(store.put(new DbTargetDocument(targetId, path)));\n        });\n        return PersistencePromise.waitFor(promises);\n    };\n    IndexedDbQueryCache.prototype.removeMatchingKeys = function (txn, keys, targetId) {\n        var _this = this;\n        // PORTING NOTE: The reverse index (documentsTargets) is maintained by\n        // IndexedDb.\n        var promises = [];\n        var store = documentTargetStore(txn);\n        keys.forEach(function (key) {\n            var path = EncodedResourcePath.encode(key.path);\n            promises.push(store.delete([targetId, path]));\n            if (_this.garbageCollector !== null) {\n                _this.garbageCollector.addPotentialGarbageKey(key);\n            }\n        });\n        return PersistencePromise.waitFor(promises);\n    };\n    IndexedDbQueryCache.prototype.removeMatchingKeysForTargetId = function (txn, targetId) {\n        var store = documentTargetStore(txn);\n        var range = IDBKeyRange.bound([targetId], [targetId + 1], \n        /*lowerOpen=*/ false, \n        /*upperOpen=*/ true);\n        return this.notifyGCForRemovedKeys(txn, range).next(function () {\n            return store.delete(range);\n        });\n    };\n    IndexedDbQueryCache.prototype.notifyGCForRemovedKeys = function (txn, range) {\n        var _this = this;\n        var store = documentTargetStore(txn);\n        if (this.garbageCollector !== null && this.garbageCollector.isEager) {\n            // In order to generate garbage events properly, we need to read these\n            // keys before deleting.\n            return store.iterate({ range: range, keysOnly: true }, function (key, _, control) {\n                var path = EncodedResourcePath.decode(key[1]);\n                var docKey = new DocumentKey(path);\n                // Paranoid assertion in case the the collector is set to null\n                // during the iteration.\n                assert(_this.garbageCollector !== null, 'GarbageCollector for query cache set to null during key removal.');\n                _this.garbageCollector.addPotentialGarbageKey(docKey);\n            });\n        }\n        else {\n            return PersistencePromise.resolve();\n        }\n    };\n    IndexedDbQueryCache.prototype.getMatchingKeysForTargetId = function (txn, targetId) {\n        var range = IDBKeyRange.bound([targetId], [targetId + 1], \n        /*lowerOpen=*/ false, \n        /*upperOpen=*/ true);\n        var store = documentTargetStore(txn);\n        var result = documentKeySet();\n        return store\n            .iterate({ range: range, keysOnly: true }, function (key, _, control) {\n            var path = EncodedResourcePath.decode(key[1]);\n            var docKey = new DocumentKey(path);\n            result = result.add(docKey);\n        })\n            .next(function () { return result; });\n    };\n    IndexedDbQueryCache.prototype.setGarbageCollector = function (gc) {\n        this.garbageCollector = gc;\n    };\n    IndexedDbQueryCache.prototype.containsKey = function (txn, key) {\n        assert(txn !== null, 'Persistence Transaction cannot be null for query cache containsKey');\n        var path = EncodedResourcePath.encode(key.path);\n        var range = IDBKeyRange.bound([path], [immediateSuccessor(path)], \n        /*lowerOpen=*/ false, \n        /*upperOpen=*/ true);\n        var count = 0;\n        return documentTargetStore(txn)\n            .iterate({\n            index: DbTargetDocument.documentTargetsIndex,\n            keysOnly: true,\n            range: range\n        }, function (key, _, control) {\n            count++;\n            control.done();\n        })\n            .next(function () { return count > 0; });\n    };\n    return IndexedDbQueryCache;\n}());\nexport { IndexedDbQueryCache };\n/**\n * Helper to get a typed SimpleDbStore for the queries object store.\n */\nfunction targetsStore(txn) {\n    return getStore(txn, DbTarget.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the target globals object store.\n */\nfunction globalTargetStore(txn) {\n    return getStore(txn, DbTargetGlobal.store);\n}\n/**\n * Helper to get a typed SimpleDbStore for the document target object store.\n */\nfunction documentTargetStore(txn) {\n    return getStore(txn, DbTargetDocument.store);\n}\n/**\n * Helper to get a typed SimpleDbStore from a transaction.\n */\nfunction getStore(txn, store) {\n    if (txn instanceof SimpleDbTransaction) {\n        return txn.store(store);\n    }\n    else {\n        return fail('Invalid transaction object provided!');\n    }\n}\n\n//# sourceMappingURL=indexeddb_query_cache.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/indexeddb_query_cache.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentMap } from '../model/collections';\nimport { Document } from '../model/document';\nimport { fail } from '../util/assert';\nimport { DbRemoteDocument } from './indexeddb_schema';\nimport { SimpleDbTransaction } from './simple_db';\nvar IndexedDbRemoteDocumentCache = /** @class */ (function () {\n    function IndexedDbRemoteDocumentCache(serializer) {\n        this.serializer = serializer;\n    }\n    IndexedDbRemoteDocumentCache.prototype.addEntry = function (transaction, maybeDocument) {\n        return remoteDocumentsStore(transaction).put(dbKey(maybeDocument.key), this.serializer.toDbRemoteDocument(maybeDocument));\n    };\n    IndexedDbRemoteDocumentCache.prototype.removeEntry = function (transaction, documentKey) {\n        return remoteDocumentsStore(transaction).delete(dbKey(documentKey));\n    };\n    IndexedDbRemoteDocumentCache.prototype.getEntry = function (transaction, documentKey) {\n        var _this = this;\n        return remoteDocumentsStore(transaction)\n            .get(dbKey(documentKey))\n            .next(function (dbRemoteDoc) {\n            return dbRemoteDoc\n                ? _this.serializer.fromDbRemoteDocument(dbRemoteDoc)\n                : null;\n        });\n    };\n    IndexedDbRemoteDocumentCache.prototype.getDocumentsMatchingQuery = function (transaction, query) {\n        var _this = this;\n        var results = documentMap();\n        // Documents are ordered by key, so we can use a prefix scan to narrow down\n        // the documents we need to match the query against.\n        var startKey = query.path.toArray();\n        var range = IDBKeyRange.lowerBound(startKey);\n        return remoteDocumentsStore(transaction)\n            .iterate({ range: range }, function (key, dbRemoteDoc, control) {\n            var maybeDoc = _this.serializer.fromDbRemoteDocument(dbRemoteDoc);\n            if (!query.path.isPrefixOf(maybeDoc.key.path)) {\n                control.done();\n            }\n            else if (maybeDoc instanceof Document && query.matches(maybeDoc)) {\n                results = results.insert(maybeDoc.key, maybeDoc);\n            }\n        })\n            .next(function () { return results; });\n    };\n    return IndexedDbRemoteDocumentCache;\n}());\nexport { IndexedDbRemoteDocumentCache };\n/**\n * Helper to get a typed SimpleDbStore for the remoteDocuments object store.\n */\nfunction remoteDocumentsStore(txn) {\n    if (txn instanceof SimpleDbTransaction) {\n        return txn.store(DbRemoteDocument.store);\n    }\n    else {\n        return fail('Invalid transaction object provided!');\n    }\n}\nfunction dbKey(docKey) {\n    return docKey.path.toArray();\n}\n\n//# sourceMappingURL=indexeddb_remote_document_cache.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/indexeddb_remote_document_cache.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { Timestamp } from '../core/timestamp';\nimport { Document, NoDocument } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { MutationBatch } from '../model/mutation_batch';\nimport { assert, fail } from '../util/assert';\nimport { DbMutationBatch, DbNoDocument, DbRemoteDocument, DbTarget, DbTimestamp } from './indexeddb_schema';\nimport { QueryData, QueryPurpose } from './query_data';\n/** Serializer for values stored in the LocalStore. */\nvar LocalSerializer = /** @class */ (function () {\n    function LocalSerializer(remoteSerializer) {\n        this.remoteSerializer = remoteSerializer;\n    }\n    /** Decodes a remote document from storage locally to a Document. */\n    LocalSerializer.prototype.fromDbRemoteDocument = function (remoteDoc) {\n        if (remoteDoc.document) {\n            return this.remoteSerializer.fromDocument(remoteDoc.document);\n        }\n        else if (remoteDoc.noDocument) {\n            var key = DocumentKey.fromSegments(remoteDoc.noDocument.path);\n            var readTime = remoteDoc.noDocument.readTime;\n            var timestamp = new Timestamp(readTime.seconds, readTime.nanos);\n            return new NoDocument(key, SnapshotVersion.fromTimestamp(timestamp));\n        }\n        else {\n            return fail('Unexpected DbRemoteDocument');\n        }\n    };\n    /** Encodes a document for storage locally. */\n    LocalSerializer.prototype.toDbRemoteDocument = function (maybeDoc) {\n        if (maybeDoc instanceof Document) {\n            var doc = this.remoteSerializer.toDocument(maybeDoc);\n            return new DbRemoteDocument(null, doc);\n        }\n        else {\n            var path = maybeDoc.key.path.toArray();\n            var timestamp = maybeDoc.version.toTimestamp();\n            var readTime = new DbTimestamp(timestamp.seconds, timestamp.nanos);\n            return new DbRemoteDocument(new DbNoDocument(path, readTime), null);\n        }\n    };\n    /** Encodes a batch of mutations into a DbMutationBatch for local storage. */\n    LocalSerializer.prototype.toDbMutationBatch = function (userId, batch) {\n        var _this = this;\n        var serializedMutations = batch.mutations.map(function (m) {\n            return _this.remoteSerializer.toMutation(m);\n        });\n        return new DbMutationBatch(userId, batch.batchId, batch.localWriteTime.toEpochMilliseconds(), serializedMutations);\n    };\n    /** Decodes a DbMutationBatch into a MutationBatch */\n    LocalSerializer.prototype.fromDbMutationBatch = function (dbBatch) {\n        var _this = this;\n        var mutations = dbBatch.mutations.map(function (m) {\n            return _this.remoteSerializer.fromMutation(m);\n        });\n        var timestamp = Timestamp.fromEpochMilliseconds(dbBatch.localWriteTimeMs);\n        return new MutationBatch(dbBatch.batchId, timestamp, mutations);\n    };\n    /** Decodes a DbTarget into QueryData */\n    LocalSerializer.prototype.fromDbTarget = function (dbTarget) {\n        var readTime = new Timestamp(dbTarget.readTime.seconds, dbTarget.readTime.nanos);\n        var version = SnapshotVersion.fromTimestamp(readTime);\n        var query;\n        if (isDocumentQuery(dbTarget.query)) {\n            query = this.remoteSerializer.fromDocumentsTarget(dbTarget.query);\n        }\n        else {\n            query = this.remoteSerializer.fromQueryTarget(dbTarget.query);\n        }\n        return new QueryData(query, dbTarget.targetId, QueryPurpose.Listen, version, dbTarget.resumeToken);\n    };\n    /** Encodes QueryData into a DbTarget for storage locally. */\n    LocalSerializer.prototype.toDbTarget = function (queryData) {\n        assert(QueryPurpose.Listen === queryData.purpose, 'Only queries with purpose ' +\n            QueryPurpose.Listen +\n            ' may be stored, got ' +\n            queryData.purpose);\n        var timestamp = queryData.snapshotVersion.toTimestamp();\n        var dbTimestamp = new DbTimestamp(timestamp.seconds, timestamp.nanos);\n        var queryProto;\n        if (queryData.query.isDocumentQuery()) {\n            queryProto = this.remoteSerializer.toDocumentsTarget(queryData.query);\n        }\n        else {\n            queryProto = this.remoteSerializer.toQueryTarget(queryData.query);\n        }\n        assert(typeof queryData.resumeToken === 'string', 'Persisting non-string resume token not supported.');\n        var resumeToken = queryData.resumeToken;\n        // lastListenSequenceNumber is always 0 until we do real GC.\n        return new DbTarget(queryData.targetId, queryData.query.canonicalId(), dbTimestamp, resumeToken, 0, queryProto);\n    };\n    return LocalSerializer;\n}());\nexport { LocalSerializer };\n/**\n * A helper function for figuring out what kind of query has been stored.\n */\nfunction isDocumentQuery(dbQuery) {\n    return dbQuery.documents !== undefined;\n}\n\n//# sourceMappingURL=local_serializer.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/local_serializer.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { User } from '../auth/user';\nimport { assert, fail } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nvar OAuthToken = /** @class */ (function () {\n    function OAuthToken(value, user) {\n        this.user = user;\n        this.type = 'OAuth';\n        this.authHeaders = { Authorization: \"Bearer \" + value };\n    }\n    return OAuthToken;\n}());\nexport { OAuthToken };\n/** A CredentialsProvider that always yields an empty token. */\nvar EmptyCredentialsProvider = /** @class */ (function () {\n    function EmptyCredentialsProvider() {\n        /**\n         * Stores the User listener registered with setUserChangeListener()\n         * This isn't actually necessary since the UID never changes, but we use this\n         * to verify the listen contract is adhered to in tests.\n         */\n        this.userListener = null;\n    }\n    EmptyCredentialsProvider.prototype.getToken = function (forceRefresh) {\n        return Promise.resolve(null);\n    };\n    EmptyCredentialsProvider.prototype.setUserChangeListener = function (listener) {\n        assert(!this.userListener, 'Can only call setUserChangeListener() once.');\n        this.userListener = listener;\n        // Fire with initial user.\n        listener(User.UNAUTHENTICATED);\n    };\n    EmptyCredentialsProvider.prototype.removeUserChangeListener = function () {\n        assert(this.userListener !== null, 'removeUserChangeListener() when no listener registered');\n        this.userListener = null;\n    };\n    return EmptyCredentialsProvider;\n}());\nexport { EmptyCredentialsProvider };\nvar FirebaseCredentialsProvider = /** @class */ (function () {\n    function FirebaseCredentialsProvider(app) {\n        var _this = this;\n        this.app = app;\n        /**\n         * The auth token listener registered with FirebaseApp, retained here so we\n         * can unregister it.\n         */\n        this.tokenListener = null;\n        /**\n         * Counter used to detect if the user changed while a getToken request was\n         * outstanding.\n         */\n        this.userCounter = 0;\n        /** The User listener registered with setUserChangeListener(). */\n        this.userListener = null;\n        // We listen for token changes but all we really care about is knowing when\n        // the uid may have changed.\n        this.tokenListener = function () {\n            var newUser = _this.getUser();\n            if (!_this.currentUser || !newUser.isEqual(_this.currentUser)) {\n                _this.currentUser = newUser;\n                _this.userCounter++;\n                if (_this.userListener) {\n                    _this.userListener(_this.currentUser);\n                }\n            }\n        };\n        this.userCounter = 0;\n        // Will fire at least once where we set this.currentUser\n        this.app.INTERNAL.addAuthTokenListener(this.tokenListener);\n    }\n    FirebaseCredentialsProvider.prototype.getToken = function (forceRefresh) {\n        var _this = this;\n        assert(this.tokenListener != null, 'getToken cannot be called after listener removed.');\n        // Take note of the current value of the userCounter so that this method can\n        // fail (with an ABORTED error) if there is a user change while the request\n        // is outstanding.\n        var initialUserCounter = this.userCounter;\n        return this.app.INTERNAL.getToken(forceRefresh).then(function (tokenData) {\n            // Cancel the request since the user changed while the request was\n            // outstanding so the response is likely for a previous user (which\n            // user, we can't be sure).\n            if (_this.userCounter !== initialUserCounter) {\n                throw new FirestoreError(Code.ABORTED, 'getToken aborted due to uid change.');\n            }\n            else {\n                if (tokenData) {\n                    assert(typeof tokenData.accessToken === 'string', 'Invalid tokenData returned from getToken():' + tokenData);\n                    return new OAuthToken(tokenData.accessToken, _this.currentUser);\n                }\n                else {\n                    return null;\n                }\n            }\n        });\n    };\n    FirebaseCredentialsProvider.prototype.setUserChangeListener = function (listener) {\n        assert(!this.userListener, 'Can only call setUserChangeListener() once.');\n        this.userListener = listener;\n        // Fire the initial event, but only if we received the initial user\n        if (this.currentUser) {\n            listener(this.currentUser);\n        }\n    };\n    FirebaseCredentialsProvider.prototype.removeUserChangeListener = function () {\n        assert(this.tokenListener != null, 'removeUserChangeListener() called twice');\n        assert(this.userListener !== null, 'removeUserChangeListener() called when no listener registered');\n        this.app.INTERNAL.removeAuthTokenListener(this.tokenListener);\n        this.tokenListener = null;\n        this.userListener = null;\n    };\n    FirebaseCredentialsProvider.prototype.getUser = function () {\n        // TODO(mikelehen): Remove this check once we're shipping with firebase.js.\n        if (typeof this.app.INTERNAL.getUid !== 'function') {\n            fail('This version of the Firestore SDK requires at least version' +\n                ' 3.7.0 of firebase.js.');\n        }\n        var currentUid = this.app.INTERNAL.getUid();\n        assert(currentUid === null || typeof currentUid === 'string', 'Received invalid UID: ' + currentUid);\n        return new User(currentUid);\n    };\n    return FirebaseCredentialsProvider;\n}());\nexport { FirebaseCredentialsProvider };\n/*\n * FirstPartyToken provides a fresh token each time its value\n * is requested, because if the token is too old, requests will be rejected.\n * TODO(b/33147818) this implementation violates the current assumption that\n * tokens are immutable.  We need to either revisit this assumption or come\n * up with some way for FPA to use the listen/unlisten interface.\n */\nvar FirstPartyToken = /** @class */ (function () {\n    function FirstPartyToken(gapi, sessionIndex) {\n        this.gapi = gapi;\n        this.sessionIndex = sessionIndex;\n        this.type = 'FirstParty';\n        this.user = User.FIRST_PARTY;\n        assert(this.gapi &&\n            this.gapi['auth'] &&\n            this.gapi['auth']['getAuthHeaderValueForFirstParty'], 'unexpected gapi interface');\n    }\n    Object.defineProperty(FirstPartyToken.prototype, \"authHeaders\", {\n        get: function () {\n            return {\n                Authorization: this.gapi['auth']['getAuthHeaderValueForFirstParty']([]),\n                'X-Goog-AuthUser': this.sessionIndex\n            };\n        },\n        enumerable: true,\n        configurable: true\n    });\n    return FirstPartyToken;\n}());\nexport { FirstPartyToken };\n/*\n * Provides user credentials required for the Firestore JavaScript SDK\n * to authenticate the user, using technique that is only available\n * to applications hosted by Google.\n */\nvar FirstPartyCredentialsProvider = /** @class */ (function () {\n    function FirstPartyCredentialsProvider(gapi, sessionIndex) {\n        this.gapi = gapi;\n        this.sessionIndex = sessionIndex;\n        assert(this.gapi &&\n            this.gapi['auth'] &&\n            this.gapi['auth']['getAuthHeaderValueForFirstParty'], 'unexpected gapi interface');\n    }\n    FirstPartyCredentialsProvider.prototype.getToken = function (forceRefresh) {\n        return Promise.resolve(new FirstPartyToken(this.gapi, this.sessionIndex));\n    };\n    // TODO(33108925): can someone switch users w/o a page refresh?\n    // TODO(33110621): need to understand token/session lifecycle\n    FirstPartyCredentialsProvider.prototype.setUserChangeListener = function (listener) {\n        // Fire with initial uid.\n        listener(User.FIRST_PARTY);\n    };\n    FirstPartyCredentialsProvider.prototype.removeUserChangeListener = function () { };\n    return FirstPartyCredentialsProvider;\n}());\nexport { FirstPartyCredentialsProvider };\n/**\n * Builds a CredentialsProvider depending on the type of\n * the credentials passed in.\n */\nexport function makeCredentialsProvider(credentials) {\n    if (!credentials) {\n        return new EmptyCredentialsProvider();\n    }\n    switch (credentials.type) {\n        case 'gapi':\n            return new FirstPartyCredentialsProvider(credentials.client, credentials.sessionIndex || '0');\n        case 'provider':\n            return credentials.client;\n        default:\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'makeCredentialsProvider failed due to invalid credential type');\n    }\n}\n\n//# sourceMappingURL=credentials.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/credentials.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nexport function isPartialObserver(obj) {\n    return implementsAnyMethods(obj, ['next', 'error', 'complete']);\n}\n/**\n * Returns true if obj is an object and contains at least one of the specified\n * methods.\n */\nfunction implementsAnyMethods(obj, methods) {\n    if (typeof obj !== 'object' || obj === null) {\n        return false;\n    }\n    var object = obj;\n    for (var _i = 0, methods_1 = methods; _i < methods_1.length; _i++) {\n        var method = methods_1[_i];\n        if (method in object && typeof object[method] === 'function') {\n            return true;\n        }\n    }\n    return false;\n}\n\n//# sourceMappingURL=observer.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/observer.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Timestamp } from '../core/timestamp';\nimport { ObjectValue } from '../model/field_value';\nimport { ArrayValue, BlobValue, BooleanValue, DoubleValue, GeoPointValue, IntegerValue, NullValue, RefValue, StringValue, TimestampValue } from '../model/field_value';\nimport { FieldMask, FieldTransform, PatchMutation, ServerTimestampTransform, SetMutation, TransformMutation } from '../model/mutation';\nimport { FieldPath } from '../model/path';\nimport { assert, fail } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nimport { isPlainObject, valueDescription } from '../util/input_validation';\nimport { primitiveComparator } from '../util/misc';\nimport * as objUtils from '../util/obj';\nimport { SortedMap } from '../util/sorted_map';\nimport * as typeUtils from '../util/types';\nimport { Blob } from './blob';\nimport { FieldPath as ExternalFieldPath, fromDotSeparatedString } from './field_path';\nimport { DeleteFieldValueImpl, FieldValueImpl, ServerTimestampFieldValueImpl } from './field_value';\nimport { GeoPoint } from './geo_point';\nvar RESERVED_FIELD_REGEX = /^__.*__$/;\n/** The result of parsing document data (e.g. for a setData call). */\nvar ParsedSetData = /** @class */ (function () {\n    function ParsedSetData(data, fieldMask, fieldTransforms) {\n        this.data = data;\n        this.fieldMask = fieldMask;\n        this.fieldTransforms = fieldTransforms;\n    }\n    ParsedSetData.prototype.toMutations = function (key, precondition) {\n        var mutations = [];\n        if (this.fieldMask !== null) {\n            mutations.push(new PatchMutation(key, this.data, this.fieldMask, precondition));\n        }\n        else {\n            mutations.push(new SetMutation(key, this.data, precondition));\n        }\n        if (this.fieldTransforms.length > 0) {\n            mutations.push(new TransformMutation(key, this.fieldTransforms));\n        }\n        return mutations;\n    };\n    return ParsedSetData;\n}());\nexport { ParsedSetData };\n/** The result of parsing \"update\" data (i.e. for an updateData call). */\nvar ParsedUpdateData = /** @class */ (function () {\n    function ParsedUpdateData(data, fieldMask, fieldTransforms) {\n        this.data = data;\n        this.fieldMask = fieldMask;\n        this.fieldTransforms = fieldTransforms;\n    }\n    ParsedUpdateData.prototype.toMutations = function (key, precondition) {\n        var mutations = [\n            new PatchMutation(key, this.data, this.fieldMask, precondition)\n        ];\n        if (this.fieldTransforms.length > 0) {\n            mutations.push(new TransformMutation(key, this.fieldTransforms));\n        }\n        return mutations;\n    };\n    return ParsedUpdateData;\n}());\nexport { ParsedUpdateData };\n/*\n * Represents what type of API method provided the data being parsed; useful\n * for determining which error conditions apply during parsing and providing\n * better error messages.\n */\nvar UserDataSource;\n(function (UserDataSource) {\n    UserDataSource[UserDataSource[\"Set\"] = 0] = \"Set\";\n    UserDataSource[UserDataSource[\"Update\"] = 1] = \"Update\";\n    UserDataSource[UserDataSource[\"MergeSet\"] = 2] = \"MergeSet\";\n    UserDataSource[UserDataSource[\"QueryValue\"] = 3] = \"QueryValue\"; // from a where clause or cursor bound\n})(UserDataSource || (UserDataSource = {}));\nfunction isWrite(dataSource) {\n    switch (dataSource) {\n        case UserDataSource.Set: // fall through\n        case UserDataSource.MergeSet: // fall through\n        case UserDataSource.Update:\n            return true;\n        case UserDataSource.QueryValue:\n            return false;\n        default:\n            throw fail(\"Unexpected case for UserDataSource: \" + dataSource);\n    }\n}\n/** A \"context\" object passed around while parsing user data. */\nvar ParseContext = /** @class */ (function () {\n    /**\n     * Initializes a ParseContext with the given source and path.\n     *\n     * @param dataSource Indicates what kind of API method this data came from.\n     * @param methodName The name of the method the user called to create this\n     *     ParseContext.\n     * @param path A path within the object being parsed. This could be an empty\n     *     path (in which case the context represents the root of the data being\n     *     parsed), or a nonempty path (indicating the context represents a nested\n     *     location within the data).\n     * @param arrayElement Whether or not this context corresponds to an element\n     *     of an array.\n     * @param fieldTransforms A mutable list of field transforms encountered while\n     *     parsing the data.\n     * @param fieldMask A mutable list of field paths encountered while parsing\n     *     the data.\n     *\n     * TODO(b/34871131): We don't support array paths right now, so path can be\n     * null to indicate the context represents any location within an array (in\n     * which case certain features will not work and errors will be somewhat\n     * compromised).\n     */\n    function ParseContext(dataSource, methodName, path, arrayElement, fieldTransforms, fieldMask) {\n        this.dataSource = dataSource;\n        this.methodName = methodName;\n        this.path = path;\n        this.arrayElement = arrayElement;\n        // Minor hack: If fieldTransforms is undefined, we assume this is an\n        // external call and we need to validate the entire path.\n        if (fieldTransforms === undefined) {\n            this.validatePath();\n        }\n        this.arrayElement = arrayElement !== undefined ? arrayElement : false;\n        this.fieldTransforms = fieldTransforms || [];\n        this.fieldMask = fieldMask || [];\n    }\n    ParseContext.prototype.childContextForField = function (field) {\n        var childPath = this.path == null ? null : this.path.child(field);\n        var context = new ParseContext(this.dataSource, this.methodName, childPath, \n        /*arrayElement=*/ false, this.fieldTransforms, this.fieldMask);\n        context.validatePathSegment(field);\n        return context;\n    };\n    ParseContext.prototype.childContextForFieldPath = function (field) {\n        var childPath = this.path == null ? null : this.path.child(field);\n        var context = new ParseContext(this.dataSource, this.methodName, childPath, \n        /*arrayElement=*/ false, this.fieldTransforms, this.fieldMask);\n        context.validatePath();\n        return context;\n    };\n    ParseContext.prototype.childContextForArray = function (index) {\n        // TODO(b/34871131): We don't support array paths right now; so make path\n        // null.\n        return new ParseContext(this.dataSource, this.methodName, \n        /*path=*/ null, \n        /*arrayElement=*/ true, this.fieldTransforms, this.fieldMask);\n    };\n    ParseContext.prototype.createError = function (reason) {\n        var fieldDescription = this.path === null || this.path.isEmpty()\n            ? ''\n            : \" (found in field \" + this.path.toString() + \")\";\n        return new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + this.methodName + \"() called with invalid data. \" +\n            reason +\n            fieldDescription);\n    };\n    ParseContext.prototype.validatePath = function () {\n        // TODO(b/34871131): Remove null check once we have proper paths for fields\n        // within arrays.\n        if (this.path === null) {\n            return;\n        }\n        for (var i = 0; i < this.path.length; i++) {\n            this.validatePathSegment(this.path.get(i));\n        }\n    };\n    ParseContext.prototype.validatePathSegment = function (segment) {\n        if (isWrite(this.dataSource) && RESERVED_FIELD_REGEX.test(segment)) {\n            throw this.createError('Document fields cannot begin and end with __');\n        }\n    };\n    return ParseContext;\n}());\n/**\n * A placeholder object for DocumentReferences in this file, in order to\n * avoid a circular dependency. See the comments for `DataPreConverter` for\n * the full context.\n */\nvar DocumentKeyReference = /** @class */ (function () {\n    function DocumentKeyReference(databaseId, key) {\n        this.databaseId = databaseId;\n        this.key = key;\n    }\n    return DocumentKeyReference;\n}());\nexport { DocumentKeyReference };\n/**\n * Helper for parsing raw user input (provided via the API) into internal model\n * classes.\n */\nvar UserDataConverter = /** @class */ (function () {\n    function UserDataConverter(preConverter) {\n        this.preConverter = preConverter;\n    }\n    /** Parse document data from a non-merge set() call. */\n    UserDataConverter.prototype.parseSetData = function (methodName, input) {\n        var context = new ParseContext(UserDataSource.Set, methodName, FieldPath.EMPTY_PATH);\n        validatePlainObject('Data must be an object, but it was:', context, input);\n        var updateData = this.parseData(input, context);\n        return new ParsedSetData(updateData, \n        /* fieldMask= */ null, context.fieldTransforms);\n    };\n    /** Parse document data from a set() call with '{merge:true}'. */\n    UserDataConverter.prototype.parseMergeData = function (methodName, input) {\n        var context = new ParseContext(UserDataSource.MergeSet, methodName, FieldPath.EMPTY_PATH);\n        validatePlainObject('Data must be an object, but it was:', context, input);\n        var updateData = this.parseData(input, context);\n        var fieldMask = new FieldMask(context.fieldMask);\n        return new ParsedSetData(updateData, fieldMask, context.fieldTransforms);\n    };\n    /** Parse update data from an update() call. */\n    UserDataConverter.prototype.parseUpdateData = function (methodName, input) {\n        var _this = this;\n        var context = new ParseContext(UserDataSource.Update, methodName, FieldPath.EMPTY_PATH);\n        validatePlainObject('Data must be an object, but it was:', context, input);\n        var fieldMaskPaths = [];\n        var updateData = ObjectValue.EMPTY;\n        objUtils.forEach(input, function (key, value) {\n            var path = fieldPathFromDotSeparatedString(methodName, key);\n            var childContext = context.childContextForFieldPath(path);\n            value = _this.runPreConverter(value, childContext);\n            if (value instanceof DeleteFieldValueImpl) {\n                // Add it to the field mask, but don't add anything to updateData.\n                fieldMaskPaths.push(path);\n            }\n            else {\n                var parsedValue = _this.parseData(value, childContext);\n                if (parsedValue != null) {\n                    fieldMaskPaths.push(path);\n                    updateData = updateData.set(path, parsedValue);\n                }\n            }\n        });\n        var mask = new FieldMask(fieldMaskPaths);\n        return new ParsedUpdateData(updateData, mask, context.fieldTransforms);\n    };\n    /** Parse update data from a list of field/value arguments. */\n    UserDataConverter.prototype.parseUpdateVarargs = function (methodName, field, value, moreFieldsAndValues) {\n        var context = new ParseContext(UserDataSource.Update, methodName, FieldPath.EMPTY_PATH);\n        var keys = [fieldPathFromArgument(methodName, field)];\n        var values = [value];\n        if (moreFieldsAndValues.length % 2 !== 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + methodName + \"() needs to be called with an even number \" +\n                'of arguments that alternate between field names and values.');\n        }\n        for (var i = 0; i < moreFieldsAndValues.length; i += 2) {\n            keys.push(fieldPathFromArgument(methodName, moreFieldsAndValues[i]));\n            values.push(moreFieldsAndValues[i + 1]);\n        }\n        var fieldMaskPaths = [];\n        var updateData = ObjectValue.EMPTY;\n        for (var i = 0; i < keys.length; ++i) {\n            var path = keys[i];\n            var childContext = context.childContextForFieldPath(path);\n            var value_1 = this.runPreConverter(values[i], childContext);\n            if (value_1 instanceof DeleteFieldValueImpl) {\n                // Add it to the field mask, but don't add anything to updateData.\n                fieldMaskPaths.push(path);\n            }\n            else {\n                var parsedValue = this.parseData(value_1, childContext);\n                if (parsedValue != null) {\n                    fieldMaskPaths.push(path);\n                    updateData = updateData.set(path, parsedValue);\n                }\n            }\n        }\n        var mask = new FieldMask(fieldMaskPaths);\n        return new ParsedUpdateData(updateData, mask, context.fieldTransforms);\n    };\n    /**\n     * Parse a \"query value\" (e.g. value in a where filter or a value in a cursor\n     * bound).\n     */\n    UserDataConverter.prototype.parseQueryValue = function (methodName, input) {\n        var context = new ParseContext(UserDataSource.QueryValue, methodName, FieldPath.EMPTY_PATH);\n        var parsed = this.parseData(input, context);\n        assert(parsed != null, 'Parsed data should not be null.');\n        assert(context.fieldTransforms.length === 0, 'Field transforms should have been disallowed.');\n        return parsed;\n    };\n    /** Sends data through this.preConverter, handling any thrown errors. */\n    UserDataConverter.prototype.runPreConverter = function (input, context) {\n        try {\n            return this.preConverter(input);\n        }\n        catch (e) {\n            var message = errorMessage(e);\n            throw context.createError(message);\n        }\n    };\n    /**\n     * Internal helper for parsing user data.\n     *\n     * @param input Data to be parsed.\n     * @param context A context object representing the current path being parsed,\n     * the source of the data being parsed, etc.\n     * @return The parsed value, or null if the value was a FieldValue sentinel\n     * that should not be included in the resulting parsed data.\n     */\n    UserDataConverter.prototype.parseData = function (input, context) {\n        input = this.runPreConverter(input, context);\n        if (input instanceof Array) {\n            // TODO(b/34871131): Include the path containing the array in the error\n            // message.\n            if (context.arrayElement) {\n                throw context.createError('Nested arrays are not supported');\n            }\n            // If context.path is null we are already inside an array and we don't\n            // support field mask paths more granular than the top-level array.\n            if (context.path) {\n                context.fieldMask.push(context.path);\n            }\n            return this.parseArray(input, context);\n        }\n        else if (looksLikeJsonObject(input)) {\n            validatePlainObject('Unsupported field value:', context, input);\n            return this.parseObject(input, context);\n        }\n        else {\n            // If context.path is null, we are inside an array and we should have\n            // already added the root of the array to the field mask.\n            if (context.path) {\n                context.fieldMask.push(context.path);\n            }\n            return this.parseScalarValue(input, context);\n        }\n    };\n    UserDataConverter.prototype.parseArray = function (array, context) {\n        var result = [];\n        var entryIndex = 0;\n        for (var _i = 0, array_1 = array; _i < array_1.length; _i++) {\n            var entry = array_1[_i];\n            var parsedEntry = this.parseData(entry, context.childContextForArray(entryIndex));\n            if (parsedEntry == null) {\n                // Just include nulls in the array for fields being replaced with a\n                // sentinel.\n                parsedEntry = NullValue.INSTANCE;\n            }\n            result.push(parsedEntry);\n            entryIndex++;\n        }\n        return new ArrayValue(result);\n    };\n    UserDataConverter.prototype.parseObject = function (obj, context) {\n        var _this = this;\n        var result = new SortedMap(primitiveComparator);\n        objUtils.forEach(obj, function (key, val) {\n            var parsedValue = _this.parseData(val, context.childContextForField(key));\n            if (parsedValue != null) {\n                result = result.insert(key, parsedValue);\n            }\n        });\n        return new ObjectValue(result);\n    };\n    /**\n     * Helper to parse a scalar value (i.e. not an Object or Array)\n     *\n     * @return The parsed value, or null if the value was a FieldValue sentinel\n     * that should not be included in the resulting parsed data.\n     */\n    UserDataConverter.prototype.parseScalarValue = function (value, context) {\n        if (value === null) {\n            return NullValue.INSTANCE;\n        }\n        else if (typeof value === 'number') {\n            if (typeUtils.isSafeInteger(value)) {\n                return new IntegerValue(value);\n            }\n            else {\n                return new DoubleValue(value);\n            }\n        }\n        else if (typeof value === 'boolean') {\n            return BooleanValue.of(value);\n        }\n        else if (typeof value === 'string') {\n            return new StringValue(value);\n        }\n        else if (value instanceof Date) {\n            return new TimestampValue(Timestamp.fromDate(value));\n        }\n        else if (value instanceof GeoPoint) {\n            return new GeoPointValue(value);\n        }\n        else if (value instanceof Blob) {\n            return new BlobValue(value);\n        }\n        else if (value instanceof DocumentKeyReference) {\n            return new RefValue(value.databaseId, value.key);\n        }\n        else if (value instanceof FieldValueImpl) {\n            if (value instanceof DeleteFieldValueImpl) {\n                if (context.dataSource === UserDataSource.MergeSet) {\n                    return null;\n                }\n                else if (context.dataSource === UserDataSource.Update) {\n                    assert(context.path == null || context.path.length > 0, 'FieldValue.delete() at the top level should have already' +\n                        ' been handled.');\n                    throw context.createError('FieldValue.delete() can only appear at the top level ' +\n                        'of your update data');\n                }\n                else {\n                    // We shouldn't encounter delete sentinels for queries or non-merge set() calls.\n                    throw context.createError('FieldValue.delete() can only be used with update() and set() with {merge:true}');\n                }\n            }\n            else if (value instanceof ServerTimestampFieldValueImpl) {\n                if (!isWrite(context.dataSource)) {\n                    throw context.createError('FieldValue.serverTimestamp() can only be used with set()' +\n                        ' and update()');\n                }\n                if (context.path === null) {\n                    throw context.createError('FieldValue.serverTimestamp() is not currently' +\n                        ' supported inside arrays');\n                }\n                context.fieldTransforms.push(new FieldTransform(context.path, ServerTimestampTransform.instance));\n                // Return null so this value is omitted from the parsed result.\n                return null;\n            }\n            else {\n                return fail('Unknown FieldValue type: ' + value);\n            }\n        }\n        else {\n            throw context.createError(\"Unsupported field value: \" + valueDescription(value));\n        }\n    };\n    return UserDataConverter;\n}());\nexport { UserDataConverter };\n/**\n * Checks whether an object looks like a JSON object that should be converted\n * into a struct. Normal class/prototype instances are considered to look like\n * JSON objects since they should be converted to a struct value. Arrays, Dates,\n * GeoPoints, etc. are not considered to look like JSON objects since they map\n * to specific FieldValue types other than ObjectValue.\n */\nfunction looksLikeJsonObject(input) {\n    return (typeof input === 'object' &&\n        input !== null &&\n        !(input instanceof Array) &&\n        !(input instanceof Date) &&\n        !(input instanceof GeoPoint) &&\n        !(input instanceof Blob) &&\n        !(input instanceof DocumentKeyReference) &&\n        !(input instanceof FieldValueImpl));\n}\nfunction validatePlainObject(message, context, input) {\n    if (!looksLikeJsonObject(input) || !isPlainObject(input)) {\n        var description = valueDescription(input);\n        if (description === 'an object') {\n            // Massage the error if it was an object.\n            throw context.createError(message + ' a custom object');\n        }\n        else {\n            throw context.createError(message + ' ' + description);\n        }\n    }\n}\n/**\n * Helper that calls fromDotSeparatedString() but wraps any error thrown.\n */\nexport function fieldPathFromArgument(methodName, path) {\n    if (path instanceof ExternalFieldPath) {\n        return path._internalPath;\n    }\n    else if (typeof path === 'string') {\n        return fieldPathFromDotSeparatedString(methodName, path);\n    }\n    else {\n        var message = 'Field path arguments must be of type string or FieldPath.';\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + methodName + \"() called with invalid data. \" + message);\n    }\n}\n/**\n * Wraps fromDotSeparatedString with an error message about the method that\n * was thrown.\n * @param methodName The publicly visible method name\n * @param path The dot-separated string form of a field path which will be split\n * on dots.\n */\nfunction fieldPathFromDotSeparatedString(methodName, path) {\n    try {\n        return fromDotSeparatedString(path)._internalPath;\n    }\n    catch (e) {\n        var message = errorMessage(e);\n        throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function \" + methodName + \"() called with invalid data. \" + message);\n    }\n}\n/**\n * Extracts the message from a caught exception, which should be an Error object\n * though JS doesn't guarantee that.\n */\nfunction errorMessage(error) {\n    return error instanceof Error ? error.message : error.toString();\n}\n\n//# sourceMappingURL=user_data_converter.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/user_data_converter.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { FieldPath as ExternalFieldPath } from './field_path';\nimport { DatabaseId, DatabaseInfo } from '../core/database_info';\nimport { FirestoreClient } from '../core/firestore_client';\nimport { Bound, Direction, fieldFilter, OrderBy, Query as InternalQuery, RelationFilter, RelationOp } from '../core/query';\nimport { ChangeType } from '../core/view_snapshot';\nimport { NoDocument } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { ArrayValue, FieldValueOptions, ObjectValue, RefValue } from '../model/field_value';\nimport { DeleteMutation, Precondition } from '../model/mutation';\nimport { ResourcePath } from '../model/path';\nimport { PlatformSupport } from '../platform/platform';\nimport { makeConstructorPrivate } from '../util/api';\nimport { assert, fail } from '../util/assert';\nimport { AsyncObserver } from '../util/async_observer';\nimport { AsyncQueue } from '../util/async_queue';\nimport { Code, FirestoreError } from '../util/error';\nimport { invalidClassError, validateArgType, validateAtLeastNumberOfArgs, validateBetweenNumberOfArgs, validateDefined, validateExactNumberOfArgs, validateNamedOptionalType, validateNamedOptionalPropertyEquals, validateNamedType, validateOptionalArgType, validateOptionNames, valueDescription } from '../util/input_validation';\nimport * as log from '../util/log';\nimport { LogLevel } from '../util/log';\nimport { AutoId } from '../util/misc';\nimport * as objUtils from '../util/obj';\nimport { EmptyCredentialsProvider, FirebaseCredentialsProvider, makeCredentialsProvider } from './credentials';\nimport { isPartialObserver } from './observer';\nimport { DocumentKeyReference, fieldPathFromArgument, UserDataConverter } from './user_data_converter';\n// The objects that are a part of this API are exposed to third-parties as\n// compiled javascript so we want to flag our private members with a leading\n// underscore to discourage their use.\n// tslint:disable:strip-private-property-underscore\nvar DEFAULT_HOST = 'firestore.googleapis.com';\nvar DEFAULT_SSL = true;\n/**\n * A concrete type describing all the values that can be applied via a\n * user-supplied firestore.Settings object. This is a separate type so that\n * defaults can be supplied and the value can be checked for equality.\n */\nvar FirestoreSettings = /** @class */ (function () {\n    function FirestoreSettings(settings) {\n        if (settings.host === undefined) {\n            if (settings.ssl !== undefined) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Can't provide ssl option if host option is not set\");\n            }\n            this.host = DEFAULT_HOST;\n            this.ssl = DEFAULT_SSL;\n        }\n        else {\n            validateNamedType('settings', 'string', 'host', settings.host);\n            this.host = settings.host;\n            validateNamedOptionalType('settings', 'boolean', 'ssl', settings.ssl);\n            this.ssl = objUtils.defaulted(settings.ssl, DEFAULT_SSL);\n        }\n        validateOptionNames('settings', settings, ['host', 'ssl', 'credentials']);\n        validateNamedOptionalType('settings', 'object', 'credentials', settings.credentials);\n        this.credentials = settings.credentials;\n    }\n    FirestoreSettings.prototype.isEqual = function (other) {\n        return (this.host === other.host &&\n            this.ssl === other.ssl &&\n            this.credentials === other.credentials);\n    };\n    return FirestoreSettings;\n}());\nvar FirestoreConfig = /** @class */ (function () {\n    function FirestoreConfig() {\n    }\n    return FirestoreConfig;\n}());\n/**\n * The root reference to the database.\n */\nvar Firestore = /** @class */ (function () {\n    function Firestore(databaseIdOrApp) {\n        var _this = this;\n        // Public for use in tests.\n        // TODO(mikelehen): Use modularized initialization instead.\n        this._queue = new AsyncQueue();\n        this.INTERNAL = {\n            delete: function () {\n                if (_this._firestoreClient) {\n                    return _this._firestoreClient.shutdown();\n                }\n                else {\n                    return Promise.resolve();\n                }\n            }\n        };\n        var config = new FirestoreConfig();\n        if (typeof databaseIdOrApp.options === 'object') {\n            // This is very likely a Firebase app object\n            // TODO(b/34177605): Can we somehow use instanceof?\n            var app = databaseIdOrApp;\n            config.firebaseApp = app;\n            config.databaseId = Firestore.databaseIdFromApp(app);\n            config.persistenceKey = config.firebaseApp.name;\n            config.credentials = new FirebaseCredentialsProvider(app);\n        }\n        else {\n            var external_1 = databaseIdOrApp;\n            if (!external_1.projectId) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide projectId');\n            }\n            config.databaseId = new DatabaseId(external_1.projectId, external_1.database);\n            // Use a default persistenceKey that lines up with FirebaseApp.\n            config.persistenceKey = '[DEFAULT]';\n            config.credentials = new EmptyCredentialsProvider();\n        }\n        config.settings = new FirestoreSettings({});\n        this._config = config;\n        this._databaseId = config.databaseId;\n    }\n    Firestore.prototype.settings = function (settingsLiteral) {\n        validateExactNumberOfArgs('Firestore.settings', arguments, 1);\n        validateArgType('Firestore.settings', 'object', 1, settingsLiteral);\n        if (objUtils.contains(settingsLiteral, 'persistence')) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, '\"persistence\" is now specified with a separate call to ' +\n                'firestore.enablePersistence().');\n        }\n        var newSettings = new FirestoreSettings(settingsLiteral);\n        if (this._firestoreClient && !this._config.settings.isEqual(newSettings)) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'Firestore has already been started and its settings can no longer ' +\n                'be changed. You can only call settings() before calling any other ' +\n                'methods on a Firestore object.');\n        }\n        this._config.settings = newSettings;\n        if (newSettings.credentials !== undefined) {\n            this._config.credentials = makeCredentialsProvider(newSettings.credentials);\n        }\n    };\n    Firestore.prototype.enableNetwork = function () {\n        this.ensureClientConfigured();\n        return this._firestoreClient.enableNetwork();\n    };\n    Firestore.prototype.disableNetwork = function () {\n        this.ensureClientConfigured();\n        return this._firestoreClient.disableNetwork();\n    };\n    Firestore.prototype.enablePersistence = function () {\n        if (this._firestoreClient) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'Firestore has already been started and persistence can no longer ' +\n                'be enabled. You can only call enablePersistence() before calling ' +\n                'any other methods on a Firestore object.');\n        }\n        return this.configureClient(/* persistence= */ true);\n    };\n    Firestore.prototype.ensureClientConfigured = function () {\n        if (!this._firestoreClient) {\n            this.configureClient(/* persistence= */ false);\n        }\n        return this._firestoreClient;\n    };\n    Firestore.prototype.configureClient = function (persistence) {\n        var _this = this;\n        assert(!!this._config.settings.host, 'FirestoreSettings.host cannot be falsey');\n        assert(!this._firestoreClient, 'configureClient() called multiple times');\n        var databaseInfo = new DatabaseInfo(this._config.databaseId, this._config.persistenceKey, this._config.settings.host, this._config.settings.ssl);\n        var preConverter = function (value) {\n            if (value instanceof DocumentReference) {\n                var thisDb = _this._config.databaseId;\n                var otherDb = value.firestore._config.databaseId;\n                if (!otherDb.isEqual(thisDb)) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Document reference is for database ' +\n                        (otherDb.projectId + \"/\" + otherDb.database + \" but should be \") +\n                        (\"for database \" + thisDb.projectId + \"/\" + thisDb.database));\n                }\n                return new DocumentKeyReference(_this._config.databaseId, value._key);\n            }\n            else {\n                return value;\n            }\n        };\n        this._dataConverter = new UserDataConverter(preConverter);\n        this._firestoreClient = new FirestoreClient(PlatformSupport.getPlatform(), databaseInfo, this._config.credentials, this._queue);\n        return this._firestoreClient.start(persistence);\n    };\n    Firestore.databaseIdFromApp = function (app) {\n        var options = app.options;\n        if (!objUtils.contains(options, 'projectId')) {\n            // TODO(b/62673263): We can safely remove the special handling of\n            // 'firestoreId' once alpha testers have upgraded.\n            if (objUtils.contains(options, 'firestoreId')) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, '\"firestoreId\" is now specified as \"projectId\" in ' +\n                    'firebase.initializeApp.');\n            }\n            throw new FirestoreError(Code.INVALID_ARGUMENT, '\"projectId\" not provided in firebase.initializeApp.');\n        }\n        if (objUtils.contains(options, 'firestoreOptions')) {\n            // TODO(b/62673263): We can safely remove the special handling of\n            // 'firestoreOptions' once alpha testers have upgraded.\n            throw new FirestoreError(Code.INVALID_ARGUMENT, '\"firestoreOptions\" values are now specified with ' +\n                'Firestore.settings()');\n        }\n        var projectId = options['projectId'];\n        if (!projectId || typeof projectId !== 'string') {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'projectId must be a string in FirebaseApp.options');\n        }\n        return new DatabaseId(projectId);\n    };\n    Object.defineProperty(Firestore.prototype, \"app\", {\n        get: function () {\n            if (!this._config.firebaseApp) {\n                throw new FirestoreError(Code.FAILED_PRECONDITION, \"Firestore was not initialized using the Firebase SDK. 'app' is \" +\n                    'not available');\n            }\n            return this._config.firebaseApp;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Firestore.prototype.collection = function (pathString) {\n        validateExactNumberOfArgs('Firestore.collection', arguments, 1);\n        validateArgType('Firestore.collection', 'string', 1, pathString);\n        if (!pathString) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide a non-empty collection path to collection()');\n        }\n        this.ensureClientConfigured();\n        return new CollectionReference(ResourcePath.fromString(pathString), this);\n    };\n    Firestore.prototype.doc = function (pathString) {\n        validateExactNumberOfArgs('Firestore.doc', arguments, 1);\n        validateArgType('Firestore.doc', 'string', 1, pathString);\n        if (!pathString) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide a non-empty document path to doc()');\n        }\n        this.ensureClientConfigured();\n        return DocumentReference.forPath(ResourcePath.fromString(pathString), this);\n    };\n    Firestore.prototype.runTransaction = function (updateFunction) {\n        var _this = this;\n        validateExactNumberOfArgs('Firestore.runTransaction', arguments, 1);\n        validateArgType('Firestore.runTransaction', 'function', 1, updateFunction);\n        return this.ensureClientConfigured().transaction(function (transaction) {\n            return updateFunction(new Transaction(_this, transaction));\n        });\n    };\n    Firestore.prototype.batch = function () {\n        this.ensureClientConfigured();\n        return new WriteBatch(this);\n    };\n    Object.defineProperty(Firestore, \"logLevel\", {\n        get: function () {\n            switch (log.getLogLevel()) {\n                case LogLevel.DEBUG:\n                    return 'debug';\n                case LogLevel.ERROR:\n                    return 'error';\n                case LogLevel.SILENT:\n                    return 'silent';\n                default:\n                    return fail('Unknown log level: ' + log.getLogLevel());\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Firestore.setLogLevel = function (level) {\n        validateExactNumberOfArgs('Firestore.setLogLevel', arguments, 1);\n        validateArgType('Firestore.setLogLevel', 'string', 1, level);\n        switch (level) {\n            case 'debug':\n                log.setLogLevel(log.LogLevel.DEBUG);\n                break;\n            case 'error':\n                log.setLogLevel(log.LogLevel.ERROR);\n                break;\n            case 'silent':\n                log.setLogLevel(log.LogLevel.SILENT);\n                break;\n            default:\n                throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid log level: ' + level);\n        }\n    };\n    return Firestore;\n}());\nexport { Firestore };\n/**\n * A reference to a transaction.\n */\nvar Transaction = /** @class */ (function () {\n    function Transaction(_firestore, _transaction) {\n        this._firestore = _firestore;\n        this._transaction = _transaction;\n    }\n    Transaction.prototype.get = function (documentRef) {\n        var _this = this;\n        validateExactNumberOfArgs('Transaction.get', arguments, 1);\n        var ref = validateReference('Transaction.get', documentRef, this._firestore);\n        return this._transaction\n            .lookup([ref._key])\n            .then(function (docs) {\n            if (!docs || docs.length !== 1) {\n                return fail('Mismatch in docs returned from document lookup.');\n            }\n            var doc = docs[0];\n            if (doc instanceof NoDocument) {\n                return new DocumentSnapshot(_this._firestore, ref._key, null, false);\n            }\n            return new DocumentSnapshot(_this._firestore, ref._key, doc, false);\n        });\n    };\n    Transaction.prototype.set = function (documentRef, value, options) {\n        validateBetweenNumberOfArgs('Transaction.set', arguments, 2, 3);\n        var ref = validateReference('Transaction.set', documentRef, this._firestore);\n        options = validateSetOptions('Transaction.set', options);\n        var parsed = options.merge\n            ? this._firestore._dataConverter.parseMergeData('Transaction.set', value)\n            : this._firestore._dataConverter.parseSetData('Transaction.set', value);\n        this._transaction.set(ref._key, parsed);\n        return this;\n    };\n    Transaction.prototype.update = function (documentRef, fieldOrUpdateData, value) {\n        var moreFieldsAndValues = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            moreFieldsAndValues[_i - 3] = arguments[_i];\n        }\n        var ref;\n        var parsed;\n        if (typeof fieldOrUpdateData === 'string' ||\n            fieldOrUpdateData instanceof ExternalFieldPath) {\n            validateAtLeastNumberOfArgs('Transaction.update', arguments, 3);\n            ref = validateReference('Transaction.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateVarargs('Transaction.update', fieldOrUpdateData, value, moreFieldsAndValues);\n        }\n        else {\n            validateExactNumberOfArgs('Transaction.update', arguments, 2);\n            ref = validateReference('Transaction.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateData('Transaction.update', fieldOrUpdateData);\n        }\n        this._transaction.update(ref._key, parsed);\n        return this;\n    };\n    Transaction.prototype.delete = function (documentRef) {\n        validateExactNumberOfArgs('Transaction.delete', arguments, 1);\n        var ref = validateReference('Transaction.delete', documentRef, this._firestore);\n        this._transaction.delete(ref._key);\n        return this;\n    };\n    return Transaction;\n}());\nexport { Transaction };\nvar WriteBatch = /** @class */ (function () {\n    function WriteBatch(_firestore) {\n        this._firestore = _firestore;\n        this._mutations = [];\n        this._committed = false;\n    }\n    WriteBatch.prototype.set = function (documentRef, value, options) {\n        validateBetweenNumberOfArgs('WriteBatch.set', arguments, 2, 3);\n        this.verifyNotCommitted();\n        var ref = validateReference('WriteBatch.set', documentRef, this._firestore);\n        options = validateSetOptions('WriteBatch.set', options);\n        var parsed = options.merge\n            ? this._firestore._dataConverter.parseMergeData('WriteBatch.set', value)\n            : this._firestore._dataConverter.parseSetData('WriteBatch.set', value);\n        this._mutations = this._mutations.concat(parsed.toMutations(ref._key, Precondition.NONE));\n        return this;\n    };\n    WriteBatch.prototype.update = function (documentRef, fieldOrUpdateData, value) {\n        var moreFieldsAndValues = [];\n        for (var _i = 3; _i < arguments.length; _i++) {\n            moreFieldsAndValues[_i - 3] = arguments[_i];\n        }\n        this.verifyNotCommitted();\n        var ref;\n        var parsed;\n        if (typeof fieldOrUpdateData === 'string' ||\n            fieldOrUpdateData instanceof ExternalFieldPath) {\n            validateAtLeastNumberOfArgs('WriteBatch.update', arguments, 3);\n            ref = validateReference('WriteBatch.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateVarargs('WriteBatch.update', fieldOrUpdateData, value, moreFieldsAndValues);\n        }\n        else {\n            validateExactNumberOfArgs('WriteBatch.update', arguments, 2);\n            ref = validateReference('WriteBatch.update', documentRef, this._firestore);\n            parsed = this._firestore._dataConverter.parseUpdateData('WriteBatch.update', fieldOrUpdateData);\n        }\n        this._mutations = this._mutations.concat(parsed.toMutations(ref._key, Precondition.exists(true)));\n        return this;\n    };\n    WriteBatch.prototype.delete = function (documentRef) {\n        validateExactNumberOfArgs('WriteBatch.delete', arguments, 1);\n        this.verifyNotCommitted();\n        var ref = validateReference('WriteBatch.delete', documentRef, this._firestore);\n        this._mutations = this._mutations.concat(new DeleteMutation(ref._key, Precondition.NONE));\n        return this;\n    };\n    WriteBatch.prototype.commit = function () {\n        this.verifyNotCommitted();\n        this._committed = true;\n        if (this._mutations.length > 0) {\n            return this._firestore.ensureClientConfigured().write(this._mutations);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    WriteBatch.prototype.verifyNotCommitted = function () {\n        if (this._committed) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'A write batch can no longer be used after commit() ' +\n                'has been called.');\n        }\n    };\n    return WriteBatch;\n}());\nexport { WriteBatch };\n/**\n * A reference to a particular document in a collection in the database.\n */\nvar DocumentReference = /** @class */ (function () {\n    function DocumentReference(_key, firestore) {\n        this._key = _key;\n        this.firestore = firestore;\n        this._firestoreClient = this.firestore.ensureClientConfigured();\n    }\n    DocumentReference.forPath = function (path, firestore) {\n        if (path.length % 2 !== 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid document reference. Document ' +\n                'references must have an even number of segments, but ' +\n                (path.canonicalString() + \" has \" + path.length));\n        }\n        return new DocumentReference(new DocumentKey(path), firestore);\n    };\n    Object.defineProperty(DocumentReference.prototype, \"id\", {\n        get: function () {\n            return this._key.path.lastSegment();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentReference.prototype, \"parent\", {\n        get: function () {\n            return new CollectionReference(this._key.path.popLast(), this.firestore);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentReference.prototype, \"path\", {\n        get: function () {\n            return this._key.path.canonicalString();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DocumentReference.prototype.collection = function (pathString) {\n        validateExactNumberOfArgs('DocumentReference.collection', arguments, 1);\n        validateArgType('DocumentReference.collection', 'string', 1, pathString);\n        if (!pathString) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Must provide a non-empty collection name to collection()');\n        }\n        var path = ResourcePath.fromString(pathString);\n        return new CollectionReference(this._key.path.child(path), this.firestore);\n    };\n    DocumentReference.prototype.isEqual = function (other) {\n        if (!(other instanceof DocumentReference)) {\n            throw invalidClassError('isEqual', 'DocumentReference', 1, other);\n        }\n        return this.firestore === other.firestore && this._key.isEqual(other._key);\n    };\n    DocumentReference.prototype.set = function (value, options) {\n        validateBetweenNumberOfArgs('DocumentReference.set', arguments, 1, 2);\n        options = validateSetOptions('DocumentReference.set', options);\n        var parsed = options.merge\n            ? this.firestore._dataConverter.parseMergeData('DocumentReference.set', value)\n            : this.firestore._dataConverter.parseSetData('DocumentReference.set', value);\n        return this._firestoreClient.write(parsed.toMutations(this._key, Precondition.NONE));\n    };\n    DocumentReference.prototype.update = function (fieldOrUpdateData, value) {\n        var moreFieldsAndValues = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            moreFieldsAndValues[_i - 2] = arguments[_i];\n        }\n        var parsed;\n        if (typeof fieldOrUpdateData === 'string' ||\n            fieldOrUpdateData instanceof ExternalFieldPath) {\n            validateAtLeastNumberOfArgs('DocumentReference.update', arguments, 2);\n            parsed = this.firestore._dataConverter.parseUpdateVarargs('DocumentReference.update', fieldOrUpdateData, value, moreFieldsAndValues);\n        }\n        else {\n            validateExactNumberOfArgs('DocumentReference.update', arguments, 1);\n            parsed = this.firestore._dataConverter.parseUpdateData('DocumentReference.update', fieldOrUpdateData);\n        }\n        return this._firestoreClient.write(parsed.toMutations(this._key, Precondition.exists(true)));\n    };\n    DocumentReference.prototype.delete = function () {\n        validateExactNumberOfArgs('DocumentReference.delete', arguments, 0);\n        return this._firestoreClient.write([\n            new DeleteMutation(this._key, Precondition.NONE)\n        ]);\n    };\n    DocumentReference.prototype.onSnapshot = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        validateBetweenNumberOfArgs('DocumentReference.onSnapshot', arguments, 1, 4);\n        var options = {\n            includeMetadataChanges: false\n        };\n        var observer;\n        var currArg = 0;\n        if (typeof args[currArg] === 'object' &&\n            !isPartialObserver(args[currArg])) {\n            options = args[currArg];\n            validateOptionNames('DocumentReference.onSnapshot', options, [\n                'includeMetadataChanges'\n            ]);\n            validateNamedOptionalType('DocumentReference.onSnapshot', 'boolean', 'includeMetadataChanges', options.includeMetadataChanges);\n            currArg++;\n        }\n        var internalOptions = {\n            includeDocumentMetadataChanges: options.includeMetadataChanges,\n            includeQueryMetadataChanges: options.includeMetadataChanges\n        };\n        if (isPartialObserver(args[currArg])) {\n            observer = args[currArg];\n        }\n        else {\n            validateArgType('DocumentReference.onSnapshot', 'function', currArg, args[currArg]);\n            validateOptionalArgType('DocumentReference.onSnapshot', 'function', currArg + 1, args[currArg + 1]);\n            validateOptionalArgType('DocumentReference.onSnapshot', 'function', currArg + 2, args[currArg + 2]);\n            observer = {\n                next: args[currArg],\n                error: args[currArg + 1],\n                complete: args[currArg + 2]\n            };\n        }\n        return this.onSnapshotInternal(internalOptions, observer);\n    };\n    DocumentReference.prototype.onSnapshotInternal = function (options, observer) {\n        var _this = this;\n        var errHandler = function (err) {\n            console.error('Uncaught Error in onSnapshot:', err);\n        };\n        if (observer.error) {\n            errHandler = observer.error.bind(observer);\n        }\n        var asyncObserver = new AsyncObserver({\n            next: function (snapshot) {\n                if (observer.next) {\n                    assert(snapshot.docs.size <= 1, 'Too many documents returned on a document query');\n                    var doc = snapshot.docs.get(_this._key);\n                    observer.next(new DocumentSnapshot(_this.firestore, _this._key, doc, snapshot.fromCache));\n                }\n            },\n            error: errHandler\n        });\n        var internalListener = this._firestoreClient.listen(InternalQuery.atPath(this._key.path), asyncObserver, options);\n        return function () {\n            asyncObserver.mute();\n            _this._firestoreClient.unlisten(internalListener);\n        };\n    };\n    DocumentReference.prototype.get = function () {\n        var _this = this;\n        validateExactNumberOfArgs('DocumentReference.get', arguments, 0);\n        return new Promise(function (resolve, reject) {\n            var unlisten = _this.onSnapshotInternal({\n                includeQueryMetadataChanges: true,\n                includeDocumentMetadataChanges: true,\n                waitForSyncWhenOnline: true\n            }, {\n                next: function (snap) {\n                    // Remove query first before passing event to user to avoid\n                    // user actions affecting the now stale query.\n                    unlisten();\n                    if (!snap.exists && snap.metadata.fromCache) {\n                        // TODO(dimond): If we're online and the document doesn't\n                        // exist then we resolve with a doc.exists set to false. If\n                        // we're offline however, we reject the Promise in this\n                        // case. Two options: 1) Cache the negative response from\n                        // the server so we can deliver that even when you're\n                        // offline 2) Actually reject the Promise in the online case\n                        // if the document doesn't exist.\n                        reject(new FirestoreError(Code.ABORTED, 'Failed to get document because the client is ' + 'offline.'));\n                    }\n                    else {\n                        resolve(snap);\n                    }\n                },\n                error: reject\n            });\n        });\n    };\n    return DocumentReference;\n}());\nexport { DocumentReference };\nvar SnapshotMetadata = /** @class */ (function () {\n    function SnapshotMetadata(hasPendingWrites, fromCache) {\n        this.hasPendingWrites = hasPendingWrites;\n        this.fromCache = fromCache;\n    }\n    SnapshotMetadata.prototype.isEqual = function (other) {\n        return (this.hasPendingWrites === other.hasPendingWrites &&\n            this.fromCache === other.fromCache);\n    };\n    return SnapshotMetadata;\n}());\nvar DocumentSnapshot = /** @class */ (function () {\n    function DocumentSnapshot(_firestore, _key, _document, _fromCache) {\n        this._firestore = _firestore;\n        this._key = _key;\n        this._document = _document;\n        this._fromCache = _fromCache;\n    }\n    DocumentSnapshot.prototype.data = function (options) {\n        validateBetweenNumberOfArgs('DocumentSnapshot.data', arguments, 0, 1);\n        options = validateSnapshotOptions('DocumentSnapshot.data', options);\n        return !this._document\n            ? undefined\n            : this.convertObject(this._document.data, FieldValueOptions.fromSnapshotOptions(options));\n    };\n    DocumentSnapshot.prototype.get = function (fieldPath, options) {\n        validateBetweenNumberOfArgs('DocumentSnapshot.get', arguments, 1, 2);\n        options = validateSnapshotOptions('DocumentSnapshot.get', options);\n        if (this._document) {\n            var value = this._document.data.field(fieldPathFromArgument('DocumentSnapshot.get', fieldPath));\n            if (value !== undefined) {\n                return this.convertValue(value, FieldValueOptions.fromSnapshotOptions(options));\n            }\n        }\n        return undefined;\n    };\n    Object.defineProperty(DocumentSnapshot.prototype, \"id\", {\n        get: function () {\n            return this._key.path.lastSegment();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentSnapshot.prototype, \"ref\", {\n        get: function () {\n            return new DocumentReference(this._key, this._firestore);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentSnapshot.prototype, \"exists\", {\n        get: function () {\n            return this._document !== null;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(DocumentSnapshot.prototype, \"metadata\", {\n        get: function () {\n            return new SnapshotMetadata(this._document !== null && this._document.hasLocalMutations, this._fromCache);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DocumentSnapshot.prototype.isEqual = function (other) {\n        if (!(other instanceof DocumentSnapshot)) {\n            throw invalidClassError('isEqual', 'DocumentSnapshot', 1, other);\n        }\n        return (this._firestore === other._firestore &&\n            this._fromCache === other._fromCache &&\n            this._key.isEqual(other._key) &&\n            (this._document === null\n                ? other._document === null\n                : this._document.isEqual(other._document)));\n    };\n    DocumentSnapshot.prototype.convertObject = function (data, options) {\n        var _this = this;\n        var result = {};\n        data.forEach(function (key, value) {\n            result[key] = _this.convertValue(value, options);\n        });\n        return result;\n    };\n    DocumentSnapshot.prototype.convertValue = function (value, options) {\n        if (value instanceof ObjectValue) {\n            return this.convertObject(value, options);\n        }\n        else if (value instanceof ArrayValue) {\n            return this.convertArray(value, options);\n        }\n        else if (value instanceof RefValue) {\n            var key = value.value(options);\n            var database = this._firestore.ensureClientConfigured().databaseId();\n            if (!value.databaseId.isEqual(database)) {\n                // TODO(b/64130202): Somehow support foreign references.\n                log.error(\"Document \" + this._key.path + \" contains a document \" +\n                    \"reference within a different database (\" +\n                    (value.databaseId.projectId + \"/\" + value.databaseId.database + \") which is not \") +\n                    \"supported. It will be treated as a reference in the current \" +\n                    (\"database (\" + database.projectId + \"/\" + database.database + \") \") +\n                    \"instead.\");\n            }\n            return new DocumentReference(key, this._firestore);\n        }\n        else {\n            return value.value(options);\n        }\n    };\n    DocumentSnapshot.prototype.convertArray = function (data, options) {\n        var _this = this;\n        return data.internalValue.map(function (value) {\n            return _this.convertValue(value, options);\n        });\n    };\n    return DocumentSnapshot;\n}());\nexport { DocumentSnapshot };\nvar QueryDocumentSnapshot = /** @class */ (function (_super) {\n    __extends(QueryDocumentSnapshot, _super);\n    function QueryDocumentSnapshot(firestore, key, document, fromCache) {\n        return _super.call(this, firestore, key, document, fromCache) || this;\n    }\n    QueryDocumentSnapshot.prototype.data = function (options) {\n        var data = _super.prototype.data.call(this, options);\n        assert(typeof data === 'object', 'Document in a QueryDocumentSnapshot should exist');\n        return data;\n    };\n    return QueryDocumentSnapshot;\n}(DocumentSnapshot));\nexport { QueryDocumentSnapshot };\nvar Query = /** @class */ (function () {\n    function Query(_query, firestore) {\n        this._query = _query;\n        this.firestore = firestore;\n    }\n    Query.prototype.where = function (field, opStr, value) {\n        validateExactNumberOfArgs('Query.where', arguments, 3);\n        validateArgType('Query.where', 'string', 2, opStr);\n        validateDefined('Query.where', 3, value);\n        var fieldValue;\n        var fieldPath = fieldPathFromArgument('Query.where', field);\n        if (fieldPath.isKeyField()) {\n            if (typeof value === 'string') {\n                if (value.indexOf('/') !== -1) {\n                    // TODO(dimond): Allow slashes once ancestor queries are supported\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Function Query.where() requires its third parameter to be a ' +\n                        'valid document ID if the first parameter is ' +\n                        'FieldPath.documentId(), but it contains a slash.');\n                }\n                if (value === '') {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Function Query.where() requires its third parameter to be a ' +\n                        'valid document ID if the first parameter is ' +\n                        'FieldPath.documentId(), but it was an empty string.');\n                }\n                var path = this._query.path.child(new ResourcePath([value]));\n                assert(path.length % 2 === 0, 'Path should be a document key');\n                fieldValue = new RefValue(this.firestore._databaseId, new DocumentKey(path));\n            }\n            else if (value instanceof DocumentReference) {\n                var ref = value;\n                fieldValue = new RefValue(this.firestore._databaseId, ref._key);\n            }\n            else {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function Query.where() requires its third parameter to be a \" +\n                    \"string or a DocumentReference if the first parameter is \" +\n                    \"FieldPath.documentId(), but it was: \" +\n                    (valueDescription(value) + \".\"));\n            }\n        }\n        else {\n            fieldValue = this.firestore._dataConverter.parseQueryValue('Query.where', value);\n        }\n        var filter = fieldFilter(fieldPath, RelationOp.fromString(opStr), fieldValue);\n        this.validateNewFilter(filter);\n        return new Query(this._query.addFilter(filter), this.firestore);\n    };\n    Query.prototype.orderBy = function (field, directionStr) {\n        validateBetweenNumberOfArgs('Query.orderBy', arguments, 1, 2);\n        validateOptionalArgType('Query.orderBy', 'string', 2, directionStr);\n        var direction;\n        if (directionStr === undefined || directionStr === 'asc') {\n            direction = Direction.ASCENDING;\n        }\n        else if (directionStr === 'desc') {\n            direction = Direction.DESCENDING;\n        }\n        else {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Function Query.orderBy() has unknown direction '\" + directionStr + \"', \" +\n                \"expected 'asc' or 'desc'.\");\n        }\n        if (this._query.startAt !== null) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You must not call Query.startAt() or ' +\n                'Query.startAfter() before calling Query.orderBy().');\n        }\n        if (this._query.endAt !== null) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. You must not call Query.endAt() or ' +\n                'Query.endBefore() before calling Query.orderBy().');\n        }\n        var fieldPath = fieldPathFromArgument('Query.orderBy', field);\n        var orderBy = new OrderBy(fieldPath, direction);\n        this.validateNewOrderBy(orderBy);\n        return new Query(this._query.addOrderBy(orderBy), this.firestore);\n    };\n    Query.prototype.limit = function (n) {\n        validateExactNumberOfArgs('Query.limit', arguments, 1);\n        validateArgType('Query.limit', 'number', 1, n);\n        if (n <= 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid Query. Query limit (\" + n + \") is invalid. Limit must be \" +\n                'positive.');\n        }\n        return new Query(this._query.withLimit(n), this.firestore);\n    };\n    Query.prototype.startAt = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.startAt', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.startAt', docOrField, fields, \n        /*before=*/ true);\n        return new Query(this._query.withStartAt(bound), this.firestore);\n    };\n    Query.prototype.startAfter = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.startAfter', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.startAfter', docOrField, fields, \n        /*before=*/ false);\n        return new Query(this._query.withStartAt(bound), this.firestore);\n    };\n    Query.prototype.endBefore = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.endBefore', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.endBefore', docOrField, fields, \n        /*before=*/ true);\n        return new Query(this._query.withEndAt(bound), this.firestore);\n    };\n    Query.prototype.endAt = function (docOrField) {\n        var fields = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            fields[_i - 1] = arguments[_i];\n        }\n        validateAtLeastNumberOfArgs('Query.endAt', arguments, 1);\n        var bound = this.boundFromDocOrFields('Query.endAt', docOrField, fields, \n        /*before=*/ false);\n        return new Query(this._query.withEndAt(bound), this.firestore);\n    };\n    Query.prototype.isEqual = function (other) {\n        if (!(other instanceof Query)) {\n            throw invalidClassError('isEqual', 'Query', 1, other);\n        }\n        return (this.firestore === other.firestore && this._query.isEqual(other._query));\n    };\n    /** Helper function to create a bound from a document or fields */\n    Query.prototype.boundFromDocOrFields = function (methodName, docOrField, fields, before) {\n        validateDefined(methodName, 1, docOrField);\n        if (docOrField instanceof DocumentSnapshot) {\n            if (fields.length > 0) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Too many arguments provided to \" + methodName + \"().\");\n            }\n            var snap = docOrField;\n            if (!snap.exists) {\n                throw new FirestoreError(Code.NOT_FOUND, \"Can't use a DocumentSnapshot that doesn't exist for \" +\n                    (methodName + \"().\"));\n            }\n            return this.boundFromDocument(methodName, snap._document, before);\n        }\n        else {\n            var allFields = [docOrField].concat(fields);\n            return this.boundFromFields(methodName, allFields, before);\n        }\n    };\n    /**\n     * Create a Bound from a query and a document.\n     *\n     * Note that the Bound will always include the key of the document\n     * and so only the provided document will compare equal to the returned\n     * position.\n     *\n     * Will throw if the document does not contain all fields of the order by\n     * of the query.\n     */\n    Query.prototype.boundFromDocument = function (methodName, doc, before) {\n        var components = [];\n        // Because people expect to continue/end a query at the exact document\n        // provided, we need to use the implicit sort order rather than the explicit\n        // sort order, because it's guaranteed to contain the document key. That way\n        // the position becomes unambiguous and the query continues/ends exactly at\n        // the provided document. Without the key (by using the explicit sort\n        // orders), multiple documents could match the position, yielding duplicate\n        // results.\n        for (var _i = 0, _a = this._query.orderBy; _i < _a.length; _i++) {\n            var orderBy = _a[_i];\n            if (orderBy.field.isKeyField()) {\n                components.push(new RefValue(this.firestore._databaseId, doc.key));\n            }\n            else {\n                var value = doc.field(orderBy.field);\n                if (value !== undefined) {\n                    components.push(value);\n                }\n                else {\n                    var field = orderBy.field.canonicalString();\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. You are trying to start or end a query using a \" +\n                        (\"document for which the field '\" + field + \"' (used as the \") +\n                        \"orderBy) does not exist.\");\n                }\n            }\n        }\n        return new Bound(components, before);\n    };\n    /**\n     * Converts a list of field values to a Bound for the given query.\n     */\n    Query.prototype.boundFromFields = function (methodName, values, before) {\n        // Use explicit order by's because it has to match the query the user made\n        var orderBy = this._query.explicitOrderBy;\n        if (values.length > orderBy.length) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Too many arguments provided to \" + methodName + \"(). \" +\n                \"The number of arguments must be less than or equal to the \" +\n                \"number of Query.orderBy() clauses\");\n        }\n        var components = [];\n        for (var i = 0; i < values.length; i++) {\n            var rawValue = values[i];\n            var orderByComponent = orderBy[i];\n            if (orderByComponent.field.isKeyField()) {\n                if (typeof rawValue !== 'string') {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. Expected a string for document ID in \" +\n                        (methodName + \"(), but got a \" + typeof rawValue));\n                }\n                if (rawValue.indexOf('/') !== -1) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. Document ID '\" + rawValue + \"' contains a slash in \" +\n                        (methodName + \"()\"));\n                }\n                var key = new DocumentKey(this._query.path.child(rawValue));\n                components.push(new RefValue(this.firestore._databaseId, key));\n            }\n            else {\n                var wrapped = this.firestore._dataConverter.parseQueryValue(methodName, rawValue);\n                components.push(wrapped);\n            }\n        }\n        return new Bound(components, before);\n    };\n    Query.prototype.onSnapshot = function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        validateBetweenNumberOfArgs('Query.onSnapshot', arguments, 1, 4);\n        var options = {};\n        var observer;\n        var currArg = 0;\n        if (typeof args[currArg] === 'object' &&\n            !isPartialObserver(args[currArg])) {\n            options = args[currArg];\n            validateOptionNames('Query.onSnapshot', options, [\n                'includeQueryMetadataChanges',\n                'includeDocumentMetadataChanges'\n            ]);\n            validateNamedOptionalType('Query.onSnapshot', 'boolean', 'includeDocumentMetadataChanges', options.includeDocumentMetadataChanges);\n            validateNamedOptionalType('Query.onSnapshot', 'boolean', 'includeQueryMetadataChanges', options.includeQueryMetadataChanges);\n            currArg++;\n        }\n        if (isPartialObserver(args[currArg])) {\n            observer = args[currArg];\n        }\n        else {\n            validateArgType('Query.onSnapshot', 'function', currArg, args[currArg]);\n            validateOptionalArgType('Query.onSnapshot', 'function', currArg + 1, args[currArg + 1]);\n            validateOptionalArgType('Query.onSnapshot', 'function', currArg + 2, args[currArg + 2]);\n            observer = {\n                next: args[currArg],\n                error: args[currArg + 1],\n                complete: args[currArg + 2]\n            };\n        }\n        return this.onSnapshotInternal(options, observer);\n    };\n    Query.prototype.onSnapshotInternal = function (options, observer) {\n        var _this = this;\n        var errHandler = function (err) {\n            console.error('Uncaught Error in onSnapshot:', err);\n        };\n        if (observer.error) {\n            errHandler = observer.error.bind(observer);\n        }\n        var asyncObserver = new AsyncObserver({\n            next: function (result) {\n                if (observer.next) {\n                    observer.next(new QuerySnapshot(_this.firestore, _this._query, result));\n                }\n            },\n            error: errHandler\n        });\n        var firestoreClient = this.firestore.ensureClientConfigured();\n        var internalListener = firestoreClient.listen(this._query, asyncObserver, options);\n        return function () {\n            asyncObserver.mute();\n            firestoreClient.unlisten(internalListener);\n        };\n    };\n    Query.prototype.get = function () {\n        var _this = this;\n        validateExactNumberOfArgs('Query.get', arguments, 0);\n        return new Promise(function (resolve, reject) {\n            var unlisten = _this.onSnapshotInternal({\n                includeDocumentMetadataChanges: false,\n                includeQueryMetadataChanges: true,\n                waitForSyncWhenOnline: true\n            }, {\n                next: function (result) {\n                    // Remove query first before passing event to user to avoid\n                    // user actions affecting the now stale query.\n                    unlisten();\n                    resolve(result);\n                },\n                error: reject\n            });\n        });\n    };\n    Query.prototype.validateNewFilter = function (filter) {\n        if (filter instanceof RelationFilter && filter.isInequality()) {\n            var existingField = this._query.getInequalityFilterField();\n            if (existingField !== null && !existingField.isEqual(filter.field)) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid query. All where filters with an inequality' +\n                    ' (<, <=, >, or >=) must be on the same field. But you have' +\n                    (\" inequality filters on '\" + existingField.toString() + \"'\") +\n                    (\" and '\" + filter.field.toString() + \"'\"));\n            }\n            var firstOrderByField = this._query.getFirstOrderByField();\n            if (firstOrderByField !== null) {\n                this.validateOrderByAndInequalityMatch(filter.field, firstOrderByField);\n            }\n        }\n    };\n    Query.prototype.validateNewOrderBy = function (orderBy) {\n        if (this._query.getFirstOrderByField() === null) {\n            // This is the first order by. It must match any inequality.\n            var inequalityField = this._query.getInequalityFilterField();\n            if (inequalityField !== null) {\n                this.validateOrderByAndInequalityMatch(inequalityField, orderBy.field);\n            }\n        }\n    };\n    Query.prototype.validateOrderByAndInequalityMatch = function (inequality, orderBy) {\n        if (!orderBy.isEqual(inequality)) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid query. You have a where filter with an inequality \" +\n                (\"(<, <=, >, or >=) on field '\" + inequality.toString() + \"' \") +\n                (\"and so you must also use '\" + inequality.toString() + \"' \") +\n                \"as your first Query.orderBy(), but your first Query.orderBy() \" +\n                (\"is on field '\" + orderBy.toString() + \"' instead.\"));\n        }\n    };\n    return Query;\n}());\nexport { Query };\nvar QuerySnapshot = /** @class */ (function () {\n    function QuerySnapshot(_firestore, _originalQuery, _snapshot) {\n        this._firestore = _firestore;\n        this._originalQuery = _originalQuery;\n        this._snapshot = _snapshot;\n        this._cachedChanges = null;\n        this.metadata = new SnapshotMetadata(_snapshot.hasPendingWrites, _snapshot.fromCache);\n    }\n    Object.defineProperty(QuerySnapshot.prototype, \"docs\", {\n        get: function () {\n            var result = [];\n            this.forEach(function (doc) { return result.push(doc); });\n            return result;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySnapshot.prototype, \"empty\", {\n        get: function () {\n            return this._snapshot.docs.isEmpty();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySnapshot.prototype, \"size\", {\n        get: function () {\n            return this._snapshot.docs.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    QuerySnapshot.prototype.forEach = function (callback, thisArg) {\n        var _this = this;\n        validateBetweenNumberOfArgs('QuerySnapshot.forEach', arguments, 1, 2);\n        validateArgType('QuerySnapshot.forEach', 'function', 1, callback);\n        this._snapshot.docs.forEach(function (doc) {\n            callback.call(thisArg, _this.convertToDocumentImpl(doc));\n        });\n    };\n    Object.defineProperty(QuerySnapshot.prototype, \"query\", {\n        get: function () {\n            return new Query(this._originalQuery, this._firestore);\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(QuerySnapshot.prototype, \"docChanges\", {\n        get: function () {\n            if (!this._cachedChanges) {\n                this._cachedChanges = changesFromSnapshot(this._firestore, this._snapshot);\n            }\n            return this._cachedChanges;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** Check the equality. The call can be very expensive. */\n    QuerySnapshot.prototype.isEqual = function (other) {\n        if (!(other instanceof QuerySnapshot)) {\n            throw invalidClassError('isEqual', 'QuerySnapshot', 1, other);\n        }\n        return (this._firestore === other._firestore &&\n            this._originalQuery.isEqual(other._originalQuery) &&\n            this._snapshot.isEqual(other._snapshot));\n    };\n    QuerySnapshot.prototype.convertToDocumentImpl = function (doc) {\n        return new QueryDocumentSnapshot(this._firestore, doc.key, doc, this.metadata.fromCache);\n    };\n    return QuerySnapshot;\n}());\nexport { QuerySnapshot };\nvar CollectionReference = /** @class */ (function (_super) {\n    __extends(CollectionReference, _super);\n    function CollectionReference(path, firestore) {\n        var _this = _super.call(this, InternalQuery.atPath(path), firestore) || this;\n        if (path.length % 2 !== 1) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Invalid collection reference. Collection ' +\n                'references must have an odd number of segments, but ' +\n                (path.canonicalString() + \" has \" + path.length));\n        }\n        return _this;\n    }\n    Object.defineProperty(CollectionReference.prototype, \"id\", {\n        get: function () {\n            return this._query.path.lastSegment();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CollectionReference.prototype, \"parent\", {\n        get: function () {\n            var parentPath = this._query.path.popLast();\n            if (parentPath.isEmpty()) {\n                return null;\n            }\n            else {\n                return new DocumentReference(new DocumentKey(parentPath), this.firestore);\n            }\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(CollectionReference.prototype, \"path\", {\n        get: function () {\n            return this._query.path.canonicalString();\n        },\n        enumerable: true,\n        configurable: true\n    });\n    CollectionReference.prototype.doc = function (pathString) {\n        validateBetweenNumberOfArgs('CollectionReference.doc', arguments, 0, 1);\n        // We allow omission of 'pathString' but explicitly prohibit passing in both\n        // 'undefined' and 'null'.\n        if (arguments.length === 0) {\n            pathString = AutoId.newId();\n        }\n        validateArgType('CollectionReference.doc', 'string', 1, pathString);\n        if (pathString === '') {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Document path must be a non-empty string');\n        }\n        var path = ResourcePath.fromString(pathString);\n        return DocumentReference.forPath(this._query.path.child(path), this.firestore);\n    };\n    CollectionReference.prototype.add = function (value) {\n        validateExactNumberOfArgs('CollectionReference.add', arguments, 1);\n        validateArgType('CollectionReference.add', 'object', 1, value);\n        var docRef = this.doc();\n        return docRef.set(value).then(function () { return docRef; });\n    };\n    return CollectionReference;\n}(Query));\nexport { CollectionReference };\nfunction validateSetOptions(methodName, options) {\n    if (options === undefined) {\n        return {\n            merge: false\n        };\n    }\n    validateOptionNames(methodName, options, ['merge']);\n    validateNamedOptionalType(methodName, 'boolean', 'merge', options.merge);\n    return options;\n}\nfunction validateSnapshotOptions(methodName, options) {\n    if (options === undefined) {\n        return {};\n    }\n    validateOptionNames(methodName, options, ['serverTimestamps']);\n    validateNamedOptionalPropertyEquals(methodName, 'options', 'serverTimestamps', options.serverTimestamps, ['estimate', 'previous', 'none']);\n    return options;\n}\nfunction validateReference(methodName, documentRef, firestore) {\n    if (!(documentRef instanceof DocumentReference)) {\n        throw invalidClassError(methodName, 'DocumentReference', 1, documentRef);\n    }\n    else if (documentRef.firestore !== firestore) {\n        throw new FirestoreError(Code.INVALID_ARGUMENT, 'Provided document reference is from a different Firestore instance.');\n    }\n    else {\n        return documentRef;\n    }\n}\n/**\n * Calculates the array of firestore.DocumentChange's for a given ViewSnapshot.\n *\n * Exported for testing.\n */\nexport function changesFromSnapshot(firestore, snapshot) {\n    if (snapshot.oldDocs.isEmpty()) {\n        // Special case the first snapshot because index calculation is easy and\n        // fast\n        var lastDoc_1;\n        var index_1 = 0;\n        return snapshot.docChanges.map(function (change) {\n            var doc = new QueryDocumentSnapshot(firestore, change.doc.key, change.doc, snapshot.fromCache);\n            assert(change.type === ChangeType.Added, 'Invalid event type for first snapshot');\n            assert(!lastDoc_1 || snapshot.query.docComparator(lastDoc_1, change.doc) < 0, 'Got added events in wrong order');\n            lastDoc_1 = change.doc;\n            return {\n                type: 'added',\n                doc: doc,\n                oldIndex: -1,\n                newIndex: index_1++\n            };\n        });\n    }\n    else {\n        // A DocumentSet that is updated incrementally as changes are applied to use\n        // to lookup the index of a document.\n        var indexTracker_1 = snapshot.oldDocs;\n        return snapshot.docChanges.map(function (change) {\n            var doc = new QueryDocumentSnapshot(firestore, change.doc.key, change.doc, snapshot.fromCache);\n            var oldIndex = -1;\n            var newIndex = -1;\n            if (change.type !== ChangeType.Added) {\n                oldIndex = indexTracker_1.indexOf(change.doc.key);\n                assert(oldIndex >= 0, 'Index for document not found');\n                indexTracker_1 = indexTracker_1.delete(change.doc.key);\n            }\n            if (change.type !== ChangeType.Removed) {\n                indexTracker_1 = indexTracker_1.add(change.doc);\n                newIndex = indexTracker_1.indexOf(change.doc.key);\n            }\n            return { type: resultChangeType(change.type), doc: doc, oldIndex: oldIndex, newIndex: newIndex };\n        });\n    }\n}\nfunction resultChangeType(type) {\n    switch (type) {\n        case ChangeType.Added:\n            return 'added';\n        case ChangeType.Modified:\n        case ChangeType.Metadata:\n            return 'modified';\n        case ChangeType.Removed:\n            return 'removed';\n        default:\n            return fail('Unknown change type: ' + type);\n    }\n}\n// Export the classes with a private constructor (it will fail if invoked\n// at runtime). Note that this still allows instanceof checks.\n// We're treating the variables as class names, so disable checking for lower\n// case variable names.\n// tslint:disable:variable-name\nexport var PublicFirestore = makeConstructorPrivate(Firestore, 'Use firebase.firestore() instead.');\nexport var PublicTransaction = makeConstructorPrivate(Transaction, 'Use firebase.firestore().runTransaction() instead.');\nexport var PublicWriteBatch = makeConstructorPrivate(WriteBatch, 'Use firebase.firestore().batch() instead.');\nexport var PublicDocumentReference = makeConstructorPrivate(DocumentReference, 'Use firebase.firestore().doc() instead.');\nexport var PublicDocumentSnapshot = makeConstructorPrivate(DocumentSnapshot);\nexport var PublicQueryDocumentSnapshot = makeConstructorPrivate(QueryDocumentSnapshot);\nexport var PublicQuery = makeConstructorPrivate(Query);\nexport var PublicQuerySnapshot = makeConstructorPrivate(QuerySnapshot);\nexport var PublicCollectionReference = makeConstructorPrivate(CollectionReference, 'Use firebase.firestore().collection() instead.');\n// tslint:enable:variable-name\n\n//# sourceMappingURL=database.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/database.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { PublicBlob } from '../api/blob';\nimport { Firestore, PublicCollectionReference, PublicDocumentReference, PublicDocumentSnapshot, PublicFirestore, PublicQuery, PublicQueryDocumentSnapshot, PublicQuerySnapshot, PublicTransaction, PublicWriteBatch } from '../api/database';\nimport { FieldPath } from '../api/field_path';\nimport { PublicFieldValue } from '../api/field_value';\nimport { GeoPoint } from '../api/geo_point';\nimport { shallowCopy } from '../util/obj';\nvar firestoreNamespace = {\n    Firestore: PublicFirestore,\n    GeoPoint: GeoPoint,\n    Blob: PublicBlob,\n    Transaction: PublicTransaction,\n    WriteBatch: PublicWriteBatch,\n    DocumentReference: PublicDocumentReference,\n    DocumentSnapshot: PublicDocumentSnapshot,\n    Query: PublicQuery,\n    QueryDocumentSnapshot: PublicQueryDocumentSnapshot,\n    QuerySnapshot: PublicQuerySnapshot,\n    CollectionReference: PublicCollectionReference,\n    FieldPath: FieldPath,\n    FieldValue: PublicFieldValue,\n    setLogLevel: Firestore.setLogLevel\n};\n/**\n * Configures Firestore as part of the Firebase SDK by calling registerService.\n */\nexport function configureForFirebase(firebase) {\n    firebase.INTERNAL.registerService('firestore', function (app) { return new Firestore(app); }, shallowCopy(firestoreNamespace));\n}\n/**\n * Exports the Firestore namespace into the provided `exportObject` object under\n * the key 'firestore'. This is used for wrapped binary that exposes Firestore\n * as a goog module.\n */\nexport function configureForStandalone(exportObject) {\n    var copiedNamespace = shallowCopy(firestoreNamespace);\n    // Unlike the use with Firebase, the standalone allows the use of the\n    // constructor, so export it's internal class\n    copiedNamespace['Firestore'] = Firestore;\n    exportObject['firestore'] = copiedNamespace;\n}\n\n//# sourceMappingURL=config.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/platform/config.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport firebase from '@firebase/app';\nimport './src/platform_browser/browser_init';\nimport { configureForFirebase } from './src/platform/config';\nexport function registerFirestore(instance) {\n    configureForFirebase(instance);\n}\nregisterFirestore(firebase);\n\n//# sourceMappingURL=index.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/index.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport firebase from '@firebase/app';\n/** The semver (www.semver.org) version of the SDK. */\nexport var SDK_VERSION = firebase.SDK_VERSION;\n\n//# sourceMappingURL=version.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/version.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\n// TODO(mcg): Change to a string enum once we've upgraded to typescript 2.4.\n//  tslint:disable-next-line:variable-name Intended to look like a TS 2.4 enum\nexport var Code = {\n    // Causes are copied from:\n    // https://github.com/grpc/grpc/blob/bceec94ea4fc5f0085d81235d8e1c06798dc341a/include/grpc%2B%2B/impl/codegen/status_code_enum.h\n    /** Not an error; returned on success. */\n    OK: 'ok',\n    /** The operation was cancelled (typically by the caller). */\n    CANCELLED: 'cancelled',\n    /** Unknown error or an error from a different error domain. */\n    UNKNOWN: 'unknown',\n    /**\n     * Client specified an invalid argument. Note that this differs from\n     * FAILED_PRECONDITION. INVALID_ARGUMENT indicates arguments that are\n     * problematic regardless of the state of the system (e.g., a malformed file\n     * name).\n     */\n    INVALID_ARGUMENT: 'invalid-argument',\n    /**\n     * Deadline expired before operation could complete. For operations that\n     * change the state of the system, this error may be returned even if the\n     * operation has completed successfully. For example, a successful response\n     * from a server could have been delayed long enough for the deadline to\n     * expire.\n     */\n    DEADLINE_EXCEEDED: 'deadline-exceeded',\n    /** Some requested entity (e.g., file or directory) was not found. */\n    NOT_FOUND: 'not-found',\n    /**\n     * Some entity that we attempted to create (e.g., file or directory) already\n     * exists.\n     */\n    ALREADY_EXISTS: 'already-exists',\n    /**\n     * The caller does not have permission to execute the specified operation.\n     * PERMISSION_DENIED must not be used for rejections caused by exhausting\n     * some resource (use RESOURCE_EXHAUSTED instead for those errors).\n     * PERMISSION_DENIED must not be used if the caller can not be identified\n     * (use UNAUTHENTICATED instead for those errors).\n     */\n    PERMISSION_DENIED: 'permission-denied',\n    /**\n     * The request does not have valid authentication credentials for the\n     * operation.\n     */\n    UNAUTHENTICATED: 'unauthenticated',\n    /**\n     * Some resource has been exhausted, perhaps a per-user quota, or perhaps the\n     * entire file system is out of space.\n     */\n    RESOURCE_EXHAUSTED: 'resource-exhausted',\n    /**\n     * Operation was rejected because the system is not in a state required for\n     * the operation's execution. For example, directory to be deleted may be\n     * non-empty, an rmdir operation is applied to a non-directory, etc.\n     *\n     * A litmus test that may help a service implementor in deciding\n     * between FAILED_PRECONDITION, ABORTED, and UNAVAILABLE:\n     *  (a) Use UNAVAILABLE if the client can retry just the failing call.\n     *  (b) Use ABORTED if the client should retry at a higher-level\n     *      (e.g., restarting a read-modify-write sequence).\n     *  (c) Use FAILED_PRECONDITION if the client should not retry until\n     *      the system state has been explicitly fixed. E.g., if an \"rmdir\"\n     *      fails because the directory is non-empty, FAILED_PRECONDITION\n     *      should be returned since the client should not retry unless\n     *      they have first fixed up the directory by deleting files from it.\n     *  (d) Use FAILED_PRECONDITION if the client performs conditional\n     *      REST Get/Update/Delete on a resource and the resource on the\n     *      server does not match the condition. E.g., conflicting\n     *      read-modify-write on the same resource.\n     */\n    FAILED_PRECONDITION: 'failed-precondition',\n    /**\n     * The operation was aborted, typically due to a concurrency issue like\n     * sequencer check failures, transaction aborts, etc.\n     *\n     * See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,\n     * and UNAVAILABLE.\n     */\n    ABORTED: 'aborted',\n    /**\n     * Operation was attempted past the valid range. E.g., seeking or reading\n     * past end of file.\n     *\n     * Unlike INVALID_ARGUMENT, this error indicates a problem that may be fixed\n     * if the system state changes. For example, a 32-bit file system will\n     * generate INVALID_ARGUMENT if asked to read at an offset that is not in the\n     * range [0,2^32-1], but it will generate OUT_OF_RANGE if asked to read from\n     * an offset past the current file size.\n     *\n     * There is a fair bit of overlap between FAILED_PRECONDITION and\n     * OUT_OF_RANGE. We recommend using OUT_OF_RANGE (the more specific error)\n     * when it applies so that callers who are iterating through a space can\n     * easily look for an OUT_OF_RANGE error to detect when they are done.\n     */\n    OUT_OF_RANGE: 'out-of-range',\n    /** Operation is not implemented or not supported/enabled in this service. */\n    UNIMPLEMENTED: 'unimplemented',\n    /**\n     * Internal errors. Means some invariants expected by underlying System has\n     * been broken. If you see one of these errors, Something is very broken.\n     */\n    INTERNAL: 'internal',\n    /**\n     * The service is currently unavailable. This is a most likely a transient\n     * condition and may be corrected by retrying with a backoff.\n     *\n     * See litmus test above for deciding between FAILED_PRECONDITION, ABORTED,\n     * and UNAVAILABLE.\n     */\n    UNAVAILABLE: 'unavailable',\n    /** Unrecoverable data loss or corruption. */\n    DATA_LOSS: 'data-loss'\n};\n/**\n * An error class used for Firestore-generated errors. Ideally we should be\n * using FirebaseError, but integrating with it is overly arduous at the moment,\n * so we define our own compatible error class (with a `name` of 'FirebaseError'\n * and compatible `code` and `message` fields.)\n */\nvar FirestoreError = /** @class */ (function (_super) {\n    __extends(FirestoreError, _super);\n    function FirestoreError(code, message) {\n        var _this = _super.call(this, message) || this;\n        _this.code = code;\n        _this.message = message;\n        _this.name = 'FirebaseError';\n        // HACK: We write a toString property directly because Error is not a real\n        // class and so inheritance does not work correctly. We could alternatively\n        // do the same \"back-door inheritance\" trick that FirebaseError does.\n        _this.toString = function () { return _this.name + \": [code=\" + _this.code + \"]: \" + _this.message; };\n        return _this;\n    }\n    return FirestoreError;\n}(Error));\nexport { FirestoreError };\n\n//# sourceMappingURL=error.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/error.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Code, FirestoreError } from '../util/error';\nimport { validateArgType, validateExactNumberOfArgs } from '../util/input_validation';\nimport { primitiveComparator } from '../util/misc';\n/**\n * Immutable class representing a geo point as latitude-longitude pair.\n * This class is directly exposed in the public API, including its constructor.\n */\nvar GeoPoint = /** @class */ (function () {\n    function GeoPoint(latitude, longitude) {\n        validateExactNumberOfArgs('GeoPoint', arguments, 2);\n        validateArgType('GeoPoint', 'number', 1, latitude);\n        validateArgType('GeoPoint', 'number', 2, longitude);\n        if (!isFinite(latitude) || latitude < -90 || latitude > 90) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Latitude must be a number between -90 and 90, but was: ' + latitude);\n        }\n        if (!isFinite(longitude) || longitude < -180 || longitude > 180) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Longitude must be a number between -180 and 180, but was: ' + longitude);\n        }\n        this._lat = latitude;\n        this._long = longitude;\n    }\n    Object.defineProperty(GeoPoint.prototype, \"latitude\", {\n        /**\n         * Returns the latitude of this geo point, a number between -90 and 90.\n         */\n        get: function () {\n            return this._lat;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Object.defineProperty(GeoPoint.prototype, \"longitude\", {\n        /**\n         * Returns the longitude of this geo point, a number between -180 and 180.\n         */\n        get: function () {\n            return this._long;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    GeoPoint.prototype.isEqual = function (other) {\n        return this._lat === other._lat && this._long === other._long;\n    };\n    /**\n     * Actually private to JS consumers of our API, so this function is prefixed\n     * with an underscore.\n     */\n    GeoPoint.prototype._compareTo = function (other) {\n        return (primitiveComparator(this._lat, other._lat) ||\n            primitiveComparator(this._long, other._long));\n    };\n    return GeoPoint;\n}());\nexport { GeoPoint };\n\n//# sourceMappingURL=geo_point.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/geo_point.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { primitiveComparator } from '../util/misc';\nvar DatabaseInfo = /** @class */ (function () {\n    /**\n     * Constructs a DatabaseInfo using the provided host, databaseId and\n     * persistenceKey.\n     *\n     * @param databaseId The database to use.\n     * @param persistenceKey A unique identifier for this Firestore's local\n     * storage (used in conjunction with the databaseId).\n     * @param host The Firestore backend host to connect to.\n     * @param ssl Whether to use SSL when connecting.\n     */\n    function DatabaseInfo(databaseId, persistenceKey, host, ssl) {\n        this.databaseId = databaseId;\n        this.persistenceKey = persistenceKey;\n        this.host = host;\n        this.ssl = ssl;\n    }\n    return DatabaseInfo;\n}());\nexport { DatabaseInfo };\n/** The default database name for a project. */\nvar DEFAULT_DATABASE_NAME = '(default)';\n/** Represents the database ID a Firestore client is associated with. */\nvar DatabaseId = /** @class */ (function () {\n    function DatabaseId(projectId, database) {\n        this.projectId = projectId;\n        this.database = database ? database : DEFAULT_DATABASE_NAME;\n    }\n    Object.defineProperty(DatabaseId.prototype, \"isDefaultDatabase\", {\n        get: function () {\n            return this.database === DEFAULT_DATABASE_NAME;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    DatabaseId.prototype.isEqual = function (other) {\n        return (other instanceof DatabaseId &&\n            other.projectId === this.projectId &&\n            other.database === this.database);\n    };\n    DatabaseId.prototype.compareTo = function (other) {\n        return (primitiveComparator(this.projectId, other.projectId) ||\n            primitiveComparator(this.database, other.database));\n    };\n    return DatabaseId;\n}());\nexport { DatabaseId };\n\n//# sourceMappingURL=database_info.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/database_info.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { assert, fail } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nexport var DOCUMENT_KEY_NAME = '__name__';\n/**\n * Path represents an ordered sequence of string segments.\n */\nvar Path = /** @class */ (function () {\n    function Path(segments, offset, length) {\n        this.init(segments, offset, length);\n    }\n    /**\n     * An initialization method that can be called from outside the constructor.\n     * We need this so that we can have a non-static construct method that returns\n     * the polymorphic `this` type.\n     */\n    Path.prototype.init = function (segments, offset, length) {\n        if (offset === undefined) {\n            offset = 0;\n        }\n        else if (offset > segments.length) {\n            fail('offset ' + offset + ' out of range ' + segments.length);\n        }\n        if (length === undefined) {\n            length = segments.length - offset;\n        }\n        else if (length > segments.length - offset) {\n            fail('length ' + length + ' out of range ' + (segments.length - offset));\n        }\n        this.segments = segments;\n        this.offset = offset;\n        this.len = length;\n    };\n    /**\n     * Constructs a new instance of Path using the same concrete type as `this`.\n     * We need this instead of using the normal constructor, because polymorphic\n     * `this` doesn't work on static methods.\n     */\n    Path.prototype.construct = function (segments, offset, length) {\n        var path = Object.create(Object.getPrototypeOf(this));\n        path.init(segments, offset, length);\n        return path;\n    };\n    Object.defineProperty(Path.prototype, \"length\", {\n        get: function () {\n            return this.len;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    Path.prototype.isEqual = function (other) {\n        return Path.comparator(this, other) === 0;\n    };\n    Path.prototype.child = function (nameOrPath) {\n        var segments = this.segments.slice(this.offset, this.limit());\n        if (nameOrPath instanceof Path) {\n            nameOrPath.forEach(function (segment) {\n                segments.push(segment);\n            });\n        }\n        else if (typeof nameOrPath === 'string') {\n            segments.push(nameOrPath);\n        }\n        else {\n            fail('Unknown parameter type for Path.child(): ' + nameOrPath);\n        }\n        return this.construct(segments);\n    };\n    /** The index of one past the last segment of the path. */\n    Path.prototype.limit = function () {\n        return this.offset + this.length;\n    };\n    Path.prototype.popFirst = function (size) {\n        size = size === undefined ? 1 : size;\n        assert(this.length >= size, \"Can't call popFirst() with less segments\");\n        return this.construct(this.segments, this.offset + size, this.length - size);\n    };\n    Path.prototype.popLast = function () {\n        assert(!this.isEmpty(), \"Can't call popLast() on empty path\");\n        return this.construct(this.segments, this.offset, this.length - 1);\n    };\n    Path.prototype.firstSegment = function () {\n        assert(!this.isEmpty(), \"Can't call firstSegment() on empty path\");\n        return this.segments[this.offset];\n    };\n    Path.prototype.lastSegment = function () {\n        assert(!this.isEmpty(), \"Can't call lastSegment() on empty path\");\n        return this.segments[this.limit() - 1];\n    };\n    Path.prototype.get = function (index) {\n        assert(index < this.length, 'Index out of range');\n        return this.segments[this.offset + index];\n    };\n    Path.prototype.isEmpty = function () {\n        return this.length === 0;\n    };\n    Path.prototype.isPrefixOf = function (other) {\n        if (other.length < this.length) {\n            return false;\n        }\n        for (var i = 0; i < this.length; i++) {\n            if (this.get(i) !== other.get(i)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    Path.prototype.forEach = function (fn) {\n        for (var i = this.offset, end = this.limit(); i < end; i++) {\n            fn(this.segments[i]);\n        }\n    };\n    Path.prototype.toArray = function () {\n        return this.segments.slice(this.offset, this.limit());\n    };\n    Path.comparator = function (p1, p2) {\n        var len = Math.min(p1.length, p2.length);\n        for (var i = 0; i < len; i++) {\n            var left = p1.get(i);\n            var right = p2.get(i);\n            if (left < right)\n                return -1;\n            if (left > right)\n                return 1;\n        }\n        if (p1.length < p2.length)\n            return -1;\n        if (p1.length > p2.length)\n            return 1;\n        return 0;\n    };\n    return Path;\n}());\nexport { Path };\n/**\n * A slash-separated path for navigating resources (documents and collections)\n * within Firestore.\n */\nvar ResourcePath = /** @class */ (function (_super) {\n    __extends(ResourcePath, _super);\n    function ResourcePath() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    ResourcePath.prototype.canonicalString = function () {\n        // NOTE: The client is ignorant of any path segments containing escape\n        // sequences (e.g. __id123__) and just passes them through raw (they exist\n        // for legacy reasons and should not be used frequently).\n        return this.toArray().join('/');\n    };\n    ResourcePath.prototype.toString = function () {\n        return this.canonicalString();\n    };\n    /**\n     * Creates a resource path from the given slash-delimited string.\n     */\n    ResourcePath.fromString = function (path) {\n        // NOTE: The client is ignorant of any path segments containing escape\n        // sequences (e.g. __id123__) and just passes them through raw (they exist\n        // for legacy reasons and should not be used frequently).\n        if (path.indexOf('//') >= 0) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid path (\" + path + \"). Paths must not contain // in them.\");\n        }\n        // We may still have an empty segment at the beginning or end if they had a\n        // leading or trailing slash (which we allow).\n        var segments = path.split('/').filter(function (segment) { return segment.length > 0; });\n        return new ResourcePath(segments);\n    };\n    ResourcePath.EMPTY_PATH = new ResourcePath([]);\n    return ResourcePath;\n}(Path));\nexport { ResourcePath };\nvar identifierRegExp = /^[_a-zA-Z][_a-zA-Z0-9]*$/;\n/** A dot-separated path for navigating sub-objects within a document. */\nvar FieldPath = /** @class */ (function (_super) {\n    __extends(FieldPath, _super);\n    function FieldPath() {\n        return _super !== null && _super.apply(this, arguments) || this;\n    }\n    /**\n     * Returns true if the string could be used as a segment in a field path\n     * without escaping.\n     */\n    FieldPath.isValidIdentifier = function (segment) {\n        return identifierRegExp.test(segment);\n    };\n    FieldPath.prototype.canonicalString = function () {\n        return this.toArray()\n            .map(function (str) {\n            str = str.replace('\\\\', '\\\\\\\\').replace('`', '\\\\`');\n            if (!FieldPath.isValidIdentifier(str)) {\n                str = '`' + str + '`';\n            }\n            return str;\n        })\n            .join('.');\n    };\n    FieldPath.prototype.toString = function () {\n        return this.canonicalString();\n    };\n    /**\n     * Returns true if this field references the key of a document.\n     */\n    FieldPath.prototype.isKeyField = function () {\n        return this.length === 1 && this.get(0) === DOCUMENT_KEY_NAME;\n    };\n    /**\n     * The field designating the key of a document.\n     */\n    FieldPath.keyField = function () {\n        return new FieldPath([DOCUMENT_KEY_NAME]);\n    };\n    /**\n     * Parses a field string from the given server-formatted string.\n     *\n     * - Splitting the empty string is not allowed (for now at least).\n     * - Empty segments within the string (e.g. if there are two consecutive\n     *   separators) are not allowed.\n     *\n     * TODO(b/37244157): we should make this more strict. Right now, it allows\n     * non-identifier path components, even if they aren't escaped.\n     */\n    FieldPath.fromServerFormat = function (path) {\n        var segments = [];\n        var current = '';\n        var i = 0;\n        var addCurrentSegment = function () {\n            if (current.length === 0) {\n                throw new FirestoreError(Code.INVALID_ARGUMENT, \"Invalid field path (\" + path + \"). Paths must not be empty, begin \" +\n                    \"with '.', end with '.', or contain '..'\");\n            }\n            segments.push(current);\n            current = '';\n        };\n        var inBackticks = false;\n        while (i < path.length) {\n            var c = path[i];\n            if (c === '\\\\') {\n                if (i + 1 === path.length) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Path has trailing escape character: ' + path);\n                }\n                var next = path[i + 1];\n                if (!(next === '\\\\' || next === '.' || next === '`')) {\n                    throw new FirestoreError(Code.INVALID_ARGUMENT, 'Path has invalid escape sequence: ' + path);\n                }\n                current += next;\n                i += 2;\n            }\n            else if (c === '`') {\n                inBackticks = !inBackticks;\n                i++;\n            }\n            else if (c === '.' && !inBackticks) {\n                addCurrentSegment();\n                i++;\n            }\n            else {\n                current += c;\n                i++;\n            }\n        }\n        addCurrentSegment();\n        if (inBackticks) {\n            throw new FirestoreError(Code.INVALID_ARGUMENT, 'Unterminated ` in path: ' + path);\n        }\n        return new FieldPath(segments);\n    };\n    FieldPath.EMPTY_PATH = new FieldPath([]);\n    return FieldPath;\n}(Path));\nexport { FieldPath };\n\n//# sourceMappingURL=path.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/path.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\nimport { ResourcePath } from './path';\nvar DocumentKey = /** @class */ (function () {\n    function DocumentKey(path) {\n        this.path = path;\n        assert(DocumentKey.isDocumentKey(path), 'Invalid DocumentKey with an odd number of segments: ' +\n            path.toArray().join('/'));\n    }\n    DocumentKey.prototype.isEqual = function (other) {\n        return (other !== null && ResourcePath.comparator(this.path, other.path) === 0);\n    };\n    DocumentKey.prototype.toString = function () {\n        return this.path.toString();\n    };\n    DocumentKey.comparator = function (k1, k2) {\n        return ResourcePath.comparator(k1.path, k2.path);\n    };\n    DocumentKey.isDocumentKey = function (path) {\n        return path.length % 2 === 0;\n    };\n    /**\n     * Creates and returns a new document key with the given segments.\n     *\n     * @param path The segments of the path to the document\n     * @return A new instance of DocumentKey\n     */\n    DocumentKey.fromSegments = function (segments) {\n        return new DocumentKey(new ResourcePath(segments.slice()));\n    };\n    /**\n     * Creates and returns a new document key using '/' to split the string into\n     * segments.\n     *\n     * @param path The slash-separated path string to the document\n     * @return A new instance of DocumentKey\n     */\n    DocumentKey.fromPathString = function (path) {\n        return new DocumentKey(ResourcePath.fromString(path));\n    };\n    DocumentKey.EMPTY = new DocumentKey(new ResourcePath([]));\n    return DocumentKey;\n}());\nexport { DocumentKey };\n\n//# sourceMappingURL=document_key.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/document_key.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { fail } from '../util/assert';\nimport { DocumentKey } from './document_key';\nvar Document = /** @class */ (function () {\n    function Document(key, version, data, options) {\n        this.key = key;\n        this.version = version;\n        this.data = data;\n        this.hasLocalMutations = options.hasLocalMutations;\n    }\n    Document.prototype.field = function (path) {\n        return this.data.field(path);\n    };\n    Document.prototype.fieldValue = function (path) {\n        var field = this.field(path);\n        return field ? field.value() : undefined;\n    };\n    Document.prototype.value = function () {\n        return this.data.value();\n    };\n    Document.prototype.isEqual = function (other) {\n        return (other instanceof Document &&\n            this.key.isEqual(other.key) &&\n            this.version.isEqual(other.version) &&\n            this.data.isEqual(other.data) &&\n            this.hasLocalMutations === other.hasLocalMutations);\n    };\n    Document.prototype.toString = function () {\n        return (\"Document(\" + this.key + \", \" + this.version + \", \" + this.data.toString() + \", \" +\n            (\"{hasLocalMutations: \" + this.hasLocalMutations + \"})\"));\n    };\n    Document.compareByKey = function (d1, d2) {\n        return DocumentKey.comparator(d1.key, d2.key);\n    };\n    Document.compareByField = function (field, d1, d2) {\n        var v1 = d1.field(field);\n        var v2 = d2.field(field);\n        if (v1 !== undefined && v2 !== undefined) {\n            return v1.compareTo(v2);\n        }\n        else {\n            return fail(\"Trying to compare documents on fields that don't exist\");\n        }\n    };\n    return Document;\n}());\nexport { Document };\n/**\n * A class representing a deleted document.\n * Version is set to 0 if we don't point to any specific time, otherwise it\n * denotes time we know it didn't exist at.\n */\nvar NoDocument = /** @class */ (function () {\n    function NoDocument(key, version) {\n        this.key = key;\n        this.version = version;\n    }\n    NoDocument.prototype.toString = function () {\n        return \"NoDocument(\" + this.key + \", \" + this.version + \")\";\n    };\n    NoDocument.prototype.isEqual = function (other) {\n        return (other &&\n            other.version.isEqual(this.version) &&\n            other.key.isEqual(this.key));\n    };\n    NoDocument.compareByKey = function (d1, d2) {\n        return DocumentKey.comparator(d1.key, d2.key);\n    };\n    return NoDocument;\n}());\nexport { NoDocument };\n\n//# sourceMappingURL=document.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/document.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert, fail } from './assert';\n// An immutable sorted map implementation, based on a Left-leaning Red-Black\n// tree.\nvar SortedMap = /** @class */ (function () {\n    function SortedMap(comparator, root) {\n        this.comparator = comparator;\n        this.root = root ? root : LLRBNode.EMPTY;\n    }\n    // Returns a copy of the map, with the specified key/value added or replaced.\n    SortedMap.prototype.insert = function (key, value) {\n        return new SortedMap(this.comparator, this.root\n            .insert(key, value, this.comparator)\n            .copy(null, null, LLRBNode.BLACK, null, null));\n    };\n    // Returns a copy of the map, with the specified key removed.\n    SortedMap.prototype.remove = function (key) {\n        return new SortedMap(this.comparator, this.root\n            .remove(key, this.comparator)\n            .copy(null, null, LLRBNode.BLACK, null, null));\n    };\n    // Returns the value of the node with the given key, or null.\n    SortedMap.prototype.get = function (key) {\n        var node = this.root;\n        while (!node.isEmpty()) {\n            var cmp = this.comparator(key, node.key);\n            if (cmp === 0) {\n                return node.value;\n            }\n            else if (cmp < 0) {\n                node = node.left;\n            }\n            else if (cmp > 0) {\n                node = node.right;\n            }\n        }\n        return null;\n    };\n    // Returns the index of the element in this sorted map, or -1 if it doesn't\n    // exist.\n    SortedMap.prototype.indexOf = function (key) {\n        // Number of nodes that were pruned when descending right\n        var prunedNodes = 0;\n        var node = this.root;\n        while (!node.isEmpty()) {\n            var cmp = this.comparator(key, node.key);\n            if (cmp === 0) {\n                return prunedNodes + node.left.size;\n            }\n            else if (cmp < 0) {\n                node = node.left;\n            }\n            else {\n                // Count all nodes left of the node plus the node itself\n                prunedNodes += node.left.size + 1;\n                node = node.right;\n            }\n        }\n        // Node not found\n        return -1;\n    };\n    SortedMap.prototype.isEmpty = function () {\n        return this.root.isEmpty();\n    };\n    Object.defineProperty(SortedMap.prototype, \"size\", {\n        // Returns the total number of nodes in the map.\n        get: function () {\n            return this.root.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // Returns the minimum key in the map.\n    SortedMap.prototype.minKey = function () {\n        return this.root.minKey();\n    };\n    // Returns the maximum key in the map.\n    SortedMap.prototype.maxKey = function () {\n        return this.root.maxKey();\n    };\n    // Traverses the map in key order and calls the specified action function\n    // for each key/value pair. If action returns true, traversal is aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    SortedMap.prototype.inorderTraversal = function (action) {\n        return this.root.inorderTraversal(action);\n    };\n    SortedMap.prototype.forEach = function (fn) {\n        this.inorderTraversal(function (k, v) {\n            fn(k, v);\n            return false;\n        });\n    };\n    // Traverses the map in reverse key order and calls the specified action\n    // function for each key/value pair. If action returns true, traversal is\n    // aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    SortedMap.prototype.reverseTraversal = function (action) {\n        return this.root.reverseTraversal(action);\n    };\n    // Returns an iterator over the SortedMap.\n    SortedMap.prototype.getIterator = function () {\n        return new SortedMapIterator(this.root, null, this.comparator, false);\n    };\n    SortedMap.prototype.getIteratorFrom = function (key) {\n        return new SortedMapIterator(this.root, key, this.comparator, false);\n    };\n    SortedMap.prototype.getReverseIterator = function () {\n        return new SortedMapIterator(this.root, null, this.comparator, true);\n    };\n    SortedMap.prototype.getReverseIteratorFrom = function (key) {\n        return new SortedMapIterator(this.root, key, this.comparator, true);\n    };\n    return SortedMap;\n}()); // end SortedMap\nexport { SortedMap };\n// An iterator over an LLRBNode.\nvar SortedMapIterator = /** @class */ (function () {\n    function SortedMapIterator(node, startKey, comparator, isReverse) {\n        this.isReverse = isReverse;\n        this.nodeStack = [];\n        var cmp = 1;\n        while (!node.isEmpty()) {\n            cmp = startKey ? comparator(node.key, startKey) : 1;\n            // flip the comparison if we're going in reverse\n            if (isReverse)\n                cmp *= -1;\n            if (cmp < 0) {\n                // This node is less than our start key. ignore it\n                if (this.isReverse) {\n                    node = node.left;\n                }\n                else {\n                    node = node.right;\n                }\n            }\n            else if (cmp === 0) {\n                // This node is exactly equal to our start key. Push it on the stack,\n                // but stop iterating;\n                this.nodeStack.push(node);\n                break;\n            }\n            else {\n                // This node is greater than our start key, add it to the stack and move\n                // to the next one\n                this.nodeStack.push(node);\n                if (this.isReverse) {\n                    node = node.right;\n                }\n                else {\n                    node = node.left;\n                }\n            }\n        }\n    }\n    SortedMapIterator.prototype.getNext = function () {\n        assert(this.nodeStack.length > 0, 'getNext() called on iterator when hasNext() is false.');\n        var node = this.nodeStack.pop();\n        var result = { key: node.key, value: node.value };\n        if (this.isReverse) {\n            node = node.left;\n            while (!node.isEmpty()) {\n                this.nodeStack.push(node);\n                node = node.right;\n            }\n        }\n        else {\n            node = node.right;\n            while (!node.isEmpty()) {\n                this.nodeStack.push(node);\n                node = node.left;\n            }\n        }\n        return result;\n    };\n    SortedMapIterator.prototype.hasNext = function () {\n        return this.nodeStack.length > 0;\n    };\n    SortedMapIterator.prototype.peek = function () {\n        if (this.nodeStack.length === 0)\n            return null;\n        var node = this.nodeStack[this.nodeStack.length - 1];\n        return { key: node.key, value: node.value };\n    };\n    return SortedMapIterator;\n}()); // end SortedMapIterator\nexport { SortedMapIterator };\n// Represents a node in a Left-leaning Red-Black tree.\nvar LLRBNode = /** @class */ (function () {\n    function LLRBNode(key, value, color, left, right) {\n        this.key = key;\n        this.value = value;\n        this.color = color != null ? color : LLRBNode.RED;\n        this.left = left != null ? left : LLRBNode.EMPTY;\n        this.right = right != null ? right : LLRBNode.EMPTY;\n        this.size = this.left.size + 1 + this.right.size;\n    }\n    // Returns a copy of the current node, optionally replacing pieces of it.\n    LLRBNode.prototype.copy = function (key, value, color, left, right) {\n        return new LLRBNode(key != null ? key : this.key, value != null ? value : this.value, color != null ? color : this.color, left != null ? left : this.left, right != null ? right : this.right);\n    };\n    LLRBNode.prototype.isEmpty = function () {\n        return false;\n    };\n    // Traverses the tree in key order and calls the specified action function\n    // for each node. If action returns true, traversal is aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    LLRBNode.prototype.inorderTraversal = function (action) {\n        return (this.left.inorderTraversal(action) ||\n            action(this.key, this.value) ||\n            this.right.inorderTraversal(action));\n    };\n    // Traverses the tree in reverse key order and calls the specified action\n    // function for each node. If action returns true, traversal is aborted.\n    // Returns the first truthy value returned by action, or the last falsey\n    // value returned by action.\n    LLRBNode.prototype.reverseTraversal = function (action) {\n        return (this.right.reverseTraversal(action) ||\n            action(this.key, this.value) ||\n            this.left.reverseTraversal(action));\n    };\n    // Returns the minimum node in the tree.\n    LLRBNode.prototype.min = function () {\n        if (this.left.isEmpty()) {\n            return this;\n        }\n        else {\n            return this.left.min();\n        }\n    };\n    // Returns the maximum key in the tree.\n    LLRBNode.prototype.minKey = function () {\n        return this.min().key;\n    };\n    // Returns the maximum key in the tree.\n    LLRBNode.prototype.maxKey = function () {\n        if (this.right.isEmpty()) {\n            return this.key;\n        }\n        else {\n            return this.right.maxKey();\n        }\n    };\n    // Returns new tree, with the key/value added.\n    LLRBNode.prototype.insert = function (key, value, comparator) {\n        var n = this;\n        var cmp = comparator(key, n.key);\n        if (cmp < 0) {\n            n = n.copy(null, null, null, n.left.insert(key, value, comparator), null);\n        }\n        else if (cmp === 0) {\n            n = n.copy(null, value, null, null, null);\n        }\n        else {\n            n = n.copy(null, null, null, null, n.right.insert(key, value, comparator));\n        }\n        return n.fixUp();\n    };\n    LLRBNode.prototype.removeMin = function () {\n        if (this.left.isEmpty()) {\n            return LLRBNode.EMPTY;\n        }\n        var n = this;\n        if (!n.left.isRed() && !n.left.left.isRed())\n            n = n.moveRedLeft();\n        n = n.copy(null, null, null, n.left.removeMin(), null);\n        return n.fixUp();\n    };\n    // Returns new tree, with the specified item removed.\n    LLRBNode.prototype.remove = function (key, comparator) {\n        var smallest;\n        var n = this;\n        if (comparator(key, n.key) < 0) {\n            if (!n.left.isEmpty() && !n.left.isRed() && !n.left.left.isRed()) {\n                n = n.moveRedLeft();\n            }\n            n = n.copy(null, null, null, n.left.remove(key, comparator), null);\n        }\n        else {\n            if (n.left.isRed())\n                n = n.rotateRight();\n            if (!n.right.isEmpty() && !n.right.isRed() && !n.right.left.isRed()) {\n                n = n.moveRedRight();\n            }\n            if (comparator(key, n.key) === 0) {\n                if (n.right.isEmpty()) {\n                    return LLRBNode.EMPTY;\n                }\n                else {\n                    smallest = n.right.min();\n                    n = n.copy(smallest.key, smallest.value, null, null, n.right.removeMin());\n                }\n            }\n            n = n.copy(null, null, null, null, n.right.remove(key, comparator));\n        }\n        return n.fixUp();\n    };\n    LLRBNode.prototype.isRed = function () {\n        return this.color;\n    };\n    // Returns new tree after performing any needed rotations.\n    LLRBNode.prototype.fixUp = function () {\n        var n = this;\n        if (n.right.isRed() && !n.left.isRed())\n            n = n.rotateLeft();\n        if (n.left.isRed() && n.left.left.isRed())\n            n = n.rotateRight();\n        if (n.left.isRed() && n.right.isRed())\n            n = n.colorFlip();\n        return n;\n    };\n    LLRBNode.prototype.moveRedLeft = function () {\n        var n = this.colorFlip();\n        if (n.right.left.isRed()) {\n            n = n.copy(null, null, null, null, n.right.rotateRight());\n            n = n.rotateLeft();\n            n = n.colorFlip();\n        }\n        return n;\n    };\n    LLRBNode.prototype.moveRedRight = function () {\n        var n = this.colorFlip();\n        if (n.left.left.isRed()) {\n            n = n.rotateRight();\n            n = n.colorFlip();\n        }\n        return n;\n    };\n    LLRBNode.prototype.rotateLeft = function () {\n        var nl = this.copy(null, null, LLRBNode.RED, null, this.right.left);\n        return this.right.copy(null, null, this.color, nl, null);\n    };\n    LLRBNode.prototype.rotateRight = function () {\n        var nr = this.copy(null, null, LLRBNode.RED, this.left.right, null);\n        return this.left.copy(null, null, this.color, null, nr);\n    };\n    LLRBNode.prototype.colorFlip = function () {\n        var left = this.left.copy(null, null, !this.left.color, null, null);\n        var right = this.right.copy(null, null, !this.right.color, null, null);\n        return this.copy(null, null, !this.color, left, right);\n    };\n    // For testing.\n    LLRBNode.prototype.checkMaxDepth = function () {\n        var blackDepth = this.check();\n        if (Math.pow(2.0, blackDepth) <= this.size + 1) {\n            return true;\n        }\n        else {\n            return false;\n        }\n    };\n    // In a balanced RB tree, the black-depth (number of black nodes) from root to\n    // leaves is equal on both sides.  This function verifies that or asserts.\n    LLRBNode.prototype.check = function () {\n        if (this.isRed() && this.left.isRed()) {\n            throw fail('Red node has red child(' + this.key + ',' + this.value + ')');\n        }\n        if (this.right.isRed()) {\n            throw fail('Right child of (' + this.key + ',' + this.value + ') is red');\n        }\n        var blackDepth = this.left.check();\n        if (blackDepth !== this.right.check()) {\n            throw fail('Black depths differ');\n        }\n        else {\n            return blackDepth + (this.isRed() ? 0 : 1);\n        }\n    };\n    // tslint:disable-next-line:no-any Empty node is shared between all LLRB trees.\n    LLRBNode.EMPTY = null;\n    LLRBNode.RED = true;\n    LLRBNode.BLACK = false;\n    return LLRBNode;\n}()); // end LLRBNode\nexport { LLRBNode };\n// Represents an empty node (a leaf node in the Red-Black Tree).\nvar LLRBEmptyNode = /** @class */ (function () {\n    function LLRBEmptyNode() {\n        this.size = 0;\n    }\n    // Returns a copy of the current node.\n    LLRBEmptyNode.prototype.copy = function (key, value, color, left, right) {\n        return this;\n    };\n    // Returns a copy of the tree, with the specified key/value added.\n    LLRBEmptyNode.prototype.insert = function (key, value, comparator) {\n        return new LLRBNode(key, value);\n    };\n    // Returns a copy of the tree, with the specified key removed.\n    LLRBEmptyNode.prototype.remove = function (key, comparator) {\n        return this;\n    };\n    LLRBEmptyNode.prototype.isEmpty = function () {\n        return true;\n    };\n    LLRBEmptyNode.prototype.inorderTraversal = function (action) {\n        return false;\n    };\n    LLRBEmptyNode.prototype.reverseTraversal = function (action) {\n        return false;\n    };\n    LLRBEmptyNode.prototype.minKey = function () {\n        return null;\n    };\n    LLRBEmptyNode.prototype.maxKey = function () {\n        return null;\n    };\n    LLRBEmptyNode.prototype.isRed = function () {\n        return false;\n    };\n    // For testing.\n    LLRBEmptyNode.prototype.checkMaxDepth = function () {\n        return true;\n    };\n    LLRBEmptyNode.prototype.check = function () {\n        return 0;\n    };\n    return LLRBEmptyNode;\n}()); // end LLRBEmptyNode\nexport { LLRBEmptyNode };\nLLRBNode.EMPTY = new LLRBEmptyNode();\n\n//# sourceMappingURL=sorted_map.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/sorted_map.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { emptyByteString } from '../platform/platform';\n/** An enumeration of the different purposes we have for queries. */\nexport var QueryPurpose;\n(function (QueryPurpose) {\n    /** A regular, normal query. */\n    QueryPurpose[QueryPurpose[\"Listen\"] = 0] = \"Listen\";\n    /**\n     * The query was used to refill a query after an existence filter mismatch.\n     */\n    QueryPurpose[QueryPurpose[\"ExistenceFilterMismatch\"] = 1] = \"ExistenceFilterMismatch\";\n    /** The query was used to resolve a limbo document. */\n    QueryPurpose[QueryPurpose[\"LimboResolution\"] = 2] = \"LimboResolution\";\n})(QueryPurpose || (QueryPurpose = {}));\n/**\n * An immutable set of metadata that the local store tracks for each query.\n */\nvar QueryData = /** @class */ (function () {\n    function QueryData(\n        /** The query being listened to. */\n        query, \n        /**\n         * The target ID to which the query corresponds; Assigned by the\n         * LocalStore for user listens and by the SyncEngine for limbo watches.\n         */\n        targetId, \n        /** The purpose of the query. */\n        purpose, \n        /** The latest snapshot version seen for this target. */\n        snapshotVersion, \n        /**\n         * An opaque, server-assigned token that allows watching a query to be\n         * resumed after disconnecting without retransmitting all the data that\n         * matches the query. The resume token essentially identifies a point in\n         * time from which the server should resume sending results.\n         */\n        resumeToken) {\n        if (snapshotVersion === void 0) { snapshotVersion = SnapshotVersion.MIN; }\n        if (resumeToken === void 0) { resumeToken = emptyByteString(); }\n        this.query = query;\n        this.targetId = targetId;\n        this.purpose = purpose;\n        this.snapshotVersion = snapshotVersion;\n        this.resumeToken = resumeToken;\n    }\n    /**\n     * Creates a new query data instance with an updated snapshot version and\n     * resume token.\n     */\n    QueryData.prototype.update = function (updated) {\n        return new QueryData(this.query, this.targetId, this.purpose, updated.snapshotVersion, updated.resumeToken);\n    };\n    QueryData.prototype.isEqual = function (other) {\n        return (this.targetId === other.targetId &&\n            this.purpose === other.purpose &&\n            this.snapshotVersion.isEqual(other.snapshotVersion) &&\n            this.resumeToken === other.resumeToken &&\n            this.query.isEqual(other.query));\n    };\n    return QueryData;\n}());\nexport { QueryData };\n\n//# sourceMappingURL=query_data.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/query_data.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\nimport { primitiveComparator } from '../util/misc';\n// A RegExp matching ISO 8601 UTC timestamps with optional fraction.\nvar isoRegExp = new RegExp(/^\\d{4}-\\d\\d-\\d\\dT\\d\\d:\\d\\d:\\d\\d(?:\\.(\\d+))?Z$/);\nvar Timestamp = /** @class */ (function () {\n    function Timestamp(seconds, nanos) {\n        this.seconds = seconds;\n        this.nanos = nanos;\n        assert(nanos >= 0, 'timestamp nanoseconds out of range: ' + nanos);\n        assert(nanos < 1e9, 'timestamp nanoseconds out of range' + nanos);\n        // Midnight at the beginning of 1/1/1 is the earliest Firestore supports.\n        assert(seconds >= -62135596800, 'timestamp seconds out of range: ' + seconds);\n        // This will break in the year 10,000.\n        assert(seconds < 253402300800, 'timestamp seconds out of range' + seconds);\n    }\n    Timestamp.now = function () {\n        return Timestamp.fromEpochMilliseconds(Date.now());\n    };\n    Timestamp.fromDate = function (date) {\n        return Timestamp.fromEpochMilliseconds(date.getTime());\n    };\n    Timestamp.fromEpochMilliseconds = function (milliseconds) {\n        var seconds = Math.floor(milliseconds / 1000);\n        var nanos = (milliseconds - seconds * 1000) * 1e6;\n        return new Timestamp(seconds, nanos);\n    };\n    Timestamp.fromISOString = function (utc) {\n        // The date string can have higher precision (nanos) than the Date class\n        // (millis), so we do some custom parsing here.\n        // Parse the nanos right out of the string.\n        var nanos = 0;\n        var fraction = isoRegExp.exec(utc);\n        assert(!!fraction, 'invalid timestamp: ' + utc);\n        if (fraction[1]) {\n            // Pad the fraction out to 9 digits (nanos).\n            var nanoStr = fraction[1];\n            nanoStr = (nanoStr + '000000000').substr(0, 9);\n            nanos = Number(nanoStr);\n        }\n        // Parse the date to get the seconds.\n        var date = new Date(utc);\n        var seconds = Math.floor(date.getTime() / 1000);\n        return new Timestamp(seconds, nanos);\n    };\n    Timestamp.prototype.toDate = function () {\n        return new Date(this.toEpochMilliseconds());\n    };\n    Timestamp.prototype.toEpochMilliseconds = function () {\n        return this.seconds * 1000 + this.nanos / 1e6;\n    };\n    Timestamp.prototype.compareTo = function (other) {\n        if (this.seconds === other.seconds) {\n            return primitiveComparator(this.nanos, other.nanos);\n        }\n        return primitiveComparator(this.seconds, other.seconds);\n    };\n    Timestamp.prototype.isEqual = function (other) {\n        return other.seconds === this.seconds && other.nanos === this.nanos;\n    };\n    Timestamp.prototype.toString = function () {\n        return 'Timestamp(seconds=' + this.seconds + ', nanos=' + this.nanos + ')';\n    };\n    return Timestamp;\n}());\nexport { Timestamp };\n\n//# sourceMappingURL=timestamp.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/timestamp.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Timestamp } from './timestamp';\n/**\n * A version of a document in Firestore. This corresponds to the version\n * timestamp, such as update_time or read_time.\n */\nvar SnapshotVersion = /** @class */ (function () {\n    function SnapshotVersion(timestamp) {\n        this.timestamp = timestamp;\n    }\n    // TODO(b/34176344): Once we no longer need to use the old alpha protos,\n    // delete this constructor and use a timestamp-backed version everywhere.\n    SnapshotVersion.fromMicroseconds = function (value) {\n        var seconds = Math.floor(value / 1e6);\n        var nanos = (value % 1e6) * 1e3;\n        return new SnapshotVersion(new Timestamp(seconds, nanos));\n    };\n    SnapshotVersion.fromTimestamp = function (value) {\n        return new SnapshotVersion(value);\n    };\n    SnapshotVersion.forDeletedDoc = function () {\n        return SnapshotVersion.MIN;\n    };\n    SnapshotVersion.prototype.compareTo = function (other) {\n        return this.timestamp.compareTo(other.timestamp);\n    };\n    SnapshotVersion.prototype.isEqual = function (other) {\n        return this.timestamp.isEqual(other.timestamp);\n    };\n    /** Returns a number representation of the version for use in spec tests. */\n    SnapshotVersion.prototype.toMicroseconds = function () {\n        // Convert to microseconds.\n        return this.timestamp.seconds * 1e6 + this.timestamp.nanos / 1000;\n    };\n    SnapshotVersion.prototype.toString = function () {\n        return 'SnapshotVersion(' + this.timestamp.toString() + ')';\n    };\n    SnapshotVersion.prototype.toTimestamp = function () {\n        return this.timestamp;\n    };\n    SnapshotVersion.MIN = new SnapshotVersion(new Timestamp(0, 0));\n    return SnapshotVersion;\n}());\nexport { SnapshotVersion };\n\n//# sourceMappingURL=snapshot_version.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/snapshot_version.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { assert, fail } from '../util/assert';\nimport * as misc from '../util/misc';\nimport { Document, NoDocument } from './document';\nimport { ObjectValue, ServerTimestampValue } from './field_value';\n/**\n * Provides a set of fields that can be used to partially patch a document.\n * FieldMask is used in conjunction with ObjectValue.\n * Examples:\n *   foo - Overwrites foo entirely with the provided value. If foo is not\n *         present in the companion ObjectValue, the field is deleted.\n *   foo.bar - Overwrites only the field bar of the object foo.\n *             If foo is not an object, foo is replaced with an object\n *             containing foo\n */\nvar FieldMask = /** @class */ (function () {\n    function FieldMask(fields) {\n        this.fields = fields;\n        // TODO(dimond): validation of FieldMask\n    }\n    FieldMask.prototype.isEqual = function (other) {\n        return misc.arrayEquals(this.fields, other.fields);\n    };\n    return FieldMask;\n}());\nexport { FieldMask };\n/** Transforms a value into a server-generated timestamp. */\nvar ServerTimestampTransform = /** @class */ (function () {\n    function ServerTimestampTransform() {\n    }\n    ServerTimestampTransform.prototype.isEqual = function (other) {\n        return other instanceof ServerTimestampTransform;\n    };\n    ServerTimestampTransform.instance = new ServerTimestampTransform();\n    return ServerTimestampTransform;\n}());\nexport { ServerTimestampTransform };\n/** A field path and the TransformOperation to perform upon it. */\nvar FieldTransform = /** @class */ (function () {\n    function FieldTransform(field, transform) {\n        this.field = field;\n        this.transform = transform;\n    }\n    FieldTransform.prototype.isEqual = function (other) {\n        return (this.field.isEqual(other.field) && this.transform.isEqual(other.transform));\n    };\n    return FieldTransform;\n}());\nexport { FieldTransform };\n/** The result of successfully applying a mutation to the backend. */\nvar MutationResult = /** @class */ (function () {\n    function MutationResult(\n        /**\n         * The version at which the mutation was committed or null for a delete.\n         */\n        version, \n        /**\n         * The resulting fields returned from the backend after a\n         * TransformMutation has been committed. Contains one FieldValue for each\n         * FieldTransform that was in the mutation.\n         *\n         * Will be null if the mutation was not a TransformMutation.\n         */\n        transformResults) {\n        this.version = version;\n        this.transformResults = transformResults;\n    }\n    return MutationResult;\n}());\nexport { MutationResult };\nexport var MutationType;\n(function (MutationType) {\n    MutationType[MutationType[\"Set\"] = 0] = \"Set\";\n    MutationType[MutationType[\"Patch\"] = 1] = \"Patch\";\n    MutationType[MutationType[\"Transform\"] = 2] = \"Transform\";\n    MutationType[MutationType[\"Delete\"] = 3] = \"Delete\";\n})(MutationType || (MutationType = {}));\n/**\n * Encodes a precondition for a mutation. This follows the model that the\n * backend accepts with the special case of an explicit \"empty\" precondition\n * (meaning no precondition).\n */\nvar Precondition = /** @class */ (function () {\n    function Precondition(updateTime, exists) {\n        this.updateTime = updateTime;\n        this.exists = exists;\n        assert(updateTime === undefined || exists === undefined, 'Precondition can specify \"exists\" or \"updateTime\" but not both');\n    }\n    /** Creates a new Precondition with an exists flag. */\n    Precondition.exists = function (exists) {\n        return new Precondition(undefined, exists);\n    };\n    /** Creates a new Precondition based on a version a document exists at. */\n    Precondition.updateTime = function (version) {\n        return new Precondition(version);\n    };\n    Object.defineProperty(Precondition.prototype, \"isNone\", {\n        /** Returns whether this Precondition is empty. */\n        get: function () {\n            return this.updateTime === undefined && this.exists === undefined;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /**\n     * Returns true if the preconditions is valid for the given document\n     * (or null if no document is available).\n     */\n    Precondition.prototype.isValidFor = function (maybeDoc) {\n        if (this.updateTime !== undefined) {\n            return (maybeDoc instanceof Document &&\n                maybeDoc.version.isEqual(this.updateTime));\n        }\n        else if (this.exists !== undefined) {\n            if (this.exists) {\n                return maybeDoc instanceof Document;\n            }\n            else {\n                return maybeDoc === null || maybeDoc instanceof NoDocument;\n            }\n        }\n        else {\n            assert(this.isNone, 'Precondition should be empty');\n            return true;\n        }\n    };\n    Precondition.prototype.isEqual = function (other) {\n        return (misc.equals(this.updateTime, other.updateTime) &&\n            this.exists === other.exists);\n    };\n    Precondition.NONE = new Precondition();\n    return Precondition;\n}());\nexport { Precondition };\n/**\n * A mutation describes a self-contained change to a document. Mutations can\n * create, replace, delete, and update subsets of documents.\n *\n * Mutations not only act on the value of the document but also it version.\n * In the case of Set, Patch, and Transform mutations we preserve the existing\n * version. In the case of Delete mutations, we reset the version to 0.\n *\n * Here's the expected transition table.\n *\n * MUTATION           APPLIED TO            RESULTS IN\n *\n * SetMutation        Document(v3)          Document(v3)\n * SetMutation        NoDocument(v3)        Document(v0)\n * SetMutation        null                  Document(v0)\n * PatchMutation      Document(v3)          Document(v3)\n * PatchMutation      NoDocument(v3)        NoDocument(v3)\n * PatchMutation      null                  null\n * TransformMutation  Document(v3)          Document(v3)\n * TransformMutation  NoDocument(v3)        NoDocument(v3)\n * TransformMutation  null                  null\n * DeleteMutation     Document(v3)          NoDocument(v0)\n * DeleteMutation     NoDocument(v3)        NoDocument(v0)\n * DeleteMutation     null                  NoDocument(v0)\n *\n * Note that TransformMutations don't create Documents (in the case of being\n * applied to a NoDocument), even though they would on the backend. This is\n * because the client always combines the TransformMutation with a SetMutation\n * or PatchMutation and we only want to apply the transform if the prior\n * mutation resulted in a Document (always true for a SetMutation, but not\n * necessarily for a PatchMutation).\n *\n * ## Subclassing Notes\n *\n * Subclasses of Mutation need to implement applyToRemoteDocument() and\n * applyToLocalView() to implement the actual behavior of applying the mutation\n * to some source document.\n */\nvar Mutation = /** @class */ (function () {\n    function Mutation() {\n    }\n    Mutation.prototype.verifyKeyMatches = function (maybeDoc) {\n        if (maybeDoc != null) {\n            assert(maybeDoc.key.isEqual(this.key), 'Can only apply a mutation to a document with the same key');\n        }\n    };\n    /**\n     * Returns the version from the given document for use as the result of a\n     * mutation. Mutations are defined to return the version of the base document\n     * only if it is an existing document. Deleted and unknown documents have a\n     * post-mutation version of SnapshotVersion.MIN.\n     */\n    Mutation.getPostMutationVersion = function (maybeDoc) {\n        if (maybeDoc instanceof Document) {\n            return maybeDoc.version;\n        }\n        else {\n            return SnapshotVersion.MIN;\n        }\n    };\n    return Mutation;\n}());\nexport { Mutation };\n/**\n * A mutation that creates or replaces the document at the given key with the\n * object value contents.\n */\nvar SetMutation = /** @class */ (function (_super) {\n    __extends(SetMutation, _super);\n    function SetMutation(key, value, precondition) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.value = value;\n        _this.precondition = precondition;\n        _this.type = MutationType.Set;\n        return _this;\n    }\n    SetMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults == null, 'Transform results received by SetMutation.');\n        // Unlike applyToLocalView, if we're applying a mutation to a remote\n        // document the server has accepted the mutation so the precondition must\n        // have held.\n        var version = Mutation.getPostMutationVersion(maybeDoc);\n        return new Document(this.key, version, this.value, {\n            hasLocalMutations: false\n        });\n    };\n    SetMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var version = Mutation.getPostMutationVersion(maybeDoc);\n        return new Document(this.key, version, this.value, {\n            hasLocalMutations: true\n        });\n    };\n    SetMutation.prototype.isEqual = function (other) {\n        return (other instanceof SetMutation &&\n            this.key.isEqual(other.key) &&\n            this.value.isEqual(other.value) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    return SetMutation;\n}(Mutation));\nexport { SetMutation };\n/**\n * A mutation that modifies fields of the document at the given key with the\n * given values. The values are applied through a field mask:\n *\n *  * When a field is in both the mask and the values, the corresponding field\n *    is updated.\n *  * When a field is in neither the mask nor the values, the corresponding\n *    field is unmodified.\n *  * When a field is in the mask but not in the values, the corresponding field\n *    is deleted.\n *  * When a field is not in the mask but is in the values, the values map is\n *    ignored.\n */\nvar PatchMutation = /** @class */ (function (_super) {\n    __extends(PatchMutation, _super);\n    function PatchMutation(key, data, fieldMask, precondition) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.data = data;\n        _this.fieldMask = fieldMask;\n        _this.precondition = precondition;\n        _this.type = MutationType.Patch;\n        return _this;\n    }\n    PatchMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults == null, 'Transform results received by PatchMutation.');\n        // TODO(mcg): Relax enforcement of this precondition\n        //\n        // We shouldn't actually enforce the precondition since it already passed on\n        // the backend, but we may not have a local version of the document to\n        // patch, so we use the precondition to prevent incorrectly putting a\n        // partial document into our cache.\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var version = Mutation.getPostMutationVersion(maybeDoc);\n        var newData = this.patchDocument(maybeDoc);\n        return new Document(this.key, version, newData, {\n            hasLocalMutations: false\n        });\n    };\n    PatchMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var version = Mutation.getPostMutationVersion(maybeDoc);\n        var newData = this.patchDocument(maybeDoc);\n        return new Document(this.key, version, newData, {\n            hasLocalMutations: true\n        });\n    };\n    PatchMutation.prototype.isEqual = function (other) {\n        return (other instanceof PatchMutation &&\n            this.key.isEqual(other.key) &&\n            this.fieldMask.isEqual(other.fieldMask) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    /**\n     * Patches the data of document if available or creates a new document. Note\n     * that this does not check whether or not the precondition of this patch\n     * holds.\n     */\n    PatchMutation.prototype.patchDocument = function (maybeDoc) {\n        var data;\n        if (maybeDoc instanceof Document) {\n            data = maybeDoc.data;\n        }\n        else {\n            data = ObjectValue.EMPTY;\n        }\n        return this.patchObject(data);\n    };\n    PatchMutation.prototype.patchObject = function (data) {\n        for (var _i = 0, _a = this.fieldMask.fields; _i < _a.length; _i++) {\n            var fieldPath = _a[_i];\n            var newValue = this.data.field(fieldPath);\n            if (newValue !== undefined) {\n                data = data.set(fieldPath, newValue);\n            }\n            else {\n                data = data.delete(fieldPath);\n            }\n        }\n        return data;\n    };\n    return PatchMutation;\n}(Mutation));\nexport { PatchMutation };\n/**\n * A mutation that modifies specific fields of the document with transform\n * operations. Currently the only supported transform is a server timestamp, but\n * IP Address, increment(n), etc. could be supported in the future.\n *\n * It is somewhat similar to a PatchMutation in that it patches specific fields\n * and has no effect when applied to a null or NoDocument (see comment on\n * Mutation for rationale).\n */\nvar TransformMutation = /** @class */ (function (_super) {\n    __extends(TransformMutation, _super);\n    function TransformMutation(key, fieldTransforms) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.fieldTransforms = fieldTransforms;\n        _this.type = MutationType.Transform;\n        // NOTE: We set a precondition of exists: true as a safety-check, since we\n        // always combine TransformMutations with a SetMutation or PatchMutation which\n        // (if successful) should end up with an existing document.\n        _this.precondition = Precondition.exists(true);\n        return _this;\n    }\n    TransformMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults != null, 'Transform results missing for TransformMutation.');\n        var transformResults = mutationResult.transformResults;\n        // TODO(mcg): Relax enforcement of this precondition\n        //\n        // We shouldn't actually enforce the precondition since it already passed on\n        // the backend, but we may not have a local version of the document to\n        // patch, so we use the precondition to prevent incorrectly putting a\n        // partial document into our cache.\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var doc = this.requireDocument(maybeDoc);\n        var newData = this.transformObject(doc.data, transformResults);\n        return new Document(this.key, doc.version, newData, {\n            hasLocalMutations: false\n        });\n    };\n    TransformMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        var doc = this.requireDocument(maybeDoc);\n        var transformResults = this.localTransformResults(localWriteTime, baseDoc);\n        var newData = this.transformObject(doc.data, transformResults);\n        return new Document(this.key, doc.version, newData, {\n            hasLocalMutations: true\n        });\n    };\n    TransformMutation.prototype.isEqual = function (other) {\n        return (other instanceof TransformMutation &&\n            this.key.isEqual(other.key) &&\n            misc.arrayEquals(this.fieldTransforms, other.fieldTransforms) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    /**\n     * Asserts that the given MaybeDocument is actually a Document and verifies\n     * that it matches the key for this mutation. Since we only support\n     * transformations with precondition exists this method is guaranteed to be\n     * safe.\n     */\n    TransformMutation.prototype.requireDocument = function (maybeDoc) {\n        assert(maybeDoc instanceof Document, 'Unknown MaybeDocument type ' + maybeDoc);\n        var doc = maybeDoc;\n        assert(doc.key.isEqual(this.key), 'Can only transform a document with the same key');\n        return doc;\n    };\n    /**\n     * Creates a list of \"transform results\" (a transform result is a field value\n     * representing the result of applying a transform) for use when applying a\n     * TransformMutation locally.\n     *\n     * @param localWriteTime The local time of the transform mutation (used to\n     *     generate ServerTimestampValues).\n     * @param baseDoc The document prior to applying this mutation batch.\n     * @return The transform results list.\n     */\n    TransformMutation.prototype.localTransformResults = function (localWriteTime, baseDoc) {\n        var transformResults = [];\n        for (var _i = 0, _a = this.fieldTransforms; _i < _a.length; _i++) {\n            var fieldTransform = _a[_i];\n            var transform = fieldTransform.transform;\n            if (transform instanceof ServerTimestampTransform) {\n                var previousValue = null;\n                if (baseDoc instanceof Document) {\n                    previousValue = baseDoc.field(fieldTransform.field) || null;\n                }\n                transformResults.push(new ServerTimestampValue(localWriteTime, previousValue));\n            }\n            else {\n                return fail('Encountered unknown transform: ' + transform);\n            }\n        }\n        return transformResults;\n    };\n    TransformMutation.prototype.transformObject = function (data, transformResults) {\n        assert(transformResults.length === this.fieldTransforms.length, 'TransformResults length mismatch.');\n        for (var i = 0; i < this.fieldTransforms.length; i++) {\n            var fieldTransform = this.fieldTransforms[i];\n            var transform = fieldTransform.transform;\n            var fieldPath = fieldTransform.field;\n            if (transform instanceof ServerTimestampTransform) {\n                data = data.set(fieldPath, transformResults[i]);\n            }\n            else {\n                return fail('Encountered unknown transform: ' + transform);\n            }\n        }\n        return data;\n    };\n    return TransformMutation;\n}(Mutation));\nexport { TransformMutation };\n/** A mutation that deletes the document at the given key. */\nvar DeleteMutation = /** @class */ (function (_super) {\n    __extends(DeleteMutation, _super);\n    function DeleteMutation(key, precondition) {\n        var _this = _super.call(this) || this;\n        _this.key = key;\n        _this.precondition = precondition;\n        _this.type = MutationType.Delete;\n        return _this;\n    }\n    DeleteMutation.prototype.applyToRemoteDocument = function (maybeDoc, mutationResult) {\n        this.verifyKeyMatches(maybeDoc);\n        assert(mutationResult.transformResults == null, 'Transform results received by DeleteMutation.');\n        // Unlike applyToLocalView, if we're applying a mutation to a remote\n        // document the server has accepted the mutation so the precondition must\n        // have held.\n        return new NoDocument(this.key, SnapshotVersion.MIN);\n    };\n    DeleteMutation.prototype.applyToLocalView = function (maybeDoc, baseDoc, localWriteTime) {\n        this.verifyKeyMatches(maybeDoc);\n        if (!this.precondition.isValidFor(maybeDoc)) {\n            return maybeDoc;\n        }\n        if (maybeDoc) {\n            assert(maybeDoc.key.isEqual(this.key), 'Can only apply mutation to document with same key');\n        }\n        return new NoDocument(this.key, SnapshotVersion.forDeletedDoc());\n    };\n    DeleteMutation.prototype.isEqual = function (other) {\n        return (other instanceof DeleteMutation &&\n            this.key.isEqual(other.key) &&\n            this.precondition.isEqual(other.precondition));\n    };\n    return DeleteMutation;\n}(Mutation));\nexport { DeleteMutation };\n\n//# sourceMappingURL=mutation.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/mutation.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar ExistenceFilter = /** @class */ (function () {\n    // TODO(b/33078163): just use simplest form of existence filter for now\n    function ExistenceFilter(count) {\n        this.count = count;\n    }\n    ExistenceFilter.prototype.isEqual = function (other) {\n        return other && other.count === this.count;\n    };\n    return ExistenceFilter;\n}());\nexport { ExistenceFilter };\n\n//# sourceMappingURL=existence_filter.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/existence_filter.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SortedMap } from './sorted_map';\n/**\n * SortedSet is an immutable (copy-on-write) collection that holds elements\n * in order specified by the provided comparator.\n *\n * NOTE: if provided comparator returns 0 for two elements, we consider them to\n * be equal!\n */\nvar SortedSet = /** @class */ (function () {\n    function SortedSet(comparator) {\n        this.comparator = comparator;\n        this.data = new SortedMap(this.comparator);\n    }\n    /**\n     * Creates a SortedSet from the keys of the map.\n     * This is currently implemented as an O(n) copy.\n     */\n    SortedSet.fromMapKeys = function (map) {\n        var keys = new SortedSet(map.comparator);\n        map.forEach(function (key) {\n            keys = keys.add(key);\n        });\n        return keys;\n    };\n    SortedSet.prototype.has = function (elem) {\n        return this.data.get(elem) !== null;\n    };\n    SortedSet.prototype.first = function () {\n        return this.data.minKey();\n    };\n    SortedSet.prototype.last = function () {\n        return this.data.maxKey();\n    };\n    Object.defineProperty(SortedSet.prototype, \"size\", {\n        get: function () {\n            return this.data.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    SortedSet.prototype.indexOf = function (elem) {\n        return this.data.indexOf(elem);\n    };\n    /** Iterates elements in order defined by \"comparator\" */\n    SortedSet.prototype.forEach = function (cb) {\n        this.data.inorderTraversal(function (k, v) {\n            cb(k);\n            return false;\n        });\n    };\n    /** Iterates over `elem`s such that: range[0] <= elem < range[1]. */\n    SortedSet.prototype.forEachInRange = function (range, cb) {\n        var iter = this.data.getIteratorFrom(range[0]);\n        while (iter.hasNext()) {\n            var elem = iter.getNext();\n            if (this.comparator(elem.key, range[1]) >= 0)\n                return;\n            cb(elem.key);\n        }\n    };\n    /**\n     * Iterates over `elem`s such that: start <= elem until false is returned.\n     */\n    SortedSet.prototype.forEachWhile = function (cb, start) {\n        var iter;\n        if (start !== undefined) {\n            iter = this.data.getIteratorFrom(start);\n        }\n        else {\n            iter = this.data.getIterator();\n        }\n        while (iter.hasNext()) {\n            var elem = iter.getNext();\n            var result = cb(elem.key);\n            if (!result)\n                return;\n        }\n    };\n    /** Finds the least element greater than or equal to `elem`. */\n    SortedSet.prototype.firstAfterOrEqual = function (elem) {\n        var iter = this.data.getIteratorFrom(elem);\n        return iter.hasNext() ? iter.getNext().key : null;\n    };\n    /** Inserts or updates an element */\n    SortedSet.prototype.add = function (elem) {\n        return this.copy(this.data.remove(elem).insert(elem, true));\n    };\n    /** Deletes an element */\n    SortedSet.prototype.delete = function (elem) {\n        if (!this.has(elem))\n            return this;\n        return this.copy(this.data.remove(elem));\n    };\n    SortedSet.prototype.isEmpty = function () {\n        return this.data.isEmpty();\n    };\n    SortedSet.prototype.unionWith = function (other) {\n        var result = this;\n        other.forEach(function (elem) {\n            result = result.add(elem);\n        });\n        return result;\n    };\n    SortedSet.prototype.isEqual = function (other) {\n        if (!(other instanceof SortedSet))\n            return false;\n        if (this.size !== other.size)\n            return false;\n        var thisIt = this.data.getIterator();\n        var otherIt = other.data.getIterator();\n        while (thisIt.hasNext()) {\n            var thisElem = thisIt.getNext().key;\n            var otherElem = otherIt.getNext().key;\n            if (this.comparator(thisElem, otherElem) !== 0)\n                return false;\n        }\n        return true;\n    };\n    SortedSet.prototype.toString = function () {\n        var result = [];\n        this.forEach(function (elem) { return result.push(elem); });\n        return 'SortedSet(' + result.toString() + ')';\n    };\n    SortedSet.prototype.copy = function (data) {\n        var result = new SortedSet(this.comparator);\n        result.data = data;\n        return result;\n    };\n    return SortedSet;\n}());\nexport { SortedSet };\n\n//# sourceMappingURL=sorted_set.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/sorted_set.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { documentKeySet } from '../model/collections';\nimport { emptyByteString } from '../platform/platform';\n/**\n * An event from the RemoteStore. It is split into targetChanges (changes to the\n * state or the set of documents in our watched targets) and documentUpdates\n * (changes to the actual documents).\n */\nvar RemoteEvent = /** @class */ (function () {\n    function RemoteEvent(\n        /**\n         * The snapshot version this event brings us up to, or MIN if not set.\n         */\n        snapshotVersion, \n        /**\n         * A map from target to changes to the target. See TargetChange.\n         */\n        targetChanges, \n        /**\n         * A set of which documents have changed or been deleted, along with the\n         * doc's new values (if not deleted).\n         */\n        documentUpdates) {\n        this.snapshotVersion = snapshotVersion;\n        this.targetChanges = targetChanges;\n        this.documentUpdates = documentUpdates;\n    }\n    RemoteEvent.prototype.addDocumentUpdate = function (doc) {\n        this.documentUpdates = this.documentUpdates.insert(doc.key, doc);\n    };\n    RemoteEvent.prototype.handleExistenceFilterMismatch = function (targetId) {\n        /*\n         * An existence filter mismatch will reset the query and we need to reset\n         * the mapping to contain no documents and an empty resume token.\n         *\n         * Note:\n         *   * The reset mapping is empty, specifically forcing the consumer of the\n         *     change to forget all keys for this targetID;\n         *   * The resume snapshot for this target must be reset\n         *   * The target must be unacked because unwatching and rewatching\n         *     introduces a race for changes.\n         */\n        this.targetChanges[targetId] = {\n            mapping: new ResetMapping(),\n            snapshotVersion: SnapshotVersion.MIN,\n            currentStatusUpdate: CurrentStatusUpdate.MarkNotCurrent,\n            resumeToken: emptyByteString()\n        };\n    };\n    return RemoteEvent;\n}());\nexport { RemoteEvent };\n/**\n * Represents an update to the current status of a target, either explicitly\n * having no new state, or the new value to set. Note \"current\" has special\n * meaning for in the RPC protocol that implies that a target is both up-to-date\n * and consistent with the rest of the watch stream.\n */\nexport var CurrentStatusUpdate;\n(function (CurrentStatusUpdate) {\n    /** The current status is not affected and should not be modified. */\n    CurrentStatusUpdate[CurrentStatusUpdate[\"None\"] = 0] = \"None\";\n    /** The target must be marked as no longer \"current\". */\n    CurrentStatusUpdate[CurrentStatusUpdate[\"MarkNotCurrent\"] = 1] = \"MarkNotCurrent\";\n    /** The target must be marked as \"current\". */\n    CurrentStatusUpdate[CurrentStatusUpdate[\"MarkCurrent\"] = 2] = \"MarkCurrent\";\n})(CurrentStatusUpdate || (CurrentStatusUpdate = {}));\nvar EMPTY_KEY_SET = documentKeySet();\nvar ResetMapping = /** @class */ (function () {\n    function ResetMapping() {\n        this.docs = EMPTY_KEY_SET;\n    }\n    Object.defineProperty(ResetMapping.prototype, \"documents\", {\n        get: function () {\n            return this.docs;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    ResetMapping.prototype.add = function (key) {\n        this.docs = this.docs.add(key);\n    };\n    ResetMapping.prototype.delete = function (key) {\n        this.docs = this.docs.delete(key);\n    };\n    ResetMapping.prototype.isEqual = function (other) {\n        return other !== null && this.docs.isEqual(other.docs);\n    };\n    return ResetMapping;\n}());\nexport { ResetMapping };\nvar UpdateMapping = /** @class */ (function () {\n    function UpdateMapping() {\n        this.addedDocuments = EMPTY_KEY_SET;\n        this.removedDocuments = EMPTY_KEY_SET;\n    }\n    UpdateMapping.prototype.applyToKeySet = function (keys) {\n        var result = keys;\n        this.addedDocuments.forEach(function (key) { return (result = result.add(key)); });\n        this.removedDocuments.forEach(function (key) { return (result = result.delete(key)); });\n        return result;\n    };\n    UpdateMapping.prototype.add = function (key) {\n        this.addedDocuments = this.addedDocuments.add(key);\n        this.removedDocuments = this.removedDocuments.delete(key);\n    };\n    UpdateMapping.prototype.delete = function (key) {\n        this.addedDocuments = this.addedDocuments.delete(key);\n        this.removedDocuments = this.removedDocuments.add(key);\n    };\n    UpdateMapping.prototype.isEqual = function (other) {\n        return (other !== null &&\n            this.addedDocuments.isEqual(other.addedDocuments) &&\n            this.removedDocuments.isEqual(other.removedDocuments));\n    };\n    return UpdateMapping;\n}());\nexport { UpdateMapping };\n\n//# sourceMappingURL=remote_event.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/remote_event.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\n/**\n * Provides a simple helper class that implements the Stream interface to\n * bridge to other implementations that are streams but do not implement the\n * interface. The stream callbacks are invoked with the callOn... methods.\n */\nvar StreamBridge = /** @class */ (function () {\n    function StreamBridge(args) {\n        this.sendFn = args.sendFn;\n        this.closeFn = args.closeFn;\n    }\n    StreamBridge.prototype.onOpen = function (callback) {\n        assert(!this.wrappedOnOpen, 'Called onOpen on stream twice!');\n        this.wrappedOnOpen = callback;\n    };\n    StreamBridge.prototype.onClose = function (callback) {\n        assert(!this.wrappedOnClose, 'Called onClose on stream twice!');\n        this.wrappedOnClose = callback;\n    };\n    StreamBridge.prototype.onMessage = function (callback) {\n        assert(!this.wrappedOnMessage, 'Called onMessage on stream twice!');\n        this.wrappedOnMessage = callback;\n    };\n    StreamBridge.prototype.close = function () {\n        this.closeFn();\n    };\n    StreamBridge.prototype.send = function (msg) {\n        this.sendFn(msg);\n    };\n    StreamBridge.prototype.callOnOpen = function () {\n        assert(this.wrappedOnOpen !== undefined, 'Cannot call onOpen because no callback was set');\n        this.wrappedOnOpen();\n    };\n    StreamBridge.prototype.callOnClose = function (err) {\n        assert(this.wrappedOnClose !== undefined, 'Cannot call onClose because no callback was set');\n        this.wrappedOnClose(err);\n    };\n    StreamBridge.prototype.callOnMessage = function (msg) {\n        assert(this.wrappedOnMessage !== undefined, 'Cannot call onMessage because no callback was set');\n        this.wrappedOnMessage(msg);\n    };\n    return StreamBridge;\n}());\nexport { StreamBridge };\n\n//# sourceMappingURL=stream_bridge.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/stream_bridge.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ErrorCode, EventType, WebChannel, XhrIoPool, createWebChannelTransport } from '@firebase/webchannel-wrapper';\nimport { SDK_VERSION } from '../core/version';\nimport { mapCodeFromHttpStatus, mapCodeFromRpcStatus } from '../remote/rpc_error';\nimport { StreamBridge } from '../remote/stream_bridge';\nimport { assert, fail } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nimport * as log from '../util/log';\nvar LOG_TAG = 'Connection';\nvar RPC_STREAM_SERVICE = 'google.firestore.v1beta1.Firestore';\nvar RPC_URL_VERSION = 'v1beta1';\n/** Maps RPC names to the corresponding REST endpoint name. */\nvar RPC_NAME_REST_MAPPING = {\n    BatchGetDocuments: 'batchGet',\n    Commit: 'commit'\n};\n// TODO(b/38203344): The SDK_VERSION is set independently from Firebase because\n// we are doing out-of-band releases. Once we release as part of Firebase, we\n// should use the Firebase version instead.\nvar X_GOOG_API_CLIENT_VALUE = 'gl-js/ fire/' + SDK_VERSION;\nvar XHR_TIMEOUT_SECS = 15;\nvar WebChannelConnection = /** @class */ (function () {\n    function WebChannelConnection(info) {\n        this.databaseId = info.databaseId;\n        this.pool = new XhrIoPool();\n        var proto = info.ssl ? 'https' : 'http';\n        this.baseUrl = proto + '://' + info.host;\n    }\n    /**\n     * Modifies the headers for a request, adding any authorization token if\n     * present and any additional headers for the request.\n     */\n    WebChannelConnection.prototype.modifyHeadersForRequest = function (headers, token) {\n        if (token) {\n            for (var header in token.authHeaders) {\n                if (token.authHeaders.hasOwnProperty(header)) {\n                    headers[header] = token.authHeaders[header];\n                }\n            }\n        }\n        headers['X-Goog-Api-Client'] = X_GOOG_API_CLIENT_VALUE;\n        // This header is used to improve routing and project isolation by the\n        // backend.\n        headers['google-cloud-resource-prefix'] =\n            \"projects/\" + this.databaseId.projectId + \"/\" +\n                (\"databases/\" + this.databaseId.database);\n    };\n    WebChannelConnection.prototype.invokeRPC = function (rpcName, request, token) {\n        var _this = this;\n        var url = this.makeUrl(rpcName);\n        return new Promise(function (resolve, reject) {\n            // tslint:disable-next-line:no-any XhrIoPool doesn't have TS typings.\n            _this.pool.getObject(function (xhr) {\n                xhr.listenOnce(EventType.COMPLETE, function () {\n                    try {\n                        switch (xhr.getLastErrorCode()) {\n                            case ErrorCode.NO_ERROR:\n                                var json = xhr.getResponseJson();\n                                log.debug(LOG_TAG, 'XHR received:', JSON.stringify(json));\n                                resolve(json);\n                                break;\n                            case ErrorCode.TIMEOUT:\n                                log.debug(LOG_TAG, 'RPC \"' + rpcName + '\" timed out');\n                                reject(new FirestoreError(Code.DEADLINE_EXCEEDED, 'Request time out'));\n                                break;\n                            case ErrorCode.HTTP_ERROR:\n                                var status_1 = xhr.getStatus();\n                                log.debug(LOG_TAG, 'RPC \"' + rpcName + '\" failed with status:', status_1, 'response text:', xhr.getResponseText());\n                                if (status_1 > 0) {\n                                    reject(new FirestoreError(mapCodeFromHttpStatus(status_1), 'Server responded with status ' + xhr.getStatusText()));\n                                }\n                                else {\n                                    // If we received an HTTP_ERROR but there's no status code,\n                                    // it's most probably a connection issue\n                                    log.debug(LOG_TAG, 'RPC \"' + rpcName + '\" failed');\n                                    reject(new FirestoreError(Code.UNAVAILABLE, 'Connection failed.'));\n                                }\n                                break;\n                            default:\n                                fail('RPC \"' +\n                                    rpcName +\n                                    '\" failed with unanticipated ' +\n                                    'webchannel error ' +\n                                    xhr.getLastErrorCode() +\n                                    ': ' +\n                                    xhr.getLastError() +\n                                    ', giving up.');\n                        }\n                    }\n                    finally {\n                        log.debug(LOG_TAG, 'RPC \"' + rpcName + '\" completed.');\n                        _this.pool.releaseObject(xhr);\n                    }\n                });\n                var requestString = JSON.stringify(request);\n                log.debug(LOG_TAG, 'XHR sending: ', url + ' ' + requestString);\n                // Content-Type: text/plain will avoid preflight requests which might\n                // mess with CORS and redirects by proxies. If we add custom headers\n                // we will need to change this code to potentially use the\n                // $httpOverwrite parameter supported by ESF to avoid\n                // triggering preflight requests.\n                var headers = { 'Content-Type': 'text/plain' };\n                _this.modifyHeadersForRequest(headers, token);\n                xhr.send(url, 'POST', requestString, headers, XHR_TIMEOUT_SECS);\n            });\n        });\n    };\n    WebChannelConnection.prototype.invokeStreamingRPC = function (rpcName, request, token) {\n        // The REST API automatically aggregates all of the streamed results, so we\n        // can just use the normal invoke() method.\n        return this.invokeRPC(rpcName, request, token);\n    };\n    WebChannelConnection.prototype.openStream = function (rpcName, token) {\n        var urlParts = [\n            this.baseUrl,\n            '/',\n            RPC_STREAM_SERVICE,\n            '/',\n            rpcName,\n            '/channel'\n        ];\n        var webchannelTransport = createWebChannelTransport();\n        var request = {\n            // Background channel test avoids the initial two test calls and decreases\n            // initial cold start time.\n            // TODO(dimond): wenboz@ mentioned this might affect use with proxies and\n            // we should monitor closely for any reports.\n            backgroundChannelTest: true,\n            // Required for backend stickiness, routing behavior is based on this\n            // parameter.\n            httpSessionIdParam: 'gsessionid',\n            initMessageHeaders: {},\n            // Send our custom headers as a '$httpHeaders=' url param to avoid CORS\n            // preflight round-trip. This is formally defined here:\n            // https://github.com/google/closure-library/blob/b0e1815b13fb92a46d7c9b3c30de5d6a396a3245/closure/goog/net/rpc/httpcors.js#L40\n            httpHeadersOverwriteParam: '$httpHeaders',\n            sendRawJson: true,\n            supportsCrossDomainXhr: true\n        };\n        this.modifyHeadersForRequest(request.initMessageHeaders, token);\n        var url = urlParts.join('');\n        log.debug(LOG_TAG, 'Creating WebChannel: ' + url + ' ' + request);\n        // tslint:disable-next-line:no-any Because listen isn't defined on it.\n        var channel = webchannelTransport.createWebChannel(url, request);\n        // WebChannel supports sending the first message with the handshake - saving\n        // a network round trip. However, it will have to call send in the same\n        // JS event loop as open. In order to enforce this, we delay actually\n        // opening the WebChannel until send is called. Whether we have called\n        // open is tracked with this variable.\n        var opened = false;\n        // A flag to determine whether the stream was closed (by us or through an\n        // error/close event) to avoid delivering multiple close events or sending\n        // on a closed stream\n        var closed = false;\n        var streamBridge = new StreamBridge({\n            sendFn: function (msg) {\n                if (!closed) {\n                    if (!opened) {\n                        log.debug(LOG_TAG, 'Opening WebChannel transport.');\n                        channel.open();\n                        opened = true;\n                    }\n                    log.debug(LOG_TAG, 'WebChannel sending:', msg);\n                    channel.send(msg);\n                }\n                else {\n                    log.debug(LOG_TAG, 'Not sending because WebChannel is closed:', msg);\n                }\n            },\n            closeFn: function () { return channel.close(); }\n        });\n        // Closure events are guarded and exceptions are swallowed, so catch any\n        // exception and rethrow using a setTimeout so they become visible again.\n        // Note that eventually this function could go away if we are confident\n        // enough the code is exception free.\n        var unguardedEventListen = function (type, fn) {\n            // TODO(dimond): closure typing seems broken because WebChannel does\n            // not implement goog.events.Listenable\n            channel.listen(type, function (param) {\n                try {\n                    fn(param);\n                }\n                catch (e) {\n                    setTimeout(function () {\n                        throw e;\n                    }, 0);\n                }\n            });\n        };\n        unguardedEventListen(WebChannel.EventType.OPEN, function () {\n            if (!closed) {\n                log.debug(LOG_TAG, 'WebChannel transport opened.');\n            }\n        });\n        unguardedEventListen(WebChannel.EventType.CLOSE, function () {\n            if (!closed) {\n                closed = true;\n                log.debug(LOG_TAG, 'WebChannel transport closed');\n                streamBridge.callOnClose();\n            }\n        });\n        unguardedEventListen(WebChannel.EventType.ERROR, function (err) {\n            if (!closed) {\n                closed = true;\n                log.debug(LOG_TAG, 'WebChannel transport errored:', err);\n                streamBridge.callOnClose(new FirestoreError(Code.UNAVAILABLE, 'The operation could not be completed'));\n            }\n        });\n        unguardedEventListen(WebChannel.EventType.MESSAGE, function (msg) {\n            if (!closed) {\n                var msgData = msg.data[0];\n                assert(!!msgData, 'Got a webchannel message without data.');\n                // TODO(b/35143891): There is a bug in One Platform that caused errors\n                // (and only errors) to be wrapped in an extra array. To be forward\n                // compatible with the bug we need to check either condition. The latter\n                // can be removed once the fix has been rolled out.\n                var error = \n                // tslint:disable-next-line:no-any msgData.error is not typed.\n                msgData.error || (msgData[0] && msgData[0].error);\n                if (error) {\n                    log.debug(LOG_TAG, 'WebChannel received error:', error);\n                    // error.status will be a string like 'OK' or 'NOT_FOUND'.\n                    var status_2 = error.status;\n                    var code = mapCodeFromRpcStatus(status_2);\n                    var message = error.message;\n                    if (code === undefined) {\n                        code = Code.INTERNAL;\n                        message =\n                            'Unknown error status: ' +\n                                status_2 +\n                                ' with message ' +\n                                error.message;\n                    }\n                    // Mark closed so no further events are propagated\n                    closed = true;\n                    streamBridge.callOnClose(new FirestoreError(code, message));\n                    channel.close();\n                }\n                else {\n                    log.debug(LOG_TAG, 'WebChannel received:', msgData);\n                    streamBridge.callOnMessage(msgData);\n                }\n            }\n        });\n        setTimeout(function () {\n            // Technically we could/should wait for the WebChannel opened event,\n            // but because we want to send the first message with the WebChannel\n            // handshake we pretend the channel opened here (asynchronously), and\n            // then delay the actual open until the first message is sent.\n            streamBridge.callOnOpen();\n        }, 0);\n        return streamBridge;\n    };\n    // visible for testing\n    WebChannelConnection.prototype.makeUrl = function (rpcName) {\n        var urlRpcName = RPC_NAME_REST_MAPPING[rpcName];\n        assert(urlRpcName !== undefined, 'Unknown REST mapping for: ' + rpcName);\n        var url = [this.baseUrl, '/', RPC_URL_VERSION];\n        url.push('/projects/');\n        url.push(this.databaseId.projectId);\n        url.push('/databases/');\n        url.push(this.databaseId.database);\n        url.push('/documents');\n        url.push(':');\n        url.push(urlRpcName);\n        return url.join('');\n    };\n    return WebChannelConnection;\n}());\nexport { WebChannelConnection };\n\n//# sourceMappingURL=webchannel_connection.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/platform_browser/webchannel_connection.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { JsonProtoSerializer } from '../remote/serializer';\nimport { WebChannelConnection } from './webchannel_connection';\nvar BrowserPlatform = /** @class */ (function () {\n    function BrowserPlatform() {\n        this.emptyByteString = '';\n        this.base64Available = typeof atob !== 'undefined';\n    }\n    BrowserPlatform.prototype.loadConnection = function (databaseInfo) {\n        return Promise.resolve(new WebChannelConnection(databaseInfo));\n    };\n    BrowserPlatform.prototype.newSerializer = function (databaseId) {\n        return new JsonProtoSerializer(databaseId, { useProto3Json: true });\n    };\n    BrowserPlatform.prototype.formatJSON = function (value) {\n        return JSON.stringify(value);\n    };\n    BrowserPlatform.prototype.atob = function (encoded) {\n        return atob(encoded);\n    };\n    BrowserPlatform.prototype.btoa = function (raw) {\n        return btoa(raw);\n    };\n    return BrowserPlatform;\n}());\nexport { BrowserPlatform };\n\n//# sourceMappingURL=browser_platform.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/platform_browser/browser_platform.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { PlatformSupport } from '../platform/platform';\nimport { BrowserPlatform } from './browser_platform';\n/**\n * This code needs to run before Firestore is used. This can be achieved in\n * several ways:\n *   1) Through the JSCompiler compiling this code and then (automatically)\n *      executing it before exporting the Firestore symbols.\n *   2) Through importing this module first in a Firestore main module\n */\nPlatformSupport.setPlatform(new BrowserPlatform());\n\n//# sourceMappingURL=browser_init.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/platform_browser/browser_init.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Describes the online state of the Firestore client. Note that this does not\n * indicate whether or not the remote store is trying to connect or not. This is\n * primarily used by the View / EventManager code to change their behavior while\n * offline (e.g. get() calls shouldn't wait for data from the server and\n * snapshot events should set metadata.isFromCache=true).\n */\nexport var OnlineState;\n(function (OnlineState) {\n    /**\n     * The Firestore client is in an unknown online state. This means the client\n     * is either not actively trying to establish a connection or it is currently\n     * trying to establish a connection, but it has not succeeded or failed yet.\n     * Higher-level components should not operate in offline mode.\n     */\n    OnlineState[OnlineState[\"Unknown\"] = 0] = \"Unknown\";\n    /**\n     * The client is connected and the connections are healthy. This state is\n     * reached after a successful connection and there has been at least one\n     * successful message received from the backends.\n     */\n    OnlineState[OnlineState[\"Healthy\"] = 1] = \"Healthy\";\n    /**\n     * The client is either trying to establish a connection but failing, or it\n     * has been explicitly marked offline via a call to disableNetwork().\n     * Higher-level components should operate in offline mode.\n     */\n    OnlineState[OnlineState[\"Failed\"] = 2] = \"Failed\";\n})(OnlineState || (OnlineState = {}));\n\n//# sourceMappingURL=types.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/types.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DocumentKey } from '../model/document_key';\nimport { fail } from '../util/assert';\nimport { SortedMap } from '../util/sorted_map';\nexport var ChangeType;\n(function (ChangeType) {\n    ChangeType[ChangeType[\"Added\"] = 0] = \"Added\";\n    ChangeType[ChangeType[\"Removed\"] = 1] = \"Removed\";\n    ChangeType[ChangeType[\"Modified\"] = 2] = \"Modified\";\n    ChangeType[ChangeType[\"Metadata\"] = 3] = \"Metadata\";\n})(ChangeType || (ChangeType = {}));\nexport var SyncState;\n(function (SyncState) {\n    SyncState[SyncState[\"Local\"] = 0] = \"Local\";\n    SyncState[SyncState[\"Synced\"] = 1] = \"Synced\";\n})(SyncState || (SyncState = {}));\n/**\n * DocumentChangeSet keeps track of a set of changes to docs in a query, merging\n * duplicate events for the same doc.\n */\nvar DocumentChangeSet = /** @class */ (function () {\n    function DocumentChangeSet() {\n        this.changeMap = new SortedMap(DocumentKey.comparator);\n    }\n    DocumentChangeSet.prototype.track = function (change) {\n        var key = change.doc.key;\n        var oldChange = this.changeMap.get(key);\n        if (!oldChange) {\n            this.changeMap = this.changeMap.insert(key, change);\n            return;\n        }\n        // Merge the new change with the existing change.\n        if (change.type !== ChangeType.Added &&\n            oldChange.type === ChangeType.Metadata) {\n            this.changeMap = this.changeMap.insert(key, change);\n        }\n        else if (change.type === ChangeType.Metadata &&\n            oldChange.type !== ChangeType.Removed) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: oldChange.type,\n                doc: change.doc\n            });\n        }\n        else if (change.type === ChangeType.Modified &&\n            oldChange.type === ChangeType.Modified) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Modified,\n                doc: change.doc\n            });\n        }\n        else if (change.type === ChangeType.Modified &&\n            oldChange.type === ChangeType.Added) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Added,\n                doc: change.doc\n            });\n        }\n        else if (change.type === ChangeType.Removed &&\n            oldChange.type === ChangeType.Added) {\n            this.changeMap = this.changeMap.remove(key);\n        }\n        else if (change.type === ChangeType.Removed &&\n            oldChange.type === ChangeType.Modified) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Removed,\n                doc: oldChange.doc\n            });\n        }\n        else if (change.type === ChangeType.Added &&\n            oldChange.type === ChangeType.Removed) {\n            this.changeMap = this.changeMap.insert(key, {\n                type: ChangeType.Modified,\n                doc: change.doc\n            });\n        }\n        else {\n            // This includes these cases, which don't make sense:\n            // Added->Added\n            // Removed->Removed\n            // Modified->Added\n            // Removed->Modified\n            // Metadata->Added\n            // Removed->Metadata\n            fail('unsupported combination of changes: ' +\n                JSON.stringify(change) +\n                ' after ' +\n                JSON.stringify(oldChange));\n        }\n    };\n    DocumentChangeSet.prototype.getChanges = function () {\n        var changes = [];\n        this.changeMap.inorderTraversal(function (key, change) {\n            changes.push(change);\n        });\n        return changes;\n    };\n    return DocumentChangeSet;\n}());\nexport { DocumentChangeSet };\nvar ViewSnapshot = /** @class */ (function () {\n    function ViewSnapshot(query, docs, oldDocs, docChanges, fromCache, hasPendingWrites, syncStateChanged) {\n        this.query = query;\n        this.docs = docs;\n        this.oldDocs = oldDocs;\n        this.docChanges = docChanges;\n        this.fromCache = fromCache;\n        this.hasPendingWrites = hasPendingWrites;\n        this.syncStateChanged = syncStateChanged;\n    }\n    ViewSnapshot.prototype.isEqual = function (other) {\n        if (this.fromCache !== other.fromCache ||\n            this.hasPendingWrites !== other.hasPendingWrites ||\n            this.syncStateChanged !== other.syncStateChanged ||\n            !this.query.isEqual(other.query) ||\n            !this.docs.isEqual(other.docs) ||\n            !this.oldDocs.isEqual(other.oldDocs)) {\n            return false;\n        }\n        var changes = this.docChanges;\n        var otherChanges = other.docChanges;\n        if (changes.length !== otherChanges.length) {\n            return false;\n        }\n        for (var i = 0; i < changes.length; i++) {\n            if (changes[i].type !== otherChanges[i].type ||\n                !changes[i].doc.isEqual(otherChanges[i].doc)) {\n                return false;\n            }\n        }\n        return true;\n    };\n    return ViewSnapshot;\n}());\nexport { ViewSnapshot };\n\n//# sourceMappingURL=view_snapshot.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/view_snapshot.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar RESERVED_BITS = 1;\nvar GeneratorIds;\n(function (GeneratorIds) {\n    GeneratorIds[GeneratorIds[\"LocalStore\"] = 0] = \"LocalStore\";\n    GeneratorIds[GeneratorIds[\"SyncEngine\"] = 1] = \"SyncEngine\";\n})(GeneratorIds || (GeneratorIds = {}));\n/**\n * TargetIdGenerator generates monotonically increasing integer IDs. There are\n * separate generators for different scopes. While these generators will operate\n * independently of each other, they are scoped, such that no two generators\n * will ever produce the same ID. This is useful, because sometimes the backend\n * may group IDs from separate parts of the client into the same ID space.\n */\nvar TargetIdGenerator = /** @class */ (function () {\n    function TargetIdGenerator(generatorId, initAfter) {\n        if (initAfter === void 0) { initAfter = 0; }\n        this.generatorId = generatorId;\n        // Replace the generator part of initAfter with this generator's ID.\n        var afterWithoutGenerator = (initAfter >> RESERVED_BITS) << RESERVED_BITS;\n        var afterGenerator = initAfter - afterWithoutGenerator;\n        if (afterGenerator >= generatorId) {\n            // For example, if:\n            //   this.generatorId = 0b0000\n            //   after = 0b1011\n            //   afterGenerator = 0b0001\n            // Then:\n            //   previous = 0b1010\n            //   next = 0b1100\n            this.previousId = afterWithoutGenerator | this.generatorId;\n        }\n        else {\n            // For example, if:\n            //   this.generatorId = 0b0001\n            //   after = 0b1010\n            //   afterGenerator = 0b0000\n            // Then:\n            //   previous = 0b1001\n            //   next = 0b1011\n            this.previousId =\n                (afterWithoutGenerator | this.generatorId) - (1 << RESERVED_BITS);\n        }\n    }\n    TargetIdGenerator.prototype.next = function () {\n        this.previousId += 1 << RESERVED_BITS;\n        return this.previousId;\n    };\n    TargetIdGenerator.forLocalStore = function (initAfter) {\n        if (initAfter === void 0) { initAfter = 0; }\n        return new TargetIdGenerator(GeneratorIds.LocalStore, initAfter);\n    };\n    TargetIdGenerator.forSyncEngine = function () {\n        return new TargetIdGenerator(GeneratorIds.SyncEngine);\n    };\n    return TargetIdGenerator;\n}());\nexport { TargetIdGenerator };\n\n//# sourceMappingURL=target_id_generator.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/target_id_generator.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SortedMap } from '../util/sorted_map';\nimport { documentMap } from './collections';\nimport { DocumentKey } from './document_key';\n/**\n * DocumentSet is an immutable (copy-on-write) collection that holds documents\n * in order specified by the provided comparator. We always add a document key\n * comparator on top of what is provided to guarantee document equality based on\n * the key.\n */\nvar DocumentSet = /** @class */ (function () {\n    /** The default ordering is by key if the comparator is omitted */\n    function DocumentSet(comp) {\n        // We are adding document key comparator to the end as it's the only\n        // guaranteed unique property of a document.\n        if (comp) {\n            this.comparator = function (d1, d2) {\n                return comp(d1, d2) || DocumentKey.comparator(d1.key, d2.key);\n            };\n        }\n        else {\n            this.comparator = function (d1, d2) {\n                return DocumentKey.comparator(d1.key, d2.key);\n            };\n        }\n        this.keyedMap = documentMap();\n        this.sortedSet = new SortedMap(this.comparator);\n    }\n    /**\n     * Returns an empty copy of the existing DocumentSet, using the same\n     * comparator.\n     */\n    DocumentSet.emptySet = function (oldSet) {\n        return new DocumentSet(oldSet.comparator);\n    };\n    DocumentSet.prototype.has = function (key) {\n        return this.keyedMap.get(key) != null;\n    };\n    DocumentSet.prototype.get = function (key) {\n        return this.keyedMap.get(key);\n    };\n    DocumentSet.prototype.first = function () {\n        return this.sortedSet.minKey();\n    };\n    DocumentSet.prototype.last = function () {\n        return this.sortedSet.maxKey();\n    };\n    DocumentSet.prototype.isEmpty = function () {\n        return this.sortedSet.isEmpty();\n    };\n    /**\n     * Returns the index of the provided key in the document set, or -1 if the\n     * document key is not present in the set;\n     */\n    DocumentSet.prototype.indexOf = function (key) {\n        var doc = this.keyedMap.get(key);\n        return doc ? this.sortedSet.indexOf(doc) : -1;\n    };\n    Object.defineProperty(DocumentSet.prototype, \"size\", {\n        get: function () {\n            return this.sortedSet.size;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    /** Iterates documents in order defined by \"comparator\" */\n    DocumentSet.prototype.forEach = function (cb) {\n        this.sortedSet.inorderTraversal(function (k, v) {\n            cb(k);\n            return false;\n        });\n    };\n    /** Inserts or updates a document with the same key */\n    DocumentSet.prototype.add = function (doc) {\n        // First remove the element if we have it.\n        var set = this.delete(doc.key);\n        return set.copy(set.keyedMap.insert(doc.key, doc), set.sortedSet.insert(doc, null));\n    };\n    /** Deletes a document with a given key */\n    DocumentSet.prototype.delete = function (key) {\n        var doc = this.get(key);\n        if (!doc) {\n            return this;\n        }\n        return this.copy(this.keyedMap.remove(key), this.sortedSet.remove(doc));\n    };\n    DocumentSet.prototype.isEqual = function (other) {\n        if (!(other instanceof DocumentSet))\n            return false;\n        if (this.size !== other.size)\n            return false;\n        var thisIt = this.sortedSet.getIterator();\n        var otherIt = other.sortedSet.getIterator();\n        while (thisIt.hasNext()) {\n            var thisDoc = thisIt.getNext().key;\n            var otherDoc = otherIt.getNext().key;\n            if (!thisDoc.isEqual(otherDoc))\n                return false;\n        }\n        return true;\n    };\n    DocumentSet.prototype.toString = function () {\n        var docStrings = [];\n        this.forEach(function (doc) {\n            docStrings.push(doc.toString());\n        });\n        if (docStrings.length === 0) {\n            return 'DocumentSet ()';\n        }\n        else {\n            return 'DocumentSet (\\n  ' + docStrings.join('  \\n') + '\\n)';\n        }\n    };\n    DocumentSet.prototype.copy = function (keyedMap, sortedSet) {\n        var newSet = new DocumentSet();\n        newSet.comparator = this.comparator;\n        newSet.keyedMap = keyedMap;\n        newSet.sortedSet = sortedSet;\n        return newSet;\n    };\n    return DocumentSet;\n}());\nexport { DocumentSet };\n\n//# sourceMappingURL=document_set.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/document_set.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport * as objUtil from './obj';\n/**\n * A map implementation that uses objects as keys. Objects must implement the\n * Equatable interface and must be immutable. Entries in the map are stored\n * together with the key being produced from the mapKeyFn. This map\n * automatically handles collisions of keys.\n */\nvar ObjectMap = /** @class */ (function () {\n    function ObjectMap(mapKeyFn) {\n        this.mapKeyFn = mapKeyFn;\n        /**\n         * The inner map for a key -> value pair. Due to the possibility of\n         * collisions we keep a list of entries that we do a linear search through\n         * to find an actual match. Note that collisions should be rare, so we still\n         * expect near constant time lookups in practice.\n         */\n        this.inner = {};\n    }\n    /** Get a value for this key, or undefined if it does not exist. */\n    ObjectMap.prototype.get = function (key) {\n        var id = this.mapKeyFn(key);\n        var matches = this.inner[id];\n        if (matches === undefined) {\n            return undefined;\n        }\n        for (var _i = 0, matches_1 = matches; _i < matches_1.length; _i++) {\n            var _a = matches_1[_i], otherKey = _a[0], value = _a[1];\n            if (otherKey.isEqual(key)) {\n                return value;\n            }\n        }\n        return undefined;\n    };\n    ObjectMap.prototype.has = function (key) {\n        return this.get(key) !== undefined;\n    };\n    /** Put this key and value in the map. */\n    ObjectMap.prototype.set = function (key, value) {\n        var id = this.mapKeyFn(key);\n        var matches = this.inner[id];\n        if (matches === undefined) {\n            this.inner[id] = [[key, value]];\n            return;\n        }\n        for (var i = 0; i < matches.length; i++) {\n            if (matches[i][0].isEqual(key)) {\n                matches[i] = [key, value];\n                return;\n            }\n        }\n        matches.push([key, value]);\n    };\n    /**\n     * Remove this key from the map. Returns a boolean if anything was deleted.\n     */\n    ObjectMap.prototype.delete = function (key) {\n        var id = this.mapKeyFn(key);\n        var matches = this.inner[id];\n        if (matches === undefined) {\n            return false;\n        }\n        for (var i = 0; i < matches.length; i++) {\n            if (matches[i][0].isEqual(key)) {\n                if (matches.length === 1) {\n                    delete this.inner[id];\n                }\n                else {\n                    matches.splice(i, 1);\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    ObjectMap.prototype.forEach = function (fn) {\n        objUtil.forEach(this.inner, function (_, entries) {\n            for (var _i = 0, entries_1 = entries; _i < entries_1.length; _i++) {\n                var _a = entries_1[_i], k = _a[0], v = _a[1];\n                fn(k, v);\n            }\n        });\n    };\n    ObjectMap.prototype.isEmpty = function () {\n        return objUtil.isEmpty(this.inner);\n    };\n    return ObjectMap;\n}());\nexport { ObjectMap };\n\n//# sourceMappingURL=obj_map.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/obj_map.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { OnlineState } from './types';\nimport { ChangeType, ViewSnapshot } from './view_snapshot';\nimport { DocumentSet } from '../model/document_set';\nimport { assert } from '../util/assert';\nimport { ObjectMap } from '../util/obj_map';\n/**\n * Holds the listeners and the last received ViewSnapshot for a query being\n * tracked by EventManager.\n */\nvar QueryListenersInfo = /** @class */ (function () {\n    function QueryListenersInfo() {\n        this.listeners = [];\n    }\n    return QueryListenersInfo;\n}());\n/**\n * EventManager is responsible for mapping queries to query event emitters.\n * It handles \"fan-out\". -- Identical queries will re-use the same watch on the\n * backend.\n */\nvar EventManager = /** @class */ (function () {\n    function EventManager(syncEngine) {\n        this.syncEngine = syncEngine;\n        this.queries = new ObjectMap(function (q) {\n            return q.canonicalId();\n        });\n        this.onlineState = OnlineState.Unknown;\n        this.syncEngine.subscribe(this.onChange.bind(this), this.onError.bind(this));\n    }\n    EventManager.prototype.listen = function (listener) {\n        var query = listener.query;\n        var firstListen = false;\n        var queryInfo = this.queries.get(query);\n        if (!queryInfo) {\n            firstListen = true;\n            queryInfo = new QueryListenersInfo();\n            this.queries.set(query, queryInfo);\n        }\n        queryInfo.listeners.push(listener);\n        listener.applyOnlineStateChange(this.onlineState);\n        if (queryInfo.viewSnap)\n            listener.onViewSnapshot(queryInfo.viewSnap);\n        if (firstListen) {\n            return this.syncEngine.listen(query).then(function (targetId) {\n                queryInfo.targetId = targetId;\n                return targetId;\n            });\n        }\n        else {\n            return Promise.resolve(queryInfo.targetId);\n        }\n    };\n    EventManager.prototype.unlisten = function (listener) {\n        var query = listener.query;\n        var lastListen = false;\n        var queryInfo = this.queries.get(query);\n        if (queryInfo) {\n            var i = queryInfo.listeners.indexOf(listener);\n            if (i >= 0) {\n                queryInfo.listeners.splice(i, 1);\n                lastListen = queryInfo.listeners.length === 0;\n            }\n        }\n        if (lastListen) {\n            this.queries.delete(query);\n            return this.syncEngine.unlisten(query);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    EventManager.prototype.onChange = function (viewSnaps) {\n        for (var _i = 0, viewSnaps_1 = viewSnaps; _i < viewSnaps_1.length; _i++) {\n            var viewSnap = viewSnaps_1[_i];\n            var query = viewSnap.query;\n            var queryInfo = this.queries.get(query);\n            if (queryInfo) {\n                for (var _a = 0, _b = queryInfo.listeners; _a < _b.length; _a++) {\n                    var listener = _b[_a];\n                    listener.onViewSnapshot(viewSnap);\n                }\n                queryInfo.viewSnap = viewSnap;\n            }\n        }\n    };\n    EventManager.prototype.onError = function (query, error) {\n        var queryInfo = this.queries.get(query);\n        if (queryInfo) {\n            for (var _i = 0, _a = queryInfo.listeners; _i < _a.length; _i++) {\n                var listener = _a[_i];\n                listener.onError(error);\n            }\n        }\n        // Remove all listeners. NOTE: We don't need to call syncEngine.unlisten()\n        // after an error.\n        this.queries.delete(query);\n    };\n    EventManager.prototype.applyOnlineStateChange = function (onlineState) {\n        this.onlineState = onlineState;\n        this.queries.forEach(function (_, queryInfo) {\n            for (var _i = 0, _a = queryInfo.listeners; _i < _a.length; _i++) {\n                var listener = _a[_i];\n                listener.applyOnlineStateChange(onlineState);\n            }\n        });\n    };\n    return EventManager;\n}());\nexport { EventManager };\n/**\n * QueryListener takes a series of internal view snapshots and determines\n * when to raise the event.\n *\n * It uses an Observer to dispatch events.\n */\nvar QueryListener = /** @class */ (function () {\n    function QueryListener(query, queryObserver, options) {\n        this.query = query;\n        this.queryObserver = queryObserver;\n        /**\n         * Initial snapshots (e.g. from cache) may not be propagated to the wrapped\n         * observer. This flag is set to true once we've actually raised an event.\n         */\n        this.raisedInitialEvent = false;\n        this.onlineState = OnlineState.Unknown;\n        this.options = options || {};\n    }\n    QueryListener.prototype.onViewSnapshot = function (snap) {\n        assert(snap.docChanges.length > 0 || snap.syncStateChanged, 'We got a new snapshot with no changes?');\n        if (!this.options.includeDocumentMetadataChanges) {\n            // Remove the metadata only changes.\n            var docChanges = [];\n            for (var _i = 0, _a = snap.docChanges; _i < _a.length; _i++) {\n                var docChange = _a[_i];\n                if (docChange.type !== ChangeType.Metadata) {\n                    docChanges.push(docChange);\n                }\n            }\n            snap = new ViewSnapshot(snap.query, snap.docs, snap.oldDocs, docChanges, snap.fromCache, snap.hasPendingWrites, snap.syncStateChanged);\n        }\n        if (!this.raisedInitialEvent) {\n            if (this.shouldRaiseInitialEvent(snap, this.onlineState)) {\n                this.raiseInitialEvent(snap);\n            }\n        }\n        else if (this.shouldRaiseEvent(snap)) {\n            this.queryObserver.next(snap);\n        }\n        this.snap = snap;\n    };\n    QueryListener.prototype.onError = function (error) {\n        this.queryObserver.error(error);\n    };\n    QueryListener.prototype.applyOnlineStateChange = function (onlineState) {\n        this.onlineState = onlineState;\n        if (this.snap &&\n            !this.raisedInitialEvent &&\n            this.shouldRaiseInitialEvent(this.snap, onlineState)) {\n            this.raiseInitialEvent(this.snap);\n        }\n    };\n    QueryListener.prototype.shouldRaiseInitialEvent = function (snap, onlineState) {\n        assert(!this.raisedInitialEvent, 'Determining whether to raise first event but already had first event');\n        // Always raise the first event when we're synced\n        if (!snap.fromCache) {\n            return true;\n        }\n        // NOTE: We consider OnlineState.Unknown as online (it should become Failed\n        // or Online if we wait long enough).\n        var maybeOnline = onlineState !== OnlineState.Failed;\n        // Don't raise the event if we're online, aren't synced yet (checked\n        // above) and are waiting for a sync.\n        if (this.options.waitForSyncWhenOnline && maybeOnline) {\n            assert(snap.fromCache, 'Waiting for sync, but snapshot is not from cache');\n            return false;\n        }\n        // Raise data from cache if we have any documents or we are offline\n        return !snap.docs.isEmpty() || onlineState === OnlineState.Failed;\n    };\n    QueryListener.prototype.shouldRaiseEvent = function (snap) {\n        // We don't need to handle includeDocumentMetadataChanges here because\n        // the Metadata only changes have already been stripped out if needed.\n        // At this point the only changes we will see are the ones we should\n        // propagate.\n        if (snap.docChanges.length > 0) {\n            return true;\n        }\n        var hasPendingWritesChanged = this.snap && this.snap.hasPendingWrites !== snap.hasPendingWrites;\n        if (snap.syncStateChanged || hasPendingWritesChanged) {\n            return this.options.includeQueryMetadataChanges === true;\n        }\n        // Generally we should have hit one of the cases above, but it's possible\n        // to get here if there were only metadata docChanges and they got\n        // stripped out.\n        return false;\n    };\n    QueryListener.prototype.raiseInitialEvent = function (snap) {\n        assert(!this.raisedInitialEvent, 'Trying to raise initial events for second time');\n        snap = new ViewSnapshot(snap.query, snap.docs, DocumentSet.emptySet(snap.docs), QueryListener.getInitialViewChanges(snap), snap.fromCache, snap.hasPendingWrites, true);\n        this.raisedInitialEvent = true;\n        this.queryObserver.next(snap);\n    };\n    /** Returns changes as if all documents in the snap were added. */\n    QueryListener.getInitialViewChanges = function (snap) {\n        var result = [];\n        snap.docs.forEach(function (doc) {\n            result.push({ type: ChangeType.Added, doc: doc });\n        });\n        return result;\n    };\n    return QueryListener;\n}());\nexport { QueryListener };\n\n//# sourceMappingURL=event_manager.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/event_manager.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { fail } from '../util/assert';\n/**\n * PersistencePromise<> is essentially a re-implementation of Promise<> except\n * it has a .next() method instead of .then() and .next() and .catch() callbacks\n * are executed synchronously when a PersistencePromise resolves rather than\n * asynchronously (Promise<> implementations use setImmediate() or similar).\n *\n * This is necessary to interoperate with IndexedDB which will automatically\n * commit transactions if control is returned to the event loop without\n * synchronously initiating another operation on the transaction.\n *\n * NOTE: .then() and .catch() only allow a single consumer, unlike normal\n * Promises.\n */\nvar PersistencePromise = /** @class */ (function () {\n    function PersistencePromise(callback) {\n        var _this = this;\n        // NOTE: next/catchCallback will always point to our own wrapper functions,\n        // not the user's raw next() or catch() callbacks.\n        // tslint:disable-next-line:no-any Accept any result type for the next call in the Promise chain.\n        this.nextCallback = null;\n        // tslint:disable-next-line:no-any Accept any result type for the error handler.\n        this.catchCallback = null;\n        // When the operation resolves, we'll set result or error and mark isDone.\n        this.result = undefined;\n        this.error = undefined;\n        this.isDone = false;\n        // Set to true when .then() or .catch() are called and prevents additional\n        // chaining.\n        this.callbackAttached = false;\n        callback(function (value) {\n            _this.isDone = true;\n            _this.result = value;\n            if (_this.nextCallback) {\n                // value should be defined unless T is Void, but we can't express\n                // that in the type system.\n                _this.nextCallback(value);\n            }\n        }, function (error) {\n            _this.isDone = true;\n            _this.error = error;\n            if (_this.catchCallback) {\n                _this.catchCallback(error);\n            }\n        });\n    }\n    PersistencePromise.prototype.catch = function (fn) {\n        return this.next(undefined, fn);\n    };\n    PersistencePromise.prototype.next = function (nextFn, catchFn) {\n        var _this = this;\n        if (this.callbackAttached) {\n            fail('Called next() or catch() twice for PersistencePromise');\n        }\n        this.callbackAttached = true;\n        if (this.isDone) {\n            if (!this.error) {\n                return this.wrapSuccess(nextFn, this.result);\n            }\n            else {\n                return this.wrapFailure(catchFn, this.error);\n            }\n        }\n        else {\n            return new PersistencePromise(function (resolve, reject) {\n                _this.nextCallback = function (value) {\n                    _this.wrapSuccess(nextFn, value).next(resolve, reject);\n                };\n                _this.catchCallback = function (error) {\n                    _this.wrapFailure(catchFn, error).next(resolve, reject);\n                };\n            });\n        }\n    };\n    PersistencePromise.prototype.toPromise = function () {\n        var _this = this;\n        return new Promise(function (resolve, reject) {\n            _this.next(resolve, reject);\n        });\n    };\n    PersistencePromise.prototype.wrapUserFunction = function (fn) {\n        try {\n            var result = fn();\n            if (result instanceof PersistencePromise) {\n                return result;\n            }\n            else {\n                return PersistencePromise.resolve(result);\n            }\n        }\n        catch (e) {\n            return PersistencePromise.reject(e);\n        }\n    };\n    PersistencePromise.prototype.wrapSuccess = function (nextFn, value) {\n        if (nextFn) {\n            return this.wrapUserFunction(function () { return nextFn(value); });\n        }\n        else {\n            // If there's no nextFn, then R must be the same as T but we\n            // can't express that in the type system.\n            // tslint:disable-next-line:no-any\n            return PersistencePromise.resolve(value);\n        }\n    };\n    PersistencePromise.prototype.wrapFailure = function (catchFn, error) {\n        if (catchFn) {\n            return this.wrapUserFunction(function () { return catchFn(error); });\n        }\n        else {\n            return PersistencePromise.reject(error);\n        }\n    };\n    PersistencePromise.resolve = function (result) {\n        return new PersistencePromise(function (resolve, reject) {\n            resolve(result);\n        });\n    };\n    PersistencePromise.reject = function (error) {\n        return new PersistencePromise(function (resolve, reject) {\n            reject(error);\n        });\n    };\n    PersistencePromise.waitFor = function (\n        // tslint:disable-next-line:no-any Accept all Promise types in waitFor().\n        all) {\n        return all.reduce(function (promise, nextPromise, idx) {\n            return promise.next(function () {\n                return nextPromise;\n            });\n        }, PersistencePromise.resolve());\n    };\n    PersistencePromise.map = function (all) {\n        var results = [];\n        var first = true;\n        // initial is ignored, so we can cheat on the type.\n        // tslint:disable-next-line:no-any\n        var initial = PersistencePromise.resolve(null);\n        return all\n            .reduce(function (promise, nextPromise) {\n            return promise.next(function (result) {\n                if (!first) {\n                    results.push(result);\n                }\n                first = false;\n                return nextPromise;\n            });\n        }, initial)\n            .next(function (result) {\n            results.push(result);\n            return results;\n        });\n    };\n    return PersistencePromise;\n}());\nexport { PersistencePromise };\n\n//# sourceMappingURL=persistence_promise.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/persistence_promise.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentKeySet } from '../model/collections';\nimport { PersistencePromise } from './persistence_promise';\n/**\n * A garbage collector implementation that eagerly collects documents as soon as\n * they're no longer referenced in any of its registered GarbageSources.\n *\n * This implementation keeps track of a set of keys that are potentially garbage\n * without keeping an exact reference count. During collectGarbage, the\n * collector verifies that all potential garbage keys actually have no\n * references by consulting its list of garbage sources.\n */\nvar EagerGarbageCollector = /** @class */ (function () {\n    function EagerGarbageCollector() {\n        this.isEager = true;\n        /**\n         * The garbage collectible sources to double-check during garbage collection.\n         */\n        this.sources = [];\n        /**\n         * A set of potentially garbage keys.\n         * PORTING NOTE: This would be a mutable set if Javascript had one.\n         */\n        this.potentialGarbage = documentKeySet();\n    }\n    EagerGarbageCollector.prototype.addGarbageSource = function (garbageSource) {\n        this.sources.push(garbageSource);\n        garbageSource.setGarbageCollector(this);\n    };\n    EagerGarbageCollector.prototype.removeGarbageSource = function (garbageSource) {\n        this.sources.splice(this.sources.indexOf(garbageSource), 1);\n        garbageSource.setGarbageCollector(null);\n    };\n    EagerGarbageCollector.prototype.addPotentialGarbageKey = function (key) {\n        this.potentialGarbage = this.potentialGarbage.add(key);\n    };\n    EagerGarbageCollector.prototype.collectGarbage = function (txn) {\n        var _this = this;\n        var promises = [];\n        var garbageKeys = documentKeySet();\n        this.potentialGarbage.forEach(function (key) {\n            var hasRefsPromise = _this.documentHasAnyReferences(txn, key);\n            promises.push(hasRefsPromise.next(function (hasRefs) {\n                // If there are no references, get the key.\n                if (!hasRefs) {\n                    garbageKeys = garbageKeys.add(key);\n                }\n                return PersistencePromise.resolve();\n            }));\n        });\n        // Clear locally retained potential keys and returned confirmed garbage.\n        this.potentialGarbage = documentKeySet();\n        return PersistencePromise.waitFor(promises).next(function () { return garbageKeys; });\n    };\n    EagerGarbageCollector.prototype.documentHasAnyReferences = function (txn, key) {\n        var initial = PersistencePromise.resolve(false);\n        return this.sources\n            .map(function (source) { return function () { return source.containsKey(txn, key); }; })\n            .reduce(function (promise, nextPromise) {\n            return promise.next(function (result) {\n                if (result) {\n                    return PersistencePromise.resolve(true);\n                }\n                else {\n                    return nextPromise();\n                }\n            });\n        }, initial);\n    };\n    return EagerGarbageCollector;\n}());\nexport { EagerGarbageCollector };\n\n//# sourceMappingURL=eager_garbage_collector.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/eager_garbage_collector.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { ChangeType } from '../core/view_snapshot';\nimport { documentKeySet } from '../model/collections';\n/**\n * A set of changes to what documents are currently in view and out of view for\n * a given query. These changes are sent to the LocalStore by the View (via\n * the SyncEngine) and are used to pin / unpin documents as appropriate.\n */\nvar LocalViewChanges = /** @class */ (function () {\n    function LocalViewChanges(query, addedKeys, removedKeys) {\n        this.query = query;\n        this.addedKeys = addedKeys;\n        this.removedKeys = removedKeys;\n    }\n    LocalViewChanges.fromSnapshot = function (viewSnapshot) {\n        var addedKeys = documentKeySet();\n        var removedKeys = documentKeySet();\n        for (var _i = 0, _a = viewSnapshot.docChanges; _i < _a.length; _i++) {\n            var docChange = _a[_i];\n            switch (docChange.type) {\n                case ChangeType.Added:\n                    addedKeys = addedKeys.add(docChange.doc.key);\n                    break;\n                case ChangeType.Removed:\n                    removedKeys = removedKeys.add(docChange.doc.key);\n                    break;\n                default:\n            }\n        }\n        return new LocalViewChanges(viewSnapshot.query, addedKeys, removedKeys);\n    };\n    return LocalViewChanges;\n}());\nexport { LocalViewChanges };\n\n//# sourceMappingURL=local_view_changes.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/local_view_changes.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentKeySet } from '../model/collections';\nimport { DocumentKey } from '../model/document_key';\nimport { primitiveComparator } from '../util/misc';\nimport { SortedSet } from '../util/sorted_set';\nimport { PersistencePromise } from './persistence_promise';\n/**\n * A collection of references to a document from some kind of numbered entity\n * (either a target ID or batch ID). As references are added to or removed from\n * the set corresponding events are emitted to a registered garbage collector.\n *\n * Each reference is represented by a DocumentReference object. Each of them\n * contains enough information to uniquely identify the reference. They are all\n * stored primarily in a set sorted by key. A document is considered garbage if\n * there's no references in that set (this can be efficiently checked thanks to\n * sorting by key).\n *\n * ReferenceSet also keeps a secondary set that contains references sorted by\n * IDs. This one is used to efficiently implement removal of all references by\n * some target ID.\n */\nvar ReferenceSet = /** @class */ (function () {\n    function ReferenceSet() {\n        // A set of outstanding references to a document sorted by key.\n        this.refsByKey = new SortedSet(DocReference.compareByKey);\n        // A set of outstanding references to a document sorted by target id.\n        this.refsByTarget = new SortedSet(DocReference.compareByTargetId);\n        /** Keeps track of keys that have references */\n        this.garbageCollector = null;\n    }\n    /** Returns true if the reference set contains no references. */\n    ReferenceSet.prototype.isEmpty = function () {\n        return this.refsByKey.isEmpty();\n    };\n    /** Adds a reference to the given document key for the given ID. */\n    ReferenceSet.prototype.addReference = function (key, id) {\n        var ref = new DocReference(key, id);\n        this.refsByKey = this.refsByKey.add(ref);\n        this.refsByTarget = this.refsByTarget.add(ref);\n    };\n    /** Add references to the given document keys for the given ID. */\n    ReferenceSet.prototype.addReferences = function (keys, id) {\n        var _this = this;\n        keys.forEach(function (key) { return _this.addReference(key, id); });\n    };\n    /**\n     * Removes a reference to the given document key for the given\n     * ID.\n     */\n    ReferenceSet.prototype.removeReference = function (key, id) {\n        this.removeRef(new DocReference(key, id));\n    };\n    ReferenceSet.prototype.removeReferences = function (keys, id) {\n        var _this = this;\n        keys.forEach(function (key) { return _this.removeReference(key, id); });\n    };\n    /**\n     * Clears all references with a given ID. Calls removeRef() for each key\n     * removed.\n     */\n    ReferenceSet.prototype.removeReferencesForId = function (id) {\n        var _this = this;\n        var emptyKey = DocumentKey.EMPTY;\n        var startRef = new DocReference(emptyKey, id);\n        var endRef = new DocReference(emptyKey, id + 1);\n        this.refsByTarget.forEachInRange([startRef, endRef], function (ref) {\n            _this.removeRef(ref);\n        });\n    };\n    ReferenceSet.prototype.removeAllReferences = function () {\n        var _this = this;\n        this.refsByKey.forEach(function (ref) { return _this.removeRef(ref); });\n    };\n    ReferenceSet.prototype.removeRef = function (ref) {\n        this.refsByKey = this.refsByKey.delete(ref);\n        this.refsByTarget = this.refsByTarget.delete(ref);\n        if (this.garbageCollector !== null) {\n            this.garbageCollector.addPotentialGarbageKey(ref.key);\n        }\n    };\n    ReferenceSet.prototype.referencesForId = function (id) {\n        var emptyKey = DocumentKey.EMPTY;\n        var startRef = new DocReference(emptyKey, id);\n        var endRef = new DocReference(emptyKey, id + 1);\n        var keys = documentKeySet();\n        this.refsByTarget.forEachInRange([startRef, endRef], function (ref) {\n            keys = keys.add(ref.key);\n        });\n        return keys;\n    };\n    ReferenceSet.prototype.setGarbageCollector = function (garbageCollector) {\n        this.garbageCollector = garbageCollector;\n    };\n    ReferenceSet.prototype.containsKey = function (txn, key) {\n        var ref = new DocReference(key, 0);\n        var firstRef = this.refsByKey.firstAfterOrEqual(ref);\n        return PersistencePromise.resolve(firstRef !== null && key.isEqual(firstRef.key));\n    };\n    return ReferenceSet;\n}());\nexport { ReferenceSet };\nvar DocReference = /** @class */ (function () {\n    function DocReference(key, targetOrBatchId) {\n        this.key = key;\n        this.targetOrBatchId = targetOrBatchId;\n    }\n    /** Compare by key then by ID */\n    DocReference.compareByKey = function (left, right) {\n        return (DocumentKey.comparator(left.key, right.key) ||\n            primitiveComparator(left.targetOrBatchId, right.targetOrBatchId));\n    };\n    /** Compare by ID then by key */\n    DocReference.compareByTargetId = function (left, right) {\n        return (primitiveComparator(left.targetOrBatchId, right.targetOrBatchId) ||\n            DocumentKey.comparator(left.key, right.key));\n    };\n    return DocReference;\n}());\nexport { DocReference };\n\n//# sourceMappingURL=reference_set.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/reference_set.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert, fail } from './assert';\nimport * as log from './log';\nimport { Deferred } from './promise';\nimport { Code, FirestoreError } from './error';\n/**\n * Wellknown \"timer\" IDs used when scheduling delayed operations on the\n * AsyncQueue. These IDs can then be used from tests to check for the presence\n * of operations or to run them early.\n */\nexport var TimerId;\n(function (TimerId) {\n    TimerId[TimerId[\"ListenStreamIdle\"] = 0] = \"ListenStreamIdle\";\n    TimerId[TimerId[\"ListenStreamConnection\"] = 1] = \"ListenStreamConnection\";\n    TimerId[TimerId[\"WriteStreamIdle\"] = 2] = \"WriteStreamIdle\";\n    TimerId[TimerId[\"WriteStreamConnection\"] = 3] = \"WriteStreamConnection\";\n})(TimerId || (TimerId = {}));\n/**\n * Represents an operation scheduled to be run in the future on an AsyncQueue.\n *\n * It is created via DelayedOperation.createAndSchedule().\n *\n * Supports cancellation (via cancel()) and early execution (via skipDelay()).\n */\nvar DelayedOperation = /** @class */ (function () {\n    function DelayedOperation(asyncQueue, timerId, targetTimeMs, op, removalCallback) {\n        this.asyncQueue = asyncQueue;\n        this.timerId = timerId;\n        this.targetTimeMs = targetTimeMs;\n        this.op = op;\n        this.removalCallback = removalCallback;\n        this.deferred = new Deferred();\n        this.then = this.deferred.promise.then.bind(this.deferred.promise);\n        this.catch = this.deferred.promise.catch.bind(this.deferred.promise);\n    }\n    /**\n     * Creates and returns a DelayedOperation that has been scheduled to be\n     * executed on the provided asyncQueue after the provided delayMs.\n     *\n     * @param asyncQueue The queue to schedule the operation on.\n     * @param id A Timer ID identifying the type of operation this is.\n     * @param delayMs The delay (ms) before the operation should be scheduled.\n     * @param op The operation to run.\n     * @param removalCallback A callback to be called synchronously once the\n     *   operation is executed or canceled, notifying the AsyncQueue to remove it\n     *   from its delayedOperations list.\n     *   PORTING NOTE: This exists to prevent making removeDelayedOperation() and\n     *   the DelayedOperation class public.\n     */\n    DelayedOperation.createAndSchedule = function (asyncQueue, timerId, delayMs, op, removalCallback) {\n        var targetTime = Date.now() + delayMs;\n        var delayedOp = new DelayedOperation(asyncQueue, timerId, targetTime, op, removalCallback);\n        delayedOp.start(delayMs);\n        return delayedOp;\n    };\n    /**\n     * Starts the timer. This is called immediately after construction by\n     * createAndSchedule().\n     */\n    DelayedOperation.prototype.start = function (delayMs) {\n        var _this = this;\n        this.timerHandle = setTimeout(function () { return _this.handleDelayElapsed(); }, delayMs);\n    };\n    /**\n     * Queues the operation to run immediately (if it hasn't already been run or\n     * canceled).\n     */\n    DelayedOperation.prototype.skipDelay = function () {\n        return this.handleDelayElapsed();\n    };\n    /**\n     * Cancels the operation if it hasn't already been executed or canceled. The\n     * promise will be rejected.\n     *\n     * As long as the operation has not yet been run, calling cancel() provides a\n     * guarantee that the operation will not be run.\n     */\n    DelayedOperation.prototype.cancel = function (reason) {\n        if (this.timerHandle !== null) {\n            this.clearTimeout();\n            this.deferred.reject(new FirestoreError(Code.CANCELLED, 'Operation cancelled' + (reason ? ': ' + reason : '')));\n        }\n    };\n    DelayedOperation.prototype.handleDelayElapsed = function () {\n        var _this = this;\n        this.asyncQueue.enqueue(function () {\n            if (_this.timerHandle !== null) {\n                _this.clearTimeout();\n                return _this.op().then(function (result) {\n                    return _this.deferred.resolve(result);\n                });\n            }\n            else {\n                return Promise.resolve();\n            }\n        });\n    };\n    DelayedOperation.prototype.clearTimeout = function () {\n        if (this.timerHandle !== null) {\n            this.removalCallback(this);\n            clearTimeout(this.timerHandle);\n            this.timerHandle = null;\n        }\n    };\n    return DelayedOperation;\n}());\nvar AsyncQueue = /** @class */ (function () {\n    function AsyncQueue() {\n        // The last promise in the queue.\n        this.tail = Promise.resolve();\n        // Operations scheduled to be queued in the future. Operations are\n        // automatically removed after they are run or canceled.\n        this.delayedOperations = [];\n        // Flag set while there's an outstanding AsyncQueue operation, used for\n        // assertion sanity-checks.\n        this.operationInProgress = false;\n    }\n    /**\n     * Adds a new operation to the queue. Returns a promise that will be resolved\n     * when the promise returned by the new operation is (with its value).\n     */\n    AsyncQueue.prototype.enqueue = function (op) {\n        var _this = this;\n        this.verifyNotFailed();\n        var newTail = this.tail.then(function () {\n            _this.operationInProgress = true;\n            return op()\n                .catch(function (error) {\n                _this.failure = error;\n                _this.operationInProgress = false;\n                var message = error.stack || error.message || '';\n                log.error('INTERNAL UNHANDLED ERROR: ', message);\n                // Escape the promise chain and throw the error globally so that\n                // e.g. any global crash reporting library detects and reports it.\n                // (but not for simulated errors in our tests since this breaks mocha)\n                if (message.indexOf('Firestore Test Simulated Error') < 0) {\n                    setTimeout(function () {\n                        throw error;\n                    }, 0);\n                }\n                // Re-throw the error so that this.tail becomes a rejected Promise and\n                // all further attempts to chain (via .then) will just short-circuit\n                // and return the rejected Promise.\n                throw error;\n            })\n                .then(function (result) {\n                _this.operationInProgress = false;\n                return result;\n            });\n        });\n        this.tail = newTail;\n        return newTail;\n    };\n    /**\n     * Schedules an operation to be queued on the AsyncQueue once the specified\n     * `delayMs` has elapsed. The returned CancelablePromise can be used to cancel\n     * the operation prior to its running.\n     */\n    AsyncQueue.prototype.enqueueAfterDelay = function (timerId, delayMs, op) {\n        var _this = this;\n        this.verifyNotFailed();\n        // While not necessarily harmful, we currently don't expect to have multiple\n        // ops with the same timer id in the queue, so defensively reject them.\n        assert(!this.containsDelayedOperation(timerId), \"Attempted to schedule multiple operations with timer id \" + TimerId[timerId] + \".\");\n        var delayedOp = DelayedOperation.createAndSchedule(this, timerId, delayMs, op, function (op) { return _this.removeDelayedOperation(op); });\n        this.delayedOperations.push(delayedOp);\n        return delayedOp;\n    };\n    AsyncQueue.prototype.verifyNotFailed = function () {\n        if (this.failure) {\n            fail('AsyncQueue is already failed: ' +\n                (this.failure.stack || this.failure.message));\n        }\n    };\n    /**\n     * Verifies there's an operation currently in-progress on the AsyncQueue.\n     * Unfortunately we can't verify that the running code is in the promise chain\n     * of that operation, so this isn't a foolproof check, but it should be enough\n     * to catch some bugs.\n     */\n    AsyncQueue.prototype.verifyOperationInProgress = function () {\n        assert(this.operationInProgress, 'verifyOpInProgress() called when no op in progress on this queue.');\n    };\n    /**\n     * Waits until all currently queued tasks are finished executing. Delayed\n     * operations are not run.\n     */\n    AsyncQueue.prototype.drain = function () {\n        return this.enqueue(function () { return Promise.resolve(); });\n    };\n    /**\n     * For Tests: Determine if a delayed operation with a particular TimerId\n     * exists.\n     */\n    AsyncQueue.prototype.containsDelayedOperation = function (timerId) {\n        return this.delayedOperations.findIndex(function (op) { return op.timerId === timerId; }) >= 0;\n    };\n    /**\n     * For Tests: Runs some or all delayed operations early.\n     *\n     * @param lastTimerId If specified, only delayed operations up to and\n     *   including this TimerId will be drained. Throws if no such operation\n     *   exists.\n     * @returns a Promise that resolves once all operations have been run.\n     */\n    AsyncQueue.prototype.runDelayedOperationsEarly = function (lastTimerId) {\n        var _this = this;\n        // Note that draining may generate more delayed ops, so we do that first.\n        return this.drain().then(function () {\n            assert(lastTimerId === undefined || _this.containsDelayedOperation(lastTimerId), \"Attempted to drain to missing operation \" + lastTimerId);\n            // Run ops in the same order they'd run if they ran naturally.\n            _this.delayedOperations.sort(function (a, b) { return a.targetTimeMs - b.targetTimeMs; });\n            for (var _i = 0, _a = _this.delayedOperations; _i < _a.length; _i++) {\n                var op = _a[_i];\n                op.skipDelay();\n                if (lastTimerId !== undefined && op.timerId === lastTimerId) {\n                    break;\n                }\n            }\n            return _this.drain();\n        });\n    };\n    /** Called once a DelayedOperation is run or canceled. */\n    AsyncQueue.prototype.removeDelayedOperation = function (op) {\n        // NOTE: indexOf / slice are O(n), but delayedOperations is expected to be small.\n        var index = this.delayedOperations.indexOf(op);\n        assert(index >= 0, 'Delayed operation not found.');\n        this.delayedOperations.splice(index, 1);\n    };\n    return AsyncQueue;\n}());\nexport { AsyncQueue };\n\n//# sourceMappingURL=async_queue.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/async_queue.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { EagerGarbageCollector } from '../local/eager_garbage_collector';\nimport { LocalViewChanges } from '../local/local_view_changes';\nimport { QueryData, QueryPurpose } from '../local/query_data';\nimport { ReferenceSet } from '../local/reference_set';\nimport { NoDocument } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { CurrentStatusUpdate, RemoteEvent } from '../remote/remote_event';\nimport { assert, fail } from '../util/assert';\nimport * as log from '../util/log';\nimport { primitiveComparator } from '../util/misc';\nimport * as objUtils from '../util/obj';\nimport { ObjectMap } from '../util/obj_map';\nimport { SortedMap } from '../util/sorted_map';\nimport { isNullOrUndefined } from '../util/types';\nimport { Query } from './query';\nimport { SnapshotVersion } from './snapshot_version';\nimport { TargetIdGenerator } from './target_id_generator';\nimport { AddedLimboDocument, RemovedLimboDocument, View } from './view';\nvar LOG_TAG = 'SyncEngine';\n/**\n * QueryView contains all of the data that SyncEngine needs to keep track of for\n * a particular query.\n */\nvar QueryView = /** @class */ (function () {\n    function QueryView(\n        /**\n         * The query itself.\n         */\n        query, \n        /**\n         * The target number created by the client that is used in the watch\n         * stream to identify this query.\n         */\n        targetId, \n        /**\n         * An identifier from the datastore backend that indicates the last state\n         * of the results that was received. This can be used to indicate where\n         * to continue receiving new doc changes for the query.\n         */\n        resumeToken, \n        /**\n         * The view is responsible for computing the final merged truth of what\n         * docs are in the query. It gets notified of local and remote changes,\n         * and applies the query filters and limits to determine the most correct\n         * possible results.\n         */\n        view) {\n        this.query = query;\n        this.targetId = targetId;\n        this.resumeToken = resumeToken;\n        this.view = view;\n    }\n    return QueryView;\n}());\n/**\n * SyncEngine is the central controller in the client SDK architecture. It is\n * the glue code between the EventManager, LocalStore, and RemoteStore. Some of\n * SyncEngine's responsibilities include:\n * 1. Coordinating client requests and remote events between the EventManager\n *    and the local and remote data stores.\n * 2. Managing a View object for each query, providing the unified view between\n *    the local and remote data stores.\n * 3. Notifying the RemoteStore when the LocalStore has new mutations in its\n *    queue that need sending to the backend.\n *\n * The SyncEngine’s methods should only ever be called by methods running in the\n * global async queue.\n */\nvar SyncEngine = /** @class */ (function () {\n    function SyncEngine(localStore, remoteStore, currentUser) {\n        this.localStore = localStore;\n        this.remoteStore = remoteStore;\n        this.currentUser = currentUser;\n        this.viewHandler = null;\n        this.errorHandler = null;\n        this.queryViewsByQuery = new ObjectMap(function (q) {\n            return q.canonicalId();\n        });\n        this.queryViewsByTarget = {};\n        this.limboTargetsByKey = new SortedMap(DocumentKey.comparator);\n        this.limboKeysByTarget = {};\n        this.limboDocumentRefs = new ReferenceSet();\n        this.limboCollector = new EagerGarbageCollector();\n        /** Stores user completion handlers, indexed by User and BatchId. */\n        this.mutationUserCallbacks = {};\n        this.targetIdGenerator = TargetIdGenerator.forSyncEngine();\n    }\n    /** Subscribes view and error handler. Can be called only once. */\n    SyncEngine.prototype.subscribe = function (viewHandler, errorHandler) {\n        assert(viewHandler !== null && errorHandler !== null, 'View and error handlers cannot be null');\n        assert(this.viewHandler === null && this.errorHandler === null, 'SyncEngine already has a subscriber.');\n        this.viewHandler = viewHandler;\n        this.errorHandler = errorHandler;\n        this.limboCollector.addGarbageSource(this.limboDocumentRefs);\n    };\n    /**\n     * Initiates the new listen, resolves promise when listen enqueued to the\n     * server. All the subsequent view snapshots or errors are sent to the\n     * subscribed handlers. Returns the targetId of the query.\n     */\n    SyncEngine.prototype.listen = function (query) {\n        var _this = this;\n        this.assertSubscribed('listen()');\n        assert(!this.queryViewsByQuery.has(query), 'We already listen to the query: ' + query);\n        return this.localStore.allocateQuery(query).then(function (queryData) {\n            return _this.localStore\n                .executeQuery(query)\n                .then(function (docs) {\n                return _this.localStore\n                    .remoteDocumentKeys(queryData.targetId)\n                    .then(function (remoteKeys) {\n                    var view = new View(query, remoteKeys);\n                    var viewDocChanges = view.computeDocChanges(docs);\n                    var viewChange = view.applyChanges(viewDocChanges);\n                    assert(viewChange.limboChanges.length === 0, 'View returned limbo docs before target ack from the server.');\n                    assert(!!viewChange.snapshot, 'applyChanges for new view should always return a snapshot');\n                    var data = new QueryView(query, queryData.targetId, queryData.resumeToken, view);\n                    _this.queryViewsByQuery.set(query, data);\n                    _this.queryViewsByTarget[queryData.targetId] = data;\n                    _this.viewHandler([viewChange.snapshot]);\n                    _this.remoteStore.listen(queryData);\n                });\n            })\n                .then(function () {\n                return queryData.targetId;\n            });\n        });\n    };\n    /** Stops listening to the query. */\n    SyncEngine.prototype.unlisten = function (query) {\n        var _this = this;\n        this.assertSubscribed('unlisten()');\n        var queryView = this.queryViewsByQuery.get(query);\n        assert(!!queryView, 'Trying to unlisten on query not found:' + query);\n        return this.localStore.releaseQuery(query).then(function () {\n            _this.remoteStore.unlisten(queryView.targetId);\n            return _this.removeAndCleanupQuery(queryView).then(function () {\n                return _this.localStore.collectGarbage();\n            });\n        });\n    };\n    /**\n     * Initiates the write of local mutation batch which involves adding the\n     * writes to the mutation queue, notifying the remote store about new\n     * mutations and raising events for any changes this write caused.\n     *\n     * The promise returned by this call is resolved when the above steps\n     * have completed, *not* when the write was acked by the backend. The\n     * userCallback is resolved once the write was acked/rejected by the\n     * backend (or failed locally for any other reason).\n     */\n    SyncEngine.prototype.write = function (batch, userCallback) {\n        var _this = this;\n        this.assertSubscribed('write()');\n        return this.localStore\n            .localWrite(batch)\n            .then(function (result) {\n            _this.addMutationCallback(result.batchId, userCallback);\n            return _this.emitNewSnapsAndNotifyLocalStore(result.changes);\n        })\n            .then(function () {\n            return _this.remoteStore.fillWritePipeline();\n        });\n    };\n    // TODO(klimt): Wrap the given error in a standard Firestore error object.\n    SyncEngine.prototype.wrapUpdateFunctionError = function (error) {\n        return error;\n    };\n    /**\n     * Takes an updateFunction in which a set of reads and writes can be performed\n     * atomically. In the updateFunction, the client can read and write values\n     * using the supplied transaction object. After the updateFunction, all\n     * changes will be committed. If some other client has changed any of the data\n     * referenced, then the updateFunction will be called again. If the\n     * updateFunction still fails after the given number of retries, then the\n     * transaction will be rejection.\n     *\n     * The transaction object passed to the updateFunction contains methods for\n     * accessing documents and collections. Unlike other datastore access, data\n     * accessed with the transaction will not reflect local changes that have not\n     * been committed. For this reason, it is required that all reads are\n     * performed before any writes. Transactions must be performed while online.\n     *\n     * The promise returned is resolved when the transaction is fully committed.\n     */\n    SyncEngine.prototype.runTransaction = function (updateFunction, retries) {\n        var _this = this;\n        if (retries === void 0) { retries = 5; }\n        assert(retries >= 0, 'Got negative number of retries for transaction.');\n        var transaction = this.remoteStore.createTransaction();\n        var wrappedUpdateFunction = function () {\n            try {\n                var userPromise = updateFunction(transaction);\n                if (isNullOrUndefined(userPromise) ||\n                    !userPromise.catch ||\n                    !userPromise.then) {\n                    return Promise.reject(Error('Transaction callback must return a Promise'));\n                }\n                return userPromise.catch(function (e) {\n                    return Promise.reject(_this.wrapUpdateFunctionError(e));\n                });\n            }\n            catch (e) {\n                return Promise.reject(_this.wrapUpdateFunctionError(e));\n            }\n        };\n        return wrappedUpdateFunction().then(function (result) {\n            return transaction\n                .commit()\n                .then(function () {\n                return result;\n            })\n                .catch(function (error) {\n                if (retries === 0) {\n                    return Promise.reject(error);\n                }\n                // TODO(klimt): Put in a retry delay?\n                return _this.runTransaction(updateFunction, retries - 1);\n            });\n        });\n    };\n    SyncEngine.prototype.applyRemoteEvent = function (remoteEvent) {\n        var _this = this;\n        this.assertSubscribed('applyRemoteEvent()');\n        // Make sure limbo documents are deleted if there were no results\n        objUtils.forEachNumber(remoteEvent.targetChanges, function (targetId, targetChange) {\n            var limboKey = _this.limboKeysByTarget[targetId];\n            if (limboKey &&\n                targetChange.currentStatusUpdate ===\n                    CurrentStatusUpdate.MarkCurrent &&\n                !remoteEvent.documentUpdates.get(limboKey)) {\n                // When listening to a query the server responds with a snapshot\n                // containing documents matching the query and a current marker\n                // telling us we're now in sync. It's possible for these to arrive\n                // as separate remote events or as a single remote event.\n                // For a document query, there will be no documents sent in the\n                // response if the document doesn't exist.\n                //\n                // If the snapshot arrives separately from the current marker,\n                // we handle it normally and updateTrackedLimbos will resolve the\n                // limbo status of the document, removing it from limboDocumentRefs.\n                // This works because clients only initiate limbo resolution when\n                // a target is current and because all current targets are\n                // always at a consistent snapshot.\n                //\n                // However, if the document doesn't exist and the current marker\n                // arrives, the document is not present in the snapshot and our\n                // normal view handling would consider the document to remain in\n                // limbo indefinitely because there are no updates to the document.\n                // To avoid this, we specially handle this just this case here:\n                // synthesizing a delete.\n                //\n                // TODO(dimond): Ideally we would have an explicit lookup query\n                // instead resulting in an explicit delete message and we could\n                // remove this special logic.\n                remoteEvent.addDocumentUpdate(new NoDocument(limboKey, remoteEvent.snapshotVersion));\n            }\n        });\n        return this.localStore.applyRemoteEvent(remoteEvent).then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes, remoteEvent);\n        });\n    };\n    /**\n     * Applies an OnlineState change to the sync engine and notifies any views of\n     * the change.\n     */\n    SyncEngine.prototype.applyOnlineStateChange = function (onlineState) {\n        var newViewSnapshots = [];\n        this.queryViewsByQuery.forEach(function (query, queryView) {\n            var viewChange = queryView.view.applyOnlineStateChange(onlineState);\n            assert(viewChange.limboChanges.length === 0, 'OnlineState should not affect limbo documents.');\n            if (viewChange.snapshot) {\n                newViewSnapshots.push(viewChange.snapshot);\n            }\n        });\n        this.viewHandler(newViewSnapshots);\n    };\n    SyncEngine.prototype.rejectListen = function (targetId, err) {\n        var _this = this;\n        this.assertSubscribed('rejectListens()');\n        var limboKey = this.limboKeysByTarget[targetId];\n        if (limboKey) {\n            // Since this query failed, we won't want to manually unlisten to it.\n            // So go ahead and remove it from bookkeeping.\n            this.limboTargetsByKey = this.limboTargetsByKey.remove(limboKey);\n            delete this.limboKeysByTarget[targetId];\n            // TODO(klimt): We really only should do the following on permission\n            // denied errors, but we don't have the cause code here.\n            // It's a limbo doc. Create a synthetic event saying it was deleted.\n            // This is kind of a hack. Ideally, we would have a method in the local\n            // store to purge a document. However, it would be tricky to keep all of\n            // the local store's invariants with another method.\n            var docMap = new SortedMap(DocumentKey.comparator);\n            docMap = docMap.insert(limboKey, new NoDocument(limboKey, SnapshotVersion.forDeletedDoc()));\n            var event_1 = new RemoteEvent(SnapshotVersion.MIN, {}, docMap);\n            return this.applyRemoteEvent(event_1);\n        }\n        else {\n            var queryView_1 = this.queryViewsByTarget[targetId];\n            assert(!!queryView_1, 'Unknown targetId: ' + targetId);\n            return this.localStore.releaseQuery(queryView_1.query).then(function () {\n                return _this.removeAndCleanupQuery(queryView_1).then(function () {\n                    _this.errorHandler(queryView_1.query, err);\n                });\n            });\n        }\n    };\n    SyncEngine.prototype.applySuccessfulWrite = function (mutationBatchResult) {\n        var _this = this;\n        this.assertSubscribed('applySuccessfulWrite()');\n        // The local store may or may not be able to apply the write result and\n        // raise events immediately (depending on whether the watcher is caught\n        // up), so we raise user callbacks first so that they consistently happen\n        // before listen events.\n        this.processUserCallback(mutationBatchResult.batch.batchId, \n        /*error=*/ null);\n        return this.localStore\n            .acknowledgeBatch(mutationBatchResult)\n            .then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes);\n        });\n    };\n    SyncEngine.prototype.rejectFailedWrite = function (batchId, error) {\n        var _this = this;\n        this.assertSubscribed('rejectFailedWrite()');\n        // The local store may or may not be able to apply the write result and\n        // raise events immediately (depending on whether the watcher is caught up),\n        // so we raise user callbacks first so that they consistently happen before\n        // listen events.\n        this.processUserCallback(batchId, error);\n        return this.localStore.rejectBatch(batchId).then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes);\n        });\n    };\n    SyncEngine.prototype.addMutationCallback = function (batchId, callback) {\n        var newCallbacks = this.mutationUserCallbacks[this.currentUser.toKey()];\n        if (!newCallbacks) {\n            newCallbacks = new SortedMap(primitiveComparator);\n        }\n        newCallbacks = newCallbacks.insert(batchId, callback);\n        this.mutationUserCallbacks[this.currentUser.toKey()] = newCallbacks;\n    };\n    /**\n     * Resolves or rejects the user callback for the given batch and then discards\n     * it.\n     */\n    SyncEngine.prototype.processUserCallback = function (batchId, error) {\n        var newCallbacks = this.mutationUserCallbacks[this.currentUser.toKey()];\n        // NOTE: Mutations restored from persistence won't have callbacks, so it's\n        // okay for there to be no callback for this ID.\n        if (newCallbacks) {\n            var callback = newCallbacks.get(batchId);\n            if (callback) {\n                assert(batchId === newCallbacks.minKey(), 'Mutation callbacks processed out-of-order?');\n                if (error) {\n                    callback.reject(error);\n                }\n                else {\n                    callback.resolve();\n                }\n                newCallbacks = newCallbacks.remove(batchId);\n            }\n            this.mutationUserCallbacks[this.currentUser.toKey()] = newCallbacks;\n        }\n    };\n    SyncEngine.prototype.removeAndCleanupQuery = function (queryView) {\n        this.queryViewsByQuery.delete(queryView.query);\n        delete this.queryViewsByTarget[queryView.targetId];\n        this.limboDocumentRefs.removeReferencesForId(queryView.targetId);\n        return this.gcLimboDocuments();\n    };\n    SyncEngine.prototype.updateTrackedLimbos = function (targetId, limboChanges) {\n        for (var _i = 0, limboChanges_1 = limboChanges; _i < limboChanges_1.length; _i++) {\n            var limboChange = limboChanges_1[_i];\n            if (limboChange instanceof AddedLimboDocument) {\n                this.limboDocumentRefs.addReference(limboChange.key, targetId);\n                this.trackLimboChange(limboChange);\n            }\n            else if (limboChange instanceof RemovedLimboDocument) {\n                log.debug(LOG_TAG, 'Document no longer in limbo: ' + limboChange.key);\n                this.limboDocumentRefs.removeReference(limboChange.key, targetId);\n            }\n            else {\n                fail('Unknown limbo change: ' + JSON.stringify(limboChange));\n            }\n        }\n        return this.gcLimboDocuments();\n    };\n    SyncEngine.prototype.trackLimboChange = function (limboChange) {\n        var key = limboChange.key;\n        if (!this.limboTargetsByKey.get(key)) {\n            log.debug(LOG_TAG, 'New document in limbo: ' + key);\n            var limboTargetId = this.targetIdGenerator.next();\n            var query = Query.atPath(key.path);\n            this.limboKeysByTarget[limboTargetId] = key;\n            this.remoteStore.listen(new QueryData(query, limboTargetId, QueryPurpose.Listen));\n            this.limboTargetsByKey = this.limboTargetsByKey.insert(key, limboTargetId);\n        }\n    };\n    SyncEngine.prototype.gcLimboDocuments = function () {\n        var _this = this;\n        // HACK: We can use a null transaction here, because we know that the\n        // reference set is entirely within memory and doesn't need a store engine.\n        return this.limboCollector\n            .collectGarbage(null)\n            .next(function (keys) {\n            keys.forEach(function (key) {\n                var limboTargetId = _this.limboTargetsByKey.get(key);\n                if (limboTargetId === null) {\n                    // This target already got removed, because the query failed.\n                    return;\n                }\n                _this.remoteStore.unlisten(limboTargetId);\n                _this.limboTargetsByKey = _this.limboTargetsByKey.remove(key);\n                delete _this.limboKeysByTarget[limboTargetId];\n            });\n        })\n            .toPromise();\n    };\n    // Visible for testing\n    SyncEngine.prototype.currentLimboDocs = function () {\n        return this.limboTargetsByKey;\n    };\n    SyncEngine.prototype.emitNewSnapsAndNotifyLocalStore = function (changes, remoteEvent) {\n        var _this = this;\n        var newSnaps = [];\n        var docChangesInAllViews = [];\n        var queriesProcessed = [];\n        this.queryViewsByQuery.forEach(function (_, queryView) {\n            queriesProcessed.push(Promise.resolve()\n                .then(function () {\n                var viewDocChanges = queryView.view.computeDocChanges(changes);\n                if (!viewDocChanges.needsRefill) {\n                    return viewDocChanges;\n                }\n                // The query has a limit and some docs were removed, so we need\n                // to re-run the query against the local store to make sure we\n                // didn't lose any good docs that had been past the limit.\n                return _this.localStore.executeQuery(queryView.query).then(function (docs) {\n                    return queryView.view.computeDocChanges(docs, viewDocChanges);\n                });\n            })\n                .then(function (viewDocChanges) {\n                var targetChange = remoteEvent && remoteEvent.targetChanges[queryView.targetId];\n                var viewChange = queryView.view.applyChanges(viewDocChanges, targetChange);\n                return _this.updateTrackedLimbos(queryView.targetId, viewChange.limboChanges).then(function () {\n                    if (viewChange.snapshot) {\n                        newSnaps.push(viewChange.snapshot);\n                        var docChanges = LocalViewChanges.fromSnapshot(viewChange.snapshot);\n                        docChangesInAllViews.push(docChanges);\n                    }\n                });\n            }));\n        });\n        return Promise.all(queriesProcessed)\n            .then(function () {\n            _this.viewHandler(newSnaps);\n            return _this.localStore.notifyLocalViewChanges(docChangesInAllViews);\n        })\n            .then(function () {\n            return _this.localStore.collectGarbage();\n        });\n    };\n    SyncEngine.prototype.assertSubscribed = function (fnName) {\n        assert(this.viewHandler !== null && this.errorHandler !== null, 'Trying to call ' + fnName + ' before calling subscribe().');\n    };\n    SyncEngine.prototype.handleUserChange = function (user) {\n        var _this = this;\n        this.currentUser = user;\n        return this.localStore\n            .handleUserChange(user)\n            .then(function (changes) {\n            return _this.emitNewSnapsAndNotifyLocalStore(changes);\n        })\n            .then(function () {\n            return _this.remoteStore.handleUserChange(user);\n        });\n    };\n    return SyncEngine;\n}());\nexport { SyncEngine };\n\n//# sourceMappingURL=sync_engine.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/sync_engine.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentKeySet, documentVersionMap } from './collections';\nimport { assert } from '../util/assert';\nimport * as misc from '../util/misc';\nexport var BATCHID_UNKNOWN = -1;\n/**\n * A batch of mutations that will be sent as one unit to the backend.\n */\nvar MutationBatch = /** @class */ (function () {\n    function MutationBatch(batchId, localWriteTime, mutations) {\n        this.batchId = batchId;\n        this.localWriteTime = localWriteTime;\n        this.mutations = mutations;\n    }\n    /**\n     * Applies all the mutations in this MutationBatch to the specified document\n     * to create a new remote document\n     *\n     * @param docKey The key of the document to apply mutations to.\n     * @param maybeDoc The document to apply mutations to.\n     * @param batchResult The result of applying the MutationBatch to the\n     * backend.\n     */\n    MutationBatch.prototype.applyToRemoteDocument = function (docKey, maybeDoc, batchResult) {\n        if (maybeDoc) {\n            assert(maybeDoc.key.isEqual(docKey), \"applyToRemoteDocument: key \" + docKey + \" should match maybeDoc key\\n        \" + maybeDoc.key);\n        }\n        var mutationResults = batchResult.mutationResults;\n        assert(mutationResults.length === this.mutations.length, \"Mismatch between mutations length\\n      (\" + this.mutations.length + \") and mutation results length\\n      (\" + mutationResults.length + \").\");\n        for (var i = 0; i < this.mutations.length; i++) {\n            var mutation = this.mutations[i];\n            if (mutation.key.isEqual(docKey)) {\n                var mutationResult = mutationResults[i];\n                maybeDoc = mutation.applyToRemoteDocument(maybeDoc, mutationResult);\n            }\n        }\n        return maybeDoc;\n    };\n    /**\n     * Computes the local view of a document given all the mutations in this\n     * batch.\n     *\n     * @param docKey The key of the document to apply mutations to.\n     * @param maybeDoc The document to apply mutations to.\n     */\n    MutationBatch.prototype.applyToLocalView = function (docKey, maybeDoc) {\n        if (maybeDoc) {\n            assert(maybeDoc.key.isEqual(docKey), \"applyToLocalDocument: key \" + docKey + \" should match maybeDoc key\\n        \" + maybeDoc.key);\n        }\n        var baseDoc = maybeDoc;\n        for (var i = 0; i < this.mutations.length; i++) {\n            var mutation = this.mutations[i];\n            if (mutation.key.isEqual(docKey)) {\n                maybeDoc = mutation.applyToLocalView(maybeDoc, baseDoc, this.localWriteTime);\n            }\n        }\n        return maybeDoc;\n    };\n    MutationBatch.prototype.keys = function () {\n        var keySet = documentKeySet();\n        for (var _i = 0, _a = this.mutations; _i < _a.length; _i++) {\n            var mutation = _a[_i];\n            keySet = keySet.add(mutation.key);\n        }\n        return keySet;\n    };\n    MutationBatch.prototype.isEqual = function (other) {\n        return (this.batchId === other.batchId &&\n            misc.arrayEquals(this.mutations, other.mutations));\n    };\n    /**\n     * Returns true if this mutation batch has already been removed from the\n     * mutation queue.\n     *\n     * Note that not all implementations of the MutationQueue necessarily use\n     * tombstones as part of their implementation and generally speaking no code\n     * outside the mutation queues should really care about this.\n     */\n    MutationBatch.prototype.isTombstone = function () {\n        return this.mutations.length === 0;\n    };\n    /** Converts this batch into a tombstone */\n    MutationBatch.prototype.toTombstone = function () {\n        return new MutationBatch(this.batchId, this.localWriteTime, []);\n    };\n    return MutationBatch;\n}());\nexport { MutationBatch };\n/** The result of applying a mutation batch to the backend. */\nvar MutationBatchResult = /** @class */ (function () {\n    function MutationBatchResult(batch, commitVersion, mutationResults, streamToken, \n        /**\n         * A pre-computed mapping from each mutated document to the resulting\n         * version.\n         */\n        docVersions) {\n        this.batch = batch;\n        this.commitVersion = commitVersion;\n        this.mutationResults = mutationResults;\n        this.streamToken = streamToken;\n        this.docVersions = docVersions;\n    }\n    /**\n     * Creates a new MutationBatchResult for the given batch and results. There\n     * must be one result for each mutation in the batch. This static factory\n     * caches a document=>version mapping (docVersions).\n     */\n    MutationBatchResult.from = function (batch, commitVersion, results, streamToken) {\n        assert(batch.mutations.length === results.length, 'Mutations sent ' +\n            batch.mutations.length +\n            ' must equal results received ' +\n            results.length);\n        var versionMap = documentVersionMap();\n        var mutations = batch.mutations;\n        for (var i = 0; i < mutations.length; i++) {\n            var version = results[i].version;\n            if (version === null) {\n                // deletes don't have a version, so we substitute the commitVersion\n                // of the entire batch.\n                version = commitVersion;\n            }\n            versionMap = versionMap.insert(mutations[i].key, version);\n        }\n        return new MutationBatchResult(batch, commitVersion, results, streamToken, versionMap);\n    };\n    return MutationBatchResult;\n}());\nexport { MutationBatchResult };\n\n//# sourceMappingURL=mutation_batch.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/model/mutation_batch.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\nimport { Code, FirestoreError } from '../util/error';\nimport * as log from '../util/log';\nimport { AutoId } from '../util/misc';\nimport { IndexedDbMutationQueue } from './indexeddb_mutation_queue';\nimport { IndexedDbQueryCache } from './indexeddb_query_cache';\nimport { IndexedDbRemoteDocumentCache } from './indexeddb_remote_document_cache';\nimport { ALL_STORES, DbOwner } from './indexeddb_schema';\nimport { createOrUpgradeDb, SCHEMA_VERSION } from './indexeddb_schema';\nimport { LocalSerializer } from './local_serializer';\nimport { PersistencePromise } from './persistence_promise';\nimport { SimpleDb } from './simple_db';\nvar LOG_TAG = 'IndexedDbPersistence';\n/** If the owner lease is older than 5 seconds, try to take ownership. */\nvar OWNER_LEASE_MAX_AGE_MS = 5000;\n/** Refresh the owner lease every 4 seconds while owner. */\nvar OWNER_LEASE_REFRESH_INTERVAL_MS = 4000;\n/** LocalStorage location to indicate a zombied ownerId (see class comment). */\nvar ZOMBIE_OWNER_LOCALSTORAGE_SUFFIX = 'zombiedOwnerId';\n/** Error when the owner lease cannot be acquired or is lost. */\nvar EXISTING_OWNER_ERROR_MSG = 'There is another tab open with offline' +\n    ' persistence enabled. Only one such tab is allowed at a time. The' +\n    ' other tab must be closed or persistence must be disabled.';\nvar UNSUPPORTED_PLATFORM_ERROR_MSG = 'This platform is either missing' +\n    ' IndexedDB or is known to have an incomplete implementation. Offline' +\n    ' persistence has been disabled.';\n/**\n * An IndexedDB-backed instance of Persistence. Data is stored persistently\n * across sessions.\n *\n * Currently the Firestore SDK only supports a single consumer of the database,\n * but browsers obviously support multiple tabs. IndexedDbPersistence ensures a\n * single consumer of the database via an \"owner lease\" stored in the database.\n *\n * On startup, IndexedDbPersistence assigns itself a random \"ownerId\" and writes\n * it to a special \"owner\" object in the database (if no entry exists already or\n * the current entry is expired). This owner lease is then verified inside every\n * transaction to ensure the lease has not been lost.\n *\n * If a tab opts not to acquire the owner lease (because there's an existing\n * non-expired owner) or loses the owner lease, IndexedDbPersistence enters a\n * failed state and all subsequent operations will automatically fail.\n *\n * The current owner regularly refreshes the owner lease with new timestamps to\n * prevent newly-opened tabs from taking over ownership.\n *\n * Additionally there is an optimization so that when a tab is closed, the owner\n * lease is released immediately (this is especially important to make sure that\n * a refreshed tab is able to immediately re-acquire the owner lease).\n * Unfortunately, IndexedDB cannot be reliably used in window.unload since it is\n * an asynchronous API. So in addition to attempting to give up the lease,\n * the owner writes its ownerId to a \"zombiedOwnerId\" entry in LocalStorage\n * which acts as an indicator that another tab should go ahead and take the\n * owner lease immediately regardless of the current lease timestamp.\n */\nvar IndexedDbPersistence = /** @class */ (function () {\n    function IndexedDbPersistence(prefix, serializer) {\n        this.ownerId = this.generateOwnerId();\n        this.dbName = prefix + IndexedDbPersistence.MAIN_DATABASE;\n        this.serializer = new LocalSerializer(serializer);\n        this.localStoragePrefix = prefix;\n    }\n    IndexedDbPersistence.prototype.start = function () {\n        var _this = this;\n        if (!IndexedDbPersistence.isAvailable()) {\n            this.persistenceError = new FirestoreError(Code.UNIMPLEMENTED, UNSUPPORTED_PLATFORM_ERROR_MSG);\n            return Promise.reject(this.persistenceError);\n        }\n        assert(!this.started, 'IndexedDbPersistence double-started!');\n        this.started = true;\n        return SimpleDb.openOrCreate(this.dbName, SCHEMA_VERSION, createOrUpgradeDb)\n            .then(function (db) {\n            _this.simpleDb = db;\n        })\n            .then(function () { return _this.tryAcquireOwnerLease(); })\n            .then(function () {\n            _this.scheduleOwnerLeaseRefreshes();\n            _this.attachWindowUnloadHook();\n        });\n    };\n    IndexedDbPersistence.prototype.shutdown = function () {\n        var _this = this;\n        assert(this.started, 'IndexedDbPersistence shutdown without start!');\n        this.started = false;\n        this.detachWindowUnloadHook();\n        this.stopOwnerLeaseRefreshes();\n        return this.releaseOwnerLease().then(function () {\n            _this.simpleDb.close();\n        });\n    };\n    IndexedDbPersistence.prototype.getMutationQueue = function (user) {\n        return IndexedDbMutationQueue.forUser(user, this.serializer);\n    };\n    IndexedDbPersistence.prototype.getQueryCache = function () {\n        return new IndexedDbQueryCache(this.serializer);\n    };\n    IndexedDbPersistence.prototype.getRemoteDocumentCache = function () {\n        return new IndexedDbRemoteDocumentCache(this.serializer);\n    };\n    IndexedDbPersistence.prototype.runTransaction = function (action, operation) {\n        var _this = this;\n        if (this.persistenceError) {\n            return Promise.reject(this.persistenceError);\n        }\n        log.debug(LOG_TAG, 'Starting transaction:', action);\n        // Do all transactions as readwrite against all object stores, since we\n        // are the only reader/writer.\n        return this.simpleDb.runTransaction('readwrite', ALL_STORES, function (txn) {\n            // Verify that we still have the owner lease as part of every transaction.\n            return _this.ensureOwnerLease(txn).next(function () { return operation(txn); });\n        });\n    };\n    IndexedDbPersistence.isAvailable = function () {\n        return SimpleDb.isAvailable();\n    };\n    /**\n     * Generates a string used as a prefix when storing data in IndexedDB and\n     * LocalStorage.\n     */\n    IndexedDbPersistence.buildStoragePrefix = function (databaseInfo) {\n        // Use two different prefix formats:\n        //\n        //   * firestore / persistenceKey / projectID . databaseID / ...\n        //   * firestore / persistenceKey / projectID / ...\n        //\n        // projectIDs are DNS-compatible names and cannot contain dots\n        // so there's no danger of collisions.\n        var database = databaseInfo.databaseId.projectId;\n        if (!databaseInfo.databaseId.isDefaultDatabase) {\n            database += '.' + databaseInfo.databaseId.database;\n        }\n        return 'firestore/' + databaseInfo.persistenceKey + '/' + database + '/';\n    };\n    /**\n     * Acquires the owner lease if there's no valid owner. Else returns a rejected\n     * promise.\n     */\n    IndexedDbPersistence.prototype.tryAcquireOwnerLease = function () {\n        var _this = this;\n        // NOTE: Don't use this.runTransaction, since it requires us to already\n        // have the lease.\n        return this.simpleDb.runTransaction('readwrite', [DbOwner.store], function (txn) {\n            var store = txn.store(DbOwner.store);\n            return store.get('owner').next(function (dbOwner) {\n                if (!_this.validOwner(dbOwner)) {\n                    var newDbOwner = new DbOwner(_this.ownerId, Date.now());\n                    log.debug(LOG_TAG, 'No valid owner. Acquiring owner lease. Current owner:', dbOwner, 'New owner:', newDbOwner);\n                    return store.put('owner', newDbOwner);\n                }\n                else {\n                    log.debug(LOG_TAG, 'Valid owner already. Failing. Current owner:', dbOwner);\n                    _this.persistenceError = new FirestoreError(Code.FAILED_PRECONDITION, EXISTING_OWNER_ERROR_MSG);\n                    return PersistencePromise.reject(_this.persistenceError);\n                }\n            });\n        });\n    };\n    /** Checks the owner lease and deletes it if we are the current owner. */\n    IndexedDbPersistence.prototype.releaseOwnerLease = function () {\n        var _this = this;\n        // NOTE: Don't use this.runTransaction, since it requires us to already\n        // have the lease.\n        return this.simpleDb.runTransaction('readwrite', [DbOwner.store], function (txn) {\n            var store = txn.store(DbOwner.store);\n            return store.get('owner').next(function (dbOwner) {\n                if (dbOwner !== null && dbOwner.ownerId === _this.ownerId) {\n                    log.debug(LOG_TAG, 'Releasing owner lease.');\n                    return store.delete('owner');\n                }\n                else {\n                    return PersistencePromise.resolve();\n                }\n            });\n        });\n    };\n    /**\n     * Checks the owner lease and returns a rejected promise if we are not the\n     * current owner. This should be included in every transaction to guard\n     * against losing the owner lease.\n     */\n    IndexedDbPersistence.prototype.ensureOwnerLease = function (txn) {\n        var _this = this;\n        var store = txn.store(DbOwner.store);\n        return store.get('owner').next(function (dbOwner) {\n            if (dbOwner === null || dbOwner.ownerId !== _this.ownerId) {\n                _this.persistenceError = new FirestoreError(Code.FAILED_PRECONDITION, EXISTING_OWNER_ERROR_MSG);\n                return PersistencePromise.reject(_this.persistenceError);\n            }\n            else {\n                return PersistencePromise.resolve();\n            }\n        });\n    };\n    /**\n     * Returns true if the provided owner exists, has a recent timestamp, and\n     * isn't zombied.\n     *\n     * NOTE: To determine if the owner is zombied, this method reads from\n     * LocalStorage which could be mildly expensive.\n     */\n    IndexedDbPersistence.prototype.validOwner = function (dbOwner) {\n        var now = Date.now();\n        var minAcceptable = now - OWNER_LEASE_MAX_AGE_MS;\n        var maxAcceptable = now;\n        if (dbOwner === null) {\n            return false; // no owner.\n        }\n        else if (dbOwner.leaseTimestampMs < minAcceptable) {\n            return false; // owner lease has expired.\n        }\n        else if (dbOwner.leaseTimestampMs > maxAcceptable) {\n            log.error('Persistence owner-lease is in the future. Discarding.', dbOwner);\n            return false;\n        }\n        else if (dbOwner.ownerId === this.getZombiedOwnerId()) {\n            return false; // owner's tab closed.\n        }\n        else {\n            return true;\n        }\n    };\n    /**\n     * Schedules a recurring timer to update the owner lease timestamp to prevent\n     * other tabs from taking the lease.\n     */\n    IndexedDbPersistence.prototype.scheduleOwnerLeaseRefreshes = function () {\n        var _this = this;\n        // NOTE: This doesn't need to be scheduled on the async queue and doing so\n        // would increase the chances of us not refreshing on time if the queue is\n        // backed up for some reason.\n        this.ownerLeaseRefreshHandle = setInterval(function () {\n            var txResult = _this.runTransaction('Refresh owner timestamp', function (txn) {\n                // NOTE: We don't need to validate the current owner contents, since\n                // runTransaction does that automatically.\n                var store = txn.store(DbOwner.store);\n                return store.put('owner', new DbOwner(_this.ownerId, Date.now()));\n            });\n            txResult.catch(function (reason) {\n                // Probably means we lost the lease. Report the error and stop trying to\n                // refresh the lease.\n                log.error(reason);\n                _this.stopOwnerLeaseRefreshes();\n            });\n        }, OWNER_LEASE_REFRESH_INTERVAL_MS);\n    };\n    IndexedDbPersistence.prototype.stopOwnerLeaseRefreshes = function () {\n        if (this.ownerLeaseRefreshHandle) {\n            clearInterval(this.ownerLeaseRefreshHandle);\n            this.ownerLeaseRefreshHandle = null;\n        }\n    };\n    /**\n     * Attaches a window.unload handler that will synchronously write our\n     * ownerId to a \"zombie owner id\" location in localstorage. This can be used\n     * by tabs trying to acquire the lease to determine that the lease should be\n     * acquired immediately even if the timestamp is recent. This is particularly\n     * important for the refresh case (so the tab correctly re-acquires the owner\n     * lease). LocalStorage is used for this rather than IndexedDb because it is\n     * a synchronous API and so can be used reliably from an unload handler.\n     */\n    IndexedDbPersistence.prototype.attachWindowUnloadHook = function () {\n        var _this = this;\n        this.windowUnloadHandler = function () {\n            // Record that we're zombied.\n            _this.setZombiedOwnerId(_this.ownerId);\n            // Attempt graceful shutdown (including releasing our owner lease), but\n            // there's no guarantee it will complete.\n            _this.shutdown();\n        };\n        window.addEventListener('unload', this.windowUnloadHandler);\n    };\n    IndexedDbPersistence.prototype.detachWindowUnloadHook = function () {\n        if (this.windowUnloadHandler) {\n            window.removeEventListener('unload', this.windowUnloadHandler);\n            this.windowUnloadHandler = null;\n        }\n    };\n    /**\n     * Returns any recorded \"zombied owner\" (i.e. a previous owner that became\n     * zombied due to their tab closing) from LocalStorage, or null if no such\n     * record exists.\n     */\n    IndexedDbPersistence.prototype.getZombiedOwnerId = function () {\n        try {\n            var zombiedOwnerId = window.localStorage.getItem(this.zombiedOwnerLocalStorageKey());\n            log.debug(LOG_TAG, 'Zombied ownerID from LocalStorage:', zombiedOwnerId);\n            return zombiedOwnerId;\n        }\n        catch (e) {\n            // Gracefully handle if LocalStorage isn't available / working.\n            log.error('Failed to get zombie owner id.', e);\n            return null;\n        }\n    };\n    /**\n     * Records a zombied owner (an owner that had its tab closed) in LocalStorage\n     * or, if passed null, deletes any recorded zombied owner.\n     */\n    IndexedDbPersistence.prototype.setZombiedOwnerId = function (zombieOwnerId) {\n        try {\n            if (zombieOwnerId === null) {\n                window.localStorage.removeItem(this.zombiedOwnerLocalStorageKey());\n            }\n            else {\n                window.localStorage.setItem(this.zombiedOwnerLocalStorageKey(), zombieOwnerId);\n            }\n        }\n        catch (e) {\n            // Gracefully handle if LocalStorage isn't available / working.\n            log.error('Failed to set zombie owner id.', e);\n        }\n    };\n    IndexedDbPersistence.prototype.zombiedOwnerLocalStorageKey = function () {\n        return this.localStoragePrefix + ZOMBIE_OWNER_LOCALSTORAGE_SUFFIX;\n    };\n    IndexedDbPersistence.prototype.generateOwnerId = function () {\n        // For convenience, just use an AutoId.\n        return AutoId.newId();\n    };\n    /**\n     * The name of the main (and currently only) IndexedDB database. this name is\n     * appended to the prefix provided to the IndexedDbPersistence constructor.\n     */\n    IndexedDbPersistence.MAIN_DATABASE = 'main';\n    return IndexedDbPersistence;\n}());\nexport { IndexedDbPersistence };\n\n//# sourceMappingURL=indexeddb_persistence.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/indexeddb_persistence.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { documentKeySet, documentMap, maybeDocumentMap } from '../model/collections';\nimport { Document, NoDocument } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { fail } from '../util/assert';\nimport { PersistencePromise } from './persistence_promise';\n/**\n * A readonly view of the local state of all documents we're tracking (i.e. we\n * have a cached version in remoteDocumentCache or local mutations for the\n * document). The view is computed by applying the mutations in the\n * MutationQueue to the RemoteDocumentCache.\n */\nvar LocalDocumentsView = /** @class */ (function () {\n    function LocalDocumentsView(remoteDocumentCache, mutationQueue) {\n        this.remoteDocumentCache = remoteDocumentCache;\n        this.mutationQueue = mutationQueue;\n    }\n    /**\n     * Get the local view of the document identified by `key`.\n     *\n     * @return Local view of the document or null if we don't have any cached\n     * state for it.\n     */\n    LocalDocumentsView.prototype.getDocument = function (transaction, key) {\n        var _this = this;\n        return this.remoteDocumentCache\n            .getEntry(transaction, key)\n            .next(function (remoteDoc) {\n            return _this.computeLocalDocument(transaction, key, remoteDoc);\n        });\n    };\n    /**\n     * Gets the local view of the documents identified by `keys`.\n     *\n     * If we don't have cached state for a document in `keys`, a NoDocument will\n     * be stored for that key in the resulting set.\n     */\n    LocalDocumentsView.prototype.getDocuments = function (transaction, keys) {\n        var _this = this;\n        var promises = [];\n        var results = maybeDocumentMap();\n        keys.forEach(function (key) {\n            promises.push(_this.getDocument(transaction, key).next(function (maybeDoc) {\n                // TODO(http://b/32275378): Don't conflate missing / deleted.\n                if (!maybeDoc) {\n                    maybeDoc = new NoDocument(key, SnapshotVersion.forDeletedDoc());\n                }\n                results = results.insert(key, maybeDoc);\n            }));\n        });\n        return PersistencePromise.waitFor(promises).next(function () { return results; });\n    };\n    /** Performs a query against the local view of all documents. */\n    LocalDocumentsView.prototype.getDocumentsMatchingQuery = function (transaction, query) {\n        if (DocumentKey.isDocumentKey(query.path)) {\n            return this.getDocumentsMatchingDocumentQuery(transaction, query.path);\n        }\n        else {\n            return this.getDocumentsMatchingCollectionQuery(transaction, query);\n        }\n    };\n    LocalDocumentsView.prototype.getDocumentsMatchingDocumentQuery = function (transaction, docPath) {\n        // Just do a simple document lookup.\n        return this.getDocument(transaction, new DocumentKey(docPath)).next(function (maybeDoc) {\n            var result = documentMap();\n            if (maybeDoc instanceof Document) {\n                result = result.insert(maybeDoc.key, maybeDoc);\n            }\n            return result;\n        });\n    };\n    LocalDocumentsView.prototype.getDocumentsMatchingCollectionQuery = function (transaction, query) {\n        var _this = this;\n        // Query the remote documents and overlay mutations.\n        // TODO(mikelehen): There may be significant overlap between the mutations\n        // affecting these remote documents and the\n        // getAllMutationBatchesAffectingQuery() mutations. Consider optimizing.\n        var results;\n        return this.remoteDocumentCache\n            .getDocumentsMatchingQuery(transaction, query)\n            .next(function (queryResults) {\n            return _this.computeLocalDocuments(transaction, queryResults);\n        })\n            .next(function (promisedResults) {\n            results = promisedResults;\n            // Now use the mutation queue to discover any other documents that may\n            // match the query after applying mutations.\n            return _this.mutationQueue.getAllMutationBatchesAffectingQuery(transaction, query);\n        })\n            .next(function (matchingMutationBatches) {\n            var matchingKeys = documentKeySet();\n            for (var _i = 0, matchingMutationBatches_1 = matchingMutationBatches; _i < matchingMutationBatches_1.length; _i++) {\n                var batch = matchingMutationBatches_1[_i];\n                for (var _a = 0, _b = batch.mutations; _a < _b.length; _a++) {\n                    var mutation = _b[_a];\n                    // TODO(mikelehen): PERF: Check if this mutation actually\n                    // affects the query to reduce work.\n                    if (!results.get(mutation.key)) {\n                        matchingKeys = matchingKeys.add(mutation.key);\n                    }\n                }\n            }\n            // Now add in the results for the matchingKeys.\n            var promises = [];\n            matchingKeys.forEach(function (key) {\n                promises.push(_this.getDocument(transaction, key).next(function (doc) {\n                    if (doc instanceof Document) {\n                        results = results.insert(doc.key, doc);\n                    }\n                }));\n            });\n            return PersistencePromise.waitFor(promises);\n        })\n            .next(function () {\n            // Finally, filter out any documents that don't actually match\n            // the query.\n            results.forEach(function (key, doc) {\n                if (!query.matches(doc)) {\n                    results = results.remove(key);\n                }\n            });\n            return results;\n        });\n    };\n    /**\n     * Takes a remote document and applies local mutations to generate the local\n     * view of the document.\n     * @param transaction The transaction in which to perform any persistence\n     *     operations.\n     * @param documentKey The key of the document (necessary when remoteDocument\n     *     is null).\n     * @param document The base remote document to apply mutations to or null.\n     */\n    LocalDocumentsView.prototype.computeLocalDocument = function (transaction, documentKey, document) {\n        return this.mutationQueue\n            .getAllMutationBatchesAffectingDocumentKey(transaction, documentKey)\n            .next(function (batches) {\n            for (var _i = 0, batches_1 = batches; _i < batches_1.length; _i++) {\n                var batch = batches_1[_i];\n                document = batch.applyToLocalView(documentKey, document);\n            }\n            return document;\n        });\n    };\n    /**\n     * Takes a set of remote documents and applies local mutations to generate the\n     * local view of the documents.\n     * @param transaction The transaction in which to perform any persistence\n     *     operations.\n     * @param documents The base remote documents to apply mutations to.\n     * @return The local view of the documents.\n     */\n    LocalDocumentsView.prototype.computeLocalDocuments = function (transaction, documents) {\n        var _this = this;\n        var promises = [];\n        documents.forEach(function (key, doc) {\n            promises.push(_this.computeLocalDocument(transaction, key, doc).next(function (mutatedDoc) {\n                if (mutatedDoc instanceof Document) {\n                    documents = documents.insert(mutatedDoc.key, mutatedDoc);\n                }\n                else if (mutatedDoc instanceof NoDocument) {\n                    documents = documents.remove(mutatedDoc.key);\n                }\n                else {\n                    fail('Unknown MaybeDocument: ' + mutatedDoc);\n                }\n            }));\n        });\n        return PersistencePromise.waitFor(promises).next(function () { return documents; });\n    };\n    return LocalDocumentsView;\n}());\nexport { LocalDocumentsView };\n\n//# sourceMappingURL=local_documents_view.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/local_documents_view.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { maybeDocumentMap } from '../model/collections';\nimport { assert } from '../util/assert';\nimport { PersistencePromise } from './persistence_promise';\n/**\n * An in-memory buffer of entries to be written to a RemoteDocumentCache.\n * It can be used to batch up a set of changes to be written to the cache, but\n * additionally supports reading entries back with the `getEntry()` method,\n * falling back to the underlying RemoteDocumentCache if no entry is\n * buffered.\n *\n * NOTE: This class was introduced in iOS to work around a limitation in\n * LevelDB. Given IndexedDb has full transaction support with\n * read-your-own-writes capability, this class is not technically needed, but\n * has been preserved as a convenience and to aid portability.\n */\nvar RemoteDocumentChangeBuffer = /** @class */ (function () {\n    function RemoteDocumentChangeBuffer(remoteDocumentCache) {\n        this.remoteDocumentCache = remoteDocumentCache;\n        this.changes = maybeDocumentMap();\n    }\n    /** Buffers a `RemoteDocumentCache.addEntry()` call. */\n    RemoteDocumentChangeBuffer.prototype.addEntry = function (maybeDocument) {\n        var changes = this.assertChanges();\n        this.changes = changes.insert(maybeDocument.key, maybeDocument);\n    };\n    // NOTE: removeEntry() is not presently necessary and so is omitted.\n    /**\n     * Looks up an entry in the cache. The buffered changes will first be checked,\n     * and if no buffered change applies, this will forward to\n     * `RemoteDocumentCache.getEntry()`.\n     *\n     * @param transaction The transaction in which to perform any persistence\n     *     operations.\n     * @param documentKey The key of the entry to look up.\n     * @return The cached Document or NoDocument entry, or null if we have nothing\n     * cached.\n     */\n    RemoteDocumentChangeBuffer.prototype.getEntry = function (transaction, documentKey) {\n        var changes = this.assertChanges();\n        var bufferedEntry = changes.get(documentKey);\n        if (bufferedEntry) {\n            return PersistencePromise.resolve(bufferedEntry);\n        }\n        else {\n            return this.remoteDocumentCache.getEntry(transaction, documentKey);\n        }\n    };\n    /**\n     * Applies buffered changes to the underlying RemoteDocumentCache, using\n     * the provided transaction.\n     */\n    RemoteDocumentChangeBuffer.prototype.apply = function (transaction) {\n        var _this = this;\n        var changes = this.assertChanges();\n        var promises = [];\n        changes.forEach(function (key, maybeDoc) {\n            promises.push(_this.remoteDocumentCache.addEntry(transaction, maybeDoc));\n        });\n        // We should not be used to buffer any more changes.\n        this.changes = null;\n        return PersistencePromise.waitFor(promises);\n    };\n    /** Helper to assert this.changes is not null and return it. */\n    RemoteDocumentChangeBuffer.prototype.assertChanges = function () {\n        assert(this.changes !== null, 'Changes have already been applied.');\n        return this.changes;\n    };\n    return RemoteDocumentChangeBuffer;\n}());\nexport { RemoteDocumentChangeBuffer };\n\n//# sourceMappingURL=remote_document_change_buffer.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/remote_document_change_buffer.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { TargetIdGenerator } from '../core/target_id_generator';\nimport { Timestamp } from '../core/timestamp';\nimport { documentKeySet } from '../model/collections';\nimport { BATCHID_UNKNOWN } from '../model/mutation_batch';\nimport { ResetMapping, UpdateMapping } from '../remote/remote_event';\nimport { assert, fail } from '../util/assert';\nimport * as log from '../util/log';\nimport * as objUtils from '../util/obj';\nimport { LocalDocumentsView } from './local_documents_view';\nimport { PersistencePromise } from './persistence_promise';\nimport { QueryData, QueryPurpose } from './query_data';\nimport { ReferenceSet } from './reference_set';\nimport { RemoteDocumentChangeBuffer } from './remote_document_change_buffer';\nvar LOG_TAG = 'LocalStore';\n/**\n * Local storage in the Firestore client. Coordinates persistence components\n * like the mutation queue and remote document cache to present a\n * latency-compensated view of stored data.\n *\n * The LocalStore is responsible for accepting mutations from the Sync Engine.\n * Writes from the client are put into a queue as provisional Mutations until\n * they are processed by the RemoteStore and confirmed as having been written\n * to the server.\n *\n * The local store provides the local version of documents that have been\n * modified locally. It maintains the constraint:\n *\n *   LocalDocument = RemoteDocument + Active(LocalMutations)\n *\n * (Active mutations are those that are enqueued and have not been previously\n * acknowledged or rejected).\n *\n * The RemoteDocument (\"ground truth\") state is provided via the\n * applyChangeBatch method. It will be some version of a server-provided\n * document OR will be a server-provided document PLUS acknowledged mutations:\n *\n *   RemoteDocument' = RemoteDocument + Acknowledged(LocalMutations)\n *\n * Note that this \"dirty\" version of a RemoteDocument will not be identical to a\n * server base version, since it has LocalMutations added to it pending getting\n * an authoritative copy from the server.\n *\n * Since LocalMutations can be rejected by the server, we have to be able to\n * revert a LocalMutation that has already been applied to the LocalDocument\n * (typically done by replaying all remaining LocalMutations to the\n * RemoteDocument to re-apply).\n *\n * The LocalStore is responsible for the garbage collection of the documents it\n * contains. For now, it every doc referenced by a view, the mutation queue, or\n * the RemoteStore.\n *\n * It also maintains the persistence of mapping queries to resume tokens and\n * target ids. It needs to know this data about queries to properly know what\n * docs it would be allowed to garbage collect.\n *\n * The LocalStore must be able to efficiently execute queries against its local\n * cache of the documents, to provide the initial set of results before any\n * remote changes have been received.\n *\n * Note: In TypeScript, most methods return Promises since the implementation\n * may rely on fetching data from IndexedDB which is async.\n * These Promises will only be rejected on an I/O error or other internal\n * (unexpected) failure (e.g. failed assert) and always represent an\n * unrecoverable error (should be caught / reported by the async_queue).\n */\nvar LocalStore = /** @class */ (function () {\n    function LocalStore(\n        /** Manages our in-memory or durable persistence. */\n        persistence, initialUser, \n        /**\n         * The garbage collector collects documents that should no longer be\n         * cached (e.g. if they are no longer retained by the above reference sets\n         * and the garbage collector is performing eager collection).\n         */\n        garbageCollector) {\n        this.persistence = persistence;\n        this.garbageCollector = garbageCollector;\n        /**\n         * The set of document references maintained by any local views.\n         */\n        this.localViewReferences = new ReferenceSet();\n        /** Maps a targetID to data about its query. */\n        this.targetIds = {};\n        /** Used to generate targetIDs for queries tracked locally. */\n        this.targetIdGenerator = TargetIdGenerator.forLocalStore();\n        /**\n         * A heldBatchResult is a mutation batch result (from a write acknowledgement)\n         * that arrived before the watch stream got notified of a snapshot that\n         * includes the write. So we \"hold\" it until the watch stream catches up. It\n         * ensures that the local write remains visible (latency compensation) and\n         * doesn't temporarily appear reverted because the watch stream is slower than\n         * the write stream and so wasn't reflecting it.\n         *\n         * NOTE: Eventually we want to move this functionality into the remote store.\n         */\n        this.heldBatchResults = [];\n        this.mutationQueue = persistence.getMutationQueue(initialUser);\n        this.remoteDocuments = persistence.getRemoteDocumentCache();\n        this.queryCache = persistence.getQueryCache();\n        this.localDocuments = new LocalDocumentsView(this.remoteDocuments, this.mutationQueue);\n        this.garbageCollector.addGarbageSource(this.localViewReferences);\n        this.garbageCollector.addGarbageSource(this.queryCache);\n        this.garbageCollector.addGarbageSource(this.mutationQueue);\n    }\n    /** Performs any initial startup actions required by the local store. */\n    LocalStore.prototype.start = function () {\n        var _this = this;\n        return this.persistence.runTransaction('Start LocalStore', function (txn) {\n            return _this.startMutationQueue(txn).next(function () { return _this.startQueryCache(txn); });\n        });\n    };\n    /**\n     * Tells the LocalStore that the currently authenticated user has changed.\n     *\n     * In response the local store switches the mutation queue to the new user and\n     * returns any resulting document changes.\n     */\n    LocalStore.prototype.handleUserChange = function (user) {\n        var _this = this;\n        return this.persistence.runTransaction('Handle user change', function (txn) {\n            // Swap out the mutation queue, grabbing the pending mutation batches\n            // before and after.\n            var oldBatches;\n            return _this.mutationQueue\n                .getAllMutationBatches(txn)\n                .next(function (promisedOldBatches) {\n                oldBatches = promisedOldBatches;\n                _this.garbageCollector.removeGarbageSource(_this.mutationQueue);\n                _this.mutationQueue = _this.persistence.getMutationQueue(user);\n                _this.garbageCollector.addGarbageSource(_this.mutationQueue);\n                return _this.startMutationQueue(txn);\n            })\n                .next(function () {\n                // Recreate our LocalDocumentsView using the new\n                // MutationQueue.\n                _this.localDocuments = new LocalDocumentsView(_this.remoteDocuments, _this.mutationQueue);\n                return _this.mutationQueue.getAllMutationBatches(txn);\n            })\n                .next(function (newBatches) {\n                // Union the old/new changed keys.\n                var changedKeys = documentKeySet();\n                for (var _i = 0, _a = [oldBatches, newBatches]; _i < _a.length; _i++) {\n                    var batches = _a[_i];\n                    for (var _b = 0, batches_1 = batches; _b < batches_1.length; _b++) {\n                        var batch = batches_1[_b];\n                        for (var _c = 0, _d = batch.mutations; _c < _d.length; _c++) {\n                            var mutation = _d[_c];\n                            changedKeys = changedKeys.add(mutation.key);\n                        }\n                    }\n                }\n                // Return the set of all (potentially) changed documents as the\n                // result of the user change.\n                return _this.localDocuments.getDocuments(txn, changedKeys);\n            });\n        });\n    };\n    LocalStore.prototype.startQueryCache = function (txn) {\n        var _this = this;\n        return this.queryCache.start(txn).next(function () {\n            var targetId = _this.queryCache.getHighestTargetId();\n            _this.targetIdGenerator = TargetIdGenerator.forLocalStore(targetId);\n        });\n    };\n    LocalStore.prototype.startMutationQueue = function (txn) {\n        var _this = this;\n        return this.mutationQueue\n            .start(txn)\n            .next(function () {\n            // If we have any leftover mutation batch results from a prior run,\n            // just drop them.\n            // TODO(http://b/33446471): We probably need to repopulate\n            // heldBatchResults or similar instead, but that is not\n            // straightforward since we're not persisting the write ack versions.\n            _this.heldBatchResults = [];\n            return _this.mutationQueue.getHighestAcknowledgedBatchId(txn);\n        })\n            .next(function (highestAck) {\n            // TODO(mikelehen): This is the only usage of\n            // getAllMutationBatchesThroughBatchId(). Consider removing it in\n            // favor of a getAcknowledgedBatches() method.\n            if (highestAck !== BATCHID_UNKNOWN) {\n                return _this.mutationQueue.getAllMutationBatchesThroughBatchId(txn, highestAck);\n            }\n            else {\n                return PersistencePromise.resolve([]);\n            }\n        })\n            .next(function (ackedBatches) {\n            if (ackedBatches.length > 0) {\n                return _this.mutationQueue.removeMutationBatches(txn, ackedBatches);\n            }\n            else {\n                return PersistencePromise.resolve();\n            }\n        });\n    };\n    /* Accept locally generated Mutations and commit them to storage. */\n    LocalStore.prototype.localWrite = function (mutations) {\n        var _this = this;\n        return this.persistence.runTransaction('Locally write mutations', function (txn) {\n            var batch;\n            var localWriteTime = Timestamp.now();\n            return _this.mutationQueue\n                .addMutationBatch(txn, localWriteTime, mutations)\n                .next(function (promisedBatch) {\n                batch = promisedBatch;\n                // TODO(koss): This is doing an N^2 update by replaying ALL the\n                // mutations on each document (instead of just the ones added) in\n                // this batch.\n                var keys = batch.keys();\n                return _this.localDocuments.getDocuments(txn, keys);\n            })\n                .next(function (changedDocuments) {\n                return { batchId: batch.batchId, changes: changedDocuments };\n            });\n        });\n    };\n    /**\n     * Acknowledge the given batch.\n     *\n     * On the happy path when a batch is acknowledged, the local store will\n     *\n     *  + remove the batch from the mutation queue;\n     *  + apply the changes to the remote document cache;\n     *  + recalculate the latency compensated view implied by those changes (there\n     *    may be mutations in the queue that affect the documents but haven't been\n     *    acknowledged yet); and\n     *  + give the changed documents back the sync engine\n     *\n     * @returns The resulting (modified) documents.\n     */\n    LocalStore.prototype.acknowledgeBatch = function (batchResult) {\n        var _this = this;\n        return this.persistence.runTransaction('Acknowledge batch', function (txn) {\n            var affected;\n            return _this.mutationQueue\n                .acknowledgeBatch(txn, batchResult.batch, batchResult.streamToken)\n                .next(function () {\n                if (_this.shouldHoldBatchResult(batchResult.commitVersion)) {\n                    _this.heldBatchResults.push(batchResult);\n                    affected = documentKeySet();\n                    return PersistencePromise.resolve();\n                }\n                else {\n                    var documentBuffer_1 = new RemoteDocumentChangeBuffer(_this.remoteDocuments);\n                    return _this.releaseBatchResults(txn, [batchResult], documentBuffer_1).next(function (promisedAffectedKeys) {\n                        affected = promisedAffectedKeys;\n                        return documentBuffer_1.apply(txn);\n                    });\n                }\n            })\n                .next(function () {\n                return _this.mutationQueue.performConsistencyCheck(txn);\n            })\n                .next(function () {\n                return _this.localDocuments.getDocuments(txn, affected);\n            });\n        });\n    };\n    /**\n     * Remove mutations from the MutationQueue for the specified batch;\n     * LocalDocuments will be recalculated.\n     *\n     * @returns The resulting modified documents.\n     */\n    LocalStore.prototype.rejectBatch = function (batchId) {\n        var _this = this;\n        return this.persistence.runTransaction('Reject batch', function (txn) {\n            var toReject;\n            var affectedKeys;\n            return _this.mutationQueue\n                .lookupMutationBatch(txn, batchId)\n                .next(function (promisedToReject) {\n                assert(promisedToReject != null, 'Attempt to reject nonexistent batch!');\n                toReject = promisedToReject;\n                return _this.mutationQueue\n                    .getHighestAcknowledgedBatchId(txn)\n                    .next(function (lastAcked) {\n                    assert(batchId > lastAcked, \"Acknowledged batches can't be rejected.\");\n                    return toReject;\n                });\n            })\n                .next(function () {\n                return _this.removeMutationBatch(txn, toReject);\n            })\n                .next(function (promisedAffectedKeys) {\n                affectedKeys = promisedAffectedKeys;\n                return _this.mutationQueue.performConsistencyCheck(txn);\n            })\n                .next(function () {\n                return _this.localDocuments.getDocuments(txn, affectedKeys);\n            });\n        });\n    };\n    /** Returns the last recorded stream token for the current user. */\n    LocalStore.prototype.getLastStreamToken = function () {\n        var _this = this;\n        return this.persistence.runTransaction('Get last stream token', function (txn) {\n            return _this.mutationQueue.getLastStreamToken(txn);\n        });\n    };\n    /**\n     * Sets the stream token for the current user without acknowledging any\n     * mutation batch. This is usually only useful after a stream handshake or in\n     * response to an error that requires clearing the stream token.\n     */\n    LocalStore.prototype.setLastStreamToken = function (streamToken) {\n        var _this = this;\n        return this.persistence.runTransaction('Set last stream token', function (txn) {\n            return _this.mutationQueue.setLastStreamToken(txn, streamToken);\n        });\n    };\n    /**\n     * Returns the last consistent snapshot processed (used by the RemoteStore to\n     * determine whether to buffer incoming snapshots from the backend).\n     */\n    LocalStore.prototype.getLastRemoteSnapshotVersion = function () {\n        return this.queryCache.getLastRemoteSnapshotVersion();\n    };\n    /**\n     * Update the \"ground-state\" (remote) documents. We assume that the remote\n     * event reflects any write batches that have been acknowledged or rejected\n     * (i.e. we do not re-apply local mutations to updates from this event).\n     *\n     * LocalDocuments are re-calculated if there are remaining mutations in the\n     * queue.\n     */\n    LocalStore.prototype.applyRemoteEvent = function (remoteEvent) {\n        var _this = this;\n        var documentBuffer = new RemoteDocumentChangeBuffer(this.remoteDocuments);\n        return this.persistence.runTransaction('Apply remote event', function (txn) {\n            var promises = [];\n            objUtils.forEachNumber(remoteEvent.targetChanges, function (targetId, change) {\n                // Do not ref/unref unassigned targetIds - it may lead to leaks.\n                var queryData = _this.targetIds[targetId];\n                if (!queryData)\n                    return;\n                var mapping = change.mapping;\n                if (mapping) {\n                    // First make sure that all references are deleted\n                    if (mapping instanceof ResetMapping) {\n                        promises.push(_this.queryCache\n                            .removeMatchingKeysForTargetId(txn, targetId)\n                            .next(function () {\n                            return _this.queryCache.addMatchingKeys(txn, mapping.documents, targetId);\n                        }));\n                    }\n                    else if (mapping instanceof UpdateMapping) {\n                        promises.push(_this.queryCache\n                            .removeMatchingKeys(txn, mapping.removedDocuments, targetId)\n                            .next(function () {\n                            return _this.queryCache.addMatchingKeys(txn, mapping.addedDocuments, targetId);\n                        }));\n                    }\n                    else {\n                        return fail('Unknown mapping type: ' + JSON.stringify(mapping));\n                    }\n                }\n                // Update the resume token if the change includes one. Don't clear\n                // any preexisting value.\n                var resumeToken = change.resumeToken;\n                if (resumeToken.length > 0) {\n                    queryData = queryData.update({\n                        resumeToken: resumeToken,\n                        snapshotVersion: change.snapshotVersion\n                    });\n                    _this.targetIds[targetId] = queryData;\n                    promises.push(_this.queryCache.addQueryData(txn, queryData));\n                }\n            });\n            var changedDocKeys = documentKeySet();\n            remoteEvent.documentUpdates.forEach(function (key, doc) {\n                changedDocKeys = changedDocKeys.add(key);\n                promises.push(documentBuffer.getEntry(txn, key).next(function (existingDoc) {\n                    // Make sure we don't apply an old document version to the remote\n                    // cache, though we make an exception for SnapshotVersion.MIN which\n                    // can happen for manufactured events (e.g. in the case of a limbo\n                    // document resolution failing).\n                    if (existingDoc == null ||\n                        doc.version.isEqual(SnapshotVersion.MIN) ||\n                        doc.version.compareTo(existingDoc.version) >= 0) {\n                        documentBuffer.addEntry(doc);\n                    }\n                    else {\n                        log.debug(LOG_TAG, 'Ignoring outdated watch update for ', key, '. Current version:', existingDoc.version, ' Watch version:', doc.version);\n                    }\n                    // The document might be garbage because it was unreferenced by\n                    // everything. Make sure to mark it as garbage if it is...\n                    _this.garbageCollector.addPotentialGarbageKey(key);\n                }));\n            });\n            // HACK: The only reason we allow a null snapshot version is so that we\n            // can synthesize remote events when we get permission denied errors while\n            // trying to resolve the state of a locally cached document that is in\n            // limbo.\n            var lastRemoteVersion = _this.queryCache.getLastRemoteSnapshotVersion();\n            var remoteVersion = remoteEvent.snapshotVersion;\n            if (!remoteVersion.isEqual(SnapshotVersion.MIN)) {\n                assert(remoteVersion.compareTo(lastRemoteVersion) >= 0, 'Watch stream reverted to previous snapshot?? ' +\n                    remoteVersion +\n                    ' < ' +\n                    lastRemoteVersion);\n                promises.push(_this.queryCache.setLastRemoteSnapshotVersion(txn, remoteVersion));\n            }\n            var releasedWriteKeys;\n            return PersistencePromise.waitFor(promises)\n                .next(function () { return _this.releaseHeldBatchResults(txn, documentBuffer); })\n                .next(function (promisedReleasedWriteKeys) {\n                releasedWriteKeys = promisedReleasedWriteKeys;\n                return documentBuffer.apply(txn);\n            })\n                .next(function () {\n                return _this.localDocuments.getDocuments(txn, changedDocKeys.unionWith(releasedWriteKeys));\n            });\n        });\n    };\n    /**\n     * Notify local store of the changed views to locally pin documents.\n     */\n    LocalStore.prototype.notifyLocalViewChanges = function (viewChanges) {\n        var _this = this;\n        return this.persistence.runTransaction('Notify local view changes', function (txn) {\n            var promises = [];\n            var _loop_1 = function (view) {\n                promises.push(_this.queryCache\n                    .getQueryData(txn, view.query)\n                    .next(function (queryData) {\n                    assert(queryData !== null, 'Local view changes contain unallocated query.');\n                    var targetId = queryData.targetId;\n                    _this.localViewReferences.addReferences(view.addedKeys, targetId);\n                    _this.localViewReferences.removeReferences(view.removedKeys, targetId);\n                }));\n            };\n            for (var _i = 0, viewChanges_1 = viewChanges; _i < viewChanges_1.length; _i++) {\n                var view = viewChanges_1[_i];\n                _loop_1(view);\n            }\n            return PersistencePromise.waitFor(promises);\n        });\n    };\n    /**\n     * Gets the mutation batch after the passed in batchId in the mutation queue\n     * or null if empty.\n     * @param afterBatchId If provided, the batch to search after.\n     * @returns The next mutation or null if there wasn't one.\n     */\n    LocalStore.prototype.nextMutationBatch = function (afterBatchId) {\n        var _this = this;\n        return this.persistence.runTransaction('Get next mutation batch', function (txn) {\n            if (afterBatchId === undefined) {\n                afterBatchId = BATCHID_UNKNOWN;\n            }\n            return _this.mutationQueue.getNextMutationBatchAfterBatchId(txn, afterBatchId);\n        });\n    };\n    /**\n     * Read the current value of a Document with a given key or null if not\n     * found - used for testing.\n     */\n    LocalStore.prototype.readDocument = function (key) {\n        var _this = this;\n        return this.persistence.runTransaction('read document', function (txn) {\n            return _this.localDocuments.getDocument(txn, key);\n        });\n    };\n    /**\n     * Assigns the given query an internal ID so that its results can be pinned so\n     * they don't get GC'd. A query must be allocated in the local store before\n     * the store can be used to manage its view.\n     */\n    LocalStore.prototype.allocateQuery = function (query) {\n        var _this = this;\n        return this.persistence.runTransaction('Allocate query', function (txn) {\n            var queryData;\n            return _this.queryCache\n                .getQueryData(txn, query)\n                .next(function (cached) {\n                if (cached) {\n                    // This query has been listened to previously, so reuse the\n                    // previous targetID.\n                    // TODO(mcg): freshen last accessed date?\n                    queryData = cached;\n                    return PersistencePromise.resolve();\n                }\n                else {\n                    var targetId = _this.targetIdGenerator.next();\n                    queryData = new QueryData(query, targetId, QueryPurpose.Listen);\n                    return _this.queryCache.addQueryData(txn, queryData);\n                }\n            })\n                .next(function () {\n                assert(!_this.targetIds[queryData.targetId], 'Tried to allocate an already allocated query: ' + query);\n                _this.targetIds[queryData.targetId] = queryData;\n                return queryData;\n            });\n        });\n    };\n    /** Unpin all the documents associated with the given query. */\n    LocalStore.prototype.releaseQuery = function (query) {\n        var _this = this;\n        return this.persistence.runTransaction('Release query', function (txn) {\n            return _this.queryCache\n                .getQueryData(txn, query)\n                .next(function (queryData) {\n                assert(queryData != null, 'Tried to release nonexistent query: ' + query);\n                _this.localViewReferences.removeReferencesForId(queryData.targetId);\n                delete _this.targetIds[queryData.targetId];\n                if (_this.garbageCollector.isEager) {\n                    return _this.queryCache.removeQueryData(txn, queryData);\n                }\n                else {\n                    return PersistencePromise.resolve();\n                }\n            })\n                .next(function () {\n                // If this was the last watch target, then we won't get any more\n                // watch snapshots, so we should release any held batch results.\n                if (objUtils.isEmpty(_this.targetIds)) {\n                    var documentBuffer_2 = new RemoteDocumentChangeBuffer(_this.remoteDocuments);\n                    return _this.releaseHeldBatchResults(txn, documentBuffer_2).next(function () {\n                        documentBuffer_2.apply(txn);\n                    });\n                }\n                else {\n                    return PersistencePromise.resolve();\n                }\n            });\n        });\n    };\n    /**\n     * Runs the specified query against all the documents in the local store and\n     * returns the results.\n     */\n    LocalStore.prototype.executeQuery = function (query) {\n        var _this = this;\n        return this.persistence.runTransaction('Execute query', function (txn) {\n            return _this.localDocuments.getDocumentsMatchingQuery(txn, query);\n        });\n    };\n    /**\n     * Returns the keys of the documents that are associated with the given\n     * target id in the remote table.\n     */\n    LocalStore.prototype.remoteDocumentKeys = function (targetId) {\n        var _this = this;\n        return this.persistence.runTransaction('Remote document keys', function (txn) {\n            return _this.queryCache.getMatchingKeysForTargetId(txn, targetId);\n        });\n    };\n    /**\n     * Collect garbage if necessary.\n     * Should be called periodically by Sync Engine to recover resources. The\n     * implementation must guarantee that GC won't happen in other places than\n     * this method call.\n     */\n    LocalStore.prototype.collectGarbage = function () {\n        var _this = this;\n        // Call collectGarbage regardless of whether isGCEnabled so the referenceSet\n        // doesn't continue to accumulate the garbage keys.\n        return this.persistence.runTransaction('Garbage collection', function (txn) {\n            return _this.garbageCollector.collectGarbage(txn).next(function (garbage) {\n                var promises = [];\n                garbage.forEach(function (key) {\n                    promises.push(_this.remoteDocuments.removeEntry(txn, key));\n                });\n                return PersistencePromise.waitFor(promises);\n            });\n        });\n    };\n    LocalStore.prototype.releaseHeldBatchResults = function (txn, documentBuffer) {\n        var toRelease = [];\n        for (var _i = 0, _a = this.heldBatchResults; _i < _a.length; _i++) {\n            var batchResult = _a[_i];\n            if (!this.isRemoteUpToVersion(batchResult.commitVersion)) {\n                break;\n            }\n            toRelease.push(batchResult);\n        }\n        if (toRelease.length === 0) {\n            return PersistencePromise.resolve(documentKeySet());\n        }\n        else {\n            this.heldBatchResults.splice(0, toRelease.length);\n            return this.releaseBatchResults(txn, toRelease, documentBuffer);\n        }\n    };\n    LocalStore.prototype.isRemoteUpToVersion = function (version) {\n        // If there are no watch targets, then we won't get remote snapshots, and\n        // we are always \"up-to-date.\"\n        var lastRemoteVersion = this.queryCache.getLastRemoteSnapshotVersion();\n        return (version.compareTo(lastRemoteVersion) <= 0 ||\n            objUtils.isEmpty(this.targetIds));\n    };\n    LocalStore.prototype.shouldHoldBatchResult = function (version) {\n        // Check if watcher isn't up to date or prior results are already held.\n        return (!this.isRemoteUpToVersion(version) || this.heldBatchResults.length > 0);\n    };\n    LocalStore.prototype.releaseBatchResults = function (txn, batchResults, documentBuffer) {\n        var _this = this;\n        var promiseChain = PersistencePromise.resolve();\n        var _loop_2 = function (batchResult) {\n            promiseChain = promiseChain.next(function () {\n                return _this.applyWriteToRemoteDocuments(txn, batchResult, documentBuffer);\n            });\n        };\n        for (var _i = 0, batchResults_1 = batchResults; _i < batchResults_1.length; _i++) {\n            var batchResult = batchResults_1[_i];\n            _loop_2(batchResult);\n        }\n        return promiseChain.next(function () {\n            return _this.removeMutationBatches(txn, batchResults.map(function (result) { return result.batch; }));\n        });\n    };\n    LocalStore.prototype.removeMutationBatch = function (txn, batch) {\n        return this.removeMutationBatches(txn, [batch]);\n    };\n    /** Removes all the mutation batches named in the given array. */\n    LocalStore.prototype.removeMutationBatches = function (txn, batches) {\n        var affectedDocs = documentKeySet();\n        for (var _i = 0, batches_2 = batches; _i < batches_2.length; _i++) {\n            var batch = batches_2[_i];\n            for (var _a = 0, _b = batch.mutations; _a < _b.length; _a++) {\n                var mutation = _b[_a];\n                var key = mutation.key;\n                affectedDocs = affectedDocs.add(key);\n            }\n        }\n        return this.mutationQueue\n            .removeMutationBatches(txn, batches)\n            .next(function () { return affectedDocs; });\n    };\n    LocalStore.prototype.applyWriteToRemoteDocuments = function (txn, batchResult, documentBuffer) {\n        var batch = batchResult.batch;\n        var docKeys = batch.keys();\n        var promiseChain = PersistencePromise.resolve();\n        docKeys.forEach(function (docKey) {\n            promiseChain = promiseChain\n                .next(function () {\n                return documentBuffer.getEntry(txn, docKey);\n            })\n                .next(function (remoteDoc) {\n                var doc = remoteDoc;\n                var ackVersion = batchResult.docVersions.get(docKey);\n                assert(ackVersion !== null, 'ackVersions should contain every doc in the write.');\n                if (!doc || doc.version.compareTo(ackVersion) < 0) {\n                    doc = batch.applyToRemoteDocument(docKey, doc, batchResult);\n                    if (!doc) {\n                        assert(!remoteDoc, 'Mutation batch ' +\n                            batch +\n                            ' applied to document ' +\n                            remoteDoc +\n                            ' resulted in null');\n                    }\n                    else {\n                        documentBuffer.addEntry(doc);\n                    }\n                }\n            });\n        });\n        return promiseChain;\n    };\n    return LocalStore;\n}());\nexport { LocalStore };\n\n//# sourceMappingURL=local_store.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/local_store.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { DocumentKey } from '../model/document_key';\nimport { BATCHID_UNKNOWN, MutationBatch } from '../model/mutation_batch';\nimport { emptyByteString } from '../platform/platform';\nimport { assert } from '../util/assert';\nimport { primitiveComparator } from '../util/misc';\nimport { SortedSet } from '../util/sorted_set';\nimport { PersistencePromise } from './persistence_promise';\nimport { DocReference } from './reference_set';\nvar MemoryMutationQueue = /** @class */ (function () {\n    function MemoryMutationQueue() {\n        /**\n         * The set of all mutations that have been sent but not yet been applied to\n         * the backend.\n         */\n        this.mutationQueue = [];\n        /** Next value to use when assigning sequential IDs to each mutation batch. */\n        this.nextBatchId = 1;\n        /** The highest acknowledged mutation in the queue. */\n        this.highestAcknowledgedBatchId = BATCHID_UNKNOWN;\n        /** The last received stream token from the server, used to acknowledge which\n         * responses the client has processed. Stream tokens are opaque checkpoint\n         * markers whose only real value is their inclusion in the next request.\n         */\n        this.lastStreamToken = emptyByteString();\n        /** The garbage collector to notify about potential garbage keys. */\n        this.garbageCollector = null;\n        /** An ordered mapping between documents and the mutations batch IDs. */\n        this.batchesByDocumentKey = new SortedSet(DocReference.compareByKey);\n    }\n    MemoryMutationQueue.prototype.start = function (transaction) {\n        // NOTE: The queue may be shutdown / started multiple times, since we\n        // maintain the queue for the duration of the app session in case a user\n        // logs out / back in. To behave like the LevelDB-backed MutationQueue (and\n        // accommodate tests that expect as much), we reset nextBatchId and\n        // highestAcknowledgedBatchId if the queue is empty.\n        if (this.mutationQueue.length === 0) {\n            this.nextBatchId = 1;\n            this.highestAcknowledgedBatchId = BATCHID_UNKNOWN;\n        }\n        assert(this.highestAcknowledgedBatchId < this.nextBatchId, 'highestAcknowledgedBatchId must be less than the nextBatchId');\n        return PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.checkEmpty = function (transaction) {\n        return PersistencePromise.resolve(this.mutationQueue.length === 0);\n    };\n    MemoryMutationQueue.prototype.getNextBatchId = function (transaction) {\n        return PersistencePromise.resolve(this.nextBatchId);\n    };\n    MemoryMutationQueue.prototype.getHighestAcknowledgedBatchId = function (transaction) {\n        return PersistencePromise.resolve(this.highestAcknowledgedBatchId);\n    };\n    MemoryMutationQueue.prototype.acknowledgeBatch = function (transaction, batch, streamToken) {\n        var batchId = batch.batchId;\n        assert(batchId > this.highestAcknowledgedBatchId, 'Mutation batchIDs must be acknowledged in order');\n        var batchIndex = this.indexOfExistingBatchId(batchId, 'acknowledged');\n        // Verify that the batch in the queue is the one to be acknowledged.\n        var check = this.mutationQueue[batchIndex];\n        assert(batchId === check.batchId, 'Queue ordering failure: expected batch ' +\n            batchId +\n            ', got batch ' +\n            check.batchId);\n        assert(!check.isTombstone(), \"Can't acknowledge a previously removed batch\");\n        this.highestAcknowledgedBatchId = batchId;\n        this.lastStreamToken = streamToken;\n        return PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.getLastStreamToken = function (transaction) {\n        return PersistencePromise.resolve(this.lastStreamToken);\n    };\n    MemoryMutationQueue.prototype.setLastStreamToken = function (transaction, streamToken) {\n        this.lastStreamToken = streamToken;\n        return PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.addMutationBatch = function (transaction, localWriteTime, mutations) {\n        assert(mutations.length !== 0, 'Mutation batches should not be empty');\n        var batchId = this.nextBatchId;\n        this.nextBatchId++;\n        if (this.mutationQueue.length > 0) {\n            var prior = this.mutationQueue[this.mutationQueue.length - 1];\n            assert(prior.batchId < batchId, 'Mutation batchIDs must be monotonically increasing order');\n        }\n        var batch = new MutationBatch(batchId, localWriteTime, mutations);\n        this.mutationQueue.push(batch);\n        // Track references by document key.\n        for (var _i = 0, mutations_1 = mutations; _i < mutations_1.length; _i++) {\n            var mutation = mutations_1[_i];\n            this.batchesByDocumentKey = this.batchesByDocumentKey.add(new DocReference(mutation.key, batchId));\n        }\n        return PersistencePromise.resolve(batch);\n    };\n    MemoryMutationQueue.prototype.lookupMutationBatch = function (transaction, batchId) {\n        return PersistencePromise.resolve(this.findMutationBatch(batchId));\n    };\n    MemoryMutationQueue.prototype.getNextMutationBatchAfterBatchId = function (transaction, batchId) {\n        var size = this.mutationQueue.length;\n        // All batches with batchId <= this.highestAcknowledgedBatchId have been\n        // acknowledged so the first unacknowledged batch after batchID will have a\n        // batchID larger than both of these values.\n        batchId = Math.max(batchId + 1, this.highestAcknowledgedBatchId);\n        // The requested batchId may still be out of range so normalize it to the\n        // start of the queue.\n        var rawIndex = this.indexOfBatchId(batchId);\n        var index = rawIndex < 0 ? 0 : rawIndex;\n        // Finally return the first non-tombstone batch.\n        for (; index < size; index++) {\n            var batch = this.mutationQueue[index];\n            if (!batch.isTombstone()) {\n                return PersistencePromise.resolve(batch);\n            }\n        }\n        return PersistencePromise.resolve(null);\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatches = function (transaction) {\n        return PersistencePromise.resolve(this.getAllLiveMutationBatchesBeforeIndex(this.mutationQueue.length));\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatchesThroughBatchId = function (transaction, batchId) {\n        var count = this.mutationQueue.length;\n        var endIndex = this.indexOfBatchId(batchId);\n        if (endIndex < 0) {\n            endIndex = 0;\n        }\n        else if (endIndex >= count) {\n            endIndex = count;\n        }\n        else {\n            // The endIndex is in the queue so increment to pull everything in the\n            // queue including it.\n            endIndex++;\n        }\n        return PersistencePromise.resolve(this.getAllLiveMutationBatchesBeforeIndex(endIndex));\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatchesAffectingDocumentKey = function (transaction, documentKey) {\n        var _this = this;\n        var start = new DocReference(documentKey, 0);\n        var end = new DocReference(documentKey, Number.POSITIVE_INFINITY);\n        var result = [];\n        this.batchesByDocumentKey.forEachInRange([start, end], function (ref) {\n            assert(documentKey.isEqual(ref.key), \"Should only iterate over a single key's batches\");\n            var batch = _this.findMutationBatch(ref.targetOrBatchId);\n            assert(batch !== null, 'Batches in the index must exist in the main table');\n            result.push(batch);\n        });\n        return PersistencePromise.resolve(result);\n    };\n    MemoryMutationQueue.prototype.getAllMutationBatchesAffectingQuery = function (transaction, query) {\n        var _this = this;\n        // Use the query path as a prefix for testing if a document matches the\n        // query.\n        var prefix = query.path;\n        var immediateChildrenPathLength = prefix.length + 1;\n        // Construct a document reference for actually scanning the index. Unlike\n        // the prefix the document key in this reference must have an even number of\n        // segments. The empty segment can be used a suffix of the query path\n        // because it precedes all other segments in an ordered traversal.\n        var startPath = prefix;\n        if (!DocumentKey.isDocumentKey(startPath)) {\n            startPath = startPath.child('');\n        }\n        var start = new DocReference(new DocumentKey(startPath), 0);\n        // Find unique batchIDs referenced by all documents potentially matching the\n        // query.\n        var uniqueBatchIDs = new SortedSet(primitiveComparator);\n        this.batchesByDocumentKey.forEachWhile(function (ref) {\n            var rowKeyPath = ref.key.path;\n            if (!prefix.isPrefixOf(rowKeyPath)) {\n                return false;\n            }\n            else {\n                // Rows with document keys more than one segment longer than the query\n                // path can't be matches. For example, a query on 'rooms' can't match\n                // the document /rooms/abc/messages/xyx.\n                // TODO(mcg): we'll need a different scanner when we implement\n                // ancestor queries.\n                if (rowKeyPath.length === immediateChildrenPathLength) {\n                    uniqueBatchIDs = uniqueBatchIDs.add(ref.targetOrBatchId);\n                }\n                return true;\n            }\n        }, start);\n        // Construct an array of matching batches, sorted by batchID to ensure that\n        // multiple mutations affecting the same document key are applied in order.\n        var result = [];\n        uniqueBatchIDs.forEach(function (batchId) {\n            var batch = _this.findMutationBatch(batchId);\n            if (batch !== null) {\n                result.push(batch);\n            }\n        });\n        return PersistencePromise.resolve(result);\n    };\n    MemoryMutationQueue.prototype.removeMutationBatches = function (transaction, batches) {\n        var batchCount = batches.length;\n        assert(batchCount > 0, 'Should not remove mutations when none exist.');\n        var firstBatchId = batches[0].batchId;\n        var queueCount = this.mutationQueue.length;\n        // Find the position of the first batch for removal. This need not be the\n        // first entry in the queue.\n        var startIndex = this.indexOfExistingBatchId(firstBatchId, 'removed');\n        assert(this.mutationQueue[startIndex].batchId === firstBatchId, 'Removed batches must exist in the queue');\n        // Check that removed batches are contiguous (while excluding tombstones).\n        var batchIndex = 1;\n        var queueIndex = startIndex + 1;\n        while (batchIndex < batchCount && queueIndex < queueCount) {\n            var batch = this.mutationQueue[queueIndex];\n            if (batch.isTombstone()) {\n                queueIndex++;\n                continue;\n            }\n            assert(batch.batchId === batches[batchIndex].batchId, 'Removed batches must be contiguous in the queue');\n            batchIndex++;\n            queueIndex++;\n        }\n        // Only actually remove batches if removing at the front of the queue.\n        // Previously rejected batches may have left tombstones in the queue, so\n        // expand the removal range to include any tombstones.\n        if (startIndex === 0) {\n            for (; queueIndex < queueCount; queueIndex++) {\n                var batch = this.mutationQueue[queueIndex];\n                if (!batch.isTombstone()) {\n                    break;\n                }\n            }\n            var length_1 = queueIndex - startIndex;\n            this.mutationQueue.splice(startIndex, length_1);\n        }\n        else {\n            // Mark the tombstones\n            for (var i = startIndex; i < queueIndex; i++) {\n                this.mutationQueue[i] = this.mutationQueue[i].toTombstone();\n            }\n        }\n        var references = this.batchesByDocumentKey;\n        for (var _i = 0, batches_1 = batches; _i < batches_1.length; _i++) {\n            var batch = batches_1[_i];\n            var batchId = batch.batchId;\n            for (var _a = 0, _b = batch.mutations; _a < _b.length; _a++) {\n                var mutation = _b[_a];\n                var key = mutation.key;\n                if (this.garbageCollector !== null) {\n                    this.garbageCollector.addPotentialGarbageKey(key);\n                }\n                var ref = new DocReference(key, batchId);\n                references = references.delete(ref);\n            }\n        }\n        this.batchesByDocumentKey = references;\n        return PersistencePromise.resolve();\n    };\n    MemoryMutationQueue.prototype.setGarbageCollector = function (garbageCollector) {\n        this.garbageCollector = garbageCollector;\n    };\n    MemoryMutationQueue.prototype.containsKey = function (txn, key) {\n        var ref = new DocReference(key, 0);\n        var firstRef = this.batchesByDocumentKey.firstAfterOrEqual(ref);\n        return PersistencePromise.resolve(key.isEqual(firstRef && firstRef.key));\n    };\n    MemoryMutationQueue.prototype.performConsistencyCheck = function (txn) {\n        if (this.mutationQueue.length === 0) {\n            assert(this.batchesByDocumentKey.isEmpty(), 'Document leak -- detected dangling mutation references when queue is empty.');\n        }\n        return PersistencePromise.resolve();\n    };\n    /**\n     * A private helper that collects all the mutations batches in the queue up to\n     * but not including the given endIndex. All tombstones in the queue are\n     * excluded.\n     */\n    MemoryMutationQueue.prototype.getAllLiveMutationBatchesBeforeIndex = function (endIndex) {\n        var result = [];\n        for (var i = 0; i < endIndex; i++) {\n            var batch = this.mutationQueue[i];\n            if (!batch.isTombstone()) {\n                result.push(batch);\n            }\n        }\n        return result;\n    };\n    /**\n     * Finds the index of the given batchId in the mutation queue and asserts that\n     * the resulting index is within the bounds of the queue.\n     *\n     * @param batchId The batchId to search for\n     * @param action A description of what the caller is doing, phrased in passive\n     * form (e.g. \"acknowledged\" in a routine that acknowledges batches).\n     */\n    MemoryMutationQueue.prototype.indexOfExistingBatchId = function (batchId, action) {\n        var index = this.indexOfBatchId(batchId);\n        assert(index >= 0 && index < this.mutationQueue.length, 'Batches must exist to be ' + action);\n        return index;\n    };\n    /**\n     * Finds the index of the given batchId in the mutation queue. This operation\n     * is O(1).\n     *\n     * @return The computed index of the batch with the given batchId, based on\n     * the state of the queue. Note this index can be negative if the requested\n     * batchId has already been remvoed from the queue or past the end of the\n     * queue if the batchId is larger than the last added batch.\n     */\n    MemoryMutationQueue.prototype.indexOfBatchId = function (batchId) {\n        if (this.mutationQueue.length === 0) {\n            // As an index this is past the end of the queue\n            return 0;\n        }\n        // Examine the front of the queue to figure out the difference between the\n        // batchId and indexes in the array. Note that since the queue is ordered\n        // by batchId, if the first batch has a larger batchId then the requested\n        // batchId doesn't exist in the queue.\n        var firstBatchId = this.mutationQueue[0].batchId;\n        return batchId - firstBatchId;\n    };\n    /**\n     * A version of lookupMutationBatch that doesn't return a promise, this makes\n     * other functions that uses this code easier to read and more efficent.\n     */\n    MemoryMutationQueue.prototype.findMutationBatch = function (batchId) {\n        var index = this.indexOfBatchId(batchId);\n        if (index < 0 || index >= this.mutationQueue.length) {\n            return null;\n        }\n        var batch = this.mutationQueue[index];\n        assert(batch.batchId === batchId, 'If found batch must match');\n        return batch.isTombstone() ? null : batch;\n    };\n    return MemoryMutationQueue;\n}());\nexport { MemoryMutationQueue };\n\n//# sourceMappingURL=memory_mutation_queue.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/memory_mutation_queue.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { ObjectMap } from '../util/obj_map';\nimport { PersistencePromise } from './persistence_promise';\nimport { ReferenceSet } from './reference_set';\nvar MemoryQueryCache = /** @class */ (function () {\n    function MemoryQueryCache() {\n        /**\n         * Maps a query to the data about that query\n         */\n        this.queries = new ObjectMap(function (q) { return q.canonicalId(); });\n        /** The last received snapshot version. */\n        this.lastRemoteSnapshotVersion = SnapshotVersion.MIN;\n        /** The highest numbered target ID encountered. */\n        this.highestTargetId = 0;\n        /**\n         * A ordered bidirectional mapping between documents and the remote target\n         * IDs.\n         */\n        this.references = new ReferenceSet();\n    }\n    MemoryQueryCache.prototype.start = function (transaction) {\n        // Nothing to do.\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.getLastRemoteSnapshotVersion = function () {\n        return this.lastRemoteSnapshotVersion;\n    };\n    MemoryQueryCache.prototype.getHighestTargetId = function () {\n        return this.highestTargetId;\n    };\n    MemoryQueryCache.prototype.setLastRemoteSnapshotVersion = function (transaction, snapshotVersion) {\n        this.lastRemoteSnapshotVersion = snapshotVersion;\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.addQueryData = function (transaction, queryData) {\n        this.queries.set(queryData.query, queryData);\n        var targetId = queryData.targetId;\n        if (targetId > this.highestTargetId) {\n            this.highestTargetId = targetId;\n        }\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.removeQueryData = function (transaction, queryData) {\n        this.queries.delete(queryData.query);\n        this.references.removeReferencesForId(queryData.targetId);\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.getQueryData = function (transaction, query) {\n        var queryData = this.queries.get(query) || null;\n        return PersistencePromise.resolve(queryData);\n    };\n    MemoryQueryCache.prototype.addMatchingKeys = function (txn, keys, targetId) {\n        this.references.addReferences(keys, targetId);\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.removeMatchingKeys = function (txn, keys, targetId) {\n        this.references.removeReferences(keys, targetId);\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.removeMatchingKeysForTargetId = function (txn, targetId) {\n        this.references.removeReferencesForId(targetId);\n        return PersistencePromise.resolve();\n    };\n    MemoryQueryCache.prototype.getMatchingKeysForTargetId = function (txn, targetId) {\n        var matchingKeys = this.references.referencesForId(targetId);\n        return PersistencePromise.resolve(matchingKeys);\n    };\n    MemoryQueryCache.prototype.setGarbageCollector = function (gc) {\n        this.references.setGarbageCollector(gc);\n    };\n    MemoryQueryCache.prototype.containsKey = function (txn, key) {\n        return this.references.containsKey(txn, key);\n    };\n    return MemoryQueryCache;\n}());\nexport { MemoryQueryCache };\n\n//# sourceMappingURL=memory_query_cache.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/memory_query_cache.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentMap, maybeDocumentMap } from '../model/collections';\nimport { Document } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { PersistencePromise } from './persistence_promise';\nvar MemoryRemoteDocumentCache = /** @class */ (function () {\n    function MemoryRemoteDocumentCache() {\n        this.docs = maybeDocumentMap();\n    }\n    MemoryRemoteDocumentCache.prototype.addEntry = function (transaction, maybeDocument) {\n        this.docs = this.docs.insert(maybeDocument.key, maybeDocument);\n        return PersistencePromise.resolve();\n    };\n    MemoryRemoteDocumentCache.prototype.removeEntry = function (transaction, documentKey) {\n        this.docs = this.docs.remove(documentKey);\n        return PersistencePromise.resolve();\n    };\n    MemoryRemoteDocumentCache.prototype.getEntry = function (transaction, documentKey) {\n        return PersistencePromise.resolve(this.docs.get(documentKey));\n    };\n    MemoryRemoteDocumentCache.prototype.getDocumentsMatchingQuery = function (transaction, query) {\n        var results = documentMap();\n        // Documents are ordered by key, so we can use a prefix scan to narrow down\n        // the documents we need to match the query against.\n        var prefix = new DocumentKey(query.path.child(''));\n        var iterator = this.docs.getIteratorFrom(prefix);\n        while (iterator.hasNext()) {\n            var _a = iterator.getNext(), key = _a.key, maybeDoc = _a.value;\n            if (!query.path.isPrefixOf(key.path)) {\n                break;\n            }\n            if (maybeDoc instanceof Document && query.matches(maybeDoc)) {\n                results = results.insert(maybeDoc.key, maybeDoc);\n            }\n        }\n        return PersistencePromise.resolve(results);\n    };\n    return MemoryRemoteDocumentCache;\n}());\nexport { MemoryRemoteDocumentCache };\n\n//# sourceMappingURL=memory_remote_document_cache.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/memory_remote_document_cache.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { assert } from '../util/assert';\nimport { debug } from '../util/log';\nimport { MemoryMutationQueue } from './memory_mutation_queue';\nimport { MemoryQueryCache } from './memory_query_cache';\nimport { MemoryRemoteDocumentCache } from './memory_remote_document_cache';\nvar LOG_TAG = 'MemoryPersistence';\n/**\n * A memory-backed instance of Persistence. Data is stored only in RAM and\n * not persisted across sessions.\n */\nvar MemoryPersistence = /** @class */ (function () {\n    function MemoryPersistence() {\n        /**\n         * Note that these are retained here to make it easier to write tests\n         * affecting both the in-memory and IndexedDB-backed persistence layers. Tests\n         * can create a new LocalStore wrapping this Persistence instance and this\n         * will make the in-memory persistence layer behave as if it were actually\n         * persisting values.\n         */\n        this.mutationQueues = {};\n        this.remoteDocumentCache = new MemoryRemoteDocumentCache();\n        this.queryCache = new MemoryQueryCache();\n        this.started = false;\n    }\n    MemoryPersistence.prototype.start = function () {\n        assert(!this.started, 'MemoryPersistence double-started!');\n        this.started = true;\n        // No durable state to read on startup.\n        return Promise.resolve();\n    };\n    MemoryPersistence.prototype.shutdown = function () {\n        // No durable state to ensure is closed on shutdown.\n        assert(this.started, 'MemoryPersistence shutdown without start!');\n        this.started = false;\n        return Promise.resolve();\n    };\n    MemoryPersistence.prototype.getMutationQueue = function (user) {\n        var queue = this.mutationQueues[user.toKey()];\n        if (!queue) {\n            queue = new MemoryMutationQueue();\n            this.mutationQueues[user.toKey()] = queue;\n        }\n        return queue;\n    };\n    MemoryPersistence.prototype.getQueryCache = function () {\n        return this.queryCache;\n    };\n    MemoryPersistence.prototype.getRemoteDocumentCache = function () {\n        return this.remoteDocumentCache;\n    };\n    MemoryPersistence.prototype.runTransaction = function (action, operation) {\n        debug(LOG_TAG, 'Starting transaction:', action);\n        return operation(new MemoryPersistenceTransaction()).toPromise();\n    };\n    return MemoryPersistence;\n}());\nexport { MemoryPersistence };\n/** Dummy class since memory persistence doesn't actually use transactions. */\nvar MemoryPersistenceTransaction = /** @class */ (function () {\n    function MemoryPersistenceTransaction() {\n    }\n    return MemoryPersistenceTransaction;\n}());\n\n//# sourceMappingURL=memory_persistence.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/memory_persistence.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { documentKeySet } from '../model/collections';\nimport { PersistencePromise } from './persistence_promise';\n/**\n * A garbage collector implementation that does absolutely nothing. It ignores\n * all addGarbageSource and addPotentialGarbageKey messages and and never\n * produces any garbage.\n */\nvar NoOpGarbageCollector = /** @class */ (function () {\n    function NoOpGarbageCollector() {\n        this.isEager = false;\n    }\n    NoOpGarbageCollector.prototype.addGarbageSource = function (garbageSource) {\n        // Not tracking garbage so don't track sources.\n    };\n    NoOpGarbageCollector.prototype.removeGarbageSource = function (garbageSource) {\n        // Not tracking garbage so don't track sources.\n    };\n    NoOpGarbageCollector.prototype.addPotentialGarbageKey = function (key) {\n        // Not tracking garbage so ignore.\n    };\n    NoOpGarbageCollector.prototype.collectGarbage = function (txn) {\n        return PersistencePromise.resolve(documentKeySet());\n    };\n    return NoOpGarbageCollector;\n}());\nexport { NoOpGarbageCollector };\n\n//# sourceMappingURL=no_op_garbage_collector.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/local/no_op_garbage_collector.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar Deferred = /** @class */ (function () {\n    function Deferred() {\n        var _this = this;\n        this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n    }\n    return Deferred;\n}());\nexport { Deferred };\n/**\n * Takes an array of values and sequences them using the promise (or value)\n * returned by the supplied callback. The callback for each item is called\n * after the promise is resolved for the previous item.\n * The function returns a promise which is resolved after the promise for\n * the last item is resolved.\n */\nexport function sequence(values, fn, initialValue) {\n    var result = Promise.resolve(initialValue);\n    values.forEach(function (value) {\n        result = result.then(function (lastResult) { return fn(value, lastResult); });\n    });\n    return result;\n}\n\n//# sourceMappingURL=promise.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/promise.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { assert } from '../util/assert';\nimport { TimerId } from '../util/async_queue';\nimport { Code, FirestoreError } from '../util/error';\nimport * as log from '../util/log';\nimport { ExponentialBackoff } from './backoff';\nimport { isNullOrUndefined } from '../util/types';\nvar LOG_TAG = 'PersistentStream';\nvar PersistentStreamState;\n(function (PersistentStreamState) {\n    /**\n     * The streaming RPC is not running and there's no error condition.\n     * Calling `start` will start the stream immediately without backoff.\n     * While in this state isStarted will return false.\n     */\n    PersistentStreamState[PersistentStreamState[\"Initial\"] = 0] = \"Initial\";\n    /**\n     * The stream is starting, and is waiting for an auth token to attach to\n     * the initial request. While in this state, isStarted will return\n     * true but isOpen will return false.\n     */\n    PersistentStreamState[PersistentStreamState[\"Auth\"] = 1] = \"Auth\";\n    /**\n     * The streaming RPC is up and running. Requests and responses can flow\n     * freely. Both isStarted and isOpen will return true.\n     */\n    PersistentStreamState[PersistentStreamState[\"Open\"] = 2] = \"Open\";\n    /**\n     * The stream encountered an error. The next start attempt will back off.\n     * While in this state isStarted() will return false.\n     *\n     */\n    PersistentStreamState[PersistentStreamState[\"Error\"] = 3] = \"Error\";\n    /**\n     * An in-between state after an error where the stream is waiting before\n     * re-starting. After\n     * waiting is complete, the stream will try to open. While in this\n     * state isStarted() will return YES but isOpen will return false.\n     */\n    PersistentStreamState[PersistentStreamState[\"Backoff\"] = 4] = \"Backoff\";\n    /**\n     * The stream has been explicitly stopped; no further events will be emitted.\n     */\n    PersistentStreamState[PersistentStreamState[\"Stopped\"] = 5] = \"Stopped\";\n})(PersistentStreamState || (PersistentStreamState = {}));\n/**\n * Initial backoff time in milliseconds after an error.\n * Set to 1s according to https://cloud.google.com/apis/design/errors.\n */\nvar BACKOFF_INITIAL_DELAY_MS = 1000;\n/** Maximum backoff time in milliseconds */\nvar BACKOFF_MAX_DELAY_MS = 60 * 1000;\nvar BACKOFF_FACTOR = 1.5;\n/** The time a stream stays open after it is marked idle. */\nvar IDLE_TIMEOUT_MS = 60 * 1000;\n/**\n * A PersistentStream is an abstract base class that represents a streaming RPC\n * to the Firestore backend. It's built on top of the connections own support\n * for streaming RPCs, and adds several critical features for our clients:\n *\n *   - Exponential backoff on failure\n *   - Authentication via CredentialsProvider\n *   - Dispatching all callbacks into the shared worker queue\n *\n * Subclasses of PersistentStream implement serialization of models to and\n * from the JSON representation of the protocol buffers for a specific\n * streaming RPC.\n *\n * ## Starting and Stopping\n *\n * Streaming RPCs are stateful and need to be `start`ed before messages can\n * be sent and received. The PersistentStream will call the onOpen function\n * of the listener once the stream is ready to accept requests.\n *\n * Should a `start` fail, PersistentStream will call the registered\n * onClose with a FirestoreError indicating what went wrong.\n *\n * A PersistentStream can be started and stopped repeatedly.\n *\n * Generic types:\n *  SendType: The type of the outgoing message of the underlying\n *    connection stream\n *  ReceiveType: The type of the incoming message of the underlying\n *    connection stream\n *  ListenerType: The type of the listener that will be used for callbacks\n */\nvar PersistentStream = /** @class */ (function () {\n    function PersistentStream(queue, connectionTimerId, idleTimerId, connection, credentialsProvider) {\n        this.queue = queue;\n        this.idleTimerId = idleTimerId;\n        this.connection = connection;\n        this.credentialsProvider = credentialsProvider;\n        this.inactivityTimerPromise = null;\n        this.stream = null;\n        this.listener = null;\n        this.backoff = new ExponentialBackoff(queue, connectionTimerId, BACKOFF_INITIAL_DELAY_MS, BACKOFF_FACTOR, BACKOFF_MAX_DELAY_MS);\n        this.state = PersistentStreamState.Initial;\n    }\n    /**\n     * Returns true if `start` has been called and no error has occurred. True\n     * indicates the stream is open or in the process of opening (which\n     * encompasses respecting backoff, getting auth tokens, and starting the\n     * actual RPC). Use `isOpen` to determine if the stream is open and ready for\n     * outbound requests.\n     */\n    PersistentStream.prototype.isStarted = function () {\n        return (this.state === PersistentStreamState.Backoff ||\n            this.state === PersistentStreamState.Auth ||\n            this.state === PersistentStreamState.Open);\n    };\n    /**\n     * Returns true if the underlying RPC is open (the openHandler has been\n     * called) and the stream is ready for outbound requests.\n     */\n    PersistentStream.prototype.isOpen = function () {\n        return this.state === PersistentStreamState.Open;\n    };\n    /**\n     * Starts the RPC. Only allowed if isStarted returns false. The stream is\n     * not immediately ready for use: onOpen will be invoked when the RPC is ready\n     * for outbound requests, at which point isOpen will return true.\n     *\n     *  When start returns, isStarted will return true.\n     */\n    PersistentStream.prototype.start = function (listener) {\n        if (this.state === PersistentStreamState.Error) {\n            this.performBackoff(listener);\n            return;\n        }\n        assert(this.state === PersistentStreamState.Initial, 'Already started');\n        this.listener = listener;\n        this.auth();\n    };\n    /**\n     * Stops the RPC. This call is idempotent and allowed regardless of the\n     * current isStarted state.\n     *\n     * When stop returns, isStarted and isOpen will both return false.\n     */\n    PersistentStream.prototype.stop = function () {\n        if (this.isStarted()) {\n            this.close(PersistentStreamState.Stopped);\n        }\n    };\n    /**\n     * After an error the stream will usually back off on the next attempt to\n     * start it. If the error warrants an immediate restart of the stream, the\n     * sender can use this to indicate that the receiver should not back off.\n     *\n     * Each error will call the onClose function. That function can decide to\n     * inhibit backoff if required.\n     */\n    PersistentStream.prototype.inhibitBackoff = function () {\n        assert(!this.isStarted(), 'Can only inhibit backoff in a stopped state');\n        this.state = PersistentStreamState.Initial;\n        this.backoff.reset();\n    };\n    /**\n     * Marks this stream as idle. If no further actions are performed on the\n     * stream for one minute, the stream will automatically close itself and\n     * notify the stream's onClose() handler with Status.OK. The stream will then\n     * be in a !isStarted() state, requiring the caller to start the stream again\n     * before further use.\n     *\n     * Only streams that are in state 'Open' can be marked idle, as all other\n     * states imply pending network operations.\n     */\n    PersistentStream.prototype.markIdle = function () {\n        var _this = this;\n        // Starts the idle time if we are in state 'Open' and are not yet already\n        // running a timer (in which case the previous idle timeout still applies).\n        if (this.isOpen() && this.inactivityTimerPromise === null) {\n            this.inactivityTimerPromise = this.queue.enqueueAfterDelay(this.idleTimerId, IDLE_TIMEOUT_MS, function () { return _this.handleIdleCloseTimer(); });\n            this.inactivityTimerPromise.catch(function (err) {\n                // When the AsyncQueue gets drained during testing, pending Promises\n                // (including these idle checks) will get rejected. We special-case\n                // these cancelled idle checks to make sure that these specific Promise\n                // rejections are not considered unhandled.\n                assert(err.code === Code.CANCELLED, \"Received unexpected error in idle timeout closure. Expected CANCELLED, but was: \" + err);\n            });\n        }\n    };\n    /** Sends a message to the underlying stream. */\n    PersistentStream.prototype.sendRequest = function (msg) {\n        this.cancelIdleCheck();\n        this.stream.send(msg);\n    };\n    /** Called by the idle timer when the stream should close due to inactivity. */\n    PersistentStream.prototype.handleIdleCloseTimer = function () {\n        if (this.isOpen()) {\n            // When timing out an idle stream there's no reason to force the stream into backoff when\n            // it restarts so set the stream state to Initial instead of Error.\n            return this.close(PersistentStreamState.Initial);\n        }\n        return Promise.resolve();\n    };\n    /** Marks the stream as active again. */\n    PersistentStream.prototype.cancelIdleCheck = function () {\n        if (this.inactivityTimerPromise) {\n            this.inactivityTimerPromise.cancel();\n            this.inactivityTimerPromise = null;\n        }\n    };\n    /**\n     * Closes the stream and cleans up as necessary:\n     *\n     * * closes the underlying GRPC stream;\n     * * calls the onClose handler with the given 'error';\n     * * sets internal stream state to 'finalState';\n     * * adjusts the backoff timer based on the error\n     *\n     * A new stream can be opened by calling `start` unless `finalState` is set to\n     * `PersistentStreamState.Stopped`.\n     *\n     * @param finalState the intended state of the stream after closing.\n     * @param error the error the connection was closed with.\n     */\n    PersistentStream.prototype.close = function (finalState, error) {\n        assert(finalState === PersistentStreamState.Error || isNullOrUndefined(error), \"Can't provide an error when not in an error state.\");\n        this.cancelIdleCheck();\n        if (finalState !== PersistentStreamState.Error) {\n            // If this is an intentional close ensure we don't delay our next connection attempt.\n            this.backoff.reset();\n        }\n        else if (error && error.code === Code.RESOURCE_EXHAUSTED) {\n            // Log the error. (Probably either 'quota exceeded' or 'max queue length reached'.)\n            log.error(error.toString());\n            log.error('Using maximum backoff delay to prevent overloading the backend.');\n            this.backoff.resetToMax();\n        }\n        // Clean up the underlying stream because we are no longer interested in events.\n        if (this.stream !== null) {\n            this.tearDown();\n            this.stream.close();\n            this.stream = null;\n        }\n        // This state must be assigned before calling onClose() to allow the callback to\n        // inhibit backoff or otherwise manipulate the state in its non-started state.\n        this.state = finalState;\n        var listener = this.listener;\n        // Clear the listener to avoid bleeding of events from the underlying streams.\n        this.listener = null;\n        // If the caller explicitly requested a stream stop, don't notify them of a closing stream (it\n        // could trigger undesirable recovery logic, etc.).\n        if (finalState !== PersistentStreamState.Stopped) {\n            return listener.onClose(error);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    /**\n     * Can be overridden to perform additional cleanup before the stream is closed.\n     * Calling super.tearDown() is not required.\n     */\n    PersistentStream.prototype.tearDown = function () { };\n    PersistentStream.prototype.auth = function () {\n        var _this = this;\n        assert(this.state === PersistentStreamState.Initial, 'Must be in initial state to auth');\n        this.state = PersistentStreamState.Auth;\n        this.credentialsProvider.getToken(/*forceRefresh=*/ false).then(function (token) {\n            // Normally we'd have to schedule the callback on the AsyncQueue.\n            // However, the following calls are safe to be called outside the\n            // AsyncQueue since they don't chain asynchronous calls\n            _this.startStream(token);\n        }, function (error) {\n            _this.queue.enqueue(function () {\n                if (_this.state !== PersistentStreamState.Stopped) {\n                    // Stream can be stopped while waiting for authorization.\n                    var rpcError = new FirestoreError(Code.UNKNOWN, 'Fetching auth token failed: ' + error.message);\n                    return _this.handleStreamClose(rpcError);\n                }\n                else {\n                    return Promise.resolve();\n                }\n            });\n        });\n    };\n    PersistentStream.prototype.startStream = function (token) {\n        var _this = this;\n        if (this.state === PersistentStreamState.Stopped) {\n            // Stream can be stopped while waiting for authorization.\n            return;\n        }\n        assert(this.state === PersistentStreamState.Auth, 'Trying to start stream in a non-auth state');\n        // Helper function to dispatch to AsyncQueue and make sure that any\n        // close will seem instantaneous and events are prevented from being\n        // raised after the close call\n        var dispatchIfStillActive = function (stream, fn) {\n            _this.queue.enqueue(function () {\n                // Only raise events if the stream instance has not changed\n                if (_this.stream === stream) {\n                    return fn();\n                }\n                else {\n                    return Promise.resolve();\n                }\n            });\n        };\n        // Only start stream if listener has not changed\n        if (this.listener !== null) {\n            var currentStream_1 = this.startRpc(token);\n            this.stream = currentStream_1;\n            this.stream.onOpen(function () {\n                dispatchIfStillActive(currentStream_1, function () {\n                    assert(_this.state === PersistentStreamState.Auth, 'Expected stream to be in state auth, but was ' + _this.state);\n                    _this.state = PersistentStreamState.Open;\n                    return _this.listener.onOpen();\n                });\n            });\n            this.stream.onClose(function (error) {\n                dispatchIfStillActive(currentStream_1, function () {\n                    return _this.handleStreamClose(error);\n                });\n            });\n            this.stream.onMessage(function (msg) {\n                dispatchIfStillActive(currentStream_1, function () {\n                    return _this.onMessage(msg);\n                });\n            });\n        }\n    };\n    PersistentStream.prototype.performBackoff = function (listener) {\n        var _this = this;\n        assert(this.state === PersistentStreamState.Error, 'Should only perform backoff in an error case');\n        this.state = PersistentStreamState.Backoff;\n        this.backoff.backoffAndRun(function () {\n            if (_this.state === PersistentStreamState.Stopped) {\n                // Stream can be stopped while waiting for backoff to complete.\n                return Promise.resolve();\n            }\n            _this.state = PersistentStreamState.Initial;\n            _this.start(listener);\n            assert(_this.isStarted(), 'PersistentStream should have started');\n            return Promise.resolve();\n        });\n    };\n    PersistentStream.prototype.handleStreamClose = function (error) {\n        assert(this.isStarted(), \"Can't handle server close on non-started stream\");\n        log.debug(LOG_TAG, \"close with error: \" + error);\n        this.stream = null;\n        // In theory the stream could close cleanly, however, in our current model\n        // we never expect this to happen because if we stop a stream ourselves,\n        // this callback will never be called. To prevent cases where we retry\n        // without a backoff accidentally, we set the stream to error in all cases.\n        return this.close(PersistentStreamState.Error, error);\n    };\n    return PersistentStream;\n}());\nexport { PersistentStream };\n/**\n * A PersistentStream that implements the Listen RPC.\n *\n * Once the Listen stream has called the openHandler, any number of listen and\n * unlisten calls calls can be sent to control what changes will be sent from\n * the server for ListenResponses.\n */\nvar PersistentListenStream = /** @class */ (function (_super) {\n    __extends(PersistentListenStream, _super);\n    function PersistentListenStream(queue, connection, credentials, serializer) {\n        var _this = _super.call(this, queue, TimerId.ListenStreamConnection, TimerId.ListenStreamIdle, connection, credentials) || this;\n        _this.serializer = serializer;\n        return _this;\n    }\n    PersistentListenStream.prototype.startRpc = function (token) {\n        return this.connection.openStream('Listen', token);\n    };\n    PersistentListenStream.prototype.onMessage = function (watchChangeProto) {\n        // A successful response means the stream is healthy\n        this.backoff.reset();\n        var watchChange = this.serializer.fromWatchChange(watchChangeProto);\n        var snapshot = this.serializer.versionFromListenResponse(watchChangeProto);\n        return this.listener.onWatchChange(watchChange, snapshot);\n    };\n    /**\n     * Registers interest in the results of the given query. If the query\n     * includes a resumeToken it will be included in the request. Results that\n     * affect the query will be streamed back as WatchChange messages that\n     * reference the targetId.\n     */\n    PersistentListenStream.prototype.watch = function (queryData) {\n        var request = {};\n        request.database = this.serializer.encodedDatabaseId;\n        request.addTarget = this.serializer.toTarget(queryData);\n        var labels = this.serializer.toListenRequestLabels(queryData);\n        if (labels) {\n            request.labels = labels;\n        }\n        this.sendRequest(request);\n    };\n    /**\n     * Unregisters interest in the results of the query associated with the\n     * given targetId.\n     */\n    PersistentListenStream.prototype.unwatch = function (targetId) {\n        var request = {};\n        request.database = this.serializer.encodedDatabaseId;\n        request.removeTarget = targetId;\n        this.sendRequest(request);\n    };\n    return PersistentListenStream;\n}(PersistentStream));\nexport { PersistentListenStream };\n/**\n * A Stream that implements the Write RPC.\n *\n * The Write RPC requires the caller to maintain special streamToken\n * state in between calls, to help the server understand which responses the\n * client has processed by the time the next request is made. Every response\n * will contain a streamToken; this value must be passed to the next\n * request.\n *\n * After calling start() on this stream, the next request must be a handshake,\n * containing whatever streamToken is on hand. Once a response to this\n * request is received, all pending mutations may be submitted. When\n * submitting multiple batches of mutations at the same time, it's\n * okay to use the same streamToken for the calls to writeMutations.\n *\n * TODO(b/33271235): Use proto types\n */\nvar PersistentWriteStream = /** @class */ (function (_super) {\n    __extends(PersistentWriteStream, _super);\n    function PersistentWriteStream(queue, connection, credentials, serializer) {\n        var _this = _super.call(this, queue, TimerId.WriteStreamConnection, TimerId.WriteStreamIdle, connection, credentials) || this;\n        _this.serializer = serializer;\n        _this.handshakeComplete_ = false;\n        return _this;\n    }\n    Object.defineProperty(PersistentWriteStream.prototype, \"handshakeComplete\", {\n        /**\n         * Tracks whether or not a handshake has been successfully exchanged and\n         * the stream is ready to accept mutations.\n         */\n        get: function () {\n            return this.handshakeComplete_;\n        },\n        enumerable: true,\n        configurable: true\n    });\n    // Override of PersistentStream.start\n    PersistentWriteStream.prototype.start = function (listener) {\n        this.handshakeComplete_ = false;\n        _super.prototype.start.call(this, listener);\n    };\n    PersistentWriteStream.prototype.tearDown = function () {\n        if (this.handshakeComplete_) {\n            this.writeMutations([]);\n        }\n    };\n    PersistentWriteStream.prototype.startRpc = function (token) {\n        return this.connection.openStream('Write', token);\n    };\n    PersistentWriteStream.prototype.onMessage = function (responseProto) {\n        // Always capture the last stream token.\n        assert(!!responseProto.streamToken, 'Got a write response without a stream token');\n        this.lastStreamToken = responseProto.streamToken;\n        if (!this.handshakeComplete_) {\n            // The first response is always the handshake response\n            assert(!responseProto.writeResults || responseProto.writeResults.length === 0, 'Got mutation results for handshake');\n            this.handshakeComplete_ = true;\n            return this.listener.onHandshakeComplete();\n        }\n        else {\n            // A successful first write response means the stream is healthy,\n            // Note, that we could consider a successful handshake healthy, however,\n            // the write itself might be causing an error we want to back off from.\n            this.backoff.reset();\n            var results = this.serializer.fromWriteResults(responseProto.writeResults);\n            var commitVersion = this.serializer.fromVersion(responseProto.commitTime);\n            return this.listener.onMutationResult(commitVersion, results);\n        }\n    };\n    /**\n     * Sends an initial streamToken to the server, performing the handshake\n     * required to make the StreamingWrite RPC work. Subsequent\n     * calls should wait until onHandshakeComplete was called.\n     */\n    PersistentWriteStream.prototype.writeHandshake = function () {\n        assert(this.isOpen(), 'Writing handshake requires an opened stream');\n        assert(!this.handshakeComplete_, 'Handshake already completed');\n        // TODO(dimond): Support stream resumption. We intentionally do not set the\n        // stream token on the handshake, ignoring any stream token we might have.\n        var request = {};\n        request.database = this.serializer.encodedDatabaseId;\n        this.sendRequest(request);\n    };\n    /** Sends a group of mutations to the Firestore backend to apply. */\n    PersistentWriteStream.prototype.writeMutations = function (mutations) {\n        var _this = this;\n        assert(this.isOpen(), 'Writing mutations requires an opened stream');\n        assert(this.handshakeComplete_, 'Handshake must be complete before writing mutations');\n        assert(this.lastStreamToken.length > 0, 'Trying to write mutation without a token');\n        var request = {\n            // Protos are typed with string, but we support UInt8Array on Node\n            // tslint:disable-next-line:no-any\n            streamToken: this.lastStreamToken,\n            writes: mutations.map(function (mutation) { return _this.serializer.toMutation(mutation); })\n        };\n        this.sendRequest(request);\n    };\n    return PersistentWriteStream;\n}(PersistentStream));\nexport { PersistentWriteStream };\n\n//# sourceMappingURL=persistent_stream.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/persistent_stream.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport * as log from '../util/log';\nvar LOG_TAG = 'ExponentialBackoff';\n/**\n * A helper for running delayed tasks following an exponential backoff curve\n * between attempts.\n *\n * Each delay is made up of a \"base\" delay which follows the exponential\n * backoff curve, and a +/- 50% \"jitter\" that is calculated and added to the\n * base delay. This prevents clients from accidentally synchronizing their\n * delays causing spikes of load to the backend.\n */\nvar ExponentialBackoff = /** @class */ (function () {\n    function ExponentialBackoff(\n        /**\n         * The AsyncQueue to run backoff operations on.\n         */\n        queue, \n        /**\n         * The ID to use when scheduling backoff operations on the AsyncQueue.\n         */\n        timerId, \n        /**\n         * The initial delay (used as the base delay on the first retry attempt).\n         * Note that jitter will still be applied, so the actual delay could be as\n         * little as 0.5*initialDelayMs.\n         */\n        initialDelayMs, \n        /**\n         * The multiplier to use to determine the extended base delay after each\n         * attempt.\n         */\n        backoffFactor, \n        /**\n         * The maximum base delay after which no further backoff is performed.\n         * Note that jitter will still be applied, so the actual delay could be as\n         * much as 1.5*maxDelayMs.\n         */\n        maxDelayMs) {\n        this.queue = queue;\n        this.timerId = timerId;\n        this.initialDelayMs = initialDelayMs;\n        this.backoffFactor = backoffFactor;\n        this.maxDelayMs = maxDelayMs;\n        this.timerPromise = null;\n        this.reset();\n    }\n    /**\n     * Resets the backoff delay.\n     *\n     * The very next backoffAndWait() will have no delay. If it is called again\n     * (i.e. due to an error), initialDelayMs (plus jitter) will be used, and\n     * subsequent ones will increase according to the backoffFactor.\n     */\n    ExponentialBackoff.prototype.reset = function () {\n        this.currentBaseMs = 0;\n    };\n    /**\n     * Resets the backoff delay to the maximum delay (e.g. for use after a\n     * RESOURCE_EXHAUSTED error).\n     */\n    ExponentialBackoff.prototype.resetToMax = function () {\n        this.currentBaseMs = this.maxDelayMs;\n    };\n    /**\n     * Returns a promise that resolves after currentDelayMs, and increases the\n     * delay for any subsequent attempts. If there was a pending backoff operation\n     * already, it will be canceled.\n     */\n    ExponentialBackoff.prototype.backoffAndRun = function (op) {\n        if (this.timerPromise !== null) {\n            this.timerPromise.cancel();\n        }\n        // First schedule using the current base (which may be 0 and should be\n        // honored as such).\n        var delayWithJitterMs = this.currentBaseMs + this.jitterDelayMs();\n        if (this.currentBaseMs > 0) {\n            log.debug(LOG_TAG, \"Backing off for \" + delayWithJitterMs + \" ms \" +\n                (\"(base delay: \" + this.currentBaseMs + \" ms)\"));\n        }\n        this.timerPromise = this.queue.enqueueAfterDelay(this.timerId, delayWithJitterMs, op);\n        // Apply backoff factor to determine next delay and ensure it is within\n        // bounds.\n        this.currentBaseMs *= this.backoffFactor;\n        if (this.currentBaseMs < this.initialDelayMs) {\n            this.currentBaseMs = this.initialDelayMs;\n        }\n        if (this.currentBaseMs > this.maxDelayMs) {\n            this.currentBaseMs = this.maxDelayMs;\n        }\n    };\n    /** Returns a random value in the range [-currentBaseMs/2, currentBaseMs/2] */\n    ExponentialBackoff.prototype.jitterDelayMs = function () {\n        return (Math.random() - 0.5) * this.currentBaseMs;\n    };\n    return ExponentialBackoff;\n}());\nexport { ExponentialBackoff };\n\n//# sourceMappingURL=backoff.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/backoff.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { maybeDocumentMap } from '../model/collections';\nimport { assert } from '../util/assert';\nimport { PersistentListenStream, PersistentWriteStream } from './persistent_stream';\n/**\n * Datastore is a wrapper around the external Google Cloud Datastore grpc API,\n * which provides an interface that is more convenient for the rest of the\n * client SDK architecture to consume.\n */\nvar Datastore = /** @class */ (function () {\n    function Datastore(queue, connection, credentials, serializer) {\n        this.queue = queue;\n        this.connection = connection;\n        this.credentials = credentials;\n        this.serializer = serializer;\n    }\n    Datastore.prototype.newPersistentWriteStream = function () {\n        return new PersistentWriteStream(this.queue, this.connection, this.credentials, this.serializer);\n    };\n    Datastore.prototype.newPersistentWatchStream = function () {\n        return new PersistentListenStream(this.queue, this.connection, this.credentials, this.serializer);\n    };\n    Datastore.prototype.commit = function (mutations) {\n        var _this = this;\n        var params = {\n            database: this.serializer.encodedDatabaseId,\n            writes: mutations.map(function (m) { return _this.serializer.toMutation(m); })\n        };\n        return this.invokeRPC('Commit', params).then(function (response) {\n            return _this.serializer.fromWriteResults(response.writeResults);\n        });\n    };\n    Datastore.prototype.lookup = function (keys) {\n        var _this = this;\n        var params = {\n            database: this.serializer.encodedDatabaseId,\n            documents: keys.map(function (k) { return _this.serializer.toName(k); })\n        };\n        return this.invokeStreamingRPC('BatchGetDocuments', params).then(function (response) {\n            var docs = maybeDocumentMap();\n            response.forEach(function (proto) {\n                var doc = _this.serializer.fromMaybeDocument(proto);\n                docs = docs.insert(doc.key, doc);\n            });\n            var result = [];\n            keys.forEach(function (key) {\n                var doc = docs.get(key);\n                assert(!!doc, 'Missing entity in write response for ' + key);\n                result.push(doc);\n            });\n            return result;\n        });\n    };\n    /** Gets an auth token and invokes the provided RPC. */\n    Datastore.prototype.invokeRPC = function (rpcName, request) {\n        var _this = this;\n        // TODO(mikelehen): Retry (with backoff) on token failures?\n        return this.credentials.getToken(/*forceRefresh=*/ false).then(function (token) {\n            return _this.connection.invokeRPC(rpcName, request, token);\n        });\n    };\n    /** Gets an auth token and invokes the provided RPC with streamed results. */\n    Datastore.prototype.invokeStreamingRPC = function (rpcName, request) {\n        var _this = this;\n        // TODO(mikelehen): Retry (with backoff) on token failures?\n        return this.credentials.getToken(/*forceRefresh=*/ false).then(function (token) {\n            return _this.connection.invokeStreamingRPC(rpcName, request, token);\n        });\n    };\n    return Datastore;\n}());\nexport { Datastore };\n\n//# sourceMappingURL=datastore.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/datastore.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from './snapshot_version';\nimport { documentVersionMap } from '../model/collections';\nimport { NoDocument } from '../model/document';\nimport { DeleteMutation, Precondition } from '../model/mutation';\nimport { Code, FirestoreError } from '../util/error';\n/**\n * Internal transaction object responsible for accumulating the mutations to\n * perform and the base versions for any documents read.\n */\nvar Transaction = /** @class */ (function () {\n    function Transaction(datastore) {\n        this.datastore = datastore;\n        // The version of each document that was read during this transaction.\n        this.readVersions = documentVersionMap();\n        this.mutations = [];\n        this.committed = false;\n    }\n    Transaction.prototype.recordVersion = function (doc) {\n        var docVersion = doc.version;\n        if (doc instanceof NoDocument) {\n            // For deleted docs, we must use baseVersion 0 when we overwrite them.\n            docVersion = SnapshotVersion.forDeletedDoc();\n        }\n        var existingVersion = this.readVersions.get(doc.key);\n        if (existingVersion !== null) {\n            if (!docVersion.isEqual(existingVersion)) {\n                // This transaction will fail no matter what.\n                throw new FirestoreError(Code.ABORTED, 'Document version changed between two reads.');\n            }\n        }\n        else {\n            this.readVersions = this.readVersions.insert(doc.key, docVersion);\n        }\n    };\n    Transaction.prototype.lookup = function (keys) {\n        var _this = this;\n        if (this.committed) {\n            return Promise.reject('Transaction has already completed.');\n        }\n        if (this.mutations.length > 0) {\n            return Promise.reject('Transactions lookups are invalid after writes.');\n        }\n        return this.datastore.lookup(keys).then(function (docs) {\n            docs.forEach(function (doc) { return _this.recordVersion(doc); });\n            return docs;\n        });\n    };\n    Transaction.prototype.write = function (mutations) {\n        if (this.committed) {\n            throw new FirestoreError(Code.FAILED_PRECONDITION, 'Transaction has already completed.');\n        }\n        this.mutations = this.mutations.concat(mutations);\n    };\n    /**\n     * Returns the version of this document when it was read in this transaction,\n     * as a precondition, or no precondition if it was not read.\n     */\n    Transaction.prototype.precondition = function (key) {\n        var version = this.readVersions.get(key);\n        if (version) {\n            return Precondition.updateTime(version);\n        }\n        else {\n            return Precondition.NONE;\n        }\n    };\n    /**\n     * Returns the precondition for a document if the operation is an update.\n     */\n    Transaction.prototype.preconditionForUpdate = function (key) {\n        var version = this.readVersions.get(key);\n        if (version && version.isEqual(SnapshotVersion.forDeletedDoc())) {\n            // The document doesn't exist, so fail the transaction.\n            throw new FirestoreError(Code.FAILED_PRECONDITION, \"Can't update a document that doesn't exist.\");\n        }\n        else if (version) {\n            // Document exists, base precondition on document update time.\n            return Precondition.updateTime(version);\n        }\n        else {\n            // Document was not read, so we just use the preconditions for a blind\n            // update.\n            return Precondition.exists(true);\n        }\n    };\n    Transaction.prototype.set = function (key, data) {\n        this.write(data.toMutations(key, this.precondition(key)));\n    };\n    Transaction.prototype.update = function (key, data) {\n        this.write(data.toMutations(key, this.preconditionForUpdate(key)));\n    };\n    Transaction.prototype.delete = function (key) {\n        this.write([new DeleteMutation(key, this.precondition(key))]);\n        // Since the delete will be applied before all following writes, we need to\n        // ensure that the precondition for the next write will be exists: false.\n        this.readVersions = this.readVersions.insert(key, SnapshotVersion.forDeletedDoc());\n    };\n    Transaction.prototype.commit = function () {\n        var _this = this;\n        var unwritten = this.readVersions;\n        // For each mutation, note that the doc was written.\n        this.mutations.forEach(function (mutation) {\n            unwritten = unwritten.remove(mutation.key);\n        });\n        if (!unwritten.isEmpty()) {\n            return Promise.reject(Error('Every document read in a transaction must also be written.'));\n        }\n        return this.datastore.commit(this.mutations).then(function () {\n            _this.committed = true;\n        });\n    };\n    return Transaction;\n}());\nexport { Transaction };\n\n//# sourceMappingURL=transaction.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/transaction.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { SnapshotVersion } from '../core/snapshot_version';\nimport { Transaction } from '../core/transaction';\nimport { OnlineState } from '../core/types';\nimport { QueryData, QueryPurpose } from '../local/query_data';\nimport { NoDocument } from '../model/document';\nimport { DocumentKey } from '../model/document_key';\nimport { BATCHID_UNKNOWN, MutationBatchResult } from '../model/mutation_batch';\nimport { emptyByteString } from '../platform/platform';\nimport { assert } from '../util/assert';\nimport { Code } from '../util/error';\nimport * as log from '../util/log';\nimport * as objUtils from '../util/obj';\nimport { ResetMapping, UpdateMapping } from './remote_event';\nimport { isPermanentError } from './rpc_error';\nimport { WatchChangeAggregator, WatchTargetChange, WatchTargetChangeState } from './watch_change';\nvar LOG_TAG = 'RemoteStore';\n// TODO(b/35853402): Negotiate this with the stream.\nvar MAX_PENDING_WRITES = 10;\n// The RemoteStore notifies an onlineStateHandler with OnlineState.Failed if we\n// fail to connect to the backend. This subsequently triggers get() requests to\n// fail or use cached data, etc. Unfortunately, our connections have\n// historically been subject to various transient failures. So we wait for\n// multiple failures before notifying the onlineStateHandler.\nvar ONLINE_ATTEMPTS_BEFORE_FAILURE = 2;\n/**\n * RemoteStore - An interface to remotely stored data, basically providing a\n * wrapper around the Datastore that is more reliable for the rest of the\n * system.\n *\n * RemoteStore is responsible for maintaining the connection to the server.\n * - maintaining a list of active listens.\n * - reconnecting when the connection is dropped.\n * - resuming all the active listens on reconnect.\n *\n * RemoteStore handles all incoming events from the Datastore.\n * - listening to the watch stream and repackaging the events as RemoteEvents\n * - notifying SyncEngine of any changes to the active listens.\n *\n * RemoteStore takes writes from other components and handles them reliably.\n * - pulling pending mutations from LocalStore and sending them to Datastore.\n * - retrying mutations that failed because of network problems.\n * - acking mutations to the SyncEngine once they are accepted or rejected.\n */\nvar RemoteStore = /** @class */ (function () {\n    function RemoteStore(\n        /**\n         * The local store, used to fill the write pipeline with outbound\n         * mutations and resolve existence filter mismatches.\n         */\n        localStore, \n        /** The client-side proxy for interacting with the backend. */\n        datastore, onlineStateHandler) {\n        this.localStore = localStore;\n        this.datastore = datastore;\n        this.onlineStateHandler = onlineStateHandler;\n        this.pendingWrites = [];\n        this.lastBatchSeen = BATCHID_UNKNOWN;\n        /**\n         * A mapping of watched targets that the client cares about tracking and the\n         * user has explicitly called a 'listen' for this target.\n         *\n         * These targets may or may not have been sent to or acknowledged by the\n         * server. On re-establishing the listen stream, these targets should be sent\n         * to the server. The targets removed with unlistens are removed eagerly\n         * without waiting for confirmation from the listen stream.\n         */\n        this.listenTargets = {};\n        /**\n         * A mapping of targetId to pending acks needed.\n         *\n         * If a targetId is present in this map, then we're waiting for watch to\n         * acknowledge a removal or addition of the target. If a target is not in this\n         * mapping, and it's in the listenTargets map, then we consider the target to\n         * be active.\n         *\n         * We increment the count here every time we issue a request over the stream\n         * to watch or unwatch. We then decrement the count every time we get a target\n         * added or target removed message from the server. Once the count is equal to\n         * 0 we know that the client and server are in the same state (once this state\n         * is reached the targetId is removed from the map to free the memory).\n         */\n        this.pendingTargetResponses = {};\n        this.accumulatedWatchChanges = [];\n        this.watchStream = null;\n        this.writeStream = null;\n        /**\n         * The online state of the watch stream. The state is set to healthy if and\n         * only if there are messages received by the backend.\n         */\n        this.watchStreamOnlineState = OnlineState.Unknown;\n        /** A count of consecutive failures to open the stream. */\n        this.watchStreamFailures = 0;\n        /** Whether the client should fire offline warning. */\n        this.shouldWarnOffline = true;\n    }\n    /**\n     * Starts up the remote store, creating streams, restoring state from\n     * LocalStore, etc.\n     */\n    RemoteStore.prototype.start = function () {\n        return this.enableNetwork();\n    };\n    /**\n     * Updates our OnlineState to the new state, updating local state\n     * and notifying the onlineStateHandler as appropriate. Idempotent.\n     */\n    RemoteStore.prototype.updateOnlineState = function (newState) {\n        if (newState !== this.watchStreamOnlineState) {\n            if (newState === OnlineState.Healthy) {\n                // We've connected to watch at least once. Don't warn the developer about\n                // being offline going forward.\n                this.shouldWarnOffline = false;\n            }\n            else if (newState === OnlineState.Unknown) {\n                // The state is set to unknown when a healthy stream is closed (e.g. due to\n                // a token timeout) or when we have no active listens and therefore there's\n                // no need to start the stream. Assuming there is (possibly in the future)\n                // an active listen, then we will eventually move to state Online or Failed,\n                // but we always want to make at least ONLINE_ATTEMPTS_BEFORE_FAILURE\n                // attempts before failing, so we reset the count here.\n                this.watchStreamFailures = 0;\n            }\n            this.watchStreamOnlineState = newState;\n            this.onlineStateHandler(newState);\n        }\n    };\n    /**\n     * Updates our OnlineState as appropriate after the watch stream reports a\n     * failure. The first failure moves us to the 'Unknown' state. We then may\n     * allow multiple failures (based on ONLINE_ATTEMPTS_BEFORE_FAILURE) before we\n     * actually transition to OnlineState.Failed.\n     */\n    RemoteStore.prototype.updateOnlineStateAfterFailure = function () {\n        if (this.watchStreamOnlineState === OnlineState.Healthy) {\n            this.updateOnlineState(OnlineState.Unknown);\n        }\n        else {\n            this.watchStreamFailures++;\n            if (this.watchStreamFailures >= ONLINE_ATTEMPTS_BEFORE_FAILURE) {\n                if (this.shouldWarnOffline) {\n                    log.error('Could not reach Firestore backend.');\n                    this.shouldWarnOffline = false;\n                }\n                this.updateOnlineState(OnlineState.Failed);\n            }\n        }\n    };\n    RemoteStore.prototype.isNetworkEnabled = function () {\n        assert((this.watchStream == null) === (this.writeStream == null), 'WatchStream and WriteStream should both be null or non-null');\n        return this.watchStream != null;\n    };\n    /** Re-enables the network. Idempotent. */\n    RemoteStore.prototype.enableNetwork = function () {\n        var _this = this;\n        if (this.isNetworkEnabled()) {\n            return Promise.resolve();\n        }\n        // Create new streams (but note they're not started yet).\n        this.watchStream = this.datastore.newPersistentWatchStream();\n        this.writeStream = this.datastore.newPersistentWriteStream();\n        // Load any saved stream token from persistent storage\n        return this.localStore.getLastStreamToken().then(function (token) {\n            _this.writeStream.lastStreamToken = token;\n            if (_this.shouldStartWatchStream()) {\n                _this.startWatchStream();\n            }\n            _this.updateOnlineState(OnlineState.Unknown);\n            return _this.fillWritePipeline(); // This may start the writeStream.\n        });\n    };\n    /**\n     * Temporarily disables the network. The network can be re-enabled using\n     * enableNetwork().\n     */\n    RemoteStore.prototype.disableNetwork = function () {\n        this.disableNetworkInternal();\n        // Set the OnlineState to failed so get()'s return from cache, etc.\n        this.updateOnlineState(OnlineState.Failed);\n        return Promise.resolve();\n    };\n    /**\n     * Disables the network, if it is currently enabled.\n     */\n    RemoteStore.prototype.disableNetworkInternal = function () {\n        if (this.isNetworkEnabled()) {\n            // NOTE: We're guaranteed not to get any further events from these streams (not even a close\n            // event).\n            this.watchStream.stop();\n            this.writeStream.stop();\n            this.cleanUpWatchStreamState();\n            this.cleanUpWriteStreamState();\n            this.writeStream = null;\n            this.watchStream = null;\n        }\n    };\n    RemoteStore.prototype.shutdown = function () {\n        log.debug(LOG_TAG, 'RemoteStore shutting down.');\n        this.disableNetworkInternal();\n        // Set the OnlineState to Unknown (rather than Failed) to avoid potentially\n        // triggering spurious listener events with cached data, etc.\n        this.updateOnlineState(OnlineState.Unknown);\n        return Promise.resolve();\n    };\n    /** Starts new listen for the given query. Uses resume token if provided */\n    RemoteStore.prototype.listen = function (queryData) {\n        assert(!objUtils.contains(this.listenTargets, queryData.targetId), 'listen called with duplicate targetId!');\n        // Mark this as something the client is currently listening for.\n        this.listenTargets[queryData.targetId] = queryData;\n        if (this.shouldStartWatchStream()) {\n            // The listen will be sent in onWatchStreamOpen\n            this.startWatchStream();\n        }\n        else if (this.isNetworkEnabled() && this.watchStream.isOpen()) {\n            this.sendWatchRequest(queryData);\n        }\n    };\n    /** Removes the listen from server */\n    RemoteStore.prototype.unlisten = function (targetId) {\n        assert(objUtils.contains(this.listenTargets, targetId), 'unlisten called without assigned target ID!');\n        delete this.listenTargets[targetId];\n        if (this.isNetworkEnabled() && this.watchStream.isOpen()) {\n            this.sendUnwatchRequest(targetId);\n            if (objUtils.isEmpty(this.listenTargets)) {\n                this.watchStream.markIdle();\n            }\n        }\n    };\n    /**\n     * We need to increment the the expected number of pending responses we're due\n     * from watch so we wait for the ack to process any messages from this target.\n     */\n    RemoteStore.prototype.sendWatchRequest = function (queryData) {\n        this.recordPendingTargetRequest(queryData.targetId);\n        this.watchStream.watch(queryData);\n    };\n    /**\n     * We need to increment the expected number of pending responses we're due\n     * from watch so we wait for the removal on the server before we process any\n     * messages from this target.\n     */\n    RemoteStore.prototype.sendUnwatchRequest = function (targetId) {\n        this.recordPendingTargetRequest(targetId);\n        this.watchStream.unwatch(targetId);\n    };\n    /**\n     * Increment the mapping of how many acks are needed from watch before we can\n     * consider the server to be 'in-sync' with the client's active targets.\n     */\n    RemoteStore.prototype.recordPendingTargetRequest = function (targetId) {\n        // For each request we get we need to record we need a response for it.\n        this.pendingTargetResponses[targetId] =\n            (this.pendingTargetResponses[targetId] || 0) + 1;\n    };\n    RemoteStore.prototype.startWatchStream = function () {\n        assert(this.shouldStartWatchStream(), 'startWriteStream() called when shouldStartWatchStream() is false.');\n        this.watchStream.start({\n            onOpen: this.onWatchStreamOpen.bind(this),\n            onClose: this.onWatchStreamClose.bind(this),\n            onWatchChange: this.onWatchStreamChange.bind(this)\n        });\n    };\n    /**\n     * Returns whether the watch stream should be started because there are\n     * active targets trying to be listened too\n     */\n    RemoteStore.prototype.shouldStartWatchStream = function () {\n        return (this.isNetworkEnabled() &&\n            !this.watchStream.isStarted() &&\n            !objUtils.isEmpty(this.listenTargets));\n    };\n    RemoteStore.prototype.cleanUpWatchStreamState = function () {\n        // If the connection is closed then we'll never get a snapshot version for\n        // the accumulated changes and so we'll never be able to complete the batch.\n        // When we start up again the server is going to resend these changes\n        // anyway, so just toss the accumulated state.\n        this.accumulatedWatchChanges = [];\n        this.pendingTargetResponses = {};\n    };\n    RemoteStore.prototype.onWatchStreamOpen = function () {\n        var _this = this;\n        // TODO(b/35852690): close the stream again (with some timeout?) if no watch\n        // targets are active\n        objUtils.forEachNumber(this.listenTargets, function (targetId, queryData) {\n            _this.sendWatchRequest(queryData);\n        });\n        return Promise.resolve();\n    };\n    RemoteStore.prototype.onWatchStreamClose = function (error) {\n        assert(this.isNetworkEnabled(), 'onWatchStreamClose() should only be called when the network is enabled');\n        this.cleanUpWatchStreamState();\n        // If there was an error, retry the connection.\n        if (this.shouldStartWatchStream()) {\n            this.updateOnlineStateAfterFailure();\n            this.startWatchStream();\n        }\n        else {\n            // No need to restart watch stream because there are no active targets.\n            // The online state is set to unknown because there is no active attempt\n            // at establishing a connection\n            this.updateOnlineState(OnlineState.Unknown);\n        }\n        return Promise.resolve();\n    };\n    RemoteStore.prototype.onWatchStreamChange = function (watchChange, snapshotVersion) {\n        // Mark the connection as healthy because we got a message from the server\n        this.updateOnlineState(OnlineState.Healthy);\n        if (watchChange instanceof WatchTargetChange &&\n            watchChange.state === WatchTargetChangeState.Removed &&\n            watchChange.cause) {\n            // There was an error on a target, don't wait for a consistent snapshot\n            // to raise events\n            return this.handleTargetError(watchChange);\n        }\n        // Accumulate watch changes but don't process them if there's no\n        // snapshotVersion or it's older than a previous snapshot we've processed\n        // (can happen after we resume a target using a resume token).\n        this.accumulatedWatchChanges.push(watchChange);\n        if (!snapshotVersion.isEqual(SnapshotVersion.MIN) &&\n            snapshotVersion.compareTo(this.localStore.getLastRemoteSnapshotVersion()) >= 0) {\n            var changes = this.accumulatedWatchChanges;\n            this.accumulatedWatchChanges = [];\n            return this.handleWatchChangeBatch(snapshotVersion, changes);\n        }\n        else {\n            return Promise.resolve();\n        }\n    };\n    /**\n     * Takes a batch of changes from the Datastore, repackages them as a\n     * RemoteEvent, and passes that on to the listener, which is typically the\n     * SyncEngine.\n     */\n    RemoteStore.prototype.handleWatchChangeBatch = function (snapshotVersion, changes) {\n        var _this = this;\n        var aggregator = new WatchChangeAggregator(snapshotVersion, this.listenTargets, this.pendingTargetResponses);\n        aggregator.addChanges(changes);\n        var remoteEvent = aggregator.createRemoteEvent();\n        // Get the new response counts from the aggregator\n        this.pendingTargetResponses = aggregator.pendingTargetResponses;\n        var promises = [];\n        // Handle existence filters and existence filter mismatches.\n        objUtils.forEachNumber(aggregator.existenceFilters, function (targetId, filter) {\n            var queryData = _this.listenTargets[targetId];\n            if (!queryData) {\n                // A watched target might have been removed already.\n                return;\n            }\n            var query = queryData.query;\n            if (query.isDocumentQuery()) {\n                if (filter.count === 0) {\n                    // The existence filter told us the document does not exist.\n                    // We need to deduce that this document does not exist and apply\n                    // a deleted document to our updates. Without applying a deleted\n                    // document there might be another query that will raise this\n                    // document as part of a snapshot until it is resolved,\n                    // essentially exposing inconsistency between queries.\n                    var key = new DocumentKey(query.path);\n                    var deletedDoc = new NoDocument(key, snapshotVersion);\n                    remoteEvent.addDocumentUpdate(deletedDoc);\n                }\n                else {\n                    assert(filter.count === 1, 'Single document existence filter with count: ' + filter.count);\n                }\n            }\n            else {\n                // Not a document query.\n                var promise = _this.localStore\n                    .remoteDocumentKeys(targetId)\n                    .then(function (trackedRemote) {\n                    if (remoteEvent.targetChanges[targetId]) {\n                        var mapping = remoteEvent.targetChanges[targetId].mapping;\n                        if (mapping !== null) {\n                            if (mapping instanceof UpdateMapping) {\n                                trackedRemote = mapping.applyToKeySet(trackedRemote);\n                            }\n                            else {\n                                assert(mapping instanceof ResetMapping, 'Expected either reset or update mapping but got something else: ' +\n                                    mapping);\n                                trackedRemote = mapping.documents;\n                            }\n                        }\n                    }\n                    if (trackedRemote.size !== filter.count) {\n                        // Existence filter mismatch, resetting mapping.\n                        // Make sure the mismatch is exposed in the remote event.\n                        remoteEvent.handleExistenceFilterMismatch(targetId);\n                        // Clear the resume token for the query, since we're in a\n                        // known mismatch state.\n                        var newQueryData = new QueryData(query, targetId, queryData.purpose);\n                        _this.listenTargets[targetId] = newQueryData;\n                        // Cause a hard reset by unwatching and rewatching\n                        // immediately, but deliberately don't send a resume token\n                        // so that we get a full update.\n                        // Make sure we expect that this acks are going to happen.\n                        _this.sendUnwatchRequest(targetId);\n                        // Mark the query we send as being on behalf of an existence\n                        // filter mismatch, but don't actually retain that in\n                        // listenTargets. This ensures that we flag the first\n                        // re-listen this way without impacting future listens of\n                        // this target (that might happen e.g. on reconnect).\n                        var requestQueryData = new QueryData(query, targetId, QueryPurpose.ExistenceFilterMismatch);\n                        _this.sendWatchRequest(requestQueryData);\n                    }\n                });\n                promises.push(promise);\n            }\n        });\n        return Promise.all(promises).then(function () {\n            // Update in-memory resume tokens. LocalStore will update the\n            // persistent view of these when applying the completed RemoteEvent.\n            objUtils.forEachNumber(remoteEvent.targetChanges, function (targetId, change) {\n                if (change.resumeToken.length > 0) {\n                    var queryData = _this.listenTargets[targetId];\n                    // A watched target might have been removed already.\n                    if (queryData) {\n                        _this.listenTargets[targetId] = queryData.update({\n                            resumeToken: change.resumeToken,\n                            snapshotVersion: change.snapshotVersion\n                        });\n                    }\n                }\n            });\n            // Finally handle remote event\n            return _this.syncEngine.applyRemoteEvent(remoteEvent);\n        });\n    };\n    /** Handles an error on a target */\n    RemoteStore.prototype.handleTargetError = function (watchChange) {\n        var _this = this;\n        assert(!!watchChange.cause, 'Handling target error without a cause');\n        var error = watchChange.cause;\n        var promiseChain = Promise.resolve();\n        watchChange.targetIds.forEach(function (targetId) {\n            promiseChain = promiseChain.then(function () {\n                if (objUtils.contains(_this.listenTargets, targetId)) {\n                    delete _this.listenTargets[targetId];\n                    return _this.syncEngine.rejectListen(targetId, error);\n                }\n                else {\n                    // A watched target might have been removed already.\n                    return Promise.resolve();\n                }\n            });\n        });\n        return promiseChain;\n    };\n    RemoteStore.prototype.cleanUpWriteStreamState = function () {\n        this.lastBatchSeen = BATCHID_UNKNOWN;\n        log.debug(LOG_TAG, 'Stopping write stream with ' +\n            this.pendingWrites.length +\n            ' pending writes');\n        this.pendingWrites = [];\n    };\n    /**\n     * Notifies that there are new mutations to process in the queue. This is\n     * typically called by SyncEngine after it has sent mutations to LocalStore.\n     */\n    RemoteStore.prototype.fillWritePipeline = function () {\n        var _this = this;\n        if (!this.canWriteMutations()) {\n            return Promise.resolve();\n        }\n        else {\n            return this.localStore\n                .nextMutationBatch(this.lastBatchSeen)\n                .then(function (batch) {\n                if (batch === null) {\n                    if (_this.pendingWrites.length === 0) {\n                        _this.writeStream.markIdle();\n                    }\n                    return Promise.resolve();\n                }\n                else {\n                    _this.commit(batch);\n                    return _this.fillWritePipeline();\n                }\n            });\n        }\n    };\n    /**\n     * Returns true if the backend can accept additional write requests.\n     *\n     * When sending mutations to the write stream (e.g. in fillWritePipeline),\n     * call this method first to check if more mutations can be sent.\n     *\n     * Currently the only thing that can prevent the backend from accepting\n     * write requests is if there are too many requests already outstanding. As\n     * writes complete the backend will be able to accept more.\n     */\n    RemoteStore.prototype.canWriteMutations = function () {\n        return (this.isNetworkEnabled() && this.pendingWrites.length < MAX_PENDING_WRITES);\n    };\n    // For testing\n    RemoteStore.prototype.outstandingWrites = function () {\n        return this.pendingWrites.length;\n    };\n    /**\n     * Given mutations to commit, actually commits them to the Datastore. Note\n     * that this does *not* return a Promise specifically because the AsyncQueue\n     * should not block operations for this.\n     */\n    RemoteStore.prototype.commit = function (batch) {\n        assert(this.canWriteMutations(), \"commit called when batches can't be written\");\n        this.lastBatchSeen = batch.batchId;\n        this.pendingWrites.push(batch);\n        if (this.shouldStartWriteStream()) {\n            this.startWriteStream();\n        }\n        else if (this.isNetworkEnabled() && this.writeStream.handshakeComplete) {\n            this.writeStream.writeMutations(batch.mutations);\n        }\n    };\n    RemoteStore.prototype.shouldStartWriteStream = function () {\n        return (this.isNetworkEnabled() &&\n            !this.writeStream.isStarted() &&\n            this.pendingWrites.length > 0);\n    };\n    RemoteStore.prototype.startWriteStream = function () {\n        assert(this.shouldStartWriteStream(), 'startWriteStream() called when shouldStartWriteStream() is false.');\n        this.writeStream.start({\n            onOpen: this.onWriteStreamOpen.bind(this),\n            onClose: this.onWriteStreamClose.bind(this),\n            onHandshakeComplete: this.onWriteHandshakeComplete.bind(this),\n            onMutationResult: this.onMutationResult.bind(this)\n        });\n    };\n    RemoteStore.prototype.onWriteStreamOpen = function () {\n        this.writeStream.writeHandshake();\n        return Promise.resolve();\n    };\n    RemoteStore.prototype.onWriteHandshakeComplete = function () {\n        var _this = this;\n        // Record the stream token.\n        return this.localStore\n            .setLastStreamToken(this.writeStream.lastStreamToken)\n            .then(function () {\n            // Drain any pending writes.\n            //\n            // Note that at this point pendingWrites contains mutations that\n            // have already been accepted by fillWritePipeline/commitBatch. If\n            // the pipeline is full, canWriteMutations will be false, despite\n            // the fact that we actually need to send mutations over.\n            //\n            // This also means that this method indirectly respects the limits\n            // imposed by canWriteMutations since writes can't be added to the\n            // pendingWrites array when canWriteMutations is false. If the\n            // limits imposed by canWriteMutations actually protect us from\n            // DOSing ourselves then those limits won't be exceeded here and\n            // we'll continue to make progress.\n            for (var _i = 0, _a = _this.pendingWrites; _i < _a.length; _i++) {\n                var batch = _a[_i];\n                _this.writeStream.writeMutations(batch.mutations);\n            }\n        });\n    };\n    RemoteStore.prototype.onMutationResult = function (commitVersion, results) {\n        var _this = this;\n        // This is a response to a write containing mutations and should be\n        // correlated to the first pending write.\n        assert(this.pendingWrites.length > 0, 'Got result for empty pending writes');\n        var batch = this.pendingWrites.shift();\n        var success = MutationBatchResult.from(batch, commitVersion, results, this.writeStream.lastStreamToken);\n        return this.syncEngine.applySuccessfulWrite(success).then(function () {\n            // It's possible that with the completion of this mutation another\n            // slot has freed up.\n            return _this.fillWritePipeline();\n        });\n    };\n    RemoteStore.prototype.onWriteStreamClose = function (error) {\n        var _this = this;\n        assert(this.isNetworkEnabled(), 'onWriteStreamClose() should only be called when the network is enabled');\n        // If the write stream closed due to an error, invoke the error callbacks if\n        // there are pending writes.\n        if (error && this.pendingWrites.length > 0) {\n            assert(!!error, 'We have pending writes, but the write stream closed without an error');\n            // A promise that is resolved after we processed the error\n            var errorHandling = void 0;\n            if (this.writeStream.handshakeComplete) {\n                // This error affects the actual write.\n                errorHandling = this.handleWriteError(error);\n            }\n            else {\n                // If there was an error before the handshake has finished, it's\n                // possible that the server is unable to process the stream token\n                // we're sending. (Perhaps it's too old?)\n                errorHandling = this.handleHandshakeError(error);\n            }\n            return errorHandling.then(function () {\n                // The write stream might have been started by refilling the write\n                // pipeline for failed writes\n                if (_this.shouldStartWriteStream()) {\n                    _this.startWriteStream();\n                }\n            });\n        }\n        else {\n            // No pending writes, nothing to do\n            return Promise.resolve();\n        }\n    };\n    RemoteStore.prototype.handleHandshakeError = function (error) {\n        // Reset the token if it's a permanent error or the error code is\n        // ABORTED, signaling the write stream is no longer valid.\n        if (isPermanentError(error.code) || error.code === Code.ABORTED) {\n            log.debug(LOG_TAG, 'RemoteStore error before completed handshake; resetting stream token: ', this.writeStream.lastStreamToken);\n            this.writeStream.lastStreamToken = emptyByteString();\n            return this.localStore.setLastStreamToken(emptyByteString());\n        }\n        else {\n            // Some other error, don't reset stream token. Our stream logic will\n            // just retry with exponential backoff.\n            return Promise.resolve();\n        }\n    };\n    RemoteStore.prototype.handleWriteError = function (error) {\n        var _this = this;\n        if (isPermanentError(error.code)) {\n            // This was a permanent error, the request itself was the problem\n            // so it's not going to succeed if we resend it.\n            var batch = this.pendingWrites.shift();\n            // In this case it's also unlikely that the server itself is melting\n            // down -- this was just a bad request so inhibit backoff on the next\n            // restart.\n            this.writeStream.inhibitBackoff();\n            return this.syncEngine\n                .rejectFailedWrite(batch.batchId, error)\n                .then(function () {\n                // It's possible that with the completion of this mutation\n                // another slot has freed up.\n                return _this.fillWritePipeline();\n            });\n        }\n        else {\n            // Transient error, just let the retry logic kick in.\n            return Promise.resolve();\n        }\n    };\n    RemoteStore.prototype.createTransaction = function () {\n        return new Transaction(this.datastore);\n    };\n    RemoteStore.prototype.handleUserChange = function (user) {\n        log.debug(LOG_TAG, 'RemoteStore changing users: uid=', user.uid);\n        // If the network has been explicitly disabled, make sure we don't\n        // accidentally re-enable it.\n        if (this.isNetworkEnabled()) {\n            // Tear down and re-create our network streams. This will ensure we get a fresh auth token\n            // for the new user and re-fill the write pipeline with new mutations from the LocalStore\n            // (since mutations are per-user).\n            this.disableNetworkInternal();\n            this.updateOnlineState(OnlineState.Unknown);\n            return this.enableNetwork();\n        }\n    };\n    return RemoteStore;\n}());\nexport { RemoteStore };\n\n//# sourceMappingURL=remote_store.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/remote/remote_store.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { EventManager, QueryListener } from './event_manager';\nimport { SyncEngine } from './sync_engine';\nimport { EagerGarbageCollector } from '../local/eager_garbage_collector';\nimport { IndexedDbPersistence } from '../local/indexeddb_persistence';\nimport { LocalStore } from '../local/local_store';\nimport { MemoryPersistence } from '../local/memory_persistence';\nimport { NoOpGarbageCollector } from '../local/no_op_garbage_collector';\nimport { Datastore } from '../remote/datastore';\nimport { RemoteStore } from '../remote/remote_store';\nimport { JsonProtoSerializer } from '../remote/serializer';\nimport { Code } from '../util/error';\nimport { debug } from '../util/log';\nimport { Deferred } from '../util/promise';\nvar LOG_TAG = 'FirestoreClient';\n/**\n * FirestoreClient is a top-level class that constructs and owns all of the\n * pieces of the client SDK architecture. It is responsible for creating the\n * async queue that is shared by all of the other components in the system.\n */\nvar FirestoreClient = /** @class */ (function () {\n    function FirestoreClient(platform, databaseInfo, credentials, \n        /**\n         * Asynchronous queue responsible for all of our internal processing. When\n         * we get incoming work from the user (via public API) or the network\n         * (incoming GRPC messages), we should always schedule onto this queue.\n         * This ensures all of our work is properly serialized (e.g. we don't\n         * start processing a new operation while the previous one is waiting for\n         * an async I/O to complete).\n         */\n        asyncQueue) {\n        this.platform = platform;\n        this.databaseInfo = databaseInfo;\n        this.credentials = credentials;\n        this.asyncQueue = asyncQueue;\n    }\n    /**\n     * Starts up the FirestoreClient, returning only whether or not enabling\n     * persistence succeeded.\n     *\n     * The intent here is to \"do the right thing\" as far as users are concerned.\n     * Namely, in cases where offline persistence is requested and possible,\n     * enable it, but otherwise fall back to persistence disabled. For the most\n     * part we expect this to succeed one way or the other so we don't expect our\n     * users to actually wait on the firestore.enablePersistence Promise since\n     * they generally won't care.\n     *\n     * Of course some users actually do care about whether or not persistence\n     * was successfully enabled, so the Promise returned from this method\n     * indicates this outcome.\n     *\n     * This presents a problem though: even before enablePersistence resolves or\n     * rejects, users may have made calls to e.g. firestore.collection() which\n     * means that the FirestoreClient in there will be available and will be\n     * enqueuing actions on the async queue.\n     *\n     * Meanwhile any failure of an operation on the async queue causes it to\n     * panic and reject any further work, on the premise that unhandled errors\n     * are fatal.\n     *\n     * Consequently the fallback is handled internally here in start, and if the\n     * fallback succeeds we signal success to the async queue even though the\n     * start() itself signals failure.\n     *\n     * @param usePersistence Whether or not to attempt to enable persistence.\n     * @returns A deferred result indicating the user-visible result of enabling\n     *     offline persistence. This method will reject this if IndexedDB fails to\n     *     start for any reason. If usePersistence is false this is\n     *     unconditionally resolved.\n     */\n    FirestoreClient.prototype.start = function (usePersistence) {\n        var _this = this;\n        // We defer our initialization until we get the current user from\n        // setUserChangeListener(). We block the async queue until we got the\n        // initial user and the initialization is completed. This will prevent\n        // any scheduled work from happening before initialization is completed.\n        //\n        // If initializationDone resolved then the FirestoreClient is in a usable\n        // state.\n        var initializationDone = new Deferred();\n        // If usePersistence is true, certain classes of errors while starting are\n        // recoverable but only by falling back to persistence disabled.\n        //\n        // If there's an error in the first case but not in recovery we cannot\n        // reject the promise blocking the async queue because this will cause the\n        // async queue to panic.\n        var persistenceResult = new Deferred();\n        var initialized = false;\n        this.credentials.setUserChangeListener(function (user) {\n            if (!initialized) {\n                initialized = true;\n                _this.initializePersistence(usePersistence, persistenceResult)\n                    .then(function () { return _this.initializeRest(user); })\n                    .then(initializationDone.resolve, initializationDone.reject);\n            }\n            else {\n                _this.asyncQueue.enqueue(function () {\n                    return _this.handleUserChange(user);\n                });\n            }\n        });\n        // Block the async queue until initialization is done\n        this.asyncQueue.enqueue(function () {\n            return initializationDone.promise;\n        });\n        // Return only the result of enabling persistence. Note that this does not\n        // need to await the completion of initializationDone because the result of\n        // this method should not reflect any other kind of failure to start.\n        return persistenceResult.promise;\n    };\n    /** Enables the network connection and requeues all pending operations. */\n    FirestoreClient.prototype.enableNetwork = function () {\n        var _this = this;\n        return this.asyncQueue.enqueue(function () {\n            return _this.remoteStore.enableNetwork();\n        });\n    };\n    /**\n     * Initializes persistent storage, attempting to use IndexedDB if\n     * usePersistence is true or memory-only if false.\n     *\n     * If IndexedDB fails because it's already open in another tab or because the\n     * platform can't possibly support our implementation then this method rejects\n     * the persistenceResult and falls back on memory-only persistence.\n     *\n     * @param usePersistence indicates whether or not to use offline persistence\n     * @param persistenceResult A deferred result indicating the user-visible\n     *     result of enabling offline persistence. This method will reject this if\n     *     IndexedDB fails to start for any reason. If usePersistence is false\n     *     this is unconditionally resolved.\n     * @returns a Promise indicating whether or not initialization should\n     *     continue, i.e. that one of the persistence implementations actually\n     *     succeeded.\n     */\n    FirestoreClient.prototype.initializePersistence = function (usePersistence, persistenceResult) {\n        var _this = this;\n        if (usePersistence) {\n            return this.startIndexedDbPersistence()\n                .then(persistenceResult.resolve)\n                .catch(function (error) {\n                // Regardless of whether or not the retry succeeds, from an user\n                // perspective, offline persistence has failed.\n                persistenceResult.reject(error);\n                // An unknown failure on the first stage shuts everything down.\n                if (!_this.canFallback(error)) {\n                    return Promise.reject(error);\n                }\n                console.warn('Error enabling offline storage. Falling back to' +\n                    ' storage disabled: ' +\n                    error);\n                return _this.startMemoryPersistence();\n            });\n        }\n        else {\n            // When usePersistence == false, enabling offline persistence is defined\n            // to unconditionally succeed. This allows start() to have the same\n            // signature for both cases, despite the fact that the returned promise\n            // is only used in the enablePersistence call.\n            persistenceResult.resolve();\n            return this.startMemoryPersistence();\n        }\n    };\n    FirestoreClient.prototype.canFallback = function (error) {\n        return (error.code === Code.FAILED_PRECONDITION ||\n            error.code === Code.UNIMPLEMENTED);\n    };\n    /**\n     * Starts IndexedDB-based persistence.\n     *\n     * @returns A promise indicating success or failure.\n     */\n    FirestoreClient.prototype.startIndexedDbPersistence = function () {\n        // TODO(http://b/33384523): For now we just disable garbage collection\n        // when persistence is enabled.\n        this.garbageCollector = new NoOpGarbageCollector();\n        var storagePrefix = IndexedDbPersistence.buildStoragePrefix(this.databaseInfo);\n        // Opt to use proto3 JSON in case the platform doesn't support Uint8Array.\n        var serializer = new JsonProtoSerializer(this.databaseInfo.databaseId, {\n            useProto3Json: true\n        });\n        this.persistence = new IndexedDbPersistence(storagePrefix, serializer);\n        return this.persistence.start();\n    };\n    /**\n     * Starts Memory-backed persistence. In practice this cannot fail.\n     *\n     * @returns A promise that will successfully resolve.\n     */\n    FirestoreClient.prototype.startMemoryPersistence = function () {\n        this.garbageCollector = new EagerGarbageCollector();\n        this.persistence = new MemoryPersistence();\n        return this.persistence.start();\n    };\n    /**\n     * Initializes the rest of the FirestoreClient, assuming the initial user\n     * has been obtained from the credential provider and some persistence\n     * implementation is available in this.persistence.\n     */\n    FirestoreClient.prototype.initializeRest = function (user) {\n        var _this = this;\n        return this.platform\n            .loadConnection(this.databaseInfo)\n            .then(function (connection) {\n            _this.localStore = new LocalStore(_this.persistence, user, _this.garbageCollector);\n            var serializer = _this.platform.newSerializer(_this.databaseInfo.databaseId);\n            var datastore = new Datastore(_this.asyncQueue, connection, _this.credentials, serializer);\n            var onlineStateChangedHandler = function (onlineState) {\n                _this.syncEngine.applyOnlineStateChange(onlineState);\n                _this.eventMgr.applyOnlineStateChange(onlineState);\n            };\n            _this.remoteStore = new RemoteStore(_this.localStore, datastore, onlineStateChangedHandler);\n            _this.syncEngine = new SyncEngine(_this.localStore, _this.remoteStore, user);\n            // Setup wiring between sync engine and remote store\n            _this.remoteStore.syncEngine = _this.syncEngine;\n            _this.eventMgr = new EventManager(_this.syncEngine);\n            // NOTE: RemoteStore depends on LocalStore (for persisting stream\n            // tokens, refilling mutation queue, etc.) so must be started after\n            // LocalStore.\n            return _this.localStore.start();\n        })\n            .then(function () {\n            return _this.remoteStore.start();\n        });\n    };\n    FirestoreClient.prototype.handleUserChange = function (user) {\n        this.asyncQueue.verifyOperationInProgress();\n        debug(LOG_TAG, 'User Changed: ' + user.uid);\n        return this.syncEngine.handleUserChange(user);\n    };\n    /** Disables the network connection. Pending operations will not complete. */\n    FirestoreClient.prototype.disableNetwork = function () {\n        var _this = this;\n        return this.asyncQueue.enqueue(function () {\n            return _this.remoteStore.disableNetwork();\n        });\n    };\n    FirestoreClient.prototype.shutdown = function () {\n        var _this = this;\n        return this.asyncQueue\n            .enqueue(function () {\n            _this.credentials.removeUserChangeListener();\n            return _this.remoteStore.shutdown();\n        })\n            .then(function () {\n            // PORTING NOTE: LocalStore does not need an explicit shutdown on web.\n            return _this.persistence.shutdown();\n        });\n    };\n    FirestoreClient.prototype.listen = function (query, observer, options) {\n        var _this = this;\n        var listener = new QueryListener(query, observer, options);\n        this.asyncQueue.enqueue(function () {\n            return _this.eventMgr.listen(listener);\n        });\n        return listener;\n    };\n    FirestoreClient.prototype.unlisten = function (listener) {\n        var _this = this;\n        this.asyncQueue.enqueue(function () {\n            return _this.eventMgr.unlisten(listener);\n        });\n    };\n    FirestoreClient.prototype.write = function (mutations) {\n        var _this = this;\n        var deferred = new Deferred();\n        this.asyncQueue.enqueue(function () { return _this.syncEngine.write(mutations, deferred); });\n        return deferred.promise;\n    };\n    FirestoreClient.prototype.databaseId = function () {\n        return this.databaseInfo.databaseId;\n    };\n    FirestoreClient.prototype.transaction = function (updateFunction) {\n        var _this = this;\n        // We have to wait for the async queue to be sure syncEngine is initialized.\n        return this.asyncQueue\n            .enqueue(function () {\n            return Promise.resolve();\n        })\n            .then(function () {\n            return _this.syncEngine.runTransaction(updateFunction);\n        });\n    };\n    return FirestoreClient;\n}());\nexport { FirestoreClient };\n\n//# sourceMappingURL=firestore_client.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/core/firestore_client.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/*\n * A wrapper implementation of Observer<T> that will dispatch events\n * asynchronously. To allow immediate silencing, a mute call is added which\n * causes events scheduled to no longer be raised.\n */\nvar AsyncObserver = /** @class */ (function () {\n    function AsyncObserver(observer) {\n        this.observer = observer;\n        /**\n         * When set to true, will not raise future events. Necessary to deal with\n         * async detachment of listener.\n         */\n        this.muted = false;\n    }\n    AsyncObserver.prototype.next = function (value) {\n        this.scheduleEvent(this.observer.next, value);\n    };\n    AsyncObserver.prototype.error = function (error) {\n        this.scheduleEvent(this.observer.error, error);\n    };\n    AsyncObserver.prototype.mute = function () {\n        this.muted = true;\n    };\n    AsyncObserver.prototype.scheduleEvent = function (eventHandler, event) {\n        var _this = this;\n        if (!this.muted) {\n            setTimeout(function () {\n                if (!_this.muted) {\n                    eventHandler(event);\n                }\n            }, 0);\n        }\n    };\n    return AsyncObserver;\n}());\nexport { AsyncObserver };\n\n//# sourceMappingURL=async_observer.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/util/async_observer.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/**\n * Simple wrapper around a nullable UID. Mostly exists to make code more\n * readable.\n */\nvar User = /** @class */ (function () {\n    function User(uid) {\n        this.uid = uid;\n    }\n    User.prototype.isAuthenticated = function () {\n        return this.uid != null;\n    };\n    /**\n     * Returns a key representing this user, suitable for inclusion in a\n     * dictionary.\n     */\n    User.prototype.toKey = function () {\n        if (this.isAuthenticated()) {\n            return 'uid:' + this.uid;\n        }\n        else {\n            return 'anonymous-user';\n        }\n    };\n    User.prototype.isEqual = function (otherUser) {\n        return otherUser.uid === this.uid;\n    };\n    /** A user with a null UID. */\n    User.UNAUTHENTICATED = new User(null);\n    // TODO(mikelehen): Look into getting a proper uid-equivalent for\n    // non-FirebaseAuth providers.\n    User.GOOGLE_CREDENTIALS = new User('google-credentials-uid');\n    User.FIRST_PARTY = new User('first-party-uid');\n    return User;\n}());\nexport { User };\n\n//# sourceMappingURL=user.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/auth/user.js\n// module id = null\n// module chunks = ","/**\n * Copyright 2017 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nvar __extends = (this && this.__extends) || (function () {\n    var extendStatics = Object.setPrototypeOf ||\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };\n    return function (d, b) {\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { makeConstructorPrivate } from '../util/api';\n/**\n * An opaque base class for FieldValue sentinel objects in our public API,\n * with public static methods for creating said sentinel objects.\n */\n// tslint:disable-next-line:class-as-namespace  We use this as a base class.\nvar FieldValueImpl = /** @class */ (function () {\n    function FieldValueImpl() {\n    }\n    FieldValueImpl.delete = function () {\n        return DeleteFieldValueImpl.instance;\n    };\n    FieldValueImpl.serverTimestamp = function () {\n        return ServerTimestampFieldValueImpl.instance;\n    };\n    FieldValueImpl.prototype.isEqual = function (other) {\n        return this === other;\n    };\n    return FieldValueImpl;\n}());\nexport { FieldValueImpl };\nvar DeleteFieldValueImpl = /** @class */ (function (_super) {\n    __extends(DeleteFieldValueImpl, _super);\n    function DeleteFieldValueImpl() {\n        return _super.call(this) || this;\n    }\n    /** Singleton instance. */\n    DeleteFieldValueImpl.instance = new DeleteFieldValueImpl();\n    return DeleteFieldValueImpl;\n}(FieldValueImpl));\nexport { DeleteFieldValueImpl };\nvar ServerTimestampFieldValueImpl = /** @class */ (function (_super) {\n    __extends(ServerTimestampFieldValueImpl, _super);\n    function ServerTimestampFieldValueImpl() {\n        return _super.call(this) || this;\n    }\n    /** Singleton instance. */\n    ServerTimestampFieldValueImpl.instance = new ServerTimestampFieldValueImpl();\n    return ServerTimestampFieldValueImpl;\n}(FieldValueImpl));\nexport { ServerTimestampFieldValueImpl };\n// Public instance that disallows construction at runtime. This constructor is\n// used when exporting FieldValueImpl on firebase.firestore.FieldValue and will\n// be called FieldValue publicly. Internally we still use FieldValueImpl which\n// has a type-checked private constructor. Note that FieldValueImpl and\n// PublicFieldValue can be used interchangeably in instanceof checks.\n// For our internal TypeScript code PublicFieldValue doesn't exist as a type,\n// and so we need to use FieldValueImpl as type and export it too.\n// tslint:disable-next-line:variable-name  We treat this as a class name.\nexport var PublicFieldValue = makeConstructorPrivate(FieldValueImpl, 'Use FieldValue.<field>() instead.');\n\n//# sourceMappingURL=field_value.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../firestore/dist/esm/src/api/field_value.js\n// module id = null\n// module chunks = ","(function() {var g,goog=goog||{},k=this;function l(a){return\"string\"==typeof a}function aa(){}\nfunction ba(a){var b=typeof a;if(\"object\"==b)if(a){if(a instanceof Array)return\"array\";if(a instanceof Object)return b;var c=Object.prototype.toString.call(a);if(\"[object Window]\"==c)return\"object\";if(\"[object Array]\"==c||\"number\"==typeof a.length&&\"undefined\"!=typeof a.splice&&\"undefined\"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable(\"splice\"))return\"array\";if(\"[object Function]\"==c||\"undefined\"!=typeof a.call&&\"undefined\"!=typeof a.propertyIsEnumerable&&!a.propertyIsEnumerable(\"call\"))return\"function\"}else return\"null\";\nelse if(\"function\"==b&&\"undefined\"==typeof a.call)return\"object\";return b}function n(a){return\"array\"==ba(a)}function ca(a){var b=ba(a);return\"array\"==b||\"object\"==b&&\"number\"==typeof a.length}function da(a){return\"function\"==ba(a)}function ea(a){var b=typeof a;return\"object\"==b&&null!=a||\"function\"==b}var p=\"closure_uid_\"+(1E9*Math.random()>>>0),fa=0;function ha(a,b,c){return a.call.apply(a.bind,arguments)}\nfunction ia(a,b,c){if(!a)throw Error();if(2<arguments.length){var d=Array.prototype.slice.call(arguments,2);return function(){var c=Array.prototype.slice.call(arguments);Array.prototype.unshift.apply(c,d);return a.apply(b,c)}}return function(){return a.apply(b,arguments)}}function q(a,b,c){Function.prototype.bind&&-1!=Function.prototype.bind.toString().indexOf(\"native code\")?q=ha:q=ia;return q.apply(null,arguments)}\nfunction ja(a,b){var c=Array.prototype.slice.call(arguments,1);return function(){var b=c.slice();b.push.apply(b,arguments);return a.apply(this,b)}}var r=Date.now||function(){return+new Date};function t(a,b){function c(){}c.prototype=b.prototype;a.H=b.prototype;a.prototype=new c;a.prototype.constructor=a;a.Db=function(a,c,f){for(var d=Array(arguments.length-2),e=2;e<arguments.length;e++)d[e-2]=arguments[e];return b.prototype[c].apply(a,d)}};function ka(a){if(Error.captureStackTrace)Error.captureStackTrace(this,ka);else{var b=Error().stack;b&&(this.stack=b)}a&&(this.message=String(a))}t(ka,Error);ka.prototype.name=\"CustomError\";function la(a,b){a=a.split(\"%s\");for(var c=\"\",d=a.length-1,e=0;e<d;e++)c+=a[e]+(e<b.length?b[e]:\"%s\");ka.call(this,c+a[d])}t(la,ka);la.prototype.name=\"AssertionError\";function ma(a,b){throw new la(\"Failure\"+(a?\": \"+a:\"\"),Array.prototype.slice.call(arguments,1));};function u(){0!=na&&(pa[this[p]||(this[p]=++fa)]=this);this.i=this.i;this.m=this.m}var na=0,pa={};u.prototype.i=!1;u.prototype.$=function(){if(!this.i&&(this.i=!0,this.w(),0!=na)){var a=this[p]||(this[p]=++fa);if(0!=na&&this.m&&0<this.m.length)throw Error(this+\" did not empty its onDisposeCallbacks queue. This probably means it overrode dispose() or disposeInternal() without calling the superclass' method.\");delete pa[a]}};u.prototype.w=function(){if(this.m)for(;this.m.length;)this.m.shift()()};var qa=Array.prototype.indexOf?function(a,b){return Array.prototype.indexOf.call(a,b,void 0)}:function(a,b){if(l(a))return l(b)&&1==b.length?a.indexOf(b,0):-1;for(var c=0;c<a.length;c++)if(c in a&&a[c]===b)return c;return-1},ra=Array.prototype.forEach?function(a,b,c){Array.prototype.forEach.call(a,b,c)}:function(a,b,c){for(var d=a.length,e=l(a)?a.split(\"\"):a,f=0;f<d;f++)f in e&&b.call(c,e[f],f,a)};\nfunction sa(a){a:{var b=ta;for(var c=a.length,d=l(a)?a.split(\"\"):a,e=0;e<c;e++)if(e in d&&b.call(void 0,d[e],e,a)){b=e;break a}b=-1}return 0>b?null:l(a)?a.charAt(b):a[b]}function ua(a){if(!n(a))for(var b=a.length-1;0<=b;b--)delete a[b];a.length=0}function va(a){return Array.prototype.concat.apply([],arguments)}function wa(a){var b=a.length;if(0<b){for(var c=Array(b),d=0;d<b;d++)c[d]=a[d];return c}return[]};function xa(a){return/^[\\s\\xa0]*$/.test(a)}var ya=String.prototype.trim?function(a){return a.trim()}:function(a){return/^[\\s\\xa0]*([\\s\\S]*?)[\\s\\xa0]*$/.exec(a)[1]};function za(a,b){return a<b?-1:a>b?1:0};var w;a:{var Aa=k.navigator;if(Aa){var Ba=Aa.userAgent;if(Ba){w=Ba;break a}}w=\"\"}function x(a){return-1!=w.indexOf(a)};function Ca(a,b,c){for(var d in a)b.call(c,a[d],d,a)}function Da(a){var b=[],c=0,d;for(d in a)b[c++]=a[d];return b}function Ea(a){var b=[],c=0,d;for(d in a)b[c++]=d;return b}function Fa(a){var b={},c;for(c in a)b[c]=a[c];return b}var Ga=\"constructor hasOwnProperty isPrototypeOf propertyIsEnumerable toLocaleString toString valueOf\".split(\" \");\nfunction Ha(a,b){for(var c,d,e=1;e<arguments.length;e++){d=arguments[e];for(c in d)a[c]=d[c];for(var f=0;f<Ga.length;f++)c=Ga[f],Object.prototype.hasOwnProperty.call(d,c)&&(a[c]=d[c])}};function Ia(a){Ia[\" \"](a);return a}Ia[\" \"]=aa;function Ja(a,b){var c=Ka;return Object.prototype.hasOwnProperty.call(c,a)?c[a]:c[a]=b(a)};var La=x(\"Opera\"),y=x(\"Trident\")||x(\"MSIE\"),Ma=x(\"Edge\"),Na=Ma||y,Oa=x(\"Gecko\")&&!(-1!=w.toLowerCase().indexOf(\"webkit\")&&!x(\"Edge\"))&&!(x(\"Trident\")||x(\"MSIE\"))&&!x(\"Edge\"),Pa=-1!=w.toLowerCase().indexOf(\"webkit\")&&!x(\"Edge\");function Qa(){var a=k.document;return a?a.documentMode:void 0}var Ra;\na:{var Sa=\"\",Ta=function(){var a=w;if(Oa)return/rv:([^\\);]+)(\\)|;)/.exec(a);if(Ma)return/Edge\\/([\\d\\.]+)/.exec(a);if(y)return/\\b(?:MSIE|rv)[: ]([^\\);]+)(\\)|;)/.exec(a);if(Pa)return/WebKit\\/(\\S+)/.exec(a);if(La)return/(?:Version)[ \\/]?(\\S+)/.exec(a)}();Ta&&(Sa=Ta?Ta[1]:\"\");if(y){var Ua=Qa();if(null!=Ua&&Ua>parseFloat(Sa)){Ra=String(Ua);break a}}Ra=Sa}var Ka={};\nfunction Va(a){return Ja(a,function(){for(var b=0,c=ya(String(Ra)).split(\".\"),d=ya(String(a)).split(\".\"),e=Math.max(c.length,d.length),f=0;0==b&&f<e;f++){var h=c[f]||\"\",m=d[f]||\"\";do{h=/(\\d*)(\\D*)(.*)/.exec(h)||[\"\",\"\",\"\",\"\"];m=/(\\d*)(\\D*)(.*)/.exec(m)||[\"\",\"\",\"\",\"\"];if(0==h[0].length&&0==m[0].length)break;b=za(0==h[1].length?0:parseInt(h[1],10),0==m[1].length?0:parseInt(m[1],10))||za(0==h[2].length,0==m[2].length)||za(h[2],m[2]);h=h[3];m=m[3]}while(0==b)}return 0<=b})}var Wa;var Xa=k.document;\nWa=Xa&&y?Qa()||(\"CSS1Compat\"==Xa.compatMode?parseInt(Ra,10):5):void 0;var Ya=Object.freeze||function(a){return a};var Za=!y||9<=Number(Wa),$a=y&&!Va(\"9\"),ab=function(){if(!k.addEventListener||!Object.defineProperty)return!1;var a=!1,b=Object.defineProperty({},\"passive\",{get:function(){a=!0}});k.addEventListener(\"test\",aa,b);k.removeEventListener(\"test\",aa,b);return a}();function z(a,b){this.type=a;this.a=this.target=b;this.Qa=!0}z.prototype.b=function(){this.Qa=!1};function bb(a,b){z.call(this,a?a.type:\"\");this.relatedTarget=this.a=this.target=null;this.button=this.screenY=this.screenX=this.clientY=this.clientX=0;this.key=\"\";this.metaKey=this.shiftKey=this.altKey=this.ctrlKey=!1;this.pointerId=0;this.pointerType=\"\";this.c=null;if(a){var c=this.type=a.type,d=a.changedTouches?a.changedTouches[0]:null;this.target=a.target||a.srcElement;this.a=b;if(b=a.relatedTarget){if(Oa){a:{try{Ia(b.nodeName);var e=!0;break a}catch(f){}e=!1}e||(b=null)}}else\"mouseover\"==c?b=\na.fromElement:\"mouseout\"==c&&(b=a.toElement);this.relatedTarget=b;null===d?(this.clientX=void 0!==a.clientX?a.clientX:a.pageX,this.clientY=void 0!==a.clientY?a.clientY:a.pageY,this.screenX=a.screenX||0,this.screenY=a.screenY||0):(this.clientX=void 0!==d.clientX?d.clientX:d.pageX,this.clientY=void 0!==d.clientY?d.clientY:d.pageY,this.screenX=d.screenX||0,this.screenY=d.screenY||0);this.button=a.button;this.key=a.key||\"\";this.ctrlKey=a.ctrlKey;this.altKey=a.altKey;this.shiftKey=a.shiftKey;this.metaKey=\na.metaKey;this.pointerId=a.pointerId||0;this.pointerType=l(a.pointerType)?a.pointerType:cb[a.pointerType]||\"\";this.c=a;a.defaultPrevented&&this.b()}}t(bb,z);var cb=Ya({2:\"touch\",3:\"pen\",4:\"mouse\"});bb.prototype.b=function(){bb.H.b.call(this);var a=this.c;if(a.preventDefault)a.preventDefault();else if(a.returnValue=!1,$a)try{if(a.ctrlKey||112<=a.keyCode&&123>=a.keyCode)a.keyCode=-1}catch(b){}};var db=\"closure_listenable_\"+(1E6*Math.random()|0),eb=0;function fb(a,b,c,d,e){this.listener=a;this.proxy=null;this.src=b;this.type=c;this.capture=!!d;this.ga=e;this.key=++eb;this.Z=this.ba=!1}function gb(a){a.Z=!0;a.listener=null;a.proxy=null;a.src=null;a.ga=null};function hb(a){this.src=a;this.a={};this.b=0}hb.prototype.add=function(a,b,c,d,e){var f=a.toString();a=this.a[f];a||(a=this.a[f]=[],this.b++);var h=ib(a,b,d,e);-1<h?(b=a[h],c||(b.ba=!1)):(b=new fb(b,this.src,f,!!d,e),b.ba=c,a.push(b));return b};function jb(a,b){var c=b.type;if(c in a.a){var d=a.a[c],e=qa(d,b),f;(f=0<=e)&&Array.prototype.splice.call(d,e,1);f&&(gb(b),0==a.a[c].length&&(delete a.a[c],a.b--))}}\nfunction ib(a,b,c,d){for(var e=0;e<a.length;++e){var f=a[e];if(!f.Z&&f.listener==b&&f.capture==!!c&&f.ga==d)return e}return-1};var kb=\"closure_lm_\"+(1E6*Math.random()|0),lb={},mb=0;function nb(a,b,c,d,e){if(d&&d.once)return ob(a,b,c,d,e);if(n(b)){for(var f=0;f<b.length;f++)nb(a,b[f],c,d,e);return null}c=pb(c);return a&&a[db]?a.Ha(b,c,ea(d)?!!d.capture:!!d,e):qb(a,b,c,!1,d,e)}\nfunction qb(a,b,c,d,e,f){if(!b)throw Error(\"Invalid event type\");var h=ea(e)?!!e.capture:!!e,m=rb(a);m||(a[kb]=m=new hb(a));c=m.add(b,c,d,h,f);if(c.proxy)return c;d=sb();c.proxy=d;d.src=a;d.listener=c;if(a.addEventListener)ab||(e=h),void 0===e&&(e=!1),a.addEventListener(b.toString(),d,e);else if(a.attachEvent)a.attachEvent(tb(b.toString()),d);else if(a.addListener&&a.removeListener)a.addListener(d);else throw Error(\"addEventListener and attachEvent are unavailable.\");mb++;return c}\nfunction sb(){var a=ub,b=Za?function(c){return a.call(b.src,b.listener,c)}:function(c){c=a.call(b.src,b.listener,c);if(!c)return c};return b}function ob(a,b,c,d,e){if(n(b)){for(var f=0;f<b.length;f++)ob(a,b[f],c,d,e);return null}c=pb(c);return a&&a[db]?a.Ia(b,c,ea(d)?!!d.capture:!!d,e):qb(a,b,c,!0,d,e)}\nfunction vb(a,b,c,d,e){if(n(b))for(var f=0;f<b.length;f++)vb(a,b[f],c,d,e);else(d=ea(d)?!!d.capture:!!d,c=pb(c),a&&a[db])?(a=a.f,b=String(b).toString(),b in a.a&&(f=a.a[b],c=ib(f,c,d,e),-1<c&&(gb(f[c]),Array.prototype.splice.call(f,c,1),0==f.length&&(delete a.a[b],a.b--)))):a&&(a=rb(a))&&(b=a.a[b.toString()],a=-1,b&&(a=ib(b,c,d,e)),(c=-1<a?b[a]:null)&&wb(c))}\nfunction wb(a){if(\"number\"!=typeof a&&a&&!a.Z){var b=a.src;if(b&&b[db])jb(b.f,a);else{var c=a.type,d=a.proxy;b.removeEventListener?b.removeEventListener(c,d,a.capture):b.detachEvent?b.detachEvent(tb(c),d):b.addListener&&b.removeListener&&b.removeListener(d);mb--;(c=rb(b))?(jb(c,a),0==c.b&&(c.src=null,b[kb]=null)):gb(a)}}}function tb(a){return a in lb?lb[a]:lb[a]=\"on\"+a}\nfunction xb(a,b,c,d){var e=!0;if(a=rb(a))if(b=a.a[b.toString()])for(b=b.concat(),a=0;a<b.length;a++){var f=b[a];f&&f.capture==c&&!f.Z&&(f=yb(f,d),e=e&&!1!==f)}return e}function yb(a,b){var c=a.listener,d=a.ga||a.src;a.ba&&wb(a);return c.call(d,b)}\nfunction ub(a,b){if(a.Z)return!0;if(!Za){if(!b)a:{b=[\"window\",\"event\"];for(var c=k,d=0;d<b.length;d++)if(c=c[b[d]],null==c){b=null;break a}b=c}d=b;b=new bb(d,this);c=!0;if(!(0>d.keyCode||void 0!=d.returnValue)){a:{var e=!1;if(0==d.keyCode)try{d.keyCode=-1;break a}catch(h){e=!0}if(e||void 0==d.returnValue)d.returnValue=!0}d=[];for(e=b.a;e;e=e.parentNode)d.push(e);a=a.type;for(e=d.length-1;0<=e;e--){b.a=d[e];var f=xb(d[e],a,!0,b);c=c&&f}for(e=0;e<d.length;e++)b.a=d[e],f=xb(d[e],a,!1,b),c=c&&f}return c}return yb(a,\nnew bb(b,this))}function rb(a){a=a[kb];return a instanceof hb?a:null}var zb=\"__closure_events_fn_\"+(1E9*Math.random()>>>0);function pb(a){if(da(a))return a;a[zb]||(a[zb]=function(b){return a.handleEvent(b)});return a[zb]};function A(){u.call(this);this.f=new hb(this);this.N=this;this.J=null}t(A,u);A.prototype[db]=!0;g=A.prototype;g.addEventListener=function(a,b,c,d){nb(this,a,b,c,d)};g.removeEventListener=function(a,b,c,d){vb(this,a,b,c,d)};\ng.dispatchEvent=function(a){var b,c=this.J;if(c)for(b=[];c;c=c.J)b.push(c);c=this.N;var d=a.type||a;if(l(a))a=new z(a,c);else if(a instanceof z)a.target=a.target||c;else{var e=a;a=new z(d,c);Ha(a,e)}e=!0;if(b)for(var f=b.length-1;0<=f;f--){var h=a.a=b[f];e=Ab(h,d,!0,a)&&e}h=a.a=c;e=Ab(h,d,!0,a)&&e;e=Ab(h,d,!1,a)&&e;if(b)for(f=0;f<b.length;f++)h=a.a=b[f],e=Ab(h,d,!1,a)&&e;return e};\ng.w=function(){A.H.w.call(this);if(this.f){var a=this.f,b=0,c;for(c in a.a){for(var d=a.a[c],e=0;e<d.length;e++)++b,gb(d[e]);delete a.a[c];a.b--}}this.J=null};g.Ha=function(a,b,c,d){return this.f.add(String(a),b,!1,c,d)};g.Ia=function(a,b,c,d){return this.f.add(String(a),b,!0,c,d)};\nfunction Ab(a,b,c,d){b=a.f.a[String(b)];if(!b)return!0;b=b.concat();for(var e=!0,f=0;f<b.length;++f){var h=b[f];if(h&&!h.Z&&h.capture==c){var m=h.listener,v=h.ga||h.src;h.ba&&jb(a.f,h);e=!1!==m.call(v,d)&&e}}return e&&0!=d.Qa};function Bb(a){return/^\\s*$/.test(a)?!1:/^[\\],:{}\\s\\u2028\\u2029]*$/.test(a.replace(/\\\\[\"\\\\\\/bfnrtu]/g,\"@\").replace(/(?:\"[^\"\\\\\\n\\r\\u2028\\u2029\\x00-\\x08\\x0a-\\x1f]*\"|true|false|null|-?\\d+(?:\\.\\d*)?(?:[eE][+\\-]?\\d+)?)[\\s\\u2028\\u2029]*(?=:|,|]|}|$)/g,\"]\").replace(/(?:^|:|,)(?:[\\s\\u2028\\u2029]*\\[)+/g,\"\"))}function Cb(a){a=String(a);if(Bb(a))try{return eval(\"(\"+a+\")\")}catch(b){}throw Error(\"Invalid JSON string: \"+a);}function Db(a){var b=[];Eb(new Fb,a,b);return b.join(\"\")}function Fb(){}\nfunction Eb(a,b,c){if(null==b)c.push(\"null\");else{if(\"object\"==typeof b){if(n(b)){var d=b;b=d.length;c.push(\"[\");for(var e=\"\",f=0;f<b;f++)c.push(e),Eb(a,d[f],c),e=\",\";c.push(\"]\");return}if(b instanceof String||b instanceof Number||b instanceof Boolean)b=b.valueOf();else{c.push(\"{\");e=\"\";for(d in b)Object.prototype.hasOwnProperty.call(b,d)&&(f=b[d],\"function\"!=typeof f&&(c.push(e),Gb(d,c),c.push(\":\"),Eb(a,f,c),e=\",\"));c.push(\"}\");return}}switch(typeof b){case \"string\":Gb(b,c);break;case \"number\":c.push(isFinite(b)&&\n!isNaN(b)?String(b):\"null\");break;case \"boolean\":c.push(String(b));break;case \"function\":c.push(\"null\");break;default:throw Error(\"Unknown type: \"+typeof b);}}}var Hb={'\"':'\\\\\"',\"\\\\\":\"\\\\\\\\\",\"/\":\"\\\\/\",\"\\b\":\"\\\\b\",\"\\f\":\"\\\\f\",\"\\n\":\"\\\\n\",\"\\r\":\"\\\\r\",\"\\t\":\"\\\\t\",\"\\x0B\":\"\\\\u000b\"},Ib=/\\uffff/.test(\"\\uffff\")?/[\\\\\"\\x00-\\x1f\\x7f-\\uffff]/g:/[\\\\\"\\x00-\\x1f\\x7f-\\xff]/g;\nfunction Gb(a,b){b.push('\"',a.replace(Ib,function(a){var b=Hb[a];b||(b=\"\\\\u\"+(a.charCodeAt(0)|65536).toString(16).substr(1),Hb[a]=b);return b}),'\"')};function Jb(a,b){this.c=a;this.f=b;this.b=0;this.a=null}Jb.prototype.get=function(){if(0<this.b){this.b--;var a=this.a;this.a=a.next;a.next=null}else a=this.c();return a};function Kb(){this.b=this.a=null}var Nb=new Jb(function(){return new Mb},function(a){a.reset()});Kb.prototype.add=function(a,b){var c=Nb.get();c.set(a,b);this.b?this.b.next=c:this.a=c;this.b=c};function Ob(){var a=Pb,b=null;a.a&&(b=a.a,a.a=a.a.next,a.a||(a.b=null),b.next=null);return b}function Mb(){this.next=this.b=this.a=null}Mb.prototype.set=function(a,b){this.a=a;this.b=b;this.next=null};Mb.prototype.reset=function(){this.next=this.b=this.a=null};function Qb(a){k.setTimeout(function(){throw a;},0)}var Rb;\nfunction Sb(){var a=k.MessageChannel;\"undefined\"===typeof a&&\"undefined\"!==typeof window&&window.postMessage&&window.addEventListener&&!x(\"Presto\")&&(a=function(){var a=document.createElement(\"IFRAME\");a.style.display=\"none\";a.src=\"\";document.documentElement.appendChild(a);var b=a.contentWindow;a=b.document;a.open();a.write(\"\");a.close();var c=\"callImmediate\"+Math.random(),d=\"file:\"==b.location.protocol?\"*\":b.location.protocol+\"//\"+b.location.host;a=q(function(a){if((\"*\"==d||a.origin==d)&&a.data==\nc)this.port1.onmessage()},this);b.addEventListener(\"message\",a,!1);this.port1={};this.port2={postMessage:function(){b.postMessage(c,d)}}});if(\"undefined\"!==typeof a&&!x(\"Trident\")&&!x(\"MSIE\")){var b=new a,c={},d=c;b.port1.onmessage=function(){if(void 0!==c.next){c=c.next;var a=c.ya;c.ya=null;a()}};return function(a){d.next={ya:a};d=d.next;b.port2.postMessage(0)}}return\"undefined\"!==typeof document&&\"onreadystatechange\"in document.createElement(\"SCRIPT\")?function(a){var b=document.createElement(\"SCRIPT\");\nb.onreadystatechange=function(){b.onreadystatechange=null;b.parentNode.removeChild(b);b=null;a();a=null};document.documentElement.appendChild(b)}:function(a){k.setTimeout(a,0)}};var Tb;function Ub(){if(-1!=String(k.Promise).indexOf(\"[native code]\")){var a=k.Promise.resolve(void 0);Tb=function(){a.then(Vb)}}else Tb=function(){var a=Vb;!da(k.setImmediate)||k.Window&&k.Window.prototype&&!x(\"Edge\")&&k.Window.prototype.setImmediate==k.setImmediate?(Rb||(Rb=Sb()),Rb(a)):k.setImmediate(a)}}var Wb=!1,Pb=new Kb;function Vb(){for(var a;a=Ob();){try{a.a.call(a.b)}catch(c){Qb(c)}var b=Nb;b.f(a);100>b.b&&(b.b++,a.next=b.a,b.a=a)}Wb=!1};function Xb(a,b){A.call(this);this.b=a||1;this.a=b||k;this.c=q(this.lb,this);this.g=r()}t(Xb,A);g=Xb.prototype;g.ea=!1;g.O=null;g.lb=function(){if(this.ea){var a=r()-this.g;0<a&&a<.8*this.b?this.O=this.a.setTimeout(this.c,this.b-a):(this.O&&(this.a.clearTimeout(this.O),this.O=null),this.dispatchEvent(\"tick\"),this.ea&&(this.O=this.a.setTimeout(this.c,this.b),this.g=r()))}};g.start=function(){this.ea=!0;this.O||(this.O=this.a.setTimeout(this.c,this.b),this.g=r())};\nfunction Yb(a){a.ea=!1;a.O&&(a.a.clearTimeout(a.O),a.O=null)}g.w=function(){Xb.H.w.call(this);Yb(this);delete this.a};function Zb(a,b,c){if(da(a))c&&(a=q(a,c));else if(a&&\"function\"==typeof a.handleEvent)a=q(a.handleEvent,a);else throw Error(\"Invalid listener argument\");return 2147483647<Number(b)?-1:k.setTimeout(a,b||0)};function $b(a,b,c){u.call(this);this.f=null!=c?q(a,c):a;this.c=b;this.b=q(this.fb,this);this.a=[]}t($b,u);g=$b.prototype;g.ha=!1;g.Y=null;g.Ya=function(a){this.a=arguments;this.Y?this.ha=!0:ac(this)};g.w=function(){$b.H.w.call(this);this.Y&&(k.clearTimeout(this.Y),this.Y=null,this.ha=!1,this.a=[])};g.fb=function(){this.Y=null;this.ha&&(this.ha=!1,ac(this))};function ac(a){a.Y=Zb(a.b,a.c);a.f.apply(null,a.a)};function bc(a){u.call(this);this.b=a;this.a={}}t(bc,u);var cc=[];function dc(a,b,c,d){n(c)||(c&&(cc[0]=c.toString()),c=cc);for(var e=0;e<c.length;e++){var f=nb(b,c[e],d||a.handleEvent,!1,a.b||a);if(!f)break;a.a[f.key]=f}}function ec(a){Ca(a.a,function(a,c){this.a.hasOwnProperty(c)&&wb(a)},a);a.a={}}bc.prototype.w=function(){bc.H.w.call(this);ec(this)};bc.prototype.handleEvent=function(){throw Error(\"EventHandler.handleEvent not implemented\");};function fc(a,b,c){this.reset(a,b,c,void 0,void 0)}fc.prototype.a=null;var gc=0;fc.prototype.reset=function(a,b,c,d,e){\"number\"==typeof e||gc++;d||r();delete this.a};function hc(a){this.f=a;this.b=this.c=this.a=null}function B(a,b){this.name=a;this.value=b}B.prototype.toString=function(){return this.name};var ic=new B(\"SEVERE\",1E3),jc=new B(\"WARNING\",900),kc=new B(\"INFO\",800),lc=new B(\"CONFIG\",700),mc=new B(\"FINE\",500);function nc(a){if(a.c)return a.c;if(a.a)return nc(a.a);ma(\"Root logger has no level set.\");return null}hc.prototype.log=function(a,b,c){if(a.value>=nc(this).value)for(da(b)&&(b=b()),a=new fc(a,String(b),this.f),c&&(a.a=c),c=this;c;)c=c.a};\nvar oc={},pc=null;function qc(a){pc||(pc=new hc(\"\"),oc[\"\"]=pc,pc.c=lc);var b;if(!(b=oc[a])){b=new hc(a);var c=a.lastIndexOf(\".\"),d=a.substr(c+1);c=qc(a.substr(0,c));c.b||(c.b={});c.b[d]=b;b.a=c;oc[a]=b}return b};function C(a,b){a&&a.log(jc,b,void 0)}function rc(a,b){a&&a.log(kc,b,void 0)}function D(a,b){a&&a.log(mc,b,void 0)};function sc(){this.a=qc(\"goog.labs.net.webChannel.WebChannelDebug\");this.b=!0}sc.prototype.Ea=function(){this.b=!1};function tc(a,b,c,d,e,f){E(a,function(){if(a.b)if(f){var h=\"\";for(var m=f.split(\"&\"),v=0;v<m.length;v++){var I=m[v].split(\"=\");if(1<I.length){var W=I[0];I=I[1];var Lb=W.split(\"_\");h=2<=Lb.length&&\"type\"==Lb[1]?h+(W+\"=\"+I+\"&\"):h+(W+\"=redacted&\")}}}else h=null;else h=f;return\"XMLHTTP REQ (\"+d+\") [attempt \"+e+\"]: \"+b+\"\\n\"+c+\"\\n\"+h})}\nfunction uc(a,b,c,d,e,f,h){E(a,function(){return\"XMLHTTP RESP (\"+d+\") [ attempt \"+e+\"]: \"+b+\"\\n\"+c+\"\\n\"+f+\" \"+h})}function F(a,b,c,d){E(a,function(){return\"XMLHTTP TEXT (\"+b+\"): \"+vc(a,c)+(d?\" \"+d:\"\")})}function wc(a,b){E(a,function(){return\"TIMEOUT: \"+b})}function G(a,b){D(a.a,b)}function xc(a,b,c){(a=a.a)&&a.log(ic,c||\"Exception\",b)}function E(a,b){rc(a.a,b)}function H(a,b){(a=a.a)&&a.log(ic,b,void 0)}\nfunction vc(a,b){if(!a.b)return b;if(!b)return null;try{var c=JSON.parse(b);if(c)for(var d=0;d<c.length;d++)if(n(c[d])){var e=c[d];if(!(2>e.length)){var f=e[1];if(n(f)&&!(1>f.length)){var h=f[0];if(\"noop\"!=h&&\"stop\"!=h&&\"close\"!=h)for(var m=1;m<f.length;m++)f[m]=\"\"}}}return Db(c)}catch(v){return G(a,\"Exception parsing expected JS array - probably was not JS\"),b}};var J=new A;function yc(a){z.call(this,\"serverreachability\",a)}t(yc,z);function zc(a){J.dispatchEvent(new yc(J,a))}function Ac(a){z.call(this,\"statevent\",a)}t(Ac,z);function K(a){J.dispatchEvent(new Ac(J,a))}function Bc(a){z.call(this,\"timingevent\",a)}t(Bc,z);function Cc(a,b,c){J.dispatchEvent(new Bc(J,a,b,c))}function Dc(a,b){if(!da(a))throw Error(\"Fn must not be null and must be a function\");return k.setTimeout(function(){a()},b)};var Ec={NO_ERROR:0,mb:1,tb:2,sb:3,pb:4,rb:5,ub:6,Sa:7,TIMEOUT:8,xb:9};var Fc={ob:\"complete\",Bb:\"success\",Ta:\"error\",Sa:\"abort\",zb:\"ready\",Ab:\"readystatechange\",TIMEOUT:\"timeout\",vb:\"incrementaldata\",yb:\"progress\",qb:\"downloadprogress\",Cb:\"uploadprogress\"};function Gc(){}var Hc={OPEN:\"a\",nb:\"b\",Ta:\"c\",wb:\"d\"};function Ic(){z.call(this,\"d\")}t(Ic,z);function Jc(){z.call(this,\"c\")}t(Jc,z);function Kc(){}Kc.prototype.a=null;function Lc(a){var b;(b=a.a)||(b={},Mc(a)&&(b[0]=!0,b[1]=!0),b=a.a=b);return b};var Nc;function Oc(){}t(Oc,Kc);function Pc(a){return(a=Mc(a))?new ActiveXObject(a):new XMLHttpRequest}function Mc(a){if(!a.b&&\"undefined\"==typeof XMLHttpRequest&&\"undefined\"!=typeof ActiveXObject){for(var b=[\"MSXML2.XMLHTTP.6.0\",\"MSXML2.XMLHTTP.3.0\",\"MSXML2.XMLHTTP\",\"Microsoft.XMLHTTP\"],c=0;c<b.length;c++){var d=b[c];try{return new ActiveXObject(d),a.b=d}catch(e){}}throw Error(\"Could not create ActiveXObject. ActiveX might be disabled, or MSXML might not be installed\");}return a.b}Nc=new Oc;function L(a,b,c,d){this.i=a;this.b=b;this.c=c;this.T=d||1;this.L=new bc(this);this.R=Qc;a=Na?125:void 0;this.S=new Xb(a);this.j=null;this.f=!1;this.l=this.g=this.h=this.J=this.D=this.U=this.s=null;this.u=[];this.a=null;this.G=0;this.m=this.o=null;this.C=-1;this.B=!1;this.N=0;this.I=null;this.v=this.X=this.K=!1}var Qc=45E3;\nfunction Rc(a,b){switch(a){case 0:return\"Non-200 return code (\"+b+\")\";case 1:return\"XMLHTTP failure (no data)\";case 2:return\"HttpConnection timeout\";default:return\"Unknown error\"}}var Sc={},Tc={};g=L.prototype;g.setTimeout=function(a){this.R=a};function Uc(a,b,c){a.J=1;a.h=Vc(M(b));a.l=c;a.K=!0;Wc(a,null)}function Xc(a,b,c,d){a.J=1;a.h=Vc(M(b));a.l=null;a.K=c;Wc(a,d)}\nfunction Wc(a,b){a.D=r();Yc(a);a.g=M(a.h);Zc(a.g,\"t\",a.T);a.G=0;a.a=a.i.ca(a.i.ia()?b:null);0<a.N&&(a.I=new $b(q(a.Ra,a,a.a),a.N));dc(a.L,a.a,\"readystatechange\",a.ib);b=a.j?Fa(a.j):{};a.l?(a.o||(a.o=\"POST\"),b[\"Content-Type\"]=\"application/x-www-form-urlencoded\",a.a.fa(a.g,a.o,a.l,b)):(a.o=\"GET\",a.a.fa(a.g,a.o,null,b));zc(1);tc(a.b,a.o,a.g,a.c,a.T,a.l)}g.ib=function(a){a=a.target;var b=this.I;b&&3==N(a)?(G(this.b,\"Throttling readystatechange.\"),b.Ya()):this.Ra(a)};\ng.Ra=function(a){try{a==this.a?$c(this):C(this.b.a,\"Called back with an unexpected xmlhttp\")}catch(c){if(G(this.b,\"Failed call to OnXmlHttpReadyStateChanged_\"),this.a&&this.a.V()){var b=this;xc(this.b,c,function(){return\"ResponseText: \"+b.a.V()})}else xc(this.b,c,\"No response text\")}finally{}};\nfunction $c(a){var b=N(a.a),c=a.a.Fa(),d=a.a.W();if(!(3>b||3==b&&!Na&&!a.a.V())){a.B||4!=b||7==c||(8==c||0>=d?zc(3):zc(2));ad(a);var e=a.a.W();a.C=e;(c=a.a.V())||G(a.b,function(){return\"No response text for uri \"+a.g+\" status \"+e});a.f=200==e;uc(a.b,a.o,a.g,a.c,a.T,b,e);if(a.f){if(d=bd(a))F(a.b,a.c,d,\"Initial handshake response via X-HTTP-Initial-Response\"),a.v=!0,cd(a,d);a.K?(dd(a,b,c),Na&&a.f&&3==b&&ed(a)):(F(a.b,a.c,c,null),cd(a,c));4==b&&fd(a);a.f&&!a.B&&(4==b?a.i.ta(a):(a.f=!1,Yc(a)))}else 400==\ne&&0<c.indexOf(\"Unknown SID\")?(a.m=3,K(12),C(a.b.a,\"XMLHTTP Unknown SID (\"+a.c+\")\")):(a.m=0,K(13),C(a.b.a,\"XMLHTTP Bad status \"+e+\" (\"+a.c+\")\")),fd(a),gd(a)}}function bd(a){return!a.X||a.v?null:a.a&&(a=hd(a.a,\"X-HTTP-Initial-Response\"))&&!xa(a)?a:null}\nfunction dd(a,b,c){for(var d=!0;!a.B&&a.G<c.length;){var e=id(a,c);if(e==Tc){4==b&&(a.m=4,K(14),d=!1);F(a.b,a.c,null,\"[Incomplete Response]\");break}else if(e==Sc){a.m=4;K(15);F(a.b,a.c,c,\"[Invalid Chunk]\");d=!1;break}else F(a.b,a.c,e,null),cd(a,e)}4==b&&0==c.length&&(a.m=1,K(16),d=!1);a.f=a.f&&d;d||(F(a.b,a.c,c,\"[Invalid Chunked Response]\"),fd(a),gd(a))}g.hb=function(){if(this.a){var a=N(this.a),b=this.a.V();this.G<b.length&&(ad(this),dd(this,a,b),this.f&&4!=a&&Yc(this))}};\nfunction ed(a){dc(a.L,a.S,\"tick\",a.hb);a.S.start()}function id(a,b){var c=a.G,d=b.indexOf(\"\\n\",c);if(-1==d)return Tc;c=Number(b.substring(c,d));if(isNaN(c))return Sc;d+=1;if(d+c>b.length)return Tc;b=b.substr(d,c);a.G=d+c;return b}g.cancel=function(){this.B=!0;fd(this)};function Yc(a){a.U=r()+a.R;jd(a,a.R)}function jd(a,b){if(null!=a.s)throw Error(\"WatchDog timer not null\");a.s=Dc(q(a.gb,a),b)}function ad(a){a.s&&(k.clearTimeout(a.s),a.s=null)}\ng.gb=function(){this.s=null;var a=r();0<=a-this.U?(this.f&&H(this.b,\"Received watchdog timeout even though request loaded successfully\"),wc(this.b,this.g),2!=this.J&&(zc(3),K(17)),fd(this),this.m=2,gd(this)):(C(this.b.a,\"WatchDog timer called too early\"),jd(this,this.U-a))};function gd(a){a.i.Ka()||a.B||a.i.ta(a)}function fd(a){ad(a);var b=a.I;b&&\"function\"==typeof b.$&&b.$();a.I=null;Yb(a.S);ec(a.L);a.a&&(b=a.a,a.a=null,b.abort(),b.$())}\nfunction cd(a,b){try{a.i.Na(a,b),zc(4)}catch(c){xc(a.b,c,\"Error in httprequest callback\")}};function kd(a){if(a.A&&\"function\"==typeof a.A)return a.A();if(l(a))return a.split(\"\");if(ca(a)){for(var b=[],c=a.length,d=0;d<c;d++)b.push(a[d]);return b}return Da(a)}\nfunction ld(a,b){if(a.forEach&&\"function\"==typeof a.forEach)a.forEach(b,void 0);else if(ca(a)||l(a))ra(a,b,void 0);else{if(a.M&&\"function\"==typeof a.M)var c=a.M();else if(a.A&&\"function\"==typeof a.A)c=void 0;else if(ca(a)||l(a)){c=[];for(var d=a.length,e=0;e<d;e++)c.push(e)}else c=Ea(a);d=kd(a);e=d.length;for(var f=0;f<e;f++)b.call(void 0,d[f],c&&c[f],a)}};function O(a,b){this.b={};this.a=[];this.c=0;var c=arguments.length;if(1<c){if(c%2)throw Error(\"Uneven number of arguments\");for(var d=0;d<c;d+=2)this.set(arguments[d],arguments[d+1])}else if(a)if(a instanceof O)for(c=a.M(),d=0;d<c.length;d++)this.set(c[d],a.get(c[d]));else for(d in a)this.set(d,a[d])}g=O.prototype;g.A=function(){md(this);for(var a=[],b=0;b<this.a.length;b++)a.push(this.b[this.a[b]]);return a};g.M=function(){md(this);return this.a.concat()};\nfunction nd(a){a.b={};a.a.length=0;a.c=0}function od(a,b){return P(a.b,b)?(delete a.b[b],a.c--,a.a.length>2*a.c&&md(a),!0):!1}function md(a){if(a.c!=a.a.length){for(var b=0,c=0;b<a.a.length;){var d=a.a[b];P(a.b,d)&&(a.a[c++]=d);b++}a.a.length=c}if(a.c!=a.a.length){var e={};for(c=b=0;b<a.a.length;)d=a.a[b],P(e,d)||(a.a[c++]=d,e[d]=1),b++;a.a.length=c}}g.get=function(a,b){return P(this.b,a)?this.b[a]:b};g.set=function(a,b){P(this.b,a)||(this.c++,this.a.push(a));this.b[a]=b};\ng.forEach=function(a,b){for(var c=this.M(),d=0;d<c.length;d++){var e=c[d],f=this.get(e);a.call(b,f,e,this)}};function P(a,b){return Object.prototype.hasOwnProperty.call(a,b)};var pd=/^(?:([^:/?#.]+):)?(?:\\/\\/(?:([^/?#]*)@)?([^/#?]*?)(?::([0-9]+))?(?=[/#?]|$))?([^?#]+)?(?:\\?([^#]*))?(?:#([\\s\\S]*))?$/;function qd(a,b){if(a){a=a.split(\"&\");for(var c=0;c<a.length;c++){var d=a[c].indexOf(\"=\"),e=null;if(0<=d){var f=a[c].substring(0,d);e=a[c].substring(d+1)}else f=a[c];b(f,e?decodeURIComponent(e.replace(/\\+/g,\" \")):\"\")}}};function Q(a,b){this.b=this.j=this.f=\"\";this.i=null;this.g=this.a=\"\";this.h=!1;var c;a instanceof Q?(this.h=void 0!==b?b:a.h,rd(this,a.f),this.j=a.j,sd(this,a.b),td(this,a.i),this.a=a.a,ud(this,vd(a.c)),this.g=a.g):a&&(c=String(a).match(pd))?(this.h=!!b,rd(this,c[1]||\"\",!0),this.j=wd(c[2]||\"\"),sd(this,c[3]||\"\",!0),td(this,c[4]),this.a=wd(c[5]||\"\",!0),ud(this,c[6]||\"\",!0),this.g=wd(c[7]||\"\")):(this.h=!!b,this.c=new xd(null,this.h))}\nQ.prototype.toString=function(){var a=[],b=this.f;b&&a.push(yd(b,zd,!0),\":\");var c=this.b;if(c||\"file\"==b)a.push(\"//\"),(b=this.j)&&a.push(yd(b,zd,!0),\"@\"),a.push(encodeURIComponent(String(c)).replace(/%25([0-9a-fA-F]{2})/g,\"%$1\")),c=this.i,null!=c&&a.push(\":\",String(c));if(c=this.a)this.b&&\"/\"!=c.charAt(0)&&a.push(\"/\"),a.push(yd(c,\"/\"==c.charAt(0)?Ad:Bd,!0));(c=this.c.toString())&&a.push(\"?\",c);(c=this.g)&&a.push(\"#\",yd(c,Cd));return a.join(\"\")};\nQ.prototype.resolve=function(a){var b=M(this),c=!!a.f;c?rd(b,a.f):c=!!a.j;c?b.j=a.j:c=!!a.b;c?sd(b,a.b):c=null!=a.i;var d=a.a;if(c)td(b,a.i);else if(c=!!a.a){if(\"/\"!=d.charAt(0))if(this.b&&!this.a)d=\"/\"+d;else{var e=b.a.lastIndexOf(\"/\");-1!=e&&(d=b.a.substr(0,e+1)+d)}e=d;if(\"..\"==e||\".\"==e)d=\"\";else if(-1!=e.indexOf(\"./\")||-1!=e.indexOf(\"/.\")){d=0==e.lastIndexOf(\"/\",0);e=e.split(\"/\");for(var f=[],h=0;h<e.length;){var m=e[h++];\".\"==m?d&&h==e.length&&f.push(\"\"):\"..\"==m?((1<f.length||1==f.length&&\"\"!=\nf[0])&&f.pop(),d&&h==e.length&&f.push(\"\")):(f.push(m),d=!0)}d=f.join(\"/\")}else d=e}c?b.a=d:c=\"\"!==a.c.toString();c?ud(b,vd(a.c)):c=!!a.g;c&&(b.g=a.g);return b};function M(a){return new Q(a)}function rd(a,b,c){a.f=c?wd(b,!0):b;a.f&&(a.f=a.f.replace(/:$/,\"\"))}function sd(a,b,c){a.b=c?wd(b,!0):b}function td(a,b){if(b){b=Number(b);if(isNaN(b)||0>b)throw Error(\"Bad port number \"+b);a.i=b}else a.i=null}function ud(a,b,c){b instanceof xd?(a.c=b,Dd(a.c,a.h)):(c||(b=yd(b,Ed)),a.c=new xd(b,a.h))}\nfunction R(a,b,c){a.c.set(b,c)}function Zc(a,b,c){n(c)||(c=[String(c)]);Fd(a.c,b,c)}function Vc(a){R(a,\"zx\",Math.floor(2147483648*Math.random()).toString(36)+Math.abs(Math.floor(2147483648*Math.random())^r()).toString(36));return a}function Gd(a){return a instanceof Q?M(a):new Q(a,void 0)}function Hd(a,b,c,d){var e=new Q(null,void 0);a&&rd(e,a);b&&sd(e,b);c&&td(e,c);d&&(e.a=d);return e}function wd(a,b){return a?b?decodeURI(a.replace(/%25/g,\"%2525\")):decodeURIComponent(a):\"\"}\nfunction yd(a,b,c){return l(a)?(a=encodeURI(a).replace(b,Id),c&&(a=a.replace(/%25([0-9a-fA-F]{2})/g,\"%$1\")),a):null}function Id(a){a=a.charCodeAt(0);return\"%\"+(a>>4&15).toString(16)+(a&15).toString(16)}var zd=/[#\\/\\?@]/g,Bd=/[#\\?:]/g,Ad=/[#\\?]/g,Ed=/[#\\?@]/g,Cd=/#/g;function xd(a,b){this.b=this.a=null;this.c=a||null;this.f=!!b}function S(a){a.a||(a.a=new O,a.b=0,a.c&&qd(a.c,function(b,c){a.add(decodeURIComponent(b.replace(/\\+/g,\" \")),c)}))}g=xd.prototype;\ng.add=function(a,b){S(this);this.c=null;a=Jd(this,a);var c=this.a.get(a);c||this.a.set(a,c=[]);c.push(b);this.b+=1;return this};function Kd(a,b){S(a);b=Jd(a,b);P(a.a.b,b)&&(a.c=null,a.b-=a.a.get(b).length,od(a.a,b))}function Ld(a,b){S(a);b=Jd(a,b);return P(a.a.b,b)}g.forEach=function(a,b){S(this);this.a.forEach(function(c,d){ra(c,function(c){a.call(b,c,d,this)},this)},this)};\ng.M=function(){S(this);for(var a=this.a.A(),b=this.a.M(),c=[],d=0;d<b.length;d++)for(var e=a[d],f=0;f<e.length;f++)c.push(b[d]);return c};g.A=function(a){S(this);var b=[];if(l(a))Ld(this,a)&&(b=va(b,this.a.get(Jd(this,a))));else{a=this.a.A();for(var c=0;c<a.length;c++)b=va(b,a[c])}return b};g.set=function(a,b){S(this);this.c=null;a=Jd(this,a);Ld(this,a)&&(this.b-=this.a.get(a).length);this.a.set(a,[b]);this.b+=1;return this};g.get=function(a,b){a=a?this.A(a):[];return 0<a.length?String(a[0]):b};\nfunction Fd(a,b,c){Kd(a,b);0<c.length&&(a.c=null,a.a.set(Jd(a,b),wa(c)),a.b+=c.length)}g.toString=function(){if(this.c)return this.c;if(!this.a)return\"\";for(var a=[],b=this.a.M(),c=0;c<b.length;c++){var d=b[c],e=encodeURIComponent(String(d));d=this.A(d);for(var f=0;f<d.length;f++){var h=e;\"\"!==d[f]&&(h+=\"=\"+encodeURIComponent(String(d[f])));a.push(h)}}return this.c=a.join(\"&\")};function vd(a){var b=new xd;b.c=a.c;a.a&&(b.a=new O(a.a),b.b=a.b);return b}\nfunction Jd(a,b){b=String(b);a.f&&(b=b.toLowerCase());return b}function Dd(a,b){b&&!a.f&&(S(a),a.c=null,a.a.forEach(function(a,b){var c=b.toLowerCase();b!=c&&(Kd(this,b),Fd(this,c,a))},a));a.f=b};function Md(){this.a=r()}var Nd=null;Md.prototype.set=function(a){this.a=a};Md.prototype.reset=function(){this.set(r())};Md.prototype.get=function(){return this.a};function Od(){Nd||(Nd=new Md)}function Pd(){Nd||(Nd=new Md)}t(Pd,Od);function Qd(a,b){this.a=a;this.b=b;this.c=this.i=null;this.h=!1;this.m=null;this.f=-1;this.l=this.g=null}g=Qd.prototype;g.P=null;\nfunction Rd(a){G(a.b,\"TestConnection: starting stage 2\");var b=a.a.I.a;if(null!=b)G(a.b,function(){return\"TestConnection: skipping stage 2, precomputed result is \"+b?\"Buffered\":\"Unbuffered\"}),K(4),b?(K(10),Sd(a.a,a,!1)):(K(11),Sd(a.a,a,!0));else{a.c=new L(a,a.b,void 0,void 0);a.c.j=a.i;var c=Td(a.a,a.g,a.m);K(4);Zc(c,\"TYPE\",\"xmlhttp\");var d=a.a.j,e=a.a.K;d&&e&&R(c,d,e);Xc(a.c,c,!1,a.g)}}g.ca=function(a){return this.a.ca(a)};g.abort=function(){this.c&&(this.c.cancel(),this.c=null);this.f=-1};\ng.Ka=function(){return!1};\ng.Na=function(a,b){this.f=a.C;if(0==this.P){G(this.b,\"TestConnection: Got data for stage 1\");if(!this.a.o&&(a=a.a)){var c=hd(a,\"X-Client-Wire-Protocol\");this.l=c?c:null;this.a.j&&((a=hd(a,\"X-HTTP-Session-Id\"))?this.a.K=a:C(this.b.a,\"Missing X_HTTP_SESSION_ID in the handshake response\"))}if(b){try{var d=this.a.la.a.parse(b)}catch(e){xc(this.b,e);Ud(this.a,this);return}this.g=d[0]}else G(this.b,\"TestConnection: Null responseText\"),Ud(this.a,this)}else if(1==this.P)if(this.h)K(6);else if(\"11111\"==b){if(K(5),\nthis.h=!0,!y||10<=Number(Wa))this.f=200,this.c.cancel(),G(this.b,\"Test connection succeeded; using streaming connection\"),K(11),Sd(this.a,this,!0)}else K(7),this.h=!1};\ng.ta=function(){this.f=this.c.C;this.c.f?0==this.P?(this.P=1,G(this.b,\"TestConnection: request complete for initial check\"),Rd(this)):1==this.P&&(G(this.b,\"TestConnection: request complete for stage 2\"),this.h?(G(this.b,\"Test connection succeeded; using streaming connection\"),K(11),Sd(this.a,this,!0)):(G(this.b,\"Test connection failed; not using streaming\"),K(10),Sd(this.a,this,!1))):(G(this.b,\"TestConnection: request failed, in state \"+this.P),0==this.P?K(8):1==this.P&&K(9),Ud(this.a,this))};\ng.ia=function(){return this.a.ia()};g.qa=function(){return this.a.qa()};function Vd(){this.a=this.b=null};function Wd(){this.a=new O}function Xd(a){var b=typeof a;return\"object\"==b&&a||\"function\"==b?\"o\"+(a[p]||(a[p]=++fa)):b.charAt(0)+a}Wd.prototype.add=function(a){this.a.set(Xd(a),a)};Wd.prototype.A=function(){return this.a.A()};function Yd(a,b){this.a=a;this.b=b};function Zd(a){this.g=a||$d;this.f=k.oa&&k.oa.La&&k.oa.La()&&k.oa.La().Fb?this.g:1;this.a=null;1<this.f&&(this.a=new Wd);this.b=null;this.c=[]}var $d=10;function ae(a,b){a.a||-1==b.indexOf(\"spdy\")&&-1==b.indexOf(\"quic\")&&-1==b.indexOf(\"h2\")||(a.f=a.g,a.a=new Wd,a.b&&(be(a,a.b),a.b=null))}function ce(a){return a.b?!0:a.a?a.a.a.c>=a.f:!1}function de(a,b){a.b?a=a.b==b:a.a?(b=Xd(b),a=P(a.a.a.b,b)):a=!1;return a}function be(a,b){a.a?a.a.add(b):a.b=b}\nfunction ee(a,b){if(a.b&&a.b==b)a.b=null;else{var c;if(c=a.a)c=Xd(b),c=P(a.a.a.b,c);c&&od(a.a.a,Xd(b))}}Zd.prototype.cancel=function(){this.c=fe(this);this.b?(this.b.cancel(),this.b=null):this.a&&0!=this.a.a.c&&(ra(this.a.A(),function(a){a.cancel()}),nd(this.a.a))};function fe(a){if(null!=a.b)return a.c.concat(a.b.u);if(null!=a.a&&0!=a.a.a.c){var b=a.c;ra(a.a.A(),function(a){b=b.concat(a.u)});return b}return wa(a.c)}function ge(a,b){a.c=a.c.concat(b)};function he(){}he.prototype.stringify=function(a){return k.JSON.stringify(a,void 0)};he.prototype.parse=function(a){return k.JSON.parse(a,void 0)};function ie(){this.a=new he}function je(a,b,c){var d=c||\"\";try{ld(a,function(a,c){var e=a;ea(a)&&(e=Db(a));b.push(d+c+\"=\"+encodeURIComponent(e))})}catch(e){throw b.push(d+\"type=\"+encodeURIComponent(\"_badmap\")),e;}};function ke(a,b){var c=new sc;G(c,\"TestLoadImage: loading \"+a);var d=new Image;d.onload=ja(le,c,d,\"TestLoadImage: loaded\",!0,b);d.onerror=ja(le,c,d,\"TestLoadImage: error\",!1,b);d.onabort=ja(le,c,d,\"TestLoadImage: abort\",!1,b);d.ontimeout=ja(le,c,d,\"TestLoadImage: timeout\",!1,b);k.setTimeout(function(){if(d.ontimeout)d.ontimeout()},1E4);d.src=a}function le(a,b,c,d,e){try{G(a,c),b.onload=null,b.onerror=null,b.onabort=null,b.ontimeout=null,e(d)}catch(f){xc(a,f)}};function T(a){A.call(this);this.headers=new O;this.D=a||null;this.c=!1;this.v=this.a=null;this.K=this.u=\"\";this.j=0;this.g=\"\";this.h=this.I=this.s=this.G=!1;this.l=0;this.B=null;this.L=me;this.C=this.o=!1}t(T,A);var me=\"\";T.prototype.b=qc(\"goog.net.XhrIo\");var ne=/^https?$/i,oe=[\"POST\",\"PUT\"];g=T.prototype;\ng.fa=function(a,b,c,d){if(this.a)throw Error(\"[goog.net.XhrIo] Object is active with another request=\"+this.u+\"; newUri=\"+a);b=b?b.toUpperCase():\"GET\";this.u=a;this.g=\"\";this.j=0;this.K=b;this.G=!1;this.c=!0;this.a=this.D?Pc(this.D):Pc(Nc);this.v=this.D?Lc(this.D):Lc(Nc);this.a.onreadystatechange=q(this.Ma,this);try{D(this.b,U(this,\"Opening Xhr\")),this.I=!0,this.a.open(b,String(a),!0),this.I=!1}catch(f){D(this.b,U(this,\"Error opening Xhr: \"+f.message));pe(this,f);return}a=c||\"\";var e=new O(this.headers);\nd&&ld(d,function(a,b){e.set(b,a)});d=sa(e.M());c=k.FormData&&a instanceof k.FormData;!(0<=qa(oe,b))||d||c||e.set(\"Content-Type\",\"application/x-www-form-urlencoded;charset=utf-8\");e.forEach(function(a,b){this.a.setRequestHeader(b,a)},this);this.L&&(this.a.responseType=this.L);\"withCredentials\"in this.a&&this.a.withCredentials!==this.o&&(this.a.withCredentials=this.o);try{qe(this),0<this.l&&(this.C=re(this.a),D(this.b,U(this,\"Will abort after \"+this.l+\"ms if incomplete, xhr2 \"+this.C)),this.C?(this.a.timeout=\nthis.l,this.a.ontimeout=q(this.Ja,this)):this.B=Zb(this.Ja,this.l,this)),D(this.b,U(this,\"Sending request\")),this.s=!0,this.a.send(a),this.s=!1}catch(f){D(this.b,U(this,\"Send error: \"+f.message)),pe(this,f)}};function re(a){return y&&Va(9)&&\"number\"==typeof a.timeout&&void 0!==a.ontimeout}function ta(a){return\"content-type\"==a.toLowerCase()}\ng.Ja=function(){\"undefined\"!=typeof goog&&this.a&&(this.g=\"Timed out after \"+this.l+\"ms, aborting\",this.j=8,D(this.b,U(this,this.g)),this.dispatchEvent(\"timeout\"),this.abort(8))};function pe(a,b){a.c=!1;a.a&&(a.h=!0,a.a.abort(),a.h=!1);a.g=b;a.j=5;se(a);te(a)}function se(a){a.G||(a.G=!0,a.dispatchEvent(\"complete\"),a.dispatchEvent(\"error\"))}\ng.abort=function(a){this.a&&this.c&&(D(this.b,U(this,\"Aborting\")),this.c=!1,this.h=!0,this.a.abort(),this.h=!1,this.j=a||7,this.dispatchEvent(\"complete\"),this.dispatchEvent(\"abort\"),te(this))};g.w=function(){this.a&&(this.c&&(this.c=!1,this.h=!0,this.a.abort(),this.h=!1),te(this,!0));T.H.w.call(this)};g.Ma=function(){this.i||(this.I||this.s||this.h?ue(this):this.eb())};g.eb=function(){ue(this)};\nfunction ue(a){if(a.c&&\"undefined\"!=typeof goog)if(a.v[1]&&4==N(a)&&2==a.W())D(a.b,U(a,\"Local request error detected and ignored\"));else if(a.s&&4==N(a))Zb(a.Ma,0,a);else if(a.dispatchEvent(\"readystatechange\"),4==N(a)){D(a.b,U(a,\"Request complete\"));a.c=!1;try{var b=a.W();a:switch(b){case 200:case 201:case 202:case 204:case 206:case 304:case 1223:var c=!0;break a;default:c=!1}var d;if(!(d=c)){var e;if(e=0===b){var f=String(a.u).match(pd)[1]||null;if(!f&&k.self&&k.self.location){var h=k.self.location.protocol;\nf=h.substr(0,h.length-1)}e=!ne.test(f?f.toLowerCase():\"\")}d=e}d?(a.dispatchEvent(\"complete\"),a.dispatchEvent(\"success\")):(a.j=6,a.g=a.Ga()+\" [\"+a.W()+\"]\",se(a))}finally{te(a)}}}function te(a,b){if(a.a){qe(a);var c=a.a,d=a.v[0]?aa:null;a.a=null;a.v=null;b||a.dispatchEvent(\"ready\");try{c.onreadystatechange=d}catch(e){(a=a.b)&&a.log(ic,\"Problem encountered resetting onreadystatechange: \"+e.message,void 0)}}}function qe(a){a.a&&a.C&&(a.a.ontimeout=null);a.B&&(k.clearTimeout(a.B),a.B=null)}\nfunction N(a){return a.a?a.a.readyState:0}g.W=function(){try{return 2<N(this)?this.a.status:-1}catch(a){return-1}};g.Ga=function(){try{return 2<N(this)?this.a.statusText:\"\"}catch(a){return D(this.b,\"Can not get status: \"+a.message),\"\"}};g.V=function(){try{return this.a?this.a.responseText:\"\"}catch(a){return D(this.b,\"Can not get responseText: \"+a.message),\"\"}};\ng.Za=function(a){if(this.a){var b=this.a.responseText;a&&0==b.indexOf(a)&&(b=b.substring(a.length));a:{a=b;if(k.JSON)try{var c=k.JSON.parse(a);break a}catch(d){}c=Cb(a)}return c}};function hd(a,b){return a.a?a.a.getResponseHeader(b):null}g.Fa=function(){return this.j};g.bb=function(){return l(this.g)?this.g:String(this.g)};function U(a,b){return b+\" [\"+a.K+\" \"+a.u+\" \"+a.W()+\"]\"};function ve(a){var b=\"\";Ca(a,function(a,d){b+=d;b+=\":\";b+=a;b+=\"\\r\\n\"});return b}function we(a,b,c){a:{for(d in c){var d=!1;break a}d=!0}if(d)return a;c=ve(c);if(l(a)){b=encodeURIComponent(String(b));c=null!=c?\"=\"+encodeURIComponent(String(c)):\"\";if(b+=c){c=a.indexOf(\"#\");0>c&&(c=a.length);d=a.indexOf(\"?\");if(0>d||d>c){d=c;var e=\"\"}else e=a.substring(d+1,c);a=[a.substr(0,d),e,a.substr(c)];c=a[1];a[1]=b?c?c+\"&\"+b:b:c;a=a[0]+(a[1]?\"?\"+a[1]:\"\")+a[2]}return a}R(a,b,c);return a};function xe(a){this.xa=0;this.g=[];this.a=new sc;this.I=new Vd;this.X=this.ua=this.D=this.ja=this.b=this.K=this.j=this.U=this.h=this.L=this.i=null;this.Va=this.R=0;this.Ua=a&&a.Eb||!1;this.ka=this.C=this.s=this.l=this.m=this.f=null;this.u=this.wa=this.N=-1;this.T=this.B=this.v=0;this.G=void 0;this.S=a&&a.supportsCrossDomainXhr||!1;this.J=\"\";this.c=new Zd(a&&a.concurrentRequestLimit);this.la=new ie;this.o=a&&void 0!==a.backgroundChannelTest?a.backgroundChannelTest:!0;(this.va=a&&a.fastHandshake||!1)&&\n!this.o&&(C(this.a.a,\"Force backgroundChannelTest when fastHandshake is enabled.\"),this.o=!0);a&&a.Ea&&this.a.Ea()}g=xe.prototype;g.na=8;g.F=1;\nfunction ye(a){G(a.a,\"disconnect()\");ze(a);if(3==a.F){var b=a.R++,c=M(a.D);R(c,\"SID\",a.J);R(c,\"RID\",b);R(c,\"TYPE\",\"terminate\");Ae(a,c);b=new L(a,a.a,b,void 0);b.J=2;b.h=Vc(M(c));c=!1;k.navigator&&k.navigator.sendBeacon&&(c=k.navigator.sendBeacon(b.h.toString(),\"\"));!c&&k.Image&&((new Image).src=b.h,c=!0);c||(b.a=b.i.ca(null),b.a.fa(b.h));b.D=r();Yc(b)}Be(a)}\nfunction ze(a){a.C&&(a.C.abort(),a.C=null);a.b&&(a.b.cancel(),a.b=null);a.l&&(k.clearTimeout(a.l),a.l=null);Ce(a);a.c.cancel();a.m&&(k.clearTimeout(a.m),a.m=null)}function De(a,b){1E3==a.g.length&&H(a.a,function(){return\"Already have 1000 queued maps upon queueing \"+Db(b)});a.g.push(new Yd(a.Va++,b));3==a.F&&Ee(a)}g.Ka=function(){return 0==this.F};function Ee(a){ce(a.c)||a.m||(a.m=Dc(q(a.Pa,a),0),a.v=0)}\nfunction Fe(a,b){var c=a.c;if((c.b?1:c.a?c.a.a.c:0)>=a.c.f-(a.m?1:0))return H(a.a,\"Unexpected retry request is scheduled.\"),!1;if(a.m)return G(a.a,\"Use the retry request that is already scheduled.\"),a.g=b.u.concat(a.g),!0;if(1==a.F||2==a.F||a.v>=(a.Ua?0:2))return!1;G(a.a,\"Going to retry POST\");a.m=Dc(q(a.Pa,a,b),Ge(a,a.v));a.v++;return!0}\ng.Pa=function(a){this.m=null;G(this.a,\"startForwardChannel_\");if(1==this.F)if(a)H(this.a,\"Not supposed to retry the open\");else{G(this.a,\"open_()\");this.R=Math.floor(1E5*Math.random());a=this.R++;var b=new L(this,this.a,a,void 0),c=this.i;this.L&&(c?(c=Fa(c),Ha(c,this.L)):c=this.L);null===this.h&&(b.j=c);var d=He(this,b),e=M(this.D);R(e,\"RID\",a);R(e,\"CVER\",22);this.o&&this.j&&R(e,\"X-HTTP-Session-Id\",this.j);Ae(this,e);this.h&&c&&we(e,this.h,c);be(this.c,b);this.va?(R(e,\"$req\",d),R(e,\"SID\",\"null\"),\nb.X=!0,Uc(b,e,null)):Uc(b,e,d);this.F=2}else 3==this.F&&(a?Ie(this,a):0==this.g.length?G(this.a,\"startForwardChannel_ returned: nothing to send\"):ce(this.c)?H(this.a,\"startForwardChannel_ returned: connection already in progress\"):(Ie(this),G(this.a,\"startForwardChannel_ finished, sent request\")))};\nfunction Ie(a,b){var c;b?c=b.c:c=a.R++;var d=M(a.D);R(d,\"SID\",a.J);R(d,\"RID\",c);R(d,\"AID\",a.N);Ae(a,d);a.h&&a.i&&we(d,a.h,a.i);c=new L(a,a.a,c,a.v+1);null===a.h&&(c.j=a.i);b&&(a.g=b.u.concat(a.g));b=He(a,c);c.setTimeout(1E4+Math.round(1E4*Math.random()));be(a.c,c);Uc(c,d,b)}function Ae(a,b){a.f&&ld({},function(a,d){R(b,d,a)})}\nfunction He(a,b){var c=Math.min(a.g.length,1E3),d=a.f?q(a.f.Wa,a.f,a):null;a:for(var e=a.g,f=-1;;){var h=[\"count=\"+c];-1==f?0<c?(f=e[0].a,h.push(\"ofs=\"+f)):f=0:h.push(\"ofs=\"+f);for(var m=!0,v=0;v<c;v++){var I=e[v].a,W=e[v].b;I-=f;if(0>I)f=Math.max(0,e[v].a-100),m=!1;else try{je(W,h,\"req\"+I+\"_\")}catch(Lb){d&&d(W)}}if(m){d=h.join(\"&\");break a}}a=a.g.splice(0,c);b.u=a;return d}function Je(a){if(!a.b&&!a.l){a.T=1;var b=a.Oa;Tb||Ub();Wb||(Tb(),Wb=!0);Pb.add(b,a);a.B=0}}\nfunction Ke(a){if(a.b||a.l)return H(a.a,\"Request already in progress\"),!1;if(3<=a.B)return!1;G(a.a,\"Going to retry GET\");a.T++;a.l=Dc(q(a.Oa,a),Ge(a,a.B));a.B++;return!0}\ng.Oa=function(){this.l=null;G(this.a,\"Creating new HttpRequest\");this.b=new L(this,this.a,\"rpc\",this.T);null===this.h&&(this.b.j=this.i);this.b.N=0;var a=M(this.ua);R(a,\"RID\",\"rpc\");R(a,\"SID\",this.J);R(a,\"CI\",this.ka?\"0\":\"1\");R(a,\"AID\",this.N);Ae(this,a);R(a,\"TYPE\",\"xmlhttp\");this.h&&this.i&&we(a,this.h,this.i);this.G&&this.b.setTimeout(this.G);Xc(this.b,a,!0,this.X);G(this.a,\"New Request created\")};\nfunction Sd(a,b,c){G(a.a,\"Test Connection Finished\");var d=b.l;d&&ae(a.c,d);a.ka=c;a.u=b.f;G(a.a,\"connectChannel_()\");a.D=Le(a,a.ja);Ee(a)}function Ud(a,b){G(a.a,\"Test Connection Failed\");a.u=b.f;V(a,2)}\ng.Na=function(a,b){if(0!=this.F&&(this.b==a||de(this.c,a)))if(this.u=a.C,!a.v&&de(this.c,a)&&3==this.F){try{var c=this.la.a.parse(b)}catch(f){c=null}if(n(c)&&3==c.length)if(b=c,0==b[0])a:if(G(this.a,\"Server claims our backchannel is missing.\"),this.l)G(this.a,\"But we are currently starting the request.\");else{if(this.b)if(this.b.D+3E3<a.D)Ce(this),this.b.cancel(),this.b=null;else break a;else C(this.a.a,\"We do not have a BackChannel established\");Ke(this);K(18)}else this.wa=b[1],a=this.wa-this.N,\n0<a&&(b=b[2],G(this.a,b+\" bytes (in \"+a+\" arrays) are outstanding on the BackChannel\"),37500>b&&this.ka&&0==this.B&&!this.s&&(this.s=Dc(q(this.cb,this),6E3)));else G(this.a,\"Bad POST response data returned\"),V(this,11)}else if((a.v||this.b==a)&&Ce(this),!xa(b))for(b=c=this.la.a.parse(b),c=0;c<b.length;c++){var d=b[c];this.N=d[0];d=d[1];if(2==this.F)if(\"c\"==d[0]){this.J=d[1];this.X=d[2];var e=d[3];null!=e&&(this.na=e,E(this.a,\"VER=\"+this.na));e=d[4];null!=e&&(this.xa=e,E(this.a,\"SVER=\"+this.xa));d=\nd[5];null!=d&&\"number\"==typeof d&&0<d&&(this.G=d*=1.5,E(this.a,\"backChannelRequestTimeoutMs_=\"+d));this.o&&(d=a.a)&&((e=hd(d,\"X-Client-Wire-Protocol\"))&&ae(this.c,e),this.j&&((d=hd(d,\"X-HTTP-Session-Id\"))?(this.K=d,R(this.D,this.j,d)):C(this.a.a,\"Missing X_HTTP_SESSION_ID in the handshake response\")));this.F=3;this.f&&this.f.Ca();d=a;this.ua=Td(this,this.X,this.ja);d.v?(G(this.a,\"Upgrade the handshake request to a backchannel.\"),ee(this.c,d),(e=this.G)&&d.setTimeout(e),d.s&&(ad(d),Yc(d)),this.b=d):\nJe(this)}else\"stop\"!=d[0]&&\"close\"!=d[0]||V(this,7);else 3==this.F&&(\"stop\"==d[0]||\"close\"==d[0]?\"stop\"==d[0]?V(this,7):ye(this):\"noop\"!=d[0]&&this.f&&this.f.Ba(d),this.B=0)}};g.cb=function(){null!=this.s&&(this.s=null,this.b.cancel(),this.b=null,Ke(this),K(19))};function Ce(a){null!=a.s&&(k.clearTimeout(a.s),a.s=null)}\ng.ta=function(a){G(this.a,\"Request complete\");var b=null;if(this.b==a){Ce(this);this.b=null;var c=2}else if(de(this.c,a))b=a.u,ee(this.c,a),c=1;else return;this.u=a.C;if(0!=this.F)if(a.f)1==c?(Cc(a.l?a.l.length:0,r()-a.D,this.v),Ee(this)):Je(this);else{var d=a.m;if(3==d||0==d&&0<this.u)G(this.a,\"Not retrying due to error type\");else{var e=this;G(this.a,function(){return\"Maybe retrying, last error: \"+Rc(d,e.u)});if(1==c&&Fe(this,a)||2==c&&Ke(this))return;G(this.a,\"Exceeded max number of retries\")}b&&\n0<b.length&&ge(this.c,b);G(this.a,\"Error: HTTP request failed\");switch(d){case 1:V(this,5);break;case 4:V(this,10);break;case 3:V(this,6);break;default:V(this,2)}}};function Ge(a,b){var c=5E3+Math.floor(1E4*Math.random());a.qa()||(G(a.a,\"Inactive channel\"),c*=2);return c*b}\nfunction V(a,b){E(a.a,\"Error code \"+b);if(2==b){var c=null;a.f&&(c=null);var d=q(a.kb,a);c||(c=new Q(\"//www.google.com/images/cleardot.gif\"),k.location&&\"http\"==k.location.protocol||rd(c,\"https\"),Vc(c));ke(c.toString(),d)}else K(2);G(a.a,\"HttpChannel: error - \"+b);a.F=0;a.f&&a.f.Aa(b);Be(a);ze(a)}g.kb=function(a){a?(E(this.a,\"Successfully pinged google.com\"),K(2)):(E(this.a,\"Failed to ping google.com\"),K(1))};\nfunction Be(a){a.F=0;a.u=-1;if(a.f){var b=fe(a.c);if(0!=b.length||0!=a.g.length)G(a.a,function(){return\"Number of undelivered maps, pending: \"+b.length+\", outgoing: \"+a.g.length}),a.c.c.length=0,wa(a.g),a.g.length=0;a.f.za()}}function Le(a,b){b=Me(a,null,b);G(a.a,\"GetForwardChannelUri: \"+b);return b}function Td(a,b,c){b=Me(a,a.ia()?b:null,c);G(a.a,\"GetBackChannelUri: \"+b);return b}\nfunction Me(a,b,c){var d=Gd(c);if(\"\"!=d.b)b&&sd(d,b+\".\"+d.b),td(d,d.i);else{var e=k.location,f;b?f=b+\".\"+e.hostname:f=e.hostname;d=Hd(e.protocol,f,e.port,c)}a.U&&Ca(a.U,function(a,b){R(d,b,a)});b=a.j;c=a.K;b&&c&&R(d,b,c);R(d,\"VER\",a.na);Ae(a,d);return d}g.ca=function(a){if(a&&!this.S)throw Error(\"Can't create secondary domain capable XhrIo object.\");a=new T;a.o=this.S;return a};g.qa=function(){return!!this.f&&!0};g.ia=function(){return this.S};new Pd;function Ne(){}g=Ne.prototype;g.Ca=function(){};\ng.Ba=function(){};g.Aa=function(){};g.za=function(){};g.Wa=function(){};function Oe(a){for(var b=arguments[0],c=1;c<arguments.length;c++){var d=arguments[c];if(0==d.lastIndexOf(\"/\",0))b=d;else{var e;(e=\"\"==b)||(e=b.length-1,e=0<=e&&b.indexOf(\"/\",e)==e);e?b+=d:b+=\"/\"+d}}return b};function Pe(){if(y&&!(10<=Number(Wa)))throw Error(\"Environmental error: no available transport.\");}Pe.prototype.a=function(a,b){return new X(a,b)};\nfunction X(a,b){A.call(this);this.a=new xe(b);this.b=a;this.o=b&&b.testUrl?b.testUrl:Oe(this.b,\"test\");this.c=qc(\"goog.labs.net.webChannel.WebChannelBaseTransport\");this.g=b&&b.messageUrlParams||null;a=b&&b.messageHeaders||null;b&&b.clientProtocolHeaderRequired&&(a?a[\"X-Client-Protocol\"]=\"webchannel\":a={\"X-Client-Protocol\":\"webchannel\"});this.a.i=a;a=b&&b.initMessageHeaders||null;b&&b.messageContentType&&(a?a[\"X-WebChannel-Content-Type\"]=b.messageContentType:a={\"X-WebChannel-Content-Type\":b.messageContentType});\nb&&b.Da&&(a?a[\"X-WebChannel-Client-Profile\"]=b.Da:a={\"X-WebChannel-Client-Profile\":b.Da});this.a.L=a;(a=b&&b.httpHeadersOverwriteParam)&&!xa(a)&&(this.a.h=a);this.l=b&&b.supportsCrossDomainXhr||!1;this.j=b&&b.sendRawJson||!1;(b=b&&b.httpSessionIdParam)&&!xa(b)&&(this.a.j=b,a=this.g,null!==a&&b in a&&(a=this.g,b in a&&delete a[b],C(this.c,\"Ignore httpSessionIdParam also specified with messageUrlParams: \"+b)));this.h=new Qe(this)}t(X,A);g=X.prototype;\ng.addEventListener=function(a,b,c,d){X.H.addEventListener.call(this,a,b,c,d)};g.removeEventListener=function(a,b,c,d){X.H.removeEventListener.call(this,a,b,c,d)};\ng.$a=function(){this.a.f=this.h;this.l&&(this.a.S=!0);var a=this.a,b=this.o,c=this.b,d=this.g||void 0;G(a.a,\"connect()\");K(0);a.ja=c;a.U=d||{};a.o&&(G(a.a,\"connect() bypassed channel-test.\"),a.I.b=[],a.I.a=!1);G(a.a,\"connectTest_()\");a.C=new Qd(a,a.a);null===a.h&&(a.C.i=a.i);c=b;a.h&&a.i&&(c=we(b,a.h,a.i));a=a.C;a.m=c;b=Le(a.a,a.m);K(3);c=a.a.I.b;null!=c?(a.g=c[0],a.P=1,Rd(a)):(Zc(b,\"MODE\",\"init\"),!a.a.o&&a.a.j&&Zc(b,\"X-HTTP-Session-Id\",a.a.j),a.c=new L(a,a.b,void 0,void 0),a.c.j=a.i,Xc(a.c,b,!1,\nnull),a.P=0)};g.close=function(){ye(this.a)};g.ab=function(a){if(l(a)){var b={};b.__data__=a;De(this.a,b)}else this.j?(b={},b.__data__=Db(a),De(this.a,b)):De(this.a,a)};g.w=function(){this.a.f=null;delete this.h;ye(this.a);delete this.a;X.H.w.call(this)};function Re(a){Ic.call(this);var b=a.__sm__;if(b){a:{for(var c in b){a=c;break a}a=void 0}(this.c=a)?(a=this.c,this.data=null!==b&&a in b?b[a]:void 0):this.data=b}else this.data=a}t(Re,Ic);function Se(){Jc.call(this);this.status=1}t(Se,Jc);\nfunction Qe(a){this.a=a}t(Qe,Ne);Qe.prototype.Ca=function(){rc(this.a.c,\"WebChannel opened on \"+this.a.b);this.a.dispatchEvent(\"a\")};Qe.prototype.Ba=function(a){this.a.dispatchEvent(new Re(a))};Qe.prototype.Aa=function(a){rc(this.a.c,\"WebChannel aborted on \"+this.a.b+\" due to channel error: \"+a);this.a.dispatchEvent(new Se(a))};Qe.prototype.za=function(){rc(this.a.c,\"WebChannel closed on \"+this.a.b);this.a.dispatchEvent(\"b\")};var Te=ja(function(a,b){function c(){}c.prototype=a.prototype;var d=new c;a.apply(d,Array.prototype.slice.call(arguments,1));return d},Pe);function Ue(){this.b=[];this.a=[]}function Ve(a){0==a.b.length&&(a.b=a.a,a.b.reverse(),a.a=[]);return a.b.pop()}function We(a){return a.b.length+a.a.length}Ue.prototype.A=function(){for(var a=[],b=this.b.length-1;0<=b;--b)a.push(this.b[b]);var c=this.a.length;for(b=0;b<c;++b)a.push(this.a[b]);return a};function Xe(a,b){u.call(this);this.h=a||0;this.c=b||10;if(this.h>this.c)throw Error(Ye);this.a=new Ue;this.b=new Wd;this.g=null;this.aa()}t(Xe,u);var Ye=\"[goog.structs.Pool] Min can not be greater than max\";g=Xe.prototype;g.da=function(){var a=r();if(!(null!=this.g&&0>a-this.g)){for(var b;0<We(this.a)&&(b=Ve(this.a),!this.sa(b));)this.aa();!b&&Ze(this)<this.c&&(b=this.pa());b&&(this.g=a,this.b.add(b));return b}};g.jb=function(a){return od(this.b.a,Xd(a))?(this.ma(a),!0):!1};\ng.ma=function(a){od(this.b.a,Xd(a));this.sa(a)&&Ze(this)<this.c?this.a.a.push(a):$e(a)};g.aa=function(){for(var a=this.a;Ze(this)<this.h;){var b=this.pa();a.a.push(b)}for(;Ze(this)>this.c&&0<We(this.a);)$e(Ve(a))};g.pa=function(){return{}};function $e(a){if(\"function\"==typeof a.$)a.$();else for(var b in a)a[b]=null}g.sa=function(a){return\"function\"==typeof a.Xa?a.Xa():!0};function Ze(a){return We(a.a)+a.b.a.c}\ng.w=function(){Xe.H.w.call(this);if(0<this.b.a.c)throw Error(\"[goog.structs.Pool] Objects not released\");delete this.b;for(var a=this.a;0!=a.b.length||0!=a.a.length;)$e(Ve(a));delete this.a};function af(a,b){this.a=a;this.b=b};function bf(a){this.a=[];if(a)a:{if(a instanceof bf){var b=a.M();a=a.A();if(0>=this.a.length){for(var c=this.a,d=0;d<b.length;d++)c.push(new af(b[d],a[d]));break a}}else b=Ea(a),a=Da(a);for(d=0;d<b.length;d++)cf(this,b[d],a[d])}}function cf(a,b,c){var d=a.a;d.push(new af(b,c));b=d.length-1;a=a.a;for(c=a[b];0<b;)if(d=b-1>>1,a[d].a>c.a)a[b]=a[d],b=d;else break;a[b]=c}bf.prototype.A=function(){for(var a=this.a,b=[],c=a.length,d=0;d<c;d++)b.push(a[d].b);return b};\nbf.prototype.M=function(){for(var a=this.a,b=[],c=a.length,d=0;d<c;d++)b.push(a[d].a);return b};function df(){bf.call(this)}t(df,bf);function Y(a,b){this.f=new df;Xe.call(this,a,b)}t(Y,Xe);g=Y.prototype;g.da=function(a,b){if(!a)return Y.H.da.call(this);cf(this.f,void 0!==b?b:100,a);this.ra()};g.ra=function(){for(var a=this.f;0<a.a.length;){var b=this.da();if(b){var c=a,d=c.a,e=d.length;var f=d[0];if(0>=e)f=void 0;else{if(1==e)ua(d);else{d[0]=d.pop();d=0;c=c.a;e=c.length;for(var h=c[d];d<e>>1;){var m=2*d+1,v=2*d+2;m=v<e&&c[v].a<c[m].a?v:m;if(c[m].a>h.a)break;c[d]=c[m];d=m}c[d]=h}f=f.b}f.apply(this,[b])}else break}};\ng.ma=function(a){Y.H.ma.call(this,a);this.ra()};g.aa=function(){Y.H.aa.call(this);this.ra()};g.w=function(){Y.H.w.call(this);k.clearTimeout(void 0);ua(this.f.a);this.f=null};function Z(a,b,c,d){this.l=a;this.j=!!d;Y.call(this,b,c)}t(Z,Y);Z.prototype.pa=function(){var a=new T,b=this.l;b&&b.forEach(function(b,d){a.headers.set(d,b)});this.j&&(a.o=!0);return a};Z.prototype.sa=function(a){return!a.i&&!a.a};Pe.prototype.createWebChannel=Pe.prototype.a;X.prototype.send=X.prototype.ab;X.prototype.open=X.prototype.$a;X.prototype.close=X.prototype.close;Ec.NO_ERROR=0;Ec.TIMEOUT=8;Ec.HTTP_ERROR=6;Fc.COMPLETE=\"complete\";Gc.EventType=Hc;Hc.OPEN=\"a\";Hc.CLOSE=\"b\";Hc.ERROR=\"c\";Hc.MESSAGE=\"d\";A.prototype.listen=A.prototype.Ha;Z.prototype.getObject=Z.prototype.da;Z.prototype.releaseObject=Z.prototype.jb;T.prototype.listenOnce=T.prototype.Ia;T.prototype.getLastError=T.prototype.bb;T.prototype.getLastErrorCode=T.prototype.Fa;\nT.prototype.getStatus=T.prototype.W;T.prototype.getStatusText=T.prototype.Ga;T.prototype.getResponseJson=T.prototype.Za;T.prototype.getResponseText=T.prototype.V;T.prototype.getResponseText=T.prototype.V;T.prototype.send=T.prototype.fa;module.exports={createWebChannelTransport:Te,ErrorCode:Ec,EventType:Fc,WebChannel:Gc,XhrIoPool:Z};}).call(typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : typeof window !== 'undefined' ? window : {})\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ../webchannel-wrapper/dist/index.js\n// module id = 115\n// module chunks = 1"],"sourceRoot":""}