.firebaseio.com');\n }\n\n if (!parsedUrl.secure) {\n warnIfPageIsSecure();\n }\n\n var webSocketOnly = parsedUrl.scheme === 'ws' || parsedUrl.scheme === 'wss';\n return {\n repoInfo: new RepoInfo(parsedUrl.host, parsedUrl.secure, namespace, nodeAdmin, webSocketOnly,\n /*persistenceKey=*/\n '',\n /*includeNamespaceInQueryParams=*/\n namespace !== parsedUrl.subdomain),\n path: new Path(parsedUrl.pathString)\n };\n};\n\nvar parseDatabaseURL = function parseDatabaseURL(dataURL) {\n // Default to empty strings in the event of a malformed string.\n var host = '',\n domain = '',\n subdomain = '',\n pathString = '',\n namespace = ''; // Always default to SSL, unless otherwise specified.\n\n var secure = true,\n scheme = 'https',\n port = 443; // Don't do any validation here. The caller is responsible for validating the result of parsing.\n\n if (typeof dataURL === 'string') {\n // Parse scheme.\n var colonInd = dataURL.indexOf('//');\n\n if (colonInd >= 0) {\n scheme = dataURL.substring(0, colonInd - 1);\n dataURL = dataURL.substring(colonInd + 2);\n } // Parse host, path, and query string.\n\n\n var slashInd = dataURL.indexOf('/');\n\n if (slashInd === -1) {\n slashInd = dataURL.length;\n }\n\n var questionMarkInd = dataURL.indexOf('?');\n\n if (questionMarkInd === -1) {\n questionMarkInd = dataURL.length;\n }\n\n host = dataURL.substring(0, Math.min(slashInd, questionMarkInd));\n\n if (slashInd < questionMarkInd) {\n // For pathString, questionMarkInd will always come after slashInd\n pathString = decodePath(dataURL.substring(slashInd, questionMarkInd));\n }\n\n var queryParams = decodeQuery(dataURL.substring(Math.min(dataURL.length, questionMarkInd))); // If we have a port, use scheme for determining if it's secure.\n\n colonInd = host.indexOf(':');\n\n if (colonInd >= 0) {\n secure = scheme === 'https' || scheme === 'wss';\n port = parseInt(host.substring(colonInd + 1), 10);\n } else {\n colonInd = host.length;\n }\n\n var hostWithoutPort = host.slice(0, colonInd);\n\n if (hostWithoutPort.toLowerCase() === 'localhost') {\n domain = 'localhost';\n } else if (hostWithoutPort.split('.').length <= 2) {\n domain = hostWithoutPort;\n } else {\n // Interpret the subdomain of a 3 or more component URL as the namespace name.\n var dotInd = host.indexOf('.');\n subdomain = host.substring(0, dotInd).toLowerCase();\n domain = host.substring(dotInd + 1); // Normalize namespaces to lowercase to share storage / connection.\n\n namespace = subdomain;\n } // Always treat the value of the `ns` as the namespace name if it is present.\n\n\n if ('ns' in queryParams) {\n namespace = queryParams['ns'];\n }\n }\n\n return {\n host: host,\n port: port,\n domain: domain,\n subdomain: subdomain,\n secure: secure,\n scheme: scheme,\n pathString: pathString,\n namespace: namespace\n };\n};\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n/**\r\n * Encapsulates the data needed to raise an event\r\n */\n\n\nvar DataEvent = /*#__PURE__*/function () {\n /**\r\n * @param eventType - One of: value, child_added, child_changed, child_moved, child_removed\r\n * @param eventRegistration - The function to call to with the event data. User provided\r\n * @param snapshot - The data backing the event\r\n * @param prevName - Optional, the name of the previous child for child_* events.\r\n */\n function DataEvent(eventType, eventRegistration, snapshot, prevName) {\n _classCallCheck(this, DataEvent);\n\n this.eventType = eventType;\n this.eventRegistration = eventRegistration;\n this.snapshot = snapshot;\n this.prevName = prevName;\n }\n\n _createClass(DataEvent, [{\n key: \"getPath\",\n value: function getPath() {\n var ref = this.snapshot.ref;\n\n if (this.eventType === 'value') {\n return ref._path;\n } else {\n return ref.parent._path;\n }\n }\n }, {\n key: \"getEventType\",\n value: function getEventType() {\n return this.eventType;\n }\n }, {\n key: \"getEventRunner\",\n value: function getEventRunner() {\n return this.eventRegistration.getEventRunner(this);\n }\n }, {\n key: \"toString\",\n value: function toString() {\n return this.getPath().toString() + ':' + this.eventType + ':' + stringify(this.snapshot.exportVal());\n }\n }]);\n\n return DataEvent;\n}();\n\nvar CancelEvent = /*#__PURE__*/function () {\n function CancelEvent(eventRegistration, error, path) {\n _classCallCheck(this, CancelEvent);\n\n this.eventRegistration = eventRegistration;\n this.error = error;\n this.path = path;\n }\n\n _createClass(CancelEvent, [{\n key: \"getPath\",\n value: function getPath() {\n return this.path;\n }\n }, {\n key: \"getEventType\",\n value: function getEventType() {\n return 'cancel';\n }\n }, {\n key: \"getEventRunner\",\n value: function getEventRunner() {\n return this.eventRegistration.getEventRunner(this);\n }\n }, {\n key: \"toString\",\n value: function toString() {\n return this.path.toString() + ':cancel';\n }\n }]);\n\n return CancelEvent;\n}();\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n/**\r\n * A wrapper class that converts events from the database@exp SDK to the legacy\r\n * Database SDK. Events are not converted directly as event registration relies\r\n * on reference comparison of the original user callback (see `matches()`) and\r\n * relies on equality of the legacy SDK's `context` object.\r\n */\n\n\nvar CallbackContext = /*#__PURE__*/function () {\n function CallbackContext(snapshotCallback, cancelCallback) {\n _classCallCheck(this, CallbackContext);\n\n this.snapshotCallback = snapshotCallback;\n this.cancelCallback = cancelCallback;\n }\n\n _createClass(CallbackContext, [{\n key: \"onValue\",\n value: function onValue(expDataSnapshot, previousChildName) {\n this.snapshotCallback.call(null, expDataSnapshot, previousChildName);\n }\n }, {\n key: \"onCancel\",\n value: function onCancel(error) {\n assert(this.hasCancelCallback, 'Raising a cancel event on a listener with no cancel callback');\n return this.cancelCallback.call(null, error);\n }\n }, {\n key: \"hasCancelCallback\",\n get: function get() {\n return !!this.cancelCallback;\n }\n }, {\n key: \"matches\",\n value: function matches(other) {\n return this.snapshotCallback === other.snapshotCallback || this.snapshotCallback.userCallback !== undefined && this.snapshotCallback.userCallback === other.snapshotCallback.userCallback && this.snapshotCallback.context === other.snapshotCallback.context;\n }\n }]);\n\n return CallbackContext;\n}();\n/**\r\n * @license\r\n * Copyright 2021 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n/**\r\n * The `onDisconnect` class allows you to write or clear data when your client\r\n * disconnects from the Database server. These updates occur whether your\r\n * client disconnects cleanly or not, so you can rely on them to clean up data\r\n * even if a connection is dropped or a client crashes.\r\n *\r\n * The `onDisconnect` class is most commonly used to manage presence in\r\n * applications where it is useful to detect how many clients are connected and\r\n * when other clients disconnect. See\r\n * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}\r\n * for more information.\r\n *\r\n * To avoid problems when a connection is dropped before the requests can be\r\n * transferred to the Database server, these functions should be called before\r\n * writing any data.\r\n *\r\n * Note that `onDisconnect` operations are only triggered once. If you want an\r\n * operation to occur each time a disconnect occurs, you'll need to re-establish\r\n * the `onDisconnect` operations each time you reconnect.\r\n */\n\n\nvar OnDisconnect = /*#__PURE__*/function () {\n /** @hideconstructor */\n function OnDisconnect(_repo, _path) {\n _classCallCheck(this, OnDisconnect);\n\n this._repo = _repo;\n this._path = _path;\n }\n /**\r\n * Cancels all previously queued `onDisconnect()` set or update events for this\r\n * location and all children.\r\n *\r\n * If a write has been queued for this location via a `set()` or `update()` at a\r\n * parent location, the write at this location will be canceled, though writes\r\n * to sibling locations will still occur.\r\n *\r\n * @returns Resolves when synchronization to the server is complete.\r\n */\n\n\n _createClass(OnDisconnect, [{\n key: \"cancel\",\n value: function cancel() {\n var deferred = new Deferred();\n repoOnDisconnectCancel(this._repo, this._path, deferred.wrapCallback(function () {}));\n return deferred.promise;\n }\n /**\r\n * Ensures the data at this location is deleted when the client is disconnected\r\n * (due to closing the browser, navigating to a new page, or network issues).\r\n *\r\n * @returns Resolves when synchronization to the server is complete.\r\n */\n\n }, {\n key: \"remove\",\n value: function remove() {\n validateWritablePath('OnDisconnect.remove', this._path);\n var deferred = new Deferred();\n repoOnDisconnectSet(this._repo, this._path, null, deferred.wrapCallback(function () {}));\n return deferred.promise;\n }\n /**\r\n * Ensures the data at this location is set to the specified value when the\r\n * client is disconnected (due to closing the browser, navigating to a new page,\r\n * or network issues).\r\n *\r\n * `set()` is especially useful for implementing \"presence\" systems, where a\r\n * value should be changed or cleared when a user disconnects so that they\r\n * appear \"offline\" to other users. See\r\n * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}\r\n * for more information.\r\n *\r\n * Note that `onDisconnect` operations are only triggered once. If you want an\r\n * operation to occur each time a disconnect occurs, you'll need to re-establish\r\n * the `onDisconnect` operations each time.\r\n *\r\n * @param value - The value to be written to this location on disconnect (can\r\n * be an object, array, string, number, boolean, or null).\r\n * @returns Resolves when synchronization to the Database is complete.\r\n */\n\n }, {\n key: \"set\",\n value: function set(value) {\n validateWritablePath('OnDisconnect.set', this._path);\n validateFirebaseDataArg('OnDisconnect.set', value, this._path, false);\n var deferred = new Deferred();\n repoOnDisconnectSet(this._repo, this._path, value, deferred.wrapCallback(function () {}));\n return deferred.promise;\n }\n /**\r\n * Ensures the data at this location is set to the specified value and priority\r\n * when the client is disconnected (due to closing the browser, navigating to a\r\n * new page, or network issues).\r\n *\r\n * @param value - The value to be written to this location on disconnect (can\r\n * be an object, array, string, number, boolean, or null).\r\n * @param priority - The priority to be written (string, number, or null).\r\n * @returns Resolves when synchronization to the Database is complete.\r\n */\n\n }, {\n key: \"setWithPriority\",\n value: function setWithPriority(value, priority) {\n validateWritablePath('OnDisconnect.setWithPriority', this._path);\n validateFirebaseDataArg('OnDisconnect.setWithPriority', value, this._path, false);\n validatePriority('OnDisconnect.setWithPriority', priority, false);\n var deferred = new Deferred();\n repoOnDisconnectSetWithPriority(this._repo, this._path, value, priority, deferred.wrapCallback(function () {}));\n return deferred.promise;\n }\n /**\r\n * Writes multiple values at this location when the client is disconnected (due\r\n * to closing the browser, navigating to a new page, or network issues).\r\n *\r\n * The `values` argument contains multiple property-value pairs that will be\r\n * written to the Database together. Each child property can either be a simple\r\n * property (for example, \"name\") or a relative path (for example, \"name/first\")\r\n * from the current location to the data to update.\r\n *\r\n * As opposed to the `set()` method, `update()` can be use to selectively update\r\n * only the referenced properties at the current location (instead of replacing\r\n * all the child properties at the current location).\r\n *\r\n * @param values - Object containing multiple values.\r\n * @returns Resolves when synchronization to the Database is complete.\r\n */\n\n }, {\n key: \"update\",\n value: function update(values) {\n validateWritablePath('OnDisconnect.update', this._path);\n validateFirebaseMergeDataArg('OnDisconnect.update', values, this._path, false);\n var deferred = new Deferred();\n repoOnDisconnectUpdate(this._repo, this._path, values, deferred.wrapCallback(function () {}));\n return deferred.promise;\n }\n }]);\n\n return OnDisconnect;\n}();\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n/**\r\n * @internal\r\n */\n\n\nvar QueryImpl = /*#__PURE__*/function () {\n /**\r\n * @hideconstructor\r\n */\n function QueryImpl(_repo, _path, _queryParams, _orderByCalled) {\n _classCallCheck(this, QueryImpl);\n\n this._repo = _repo;\n this._path = _path;\n this._queryParams = _queryParams;\n this._orderByCalled = _orderByCalled;\n }\n\n _createClass(QueryImpl, [{\n key: \"key\",\n get: function get() {\n if (pathIsEmpty(this._path)) {\n return null;\n } else {\n return pathGetBack(this._path);\n }\n }\n }, {\n key: \"ref\",\n get: function get() {\n return new ReferenceImpl(this._repo, this._path);\n }\n }, {\n key: \"_queryIdentifier\",\n get: function get() {\n var obj = queryParamsGetQueryObject(this._queryParams);\n var id = ObjectToUniqueKey(obj);\n return id === '{}' ? 'default' : id;\n }\n /**\r\n * An object representation of the query parameters used by this Query.\r\n */\n\n }, {\n key: \"_queryObject\",\n get: function get() {\n return queryParamsGetQueryObject(this._queryParams);\n }\n }, {\n key: \"isEqual\",\n value: function isEqual(other) {\n other = getModularInstance(other);\n\n if (!(other instanceof QueryImpl)) {\n return false;\n }\n\n var sameRepo = this._repo === other._repo;\n var samePath = pathEquals(this._path, other._path);\n var sameQueryIdentifier = this._queryIdentifier === other._queryIdentifier;\n return sameRepo && samePath && sameQueryIdentifier;\n }\n }, {\n key: \"toJSON\",\n value: function toJSON() {\n return this.toString();\n }\n }, {\n key: \"toString\",\n value: function toString() {\n return this._repo.toString() + pathToUrlEncodedString(this._path);\n }\n }]);\n\n return QueryImpl;\n}();\n/**\r\n * Validates that no other order by call has been made\r\n */\n\n\nfunction validateNoPreviousOrderByCall(query, fnName) {\n if (query._orderByCalled === true) {\n throw new Error(fnName + \": You can't combine multiple orderBy calls.\");\n }\n}\n/**\r\n * Validates start/end values for queries.\r\n */\n\n\nfunction validateQueryEndpoints(params) {\n var startNode = null;\n var endNode = null;\n\n if (params.hasStart()) {\n startNode = params.getIndexStartValue();\n }\n\n if (params.hasEnd()) {\n endNode = params.getIndexEndValue();\n }\n\n if (params.getIndex() === KEY_INDEX) {\n var tooManyArgsError = 'Query: When ordering by key, you may only pass one argument to ' + 'startAt(), endAt(), or equalTo().';\n var wrongArgTypeError = 'Query: When ordering by key, the argument passed to startAt(), startAfter(), ' + 'endAt(), endBefore(), or equalTo() must be a string.';\n\n if (params.hasStart()) {\n var startName = params.getIndexStartName();\n\n if (startName !== MIN_NAME) {\n throw new Error(tooManyArgsError);\n } else if (typeof startNode !== 'string') {\n throw new Error(wrongArgTypeError);\n }\n }\n\n if (params.hasEnd()) {\n var endName = params.getIndexEndName();\n\n if (endName !== MAX_NAME) {\n throw new Error(tooManyArgsError);\n } else if (typeof endNode !== 'string') {\n throw new Error(wrongArgTypeError);\n }\n }\n } else if (params.getIndex() === PRIORITY_INDEX) {\n if (startNode != null && !isValidPriority(startNode) || endNode != null && !isValidPriority(endNode)) {\n throw new Error('Query: When ordering by priority, the first argument passed to startAt(), ' + 'startAfter() endAt(), endBefore(), or equalTo() must be a valid priority value ' + '(null, a number, or a string).');\n }\n } else {\n assert(params.getIndex() instanceof PathIndex || params.getIndex() === VALUE_INDEX, 'unknown index type.');\n\n if (startNode != null && typeof startNode === 'object' || endNode != null && typeof endNode === 'object') {\n throw new Error('Query: First argument passed to startAt(), startAfter(), endAt(), endBefore(), or ' + 'equalTo() cannot be an object.');\n }\n }\n}\n/**\r\n * Validates that limit* has been called with the correct combination of parameters\r\n */\n\n\nfunction validateLimit(params) {\n if (params.hasStart() && params.hasEnd() && params.hasLimit() && !params.hasAnchoredLimit()) {\n throw new Error(\"Query: Can't combine startAt(), startAfter(), endAt(), endBefore(), and limit(). Use \" + 'limitToFirst() or limitToLast() instead.');\n }\n}\n/**\r\n * @internal\r\n */\n\n\nvar ReferenceImpl = /*#__PURE__*/function (_QueryImpl) {\n _inherits(ReferenceImpl, _QueryImpl);\n\n var _super10 = _createSuper(ReferenceImpl);\n\n /** @hideconstructor */\n function ReferenceImpl(repo, path) {\n _classCallCheck(this, ReferenceImpl);\n\n return _super10.call(this, repo, path, new QueryParams(), false);\n }\n\n _createClass(ReferenceImpl, [{\n key: \"parent\",\n get: function get() {\n var parentPath = pathParent(this._path);\n return parentPath === null ? null : new ReferenceImpl(this._repo, parentPath);\n }\n }, {\n key: \"root\",\n get: function get() {\n var ref = this;\n\n while (ref.parent !== null) {\n ref = ref.parent;\n }\n\n return ref;\n }\n }]);\n\n return ReferenceImpl;\n}(QueryImpl);\n/**\r\n * A `DataSnapshot` contains data from a Database location.\r\n *\r\n * Any time you read data from the Database, you receive the data as a\r\n * `DataSnapshot`. A `DataSnapshot` is passed to the event callbacks you attach\r\n * with `on()` or `once()`. You can extract the contents of the snapshot as a\r\n * JavaScript object by calling the `val()` method. Alternatively, you can\r\n * traverse into the snapshot by calling `child()` to return child snapshots\r\n * (which you could then call `val()` on).\r\n *\r\n * A `DataSnapshot` is an efficiently generated, immutable copy of the data at\r\n * a Database location. It cannot be modified and will never change (to modify\r\n * data, you always call the `set()` method on a `Reference` directly).\r\n */\n\n\nvar DataSnapshot = /*#__PURE__*/function () {\n /**\r\n * @param _node - A SnapshotNode to wrap.\r\n * @param ref - The location this snapshot came from.\r\n * @param _index - The iteration order for this snapshot\r\n * @hideconstructor\r\n */\n function DataSnapshot(_node,\n /**\r\n * The location of this DataSnapshot.\r\n */\n ref, _index) {\n _classCallCheck(this, DataSnapshot);\n\n this._node = _node;\n this.ref = ref;\n this._index = _index;\n }\n /**\r\n * Gets the priority value of the data in this `DataSnapshot`.\r\n *\r\n * Applications need not use priority but can order collections by\r\n * ordinary properties (see\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data |Sorting and filtering data}\r\n * ).\r\n */\n\n\n _createClass(DataSnapshot, [{\n key: \"priority\",\n get: function get() {\n // typecast here because we never return deferred values or internal priorities (MAX_PRIORITY)\n return this._node.getPriority().val();\n }\n /**\r\n * The key (last part of the path) of the location of this `DataSnapshot`.\r\n *\r\n * The last token in a Database location is considered its key. For example,\r\n * \"ada\" is the key for the /users/ada/ node. Accessing the key on any\r\n * `DataSnapshot` will return the key for the location that generated it.\r\n * However, accessing the key on the root URL of a Database will return\r\n * `null`.\r\n */\n\n }, {\n key: \"key\",\n get: function get() {\n return this.ref.key;\n }\n /** Returns the number of child properties of this `DataSnapshot`. */\n\n }, {\n key: \"size\",\n get: function get() {\n return this._node.numChildren();\n }\n /**\r\n * Gets another `DataSnapshot` for the location at the specified relative path.\r\n *\r\n * Passing a relative path to the `child()` method of a DataSnapshot returns\r\n * another `DataSnapshot` for the location at the specified relative path. The\r\n * relative path can either be a simple child name (for example, \"ada\") or a\r\n * deeper, slash-separated path (for example, \"ada/name/first\"). If the child\r\n * location has no data, an empty `DataSnapshot` (that is, a `DataSnapshot`\r\n * whose value is `null`) is returned.\r\n *\r\n * @param path - A relative path to the location of child data.\r\n */\n\n }, {\n key: \"child\",\n value: function child(path) {\n var childPath = new Path(path);\n\n var childRef = _child9(this.ref, path);\n\n return new DataSnapshot(this._node.getChild(childPath), childRef, PRIORITY_INDEX);\n }\n /**\r\n * Returns true if this `DataSnapshot` contains any data. It is slightly more\r\n * efficient than using `snapshot.val() !== null`.\r\n */\n\n }, {\n key: \"exists\",\n value: function exists() {\n return !this._node.isEmpty();\n }\n /**\r\n * Exports the entire contents of the DataSnapshot as a JavaScript object.\r\n *\r\n * The `exportVal()` method is similar to `val()`, except priority information\r\n * is included (if available), making it suitable for backing up your data.\r\n *\r\n * @returns The DataSnapshot's contents as a JavaScript value (Object,\r\n * Array, string, number, boolean, or `null`).\r\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n }, {\n key: \"exportVal\",\n value: function exportVal() {\n return this._node.val(true);\n }\n /**\r\n * Enumerates the top-level children in the `DataSnapshot`.\r\n *\r\n * Because of the way JavaScript objects work, the ordering of data in the\r\n * JavaScript object returned by `val()` is not guaranteed to match the\r\n * ordering on the server nor the ordering of `onChildAdded()` events. That is\r\n * where `forEach()` comes in handy. It guarantees the children of a\r\n * `DataSnapshot` will be iterated in their query order.\r\n *\r\n * If no explicit `orderBy*()` method is used, results are returned\r\n * ordered by key (unless priorities are used, in which case, results are\r\n * returned by priority).\r\n *\r\n * @param action - A function that will be called for each child DataSnapshot.\r\n * The callback can return true to cancel further enumeration.\r\n * @returns true if enumeration was canceled due to your callback returning\r\n * true.\r\n */\n\n }, {\n key: \"forEach\",\n value: function forEach(action) {\n var _this37 = this;\n\n if (this._node.isLeafNode()) {\n return false;\n }\n\n var childrenNode = this._node; // Sanitize the return value to a boolean. ChildrenNode.forEachChild has a weird return type...\n\n return !!childrenNode.forEachChild(this._index, function (key, node) {\n return action(new DataSnapshot(node, _child9(_this37.ref, key), PRIORITY_INDEX));\n });\n }\n /**\r\n * Returns true if the specified child path has (non-null) data.\r\n *\r\n * @param path - A relative path to the location of a potential child.\r\n * @returns `true` if data exists at the specified child path; else\r\n * `false`.\r\n */\n\n }, {\n key: \"hasChild\",\n value: function hasChild(path) {\n var childPath = new Path(path);\n return !this._node.getChild(childPath).isEmpty();\n }\n /**\r\n * Returns whether or not the `DataSnapshot` has any non-`null` child\r\n * properties.\r\n *\r\n * You can use `hasChildren()` to determine if a `DataSnapshot` has any\r\n * children. If it does, you can enumerate them using `forEach()`. If it\r\n * doesn't, then either this snapshot contains a primitive value (which can be\r\n * retrieved with `val()`) or it is empty (in which case, `val()` will return\r\n * `null`).\r\n *\r\n * @returns true if this snapshot has any children; else false.\r\n */\n\n }, {\n key: \"hasChildren\",\n value: function hasChildren() {\n if (this._node.isLeafNode()) {\n return false;\n } else {\n return !this._node.isEmpty();\n }\n }\n /**\r\n * Returns a JSON-serializable representation of this object.\r\n */\n\n }, {\n key: \"toJSON\",\n value: function toJSON() {\n return this.exportVal();\n }\n /**\r\n * Extracts a JavaScript value from a `DataSnapshot`.\r\n *\r\n * Depending on the data in a `DataSnapshot`, the `val()` method may return a\r\n * scalar type (string, number, or boolean), an array, or an object. It may\r\n * also return null, indicating that the `DataSnapshot` is empty (contains no\r\n * data).\r\n *\r\n * @returns The DataSnapshot's contents as a JavaScript value (Object,\r\n * Array, string, number, boolean, or `null`).\r\n */\n // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n }, {\n key: \"val\",\n value: function val() {\n return this._node.val();\n }\n }]);\n\n return DataSnapshot;\n}();\n/**\r\n *\r\n * Returns a `Reference` representing the location in the Database\r\n * corresponding to the provided path. If no path is provided, the `Reference`\r\n * will point to the root of the Database.\r\n *\r\n * @param db - The database instance to obtain a reference for.\r\n * @param path - Optional path representing the location the returned\r\n * `Reference` will point. If not provided, the returned `Reference` will\r\n * point to the root of the Database.\r\n * @returns If a path is provided, a `Reference`\r\n * pointing to the provided path. Otherwise, a `Reference` pointing to the\r\n * root of the Database.\r\n */\n\n\nfunction ref(db, path) {\n db = getModularInstance(db);\n\n db._checkNotDeleted('ref');\n\n return path !== undefined ? _child9(db._root, path) : db._root;\n}\n/**\r\n * Returns a `Reference` representing the location in the Database\r\n * corresponding to the provided Firebase URL.\r\n *\r\n * An exception is thrown if the URL is not a valid Firebase Database URL or it\r\n * has a different domain than the current `Database` instance.\r\n *\r\n * Note that all query parameters (`orderBy`, `limitToLast`, etc.) are ignored\r\n * and are not applied to the returned `Reference`.\r\n *\r\n * @param db - The database instance to obtain a reference for.\r\n * @param url - The Firebase URL at which the returned `Reference` will\r\n * point.\r\n * @returns A `Reference` pointing to the provided\r\n * Firebase URL.\r\n */\n\n\nfunction refFromURL(db, url) {\n db = getModularInstance(db);\n\n db._checkNotDeleted('refFromURL');\n\n var parsedURL = parseRepoInfo(url, db._repo.repoInfo_.nodeAdmin);\n validateUrl('refFromURL', parsedURL);\n var repoInfo = parsedURL.repoInfo;\n\n if (!db._repo.repoInfo_.isCustomHost() && repoInfo.host !== db._repo.repoInfo_.host) {\n fatal('refFromURL' + ': Host name does not match the current database: ' + '(found ' + repoInfo.host + ' but expected ' + db._repo.repoInfo_.host + ')');\n }\n\n return ref(db, parsedURL.path.toString());\n}\n/**\r\n * Gets a `Reference` for the location at the specified relative path.\r\n *\r\n * The relative path can either be a simple child name (for example, \"ada\") or\r\n * a deeper slash-separated path (for example, \"ada/name/first\").\r\n *\r\n * @param parent - The parent location.\r\n * @param path - A relative path from this location to the desired child\r\n * location.\r\n * @returns The specified child location.\r\n */\n\n\nfunction _child9(parent, path) {\n parent = getModularInstance(parent);\n\n if (pathGetFront(parent._path) === null) {\n validateRootPathString('child', 'path', path, false);\n } else {\n validatePathString('child', 'path', path, false);\n }\n\n return new ReferenceImpl(parent._repo, pathChild(parent._path, path));\n}\n/**\r\n * Returns an `OnDisconnect` object - see\r\n * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}\r\n * for more information on how to use it.\r\n *\r\n * @param ref - The reference to add OnDisconnect triggers for.\r\n */\n\n\nfunction onDisconnect(ref) {\n ref = getModularInstance(ref);\n return new OnDisconnect(ref._repo, ref._path);\n}\n/**\r\n * Generates a new child location using a unique key and returns its\r\n * `Reference`.\r\n *\r\n * This is the most common pattern for adding data to a collection of items.\r\n *\r\n * If you provide a value to `push()`, the value is written to the\r\n * generated location. If you don't pass a value, nothing is written to the\r\n * database and the child remains empty (but you can use the `Reference`\r\n * elsewhere).\r\n *\r\n * The unique keys generated by `push()` are ordered by the current time, so the\r\n * resulting list of items is chronologically sorted. The keys are also\r\n * designed to be unguessable (they contain 72 random bits of entropy).\r\n *\r\n * See {@link https://firebase.google.com/docs/database/web/lists-of-data#append_to_a_list_of_data | Append to a list of data}\r\n * See {@link ttps://firebase.googleblog.com/2015/02/the-2120-ways-to-ensure-unique_68.html | The 2^120 Ways to Ensure Unique Identifiers}\r\n *\r\n * @param parent - The parent location.\r\n * @param value - Optional value to be written at the generated location.\r\n * @returns Combined `Promise` and `Reference`; resolves when write is complete,\r\n * but can be used immediately as the `Reference` to the child location.\r\n */\n\n\nfunction push(parent, value) {\n parent = getModularInstance(parent);\n validateWritablePath('push', parent._path);\n validateFirebaseDataArg('push', value, parent._path, true);\n var now = repoServerTime(parent._repo);\n var name = nextPushId(now); // push() returns a ThennableReference whose promise is fulfilled with a\n // regular Reference. We use child() to create handles to two different\n // references. The first is turned into a ThennableReference below by adding\n // then() and catch() methods and is used as the return value of push(). The\n // second remains a regular Reference and is used as the fulfilled value of\n // the first ThennableReference.\n\n var thennablePushRef = _child9(parent, name);\n\n var pushRef = _child9(parent, name);\n\n var promise;\n\n if (value != null) {\n promise = set(pushRef, value).then(function () {\n return pushRef;\n });\n } else {\n promise = Promise.resolve(pushRef);\n }\n\n thennablePushRef.then = promise.then.bind(promise);\n thennablePushRef.catch = promise.then.bind(promise, undefined);\n return thennablePushRef;\n}\n/**\r\n * Removes the data at this Database location.\r\n *\r\n * Any data at child locations will also be deleted.\r\n *\r\n * The effect of the remove will be visible immediately and the corresponding\r\n * event 'value' will be triggered. Synchronization of the remove to the\r\n * Firebase servers will also be started, and the returned Promise will resolve\r\n * when complete. If provided, the onComplete callback will be called\r\n * asynchronously after synchronization has finished.\r\n *\r\n * @param ref - The location to remove.\r\n * @returns Resolves when remove on server is complete.\r\n */\n\n\nfunction remove(ref) {\n validateWritablePath('remove', ref._path);\n return set(ref, null);\n}\n/**\r\n * Writes data to this Database location.\r\n *\r\n * This will overwrite any data at this location and all child locations.\r\n *\r\n * The effect of the write will be visible immediately, and the corresponding\r\n * events (\"value\", \"child_added\", etc.) will be triggered. Synchronization of\r\n * the data to the Firebase servers will also be started, and the returned\r\n * Promise will resolve when complete. If provided, the `onComplete` callback\r\n * will be called asynchronously after synchronization has finished.\r\n *\r\n * Passing `null` for the new value is equivalent to calling `remove()`; namely,\r\n * all data at this location and all child locations will be deleted.\r\n *\r\n * `set()` will remove any priority stored at this location, so if priority is\r\n * meant to be preserved, you need to use `setWithPriority()` instead.\r\n *\r\n * Note that modifying data with `set()` will cancel any pending transactions\r\n * at that location, so extreme care should be taken if mixing `set()` and\r\n * `transaction()` to modify the same data.\r\n *\r\n * A single `set()` will generate a single \"value\" event at the location where\r\n * the `set()` was performed.\r\n *\r\n * @param ref - The location to write to.\r\n * @param value - The value to be written (string, number, boolean, object,\r\n * array, or null).\r\n * @returns Resolves when write to server is complete.\r\n */\n\n\nfunction set(ref, value) {\n ref = getModularInstance(ref);\n validateWritablePath('set', ref._path);\n validateFirebaseDataArg('set', value, ref._path, false);\n var deferred = new Deferred();\n repoSetWithPriority(ref._repo, ref._path, value,\n /*priority=*/\n null, deferred.wrapCallback(function () {}));\n return deferred.promise;\n}\n/**\r\n * Sets a priority for the data at this Database location.\r\n *\r\n * Applications need not use priority but can order collections by\r\n * ordinary properties (see\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}\r\n * ).\r\n *\r\n * @param ref - The location to write to.\r\n * @param priority - The priority to be written (string, number, or null).\r\n * @returns Resolves when write to server is complete.\r\n */\n\n\nfunction setPriority(ref, priority) {\n ref = getModularInstance(ref);\n validateWritablePath('setPriority', ref._path);\n validatePriority('setPriority', priority, false);\n var deferred = new Deferred();\n repoSetWithPriority(ref._repo, pathChild(ref._path, '.priority'), priority, null, deferred.wrapCallback(function () {}));\n return deferred.promise;\n}\n/**\r\n * Writes data the Database location. Like `set()` but also specifies the\r\n * priority for that data.\r\n *\r\n * Applications need not use priority but can order collections by\r\n * ordinary properties (see\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}\r\n * ).\r\n *\r\n * @param ref - The location to write to.\r\n * @param value - The value to be written (string, number, boolean, object,\r\n * array, or null).\r\n * @param priority - The priority to be written (string, number, or null).\r\n * @returns Resolves when write to server is complete.\r\n */\n\n\nfunction setWithPriority(ref, value, priority) {\n validateWritablePath('setWithPriority', ref._path);\n validateFirebaseDataArg('setWithPriority', value, ref._path, false);\n validatePriority('setWithPriority', priority, false);\n\n if (ref.key === '.length' || ref.key === '.keys') {\n throw 'setWithPriority failed: ' + ref.key + ' is a read-only object.';\n }\n\n var deferred = new Deferred();\n repoSetWithPriority(ref._repo, ref._path, value, priority, deferred.wrapCallback(function () {}));\n return deferred.promise;\n}\n/**\r\n * Writes multiple values to the Database at once.\r\n *\r\n * The `values` argument contains multiple property-value pairs that will be\r\n * written to the Database together. Each child property can either be a simple\r\n * property (for example, \"name\") or a relative path (for example,\r\n * \"name/first\") from the current location to the data to update.\r\n *\r\n * As opposed to the `set()` method, `update()` can be use to selectively update\r\n * only the referenced properties at the current location (instead of replacing\r\n * all the child properties at the current location).\r\n *\r\n * The effect of the write will be visible immediately, and the corresponding\r\n * events ('value', 'child_added', etc.) will be triggered. Synchronization of\r\n * the data to the Firebase servers will also be started, and the returned\r\n * Promise will resolve when complete. If provided, the `onComplete` callback\r\n * will be called asynchronously after synchronization has finished.\r\n *\r\n * A single `update()` will generate a single \"value\" event at the location\r\n * where the `update()` was performed, regardless of how many children were\r\n * modified.\r\n *\r\n * Note that modifying data with `update()` will cancel any pending\r\n * transactions at that location, so extreme care should be taken if mixing\r\n * `update()` and `transaction()` to modify the same data.\r\n *\r\n * Passing `null` to `update()` will remove the data at this location.\r\n *\r\n * See\r\n * {@link https://firebase.googleblog.com/2015/09/introducing-multi-location-updates-and_86.html | Introducing multi-location updates and more}.\r\n *\r\n * @param ref - The location to write to.\r\n * @param values - Object containing multiple values.\r\n * @returns Resolves when update on server is complete.\r\n */\n\n\nfunction update(ref, values) {\n validateFirebaseMergeDataArg('update', values, ref._path, false);\n var deferred = new Deferred();\n repoUpdate(ref._repo, ref._path, values, deferred.wrapCallback(function () {}));\n return deferred.promise;\n}\n/**\r\n * Gets the most up-to-date result for this query.\r\n *\r\n * @param query - The query to run.\r\n * @returns A `Promise` which resolves to the resulting DataSnapshot if a value is\r\n * available, or rejects if the client is unable to return a value (e.g., if the\r\n * server is unreachable and there is nothing cached).\r\n */\n\n\nfunction get(query) {\n query = getModularInstance(query);\n return repoGetValue(query._repo, query).then(function (node) {\n return new DataSnapshot(node, new ReferenceImpl(query._repo, query._path), query._queryParams.getIndex());\n });\n}\n/**\r\n * Represents registration for 'value' events.\r\n */\n\n\nvar ValueEventRegistration = /*#__PURE__*/function () {\n function ValueEventRegistration(callbackContext) {\n _classCallCheck(this, ValueEventRegistration);\n\n this.callbackContext = callbackContext;\n }\n\n _createClass(ValueEventRegistration, [{\n key: \"respondsTo\",\n value: function respondsTo(eventType) {\n return eventType === 'value';\n }\n }, {\n key: \"createEvent\",\n value: function createEvent(change, query) {\n var index = query._queryParams.getIndex();\n\n return new DataEvent('value', this, new DataSnapshot(change.snapshotNode, new ReferenceImpl(query._repo, query._path), index));\n }\n }, {\n key: \"getEventRunner\",\n value: function getEventRunner(eventData) {\n var _this38 = this;\n\n if (eventData.getEventType() === 'cancel') {\n return function () {\n return _this38.callbackContext.onCancel(eventData.error);\n };\n } else {\n return function () {\n return _this38.callbackContext.onValue(eventData.snapshot, null);\n };\n }\n }\n }, {\n key: \"createCancelEvent\",\n value: function createCancelEvent(error, path) {\n if (this.callbackContext.hasCancelCallback) {\n return new CancelEvent(this, error, path);\n } else {\n return null;\n }\n }\n }, {\n key: \"matches\",\n value: function matches(other) {\n if (!(other instanceof ValueEventRegistration)) {\n return false;\n } else if (!other.callbackContext || !this.callbackContext) {\n // If no callback specified, we consider it to match any callback.\n return true;\n } else {\n return other.callbackContext.matches(this.callbackContext);\n }\n }\n }, {\n key: \"hasAnyCallback\",\n value: function hasAnyCallback() {\n return this.callbackContext !== null;\n }\n }]);\n\n return ValueEventRegistration;\n}();\n/**\r\n * Represents the registration of a child_x event.\r\n */\n\n\nvar ChildEventRegistration = /*#__PURE__*/function () {\n function ChildEventRegistration(eventType, callbackContext) {\n _classCallCheck(this, ChildEventRegistration);\n\n this.eventType = eventType;\n this.callbackContext = callbackContext;\n }\n\n _createClass(ChildEventRegistration, [{\n key: \"respondsTo\",\n value: function respondsTo(eventType) {\n var eventToCheck = eventType === 'children_added' ? 'child_added' : eventType;\n eventToCheck = eventToCheck === 'children_removed' ? 'child_removed' : eventToCheck;\n return this.eventType === eventToCheck;\n }\n }, {\n key: \"createCancelEvent\",\n value: function createCancelEvent(error, path) {\n if (this.callbackContext.hasCancelCallback) {\n return new CancelEvent(this, error, path);\n } else {\n return null;\n }\n }\n }, {\n key: \"createEvent\",\n value: function createEvent(change, query) {\n assert(change.childName != null, 'Child events should have a childName.');\n\n var childRef = _child9(new ReferenceImpl(query._repo, query._path), change.childName);\n\n var index = query._queryParams.getIndex();\n\n return new DataEvent(change.type, this, new DataSnapshot(change.snapshotNode, childRef, index), change.prevName);\n }\n }, {\n key: \"getEventRunner\",\n value: function getEventRunner(eventData) {\n var _this39 = this;\n\n if (eventData.getEventType() === 'cancel') {\n return function () {\n return _this39.callbackContext.onCancel(eventData.error);\n };\n } else {\n return function () {\n return _this39.callbackContext.onValue(eventData.snapshot, eventData.prevName);\n };\n }\n }\n }, {\n key: \"matches\",\n value: function matches(other) {\n if (other instanceof ChildEventRegistration) {\n return this.eventType === other.eventType && (!this.callbackContext || !other.callbackContext || this.callbackContext.matches(other.callbackContext));\n }\n\n return false;\n }\n }, {\n key: \"hasAnyCallback\",\n value: function hasAnyCallback() {\n return !!this.callbackContext;\n }\n }]);\n\n return ChildEventRegistration;\n}();\n\nfunction addEventListener(query, eventType, callback, cancelCallbackOrListenOptions, options) {\n var cancelCallback;\n\n if (typeof cancelCallbackOrListenOptions === 'object') {\n cancelCallback = undefined;\n options = cancelCallbackOrListenOptions;\n }\n\n if (typeof cancelCallbackOrListenOptions === 'function') {\n cancelCallback = cancelCallbackOrListenOptions;\n }\n\n if (options && options.onlyOnce) {\n var userCallback = callback;\n\n var onceCallback = function onceCallback(dataSnapshot, previousChildName) {\n repoRemoveEventCallbackForQuery(query._repo, query, container);\n userCallback(dataSnapshot, previousChildName);\n };\n\n onceCallback.userCallback = callback.userCallback;\n onceCallback.context = callback.context;\n callback = onceCallback;\n }\n\n var callbackContext = new CallbackContext(callback, cancelCallback || undefined);\n var container = eventType === 'value' ? new ValueEventRegistration(callbackContext) : new ChildEventRegistration(eventType, callbackContext);\n repoAddEventCallbackForQuery(query._repo, query, container);\n return function () {\n return repoRemoveEventCallbackForQuery(query._repo, query, container);\n };\n}\n\nfunction onValue(query, callback, cancelCallbackOrListenOptions, options) {\n return addEventListener(query, 'value', callback, cancelCallbackOrListenOptions, options);\n}\n\nfunction onChildAdded(query, callback, cancelCallbackOrListenOptions, options) {\n return addEventListener(query, 'child_added', callback, cancelCallbackOrListenOptions, options);\n}\n\nfunction onChildChanged(query, callback, cancelCallbackOrListenOptions, options) {\n return addEventListener(query, 'child_changed', callback, cancelCallbackOrListenOptions, options);\n}\n\nfunction onChildMoved(query, callback, cancelCallbackOrListenOptions, options) {\n return addEventListener(query, 'child_moved', callback, cancelCallbackOrListenOptions, options);\n}\n\nfunction onChildRemoved(query, callback, cancelCallbackOrListenOptions, options) {\n return addEventListener(query, 'child_removed', callback, cancelCallbackOrListenOptions, options);\n}\n/**\r\n * Detaches a callback previously attached with `on()`.\r\n *\r\n * Detach a callback previously attached with `on()`. Note that if `on()` was\r\n * called multiple times with the same eventType and callback, the callback\r\n * will be called multiple times for each event, and `off()` must be called\r\n * multiple times to remove the callback. Calling `off()` on a parent listener\r\n * will not automatically remove listeners registered on child nodes, `off()`\r\n * must also be called on any child listeners to remove the callback.\r\n *\r\n * If a callback is not specified, all callbacks for the specified eventType\r\n * will be removed. Similarly, if no eventType is specified, all callbacks\r\n * for the `Reference` will be removed.\r\n *\r\n * Individual listeners can also be removed by invoking their unsubscribe\r\n * callbacks.\r\n *\r\n * @param query - The query that the listener was registered with.\r\n * @param eventType - One of the following strings: \"value\", \"child_added\",\r\n * \"child_changed\", \"child_removed\", or \"child_moved.\" If omitted, all callbacks\r\n * for the `Reference` will be removed.\r\n * @param callback - The callback function that was passed to `on()` or\r\n * `undefined` to remove all callbacks.\r\n */\n\n\nfunction off(query, eventType, callback) {\n var container = null;\n var expCallback = callback ? new CallbackContext(callback) : null;\n\n if (eventType === 'value') {\n container = new ValueEventRegistration(expCallback);\n } else if (eventType) {\n container = new ChildEventRegistration(eventType, expCallback);\n }\n\n repoRemoveEventCallbackForQuery(query._repo, query, container);\n}\n/**\r\n * A `QueryConstraint` is used to narrow the set of documents returned by a\r\n * Database query. `QueryConstraint`s are created by invoking {@link endAt},\r\n * {@link endBefore}, {@link startAt}, {@link startAfter}, {@link\r\n * limitToFirst}, {@link limitToLast}, {@link orderByChild},\r\n * {@link orderByChild}, {@link orderByKey} , {@link orderByPriority} ,\r\n * {@link orderByValue} or {@link equalTo} and\r\n * can then be passed to {@link query} to create a new query instance that\r\n * also contains this `QueryConstraint`.\r\n */\n\n\nvar QueryConstraint = /*#__PURE__*/_createClass(function QueryConstraint() {\n _classCallCheck(this, QueryConstraint);\n});\n\nvar QueryEndAtConstraint = /*#__PURE__*/function (_QueryConstraint) {\n _inherits(QueryEndAtConstraint, _QueryConstraint);\n\n var _super11 = _createSuper(QueryEndAtConstraint);\n\n function QueryEndAtConstraint(_value, _key) {\n var _this40;\n\n _classCallCheck(this, QueryEndAtConstraint);\n\n _this40 = _super11.call(this);\n _this40._value = _value;\n _this40._key = _key;\n return _this40;\n }\n\n _createClass(QueryEndAtConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateFirebaseDataArg('endAt', this._value, query._path, true);\n var newParams = queryParamsEndAt(query._queryParams, this._value, this._key);\n validateLimit(newParams);\n validateQueryEndpoints(newParams);\n\n if (query._queryParams.hasEnd()) {\n throw new Error('endAt: Starting point was already set (by another call to endAt, ' + 'endBefore or equalTo).');\n }\n\n return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);\n }\n }]);\n\n return QueryEndAtConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a `QueryConstraint` with the specified ending point.\r\n *\r\n * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`\r\n * allows you to choose arbitrary starting and ending points for your queries.\r\n *\r\n * The ending point is inclusive, so children with exactly the specified value\r\n * will be included in the query. The optional key argument can be used to\r\n * further limit the range of the query. If it is specified, then children that\r\n * have exactly the specified value must also have a key name less than or equal\r\n * to the specified key.\r\n *\r\n * You can read more about `endAt()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.\r\n *\r\n * @param value - The value to end at. The argument type depends on which\r\n * `orderBy*()` function was used in this query. Specify a value that matches\r\n * the `orderBy*()` type. When used in combination with `orderByKey()`, the\r\n * value must be a string.\r\n * @param key - The child key to end at, among the children with the previously\r\n * specified priority. This argument is only allowed if ordering by child,\r\n * value, or priority.\r\n */\n\n\nfunction endAt(value, key) {\n validateKey('endAt', 'key', key, true);\n return new QueryEndAtConstraint(value, key);\n}\n\nvar QueryEndBeforeConstraint = /*#__PURE__*/function (_QueryConstraint2) {\n _inherits(QueryEndBeforeConstraint, _QueryConstraint2);\n\n var _super12 = _createSuper(QueryEndBeforeConstraint);\n\n function QueryEndBeforeConstraint(_value, _key) {\n var _this41;\n\n _classCallCheck(this, QueryEndBeforeConstraint);\n\n _this41 = _super12.call(this);\n _this41._value = _value;\n _this41._key = _key;\n return _this41;\n }\n\n _createClass(QueryEndBeforeConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateFirebaseDataArg('endBefore', this._value, query._path, false);\n var newParams = queryParamsEndBefore(query._queryParams, this._value, this._key);\n validateLimit(newParams);\n validateQueryEndpoints(newParams);\n\n if (query._queryParams.hasEnd()) {\n throw new Error('endBefore: Starting point was already set (by another call to endAt, ' + 'endBefore or equalTo).');\n }\n\n return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);\n }\n }]);\n\n return QueryEndBeforeConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a `QueryConstraint` with the specified ending point (exclusive).\r\n *\r\n * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`\r\n * allows you to choose arbitrary starting and ending points for your queries.\r\n *\r\n * The ending point is exclusive. If only a value is provided, children\r\n * with a value less than the specified value will be included in the query.\r\n * If a key is specified, then children must have a value lesss than or equal\r\n * to the specified value and a a key name less than the specified key.\r\n *\r\n * @param value - The value to end before. The argument type depends on which\r\n * `orderBy*()` function was used in this query. Specify a value that matches\r\n * the `orderBy*()` type. When used in combination with `orderByKey()`, the\r\n * value must be a string.\r\n * @param key - The child key to end before, among the children with the\r\n * previously specified priority. This argument is only allowed if ordering by\r\n * child, value, or priority.\r\n */\n\n\nfunction endBefore(value, key) {\n validateKey('endBefore', 'key', key, true);\n return new QueryEndBeforeConstraint(value, key);\n}\n\nvar QueryStartAtConstraint = /*#__PURE__*/function (_QueryConstraint3) {\n _inherits(QueryStartAtConstraint, _QueryConstraint3);\n\n var _super13 = _createSuper(QueryStartAtConstraint);\n\n function QueryStartAtConstraint(_value, _key) {\n var _this42;\n\n _classCallCheck(this, QueryStartAtConstraint);\n\n _this42 = _super13.call(this);\n _this42._value = _value;\n _this42._key = _key;\n return _this42;\n }\n\n _createClass(QueryStartAtConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateFirebaseDataArg('startAt', this._value, query._path, true);\n var newParams = queryParamsStartAt(query._queryParams, this._value, this._key);\n validateLimit(newParams);\n validateQueryEndpoints(newParams);\n\n if (query._queryParams.hasStart()) {\n throw new Error('startAt: Starting point was already set (by another call to startAt, ' + 'startBefore or equalTo).');\n }\n\n return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);\n }\n }]);\n\n return QueryStartAtConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a `QueryConstraint` with the specified starting point.\r\n *\r\n * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`\r\n * allows you to choose arbitrary starting and ending points for your queries.\r\n *\r\n * The starting point is inclusive, so children with exactly the specified value\r\n * will be included in the query. The optional key argument can be used to\r\n * further limit the range of the query. If it is specified, then children that\r\n * have exactly the specified value must also have a key name greater than or\r\n * equal to the specified key.\r\n *\r\n * You can read more about `startAt()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.\r\n *\r\n * @param value - The value to start at. The argument type depends on which\r\n * `orderBy*()` function was used in this query. Specify a value that matches\r\n * the `orderBy*()` type. When used in combination with `orderByKey()`, the\r\n * value must be a string.\r\n * @param key - The child key to start at. This argument is only allowed if\r\n * ordering by child, value, or priority.\r\n */\n\n\nfunction startAt() {\n var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n var key = arguments.length > 1 ? arguments[1] : undefined;\n validateKey('startAt', 'key', key, true);\n return new QueryStartAtConstraint(value, key);\n}\n\nvar QueryStartAfterConstraint = /*#__PURE__*/function (_QueryConstraint4) {\n _inherits(QueryStartAfterConstraint, _QueryConstraint4);\n\n var _super14 = _createSuper(QueryStartAfterConstraint);\n\n function QueryStartAfterConstraint(_value, _key) {\n var _this43;\n\n _classCallCheck(this, QueryStartAfterConstraint);\n\n _this43 = _super14.call(this);\n _this43._value = _value;\n _this43._key = _key;\n return _this43;\n }\n\n _createClass(QueryStartAfterConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateFirebaseDataArg('startAfter', this._value, query._path, false);\n var newParams = queryParamsStartAfter(query._queryParams, this._value, this._key);\n validateLimit(newParams);\n validateQueryEndpoints(newParams);\n\n if (query._queryParams.hasStart()) {\n throw new Error('startAfter: Starting point was already set (by another call to startAt, ' + 'startAfter, or equalTo).');\n }\n\n return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);\n }\n }]);\n\n return QueryStartAfterConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a `QueryConstraint` with the specified starting point (exclusive).\r\n *\r\n * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`\r\n * allows you to choose arbitrary starting and ending points for your queries.\r\n *\r\n * The starting point is exclusive. If only a value is provided, children\r\n * with a value greater than the specified value will be included in the query.\r\n * If a key is specified, then children must have a value greater than or equal\r\n * to the specified value and a a key name greater than the specified key.\r\n *\r\n * @param value - The value to start after. The argument type depends on which\r\n * `orderBy*()` function was used in this query. Specify a value that matches\r\n * the `orderBy*()` type. When used in combination with `orderByKey()`, the\r\n * value must be a string.\r\n * @param key - The child key to start after. This argument is only allowed if\r\n * ordering by child, value, or priority.\r\n */\n\n\nfunction startAfter(value, key) {\n validateKey('startAfter', 'key', key, true);\n return new QueryStartAfterConstraint(value, key);\n}\n\nvar QueryLimitToFirstConstraint = /*#__PURE__*/function (_QueryConstraint5) {\n _inherits(QueryLimitToFirstConstraint, _QueryConstraint5);\n\n var _super15 = _createSuper(QueryLimitToFirstConstraint);\n\n function QueryLimitToFirstConstraint(_limit) {\n var _this44;\n\n _classCallCheck(this, QueryLimitToFirstConstraint);\n\n _this44 = _super15.call(this);\n _this44._limit = _limit;\n return _this44;\n }\n\n _createClass(QueryLimitToFirstConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n if (query._queryParams.hasLimit()) {\n throw new Error('limitToFirst: Limit was already set (by another call to limitToFirst ' + 'or limitToLast).');\n }\n\n return new QueryImpl(query._repo, query._path, queryParamsLimitToFirst(query._queryParams, this._limit), query._orderByCalled);\n }\n }]);\n\n return QueryLimitToFirstConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a new `QueryConstraint` that if limited to the first specific number\r\n * of children.\r\n *\r\n * The `limitToFirst()` method is used to set a maximum number of children to be\r\n * synced for a given callback. If we set a limit of 100, we will initially only\r\n * receive up to 100 `child_added` events. If we have fewer than 100 messages\r\n * stored in our Database, a `child_added` event will fire for each message.\r\n * However, if we have over 100 messages, we will only receive a `child_added`\r\n * event for the first 100 ordered messages. As items change, we will receive\r\n * `child_removed` events for each item that drops out of the active list so\r\n * that the total number stays at 100.\r\n *\r\n * You can read more about `limitToFirst()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.\r\n *\r\n * @param limit - The maximum number of nodes to include in this query.\r\n */\n\n\nfunction limitToFirst(limit) {\n if (typeof limit !== 'number' || Math.floor(limit) !== limit || limit <= 0) {\n throw new Error('limitToFirst: First argument must be a positive integer.');\n }\n\n return new QueryLimitToFirstConstraint(limit);\n}\n\nvar QueryLimitToLastConstraint = /*#__PURE__*/function (_QueryConstraint6) {\n _inherits(QueryLimitToLastConstraint, _QueryConstraint6);\n\n var _super16 = _createSuper(QueryLimitToLastConstraint);\n\n function QueryLimitToLastConstraint(_limit) {\n var _this45;\n\n _classCallCheck(this, QueryLimitToLastConstraint);\n\n _this45 = _super16.call(this);\n _this45._limit = _limit;\n return _this45;\n }\n\n _createClass(QueryLimitToLastConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n if (query._queryParams.hasLimit()) {\n throw new Error('limitToLast: Limit was already set (by another call to limitToFirst ' + 'or limitToLast).');\n }\n\n return new QueryImpl(query._repo, query._path, queryParamsLimitToLast(query._queryParams, this._limit), query._orderByCalled);\n }\n }]);\n\n return QueryLimitToLastConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a new `QueryConstraint` that is limited to return only the last\r\n * specified number of children.\r\n *\r\n * The `limitToLast()` method is used to set a maximum number of children to be\r\n * synced for a given callback. If we set a limit of 100, we will initially only\r\n * receive up to 100 `child_added` events. If we have fewer than 100 messages\r\n * stored in our Database, a `child_added` event will fire for each message.\r\n * However, if we have over 100 messages, we will only receive a `child_added`\r\n * event for the last 100 ordered messages. As items change, we will receive\r\n * `child_removed` events for each item that drops out of the active list so\r\n * that the total number stays at 100.\r\n *\r\n * You can read more about `limitToLast()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.\r\n *\r\n * @param limit - The maximum number of nodes to include in this query.\r\n */\n\n\nfunction limitToLast(limit) {\n if (typeof limit !== 'number' || Math.floor(limit) !== limit || limit <= 0) {\n throw new Error('limitToLast: First argument must be a positive integer.');\n }\n\n return new QueryLimitToLastConstraint(limit);\n}\n\nvar QueryOrderByChildConstraint = /*#__PURE__*/function (_QueryConstraint7) {\n _inherits(QueryOrderByChildConstraint, _QueryConstraint7);\n\n var _super17 = _createSuper(QueryOrderByChildConstraint);\n\n function QueryOrderByChildConstraint(_path) {\n var _this46;\n\n _classCallCheck(this, QueryOrderByChildConstraint);\n\n _this46 = _super17.call(this);\n _this46._path = _path;\n return _this46;\n }\n\n _createClass(QueryOrderByChildConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateNoPreviousOrderByCall(query, 'orderByChild');\n var parsedPath = new Path(this._path);\n\n if (pathIsEmpty(parsedPath)) {\n throw new Error('orderByChild: cannot pass in empty path. Use orderByValue() instead.');\n }\n\n var index = new PathIndex(parsedPath);\n var newParams = queryParamsOrderBy(query._queryParams, index);\n validateQueryEndpoints(newParams);\n return new QueryImpl(query._repo, query._path, newParams,\n /*orderByCalled=*/\n true);\n }\n }]);\n\n return QueryOrderByChildConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a new `QueryConstraint` that orders by the specified child key.\r\n *\r\n * Queries can only order by one key at a time. Calling `orderByChild()`\r\n * multiple times on the same query is an error.\r\n *\r\n * Firebase queries allow you to order your data by any child key on the fly.\r\n * However, if you know in advance what your indexes will be, you can define\r\n * them via the .indexOn rule in your Security Rules for better performance. See\r\n * the{@link https://firebase.google.com/docs/database/security/indexing-data}\r\n * rule for more information.\r\n *\r\n * You can read more about `orderByChild()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.\r\n *\r\n * @param path - The path to order by.\r\n */\n\n\nfunction orderByChild(path) {\n if (path === '$key') {\n throw new Error('orderByChild: \"$key\" is invalid. Use orderByKey() instead.');\n } else if (path === '$priority') {\n throw new Error('orderByChild: \"$priority\" is invalid. Use orderByPriority() instead.');\n } else if (path === '$value') {\n throw new Error('orderByChild: \"$value\" is invalid. Use orderByValue() instead.');\n }\n\n validatePathString('orderByChild', 'path', path, false);\n return new QueryOrderByChildConstraint(path);\n}\n\nvar QueryOrderByKeyConstraint = /*#__PURE__*/function (_QueryConstraint8) {\n _inherits(QueryOrderByKeyConstraint, _QueryConstraint8);\n\n var _super18 = _createSuper(QueryOrderByKeyConstraint);\n\n function QueryOrderByKeyConstraint() {\n _classCallCheck(this, QueryOrderByKeyConstraint);\n\n return _super18.apply(this, arguments);\n }\n\n _createClass(QueryOrderByKeyConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateNoPreviousOrderByCall(query, 'orderByKey');\n var newParams = queryParamsOrderBy(query._queryParams, KEY_INDEX);\n validateQueryEndpoints(newParams);\n return new QueryImpl(query._repo, query._path, newParams,\n /*orderByCalled=*/\n true);\n }\n }]);\n\n return QueryOrderByKeyConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a new `QueryConstraint` that orders by the key.\r\n *\r\n * Sorts the results of a query by their (ascending) key values.\r\n *\r\n * You can read more about `orderByKey()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.\r\n */\n\n\nfunction orderByKey() {\n return new QueryOrderByKeyConstraint();\n}\n\nvar QueryOrderByPriorityConstraint = /*#__PURE__*/function (_QueryConstraint9) {\n _inherits(QueryOrderByPriorityConstraint, _QueryConstraint9);\n\n var _super19 = _createSuper(QueryOrderByPriorityConstraint);\n\n function QueryOrderByPriorityConstraint() {\n _classCallCheck(this, QueryOrderByPriorityConstraint);\n\n return _super19.apply(this, arguments);\n }\n\n _createClass(QueryOrderByPriorityConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateNoPreviousOrderByCall(query, 'orderByPriority');\n var newParams = queryParamsOrderBy(query._queryParams, PRIORITY_INDEX);\n validateQueryEndpoints(newParams);\n return new QueryImpl(query._repo, query._path, newParams,\n /*orderByCalled=*/\n true);\n }\n }]);\n\n return QueryOrderByPriorityConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a new `QueryConstraint` that orders by priority.\r\n *\r\n * Applications need not use priority but can order collections by\r\n * ordinary properties (see\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}\r\n * for alternatives to priority.\r\n */\n\n\nfunction orderByPriority() {\n return new QueryOrderByPriorityConstraint();\n}\n\nvar QueryOrderByValueConstraint = /*#__PURE__*/function (_QueryConstraint10) {\n _inherits(QueryOrderByValueConstraint, _QueryConstraint10);\n\n var _super20 = _createSuper(QueryOrderByValueConstraint);\n\n function QueryOrderByValueConstraint() {\n _classCallCheck(this, QueryOrderByValueConstraint);\n\n return _super20.apply(this, arguments);\n }\n\n _createClass(QueryOrderByValueConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateNoPreviousOrderByCall(query, 'orderByValue');\n var newParams = queryParamsOrderBy(query._queryParams, VALUE_INDEX);\n validateQueryEndpoints(newParams);\n return new QueryImpl(query._repo, query._path, newParams,\n /*orderByCalled=*/\n true);\n }\n }]);\n\n return QueryOrderByValueConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a new `QueryConstraint` that orders by value.\r\n *\r\n * If the children of a query are all scalar values (string, number, or\r\n * boolean), you can order the results by their (ascending) values.\r\n *\r\n * You can read more about `orderByValue()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.\r\n */\n\n\nfunction orderByValue() {\n return new QueryOrderByValueConstraint();\n}\n\nvar QueryEqualToValueConstraint = /*#__PURE__*/function (_QueryConstraint11) {\n _inherits(QueryEqualToValueConstraint, _QueryConstraint11);\n\n var _super21 = _createSuper(QueryEqualToValueConstraint);\n\n function QueryEqualToValueConstraint(_value, _key) {\n var _this47;\n\n _classCallCheck(this, QueryEqualToValueConstraint);\n\n _this47 = _super21.call(this);\n _this47._value = _value;\n _this47._key = _key;\n return _this47;\n }\n\n _createClass(QueryEqualToValueConstraint, [{\n key: \"_apply\",\n value: function _apply(query) {\n validateFirebaseDataArg('equalTo', this._value, query._path, false);\n\n if (query._queryParams.hasStart()) {\n throw new Error('equalTo: Starting point was already set (by another call to startAt/startAfter or ' + 'equalTo).');\n }\n\n if (query._queryParams.hasEnd()) {\n throw new Error('equalTo: Ending point was already set (by another call to endAt/endBefore or ' + 'equalTo).');\n }\n\n return new QueryEndAtConstraint(this._value, this._key)._apply(new QueryStartAtConstraint(this._value, this._key)._apply(query));\n }\n }]);\n\n return QueryEqualToValueConstraint;\n}(QueryConstraint);\n/**\r\n * Creates a `QueryConstraint` that includes children that match the specified\r\n * value.\r\n *\r\n * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`\r\n * allows you to choose arbitrary starting and ending points for your queries.\r\n *\r\n * The optional key argument can be used to further limit the range of the\r\n * query. If it is specified, then children that have exactly the specified\r\n * value must also have exactly the specified key as their key name. This can be\r\n * used to filter result sets with many matches for the same value.\r\n *\r\n * You can read more about `equalTo()` in\r\n * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.\r\n *\r\n * @param value - The value to match for. The argument type depends on which\r\n * `orderBy*()` function was used in this query. Specify a value that matches\r\n * the `orderBy*()` type. When used in combination with `orderByKey()`, the\r\n * value must be a string.\r\n * @param key - The child key to start at, among the children with the\r\n * previously specified priority. This argument is only allowed if ordering by\r\n * child, value, or priority.\r\n */\n\n\nfunction equalTo(value, key) {\n validateKey('equalTo', 'key', key, true);\n return new QueryEqualToValueConstraint(value, key);\n}\n/**\r\n * Creates a new immutable instance of `Query` that is extended to also include\r\n * additional query constraints.\r\n *\r\n * @param query - The Query instance to use as a base for the new constraints.\r\n * @param queryConstraints - The list of `QueryConstraint`s to apply.\r\n * @throws if any of the provided query constraints cannot be combined with the\r\n * existing or new constraints.\r\n */\n\n\nfunction query(query) {\n var queryImpl = getModularInstance(query);\n\n for (var _len7 = arguments.length, queryConstraints = new Array(_len7 > 1 ? _len7 - 1 : 0), _key8 = 1; _key8 < _len7; _key8++) {\n queryConstraints[_key8 - 1] = arguments[_key8];\n }\n\n for (var _i11 = 0, _queryConstraints = queryConstraints; _i11 < _queryConstraints.length; _i11++) {\n var constraint = _queryConstraints[_i11];\n queryImpl = constraint._apply(queryImpl);\n }\n\n return queryImpl;\n}\n/**\r\n * Define reference constructor in various modules\r\n *\r\n * We are doing this here to avoid several circular\r\n * dependency issues\r\n */\n\n\nsyncPointSetReferenceConstructor(ReferenceImpl);\nsyncTreeSetReferenceConstructor(ReferenceImpl);\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n/**\r\n * This variable is also defined in the firebase Node.js Admin SDK. Before\r\n * modifying this definition, consult the definition in:\r\n *\r\n * https://github.com/firebase/firebase-admin-node\r\n *\r\n * and make sure the two are consistent.\r\n */\n\nvar FIREBASE_DATABASE_EMULATOR_HOST_VAR = 'FIREBASE_DATABASE_EMULATOR_HOST';\n/**\r\n * Creates and caches `Repo` instances.\r\n */\n\nvar repos = {};\n/**\r\n * If true, any new `Repo` will be created to use `ReadonlyRestClient` (for testing purposes).\r\n */\n\nvar useRestClient = false;\n/**\r\n * Update an existing `Repo` in place to point to a new host/port.\r\n */\n\nfunction repoManagerApplyEmulatorSettings(repo, host, port, tokenProvider) {\n repo.repoInfo_ = new RepoInfo(\"\".concat(host, \":\").concat(port),\n /* secure= */\n false, repo.repoInfo_.namespace, repo.repoInfo_.webSocketOnly, repo.repoInfo_.nodeAdmin, repo.repoInfo_.persistenceKey, repo.repoInfo_.includeNamespaceInQueryParams);\n\n if (tokenProvider) {\n repo.authTokenProvider_ = tokenProvider;\n }\n}\n/**\r\n * This function should only ever be called to CREATE a new database instance.\r\n * @internal\r\n */\n\n\nfunction repoManagerDatabaseFromApp(app, authProvider, appCheckProvider, url, nodeAdmin) {\n var dbUrl = url || app.options.databaseURL;\n\n if (dbUrl === undefined) {\n if (!app.options.projectId) {\n fatal(\"Can't determine Firebase Database URL. Be sure to include \" + ' a Project ID when calling firebase.initializeApp().');\n }\n\n log('Using default host for project ', app.options.projectId);\n dbUrl = \"\".concat(app.options.projectId, \"-default-rtdb.firebaseio.com\");\n }\n\n var parsedUrl = parseRepoInfo(dbUrl, nodeAdmin);\n var repoInfo = parsedUrl.repoInfo;\n var isEmulator;\n var dbEmulatorHost = undefined;\n\n if (typeof process !== 'undefined') {\n dbEmulatorHost = process.env[FIREBASE_DATABASE_EMULATOR_HOST_VAR];\n }\n\n if (dbEmulatorHost) {\n isEmulator = true;\n dbUrl = \"http://\".concat(dbEmulatorHost, \"?ns=\").concat(repoInfo.namespace);\n parsedUrl = parseRepoInfo(dbUrl, nodeAdmin);\n repoInfo = parsedUrl.repoInfo;\n } else {\n isEmulator = !parsedUrl.repoInfo.secure;\n }\n\n var authTokenProvider = nodeAdmin && isEmulator ? new EmulatorTokenProvider(EmulatorTokenProvider.OWNER) : new FirebaseAuthTokenProvider(app.name, app.options, authProvider);\n validateUrl('Invalid Firebase Database URL', parsedUrl);\n\n if (!pathIsEmpty(parsedUrl.path)) {\n fatal('Database URL must point to the root of a Firebase Database ' + '(not including a child path).');\n }\n\n var repo = repoManagerCreateRepo(repoInfo, app, authTokenProvider, new AppCheckTokenProvider(app.name, appCheckProvider));\n return new Database(repo, app);\n}\n/**\r\n * Remove the repo and make sure it is disconnected.\r\n *\r\n */\n\n\nfunction repoManagerDeleteRepo(repo, appName) {\n var appRepos = repos[appName]; // This should never happen...\n\n if (!appRepos || appRepos[repo.key] !== repo) {\n fatal(\"Database \".concat(appName, \"(\").concat(repo.repoInfo_, \") has already been deleted.\"));\n }\n\n repoInterrupt(repo);\n delete appRepos[repo.key];\n}\n/**\r\n * Ensures a repo doesn't already exist and then creates one using the\r\n * provided app.\r\n *\r\n * @param repoInfo - The metadata about the Repo\r\n * @returns The Repo object for the specified server / repoName.\r\n */\n\n\nfunction repoManagerCreateRepo(repoInfo, app, authTokenProvider, appCheckProvider) {\n var appRepos = repos[app.name];\n\n if (!appRepos) {\n appRepos = {};\n repos[app.name] = appRepos;\n }\n\n var repo = appRepos[repoInfo.toURLString()];\n\n if (repo) {\n fatal('Database initialized multiple times. Please make sure the format of the database URL matches with each database() call.');\n }\n\n repo = new Repo(repoInfo, useRestClient, authTokenProvider, appCheckProvider);\n appRepos[repoInfo.toURLString()] = repo;\n return repo;\n}\n/**\r\n * Forces us to use ReadonlyRestClient instead of PersistentConnection for new Repos.\r\n */\n\n\nfunction repoManagerForceRestClient(forceRestClient) {\n useRestClient = forceRestClient;\n}\n/**\r\n * Class representing a Firebase Realtime Database.\r\n */\n\n\nvar Database = /*#__PURE__*/function () {\n /** @hideconstructor */\n function Database(_repoInternal,\n /** The {@link @firebase/app#FirebaseApp} associated with this Realtime Database instance. */\n app) {\n _classCallCheck(this, Database);\n\n this._repoInternal = _repoInternal;\n this.app = app;\n /** Represents a `Database` instance. */\n\n this['type'] = 'database';\n /** Track if the instance has been used (root or repo accessed) */\n\n this._instanceStarted = false;\n }\n\n _createClass(Database, [{\n key: \"_repo\",\n get: function get() {\n if (!this._instanceStarted) {\n repoStart(this._repoInternal, this.app.options.appId, this.app.options['databaseAuthVariableOverride']);\n this._instanceStarted = true;\n }\n\n return this._repoInternal;\n }\n }, {\n key: \"_root\",\n get: function get() {\n if (!this._rootInternal) {\n this._rootInternal = new ReferenceImpl(this._repo, newEmptyPath());\n }\n\n return this._rootInternal;\n }\n }, {\n key: \"_delete\",\n value: function _delete() {\n if (this._rootInternal !== null) {\n repoManagerDeleteRepo(this._repo, this.app.name);\n this._repoInternal = null;\n this._rootInternal = null;\n }\n\n return Promise.resolve();\n }\n }, {\n key: \"_checkNotDeleted\",\n value: function _checkNotDeleted(apiName) {\n if (this._rootInternal === null) {\n fatal('Cannot call ' + apiName + ' on a deleted database.');\n }\n }\n }]);\n\n return Database;\n}();\n/**\r\n * Returns the instance of the Realtime Database SDK that is associated\r\n * with the provided {@link @firebase/app#FirebaseApp}. Initializes a new instance with\r\n * with default settings if no instance exists or if the existing instance uses\r\n * a custom database URL.\r\n *\r\n * @param app - The {@link @firebase/app#FirebaseApp} instance that the returned Realtime\r\n * Database instance is associated with.\r\n * @param url - The URL of the Realtime Database instance to connect to. If not\r\n * provided, the SDK connects to the default instance of the Firebase App.\r\n * @returns The `Database` instance of the provided app.\r\n */\n\n\nfunction getDatabase() {\n var app = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getApp();\n var url = arguments.length > 1 ? arguments[1] : undefined;\n return _getProvider(app, 'database').getImmediate({\n identifier: url\n });\n}\n/**\r\n * Modify the provided instance to communicate with the Realtime Database\r\n * emulator.\r\n *\r\n * Note: This method must be called before performing any other operation.\r\n *\r\n * @param db - The instance to modify.\r\n * @param host - The emulator host (ex: localhost)\r\n * @param port - The emulator port (ex: 8080)\r\n * @param options.mockUserToken - the mock auth token to use for unit testing Security Rules\r\n */\n\n\nfunction connectDatabaseEmulator(db, host, port) {\n var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n db = getModularInstance(db);\n\n db._checkNotDeleted('useEmulator');\n\n if (db._instanceStarted) {\n fatal('Cannot call useEmulator() after instance has already been initialized.');\n }\n\n var repo = db._repoInternal;\n var tokenProvider = undefined;\n\n if (repo.repoInfo_.nodeAdmin) {\n if (options.mockUserToken) {\n fatal('mockUserToken is not supported by the Admin SDK. For client access with mock users, please use the \"firebase\" package instead of \"firebase-admin\".');\n }\n\n tokenProvider = new EmulatorTokenProvider(EmulatorTokenProvider.OWNER);\n } else if (options.mockUserToken) {\n var token = typeof options.mockUserToken === 'string' ? options.mockUserToken : createMockUserToken(options.mockUserToken, db.app.options.projectId);\n tokenProvider = new EmulatorTokenProvider(token);\n } // Modify the repo to apply emulator settings\n\n\n repoManagerApplyEmulatorSettings(repo, host, port, tokenProvider);\n}\n/**\r\n * Disconnects from the server (all Database operations will be completed\r\n * offline).\r\n *\r\n * The client automatically maintains a persistent connection to the Database\r\n * server, which will remain active indefinitely and reconnect when\r\n * disconnected. However, the `goOffline()` and `goOnline()` methods may be used\r\n * to control the client connection in cases where a persistent connection is\r\n * undesirable.\r\n *\r\n * While offline, the client will no longer receive data updates from the\r\n * Database. However, all Database operations performed locally will continue to\r\n * immediately fire events, allowing your application to continue behaving\r\n * normally. Additionally, each operation performed locally will automatically\r\n * be queued and retried upon reconnection to the Database server.\r\n *\r\n * To reconnect to the Database and begin receiving remote events, see\r\n * `goOnline()`.\r\n *\r\n * @param db - The instance to disconnect.\r\n */\n\n\nfunction goOffline(db) {\n db = getModularInstance(db);\n\n db._checkNotDeleted('goOffline');\n\n repoInterrupt(db._repo);\n}\n/**\r\n * Reconnects to the server and synchronizes the offline Database state\r\n * with the server state.\r\n *\r\n * This method should be used after disabling the active connection with\r\n * `goOffline()`. Once reconnected, the client will transmit the proper data\r\n * and fire the appropriate events so that your client \"catches up\"\r\n * automatically.\r\n *\r\n * @param db - The instance to reconnect.\r\n */\n\n\nfunction goOnline(db) {\n db = getModularInstance(db);\n\n db._checkNotDeleted('goOnline');\n\n repoResume(db._repo);\n}\n\nfunction enableLogging(logger, persistent) {\n enableLogging$1(logger, persistent);\n}\n/**\r\n * @license\r\n * Copyright 2021 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n\nfunction registerDatabase(variant) {\n setSDKVersion(SDK_VERSION$1);\n\n _registerComponent(new Component('database', function (container, _ref3) {\n var url = _ref3.instanceIdentifier;\n var app = container.getProvider('app').getImmediate();\n var authProvider = container.getProvider('auth-internal');\n var appCheckProvider = container.getProvider('app-check-internal');\n return repoManagerDatabaseFromApp(app, authProvider, appCheckProvider, url);\n }, \"PUBLIC\"\n /* PUBLIC */\n ).setMultipleInstances(true));\n\n registerVersion(name, version, variant); // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\n\n registerVersion(name, version, 'esm2017');\n}\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n\nvar SERVER_TIMESTAMP = {\n '.sv': 'timestamp'\n};\n/**\r\n * Returns a placeholder value for auto-populating the current timestamp (time\r\n * since the Unix epoch, in milliseconds) as determined by the Firebase\r\n * servers.\r\n */\n\nfunction serverTimestamp() {\n return SERVER_TIMESTAMP;\n}\n/**\r\n * Returns a placeholder value that can be used to atomically increment the\r\n * current database value by the provided delta.\r\n *\r\n * @param delta - the amount to modify the current value atomically.\r\n * @returns A placeholder value for modifying data atomically server-side.\r\n */\n\n\nfunction increment(delta) {\n return {\n '.sv': {\n 'increment': delta\n }\n };\n}\n/**\r\n * @license\r\n * Copyright 2020 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n/**\r\n * A type for the resolve value of {@link runTransaction}.\r\n */\n\n\nvar TransactionResult = /*#__PURE__*/function () {\n /** @hideconstructor */\n function TransactionResult(\n /** Whether the transaction was successfully committed. */\n committed,\n /** The resulting data snapshot. */\n snapshot) {\n _classCallCheck(this, TransactionResult);\n\n this.committed = committed;\n this.snapshot = snapshot;\n }\n /** Returns a JSON-serializable representation of this object. */\n\n\n _createClass(TransactionResult, [{\n key: \"toJSON\",\n value: function toJSON() {\n return {\n committed: this.committed,\n snapshot: this.snapshot.toJSON()\n };\n }\n }]);\n\n return TransactionResult;\n}();\n/**\r\n * Atomically modifies the data at this location.\r\n *\r\n * Atomically modify the data at this location. Unlike a normal `set()`, which\r\n * just overwrites the data regardless of its previous value, `runTransaction()` is\r\n * used to modify the existing value to a new value, ensuring there are no\r\n * conflicts with other clients writing to the same location at the same time.\r\n *\r\n * To accomplish this, you pass `runTransaction()` an update function which is\r\n * used to transform the current value into a new value. If another client\r\n * writes to the location before your new value is successfully written, your\r\n * update function will be called again with the new current value, and the\r\n * write will be retried. This will happen repeatedly until your write succeeds\r\n * without conflict or you abort the transaction by not returning a value from\r\n * your update function.\r\n *\r\n * Note: Modifying data with `set()` will cancel any pending transactions at\r\n * that location, so extreme care should be taken if mixing `set()` and\r\n * `runTransaction()` to update the same data.\r\n *\r\n * Note: When using transactions with Security and Firebase Rules in place, be\r\n * aware that a client needs `.read` access in addition to `.write` access in\r\n * order to perform a transaction. This is because the client-side nature of\r\n * transactions requires the client to read the data in order to transactionally\r\n * update it.\r\n *\r\n * @param ref - The location to atomically modify.\r\n * @param transactionUpdate - A developer-supplied function which will be passed\r\n * the current data stored at this location (as a JavaScript object). The\r\n * function should return the new value it would like written (as a JavaScript\r\n * object). If `undefined` is returned (i.e. you return with no arguments) the\r\n * transaction will be aborted and the data at this location will not be\r\n * modified.\r\n * @param options - An options object to configure transactions.\r\n * @returns A `Promise` that can optionally be used instead of the `onComplete`\r\n * callback to handle success and failure.\r\n */\n\n\nfunction runTransaction(ref, // eslint-disable-next-line @typescript-eslint/no-explicit-any\ntransactionUpdate, options) {\n var _a;\n\n ref = getModularInstance(ref);\n validateWritablePath('Reference.transaction', ref._path);\n\n if (ref.key === '.length' || ref.key === '.keys') {\n throw 'Reference.transaction failed: ' + ref.key + ' is a read-only object.';\n }\n\n var applyLocally = (_a = options === null || options === void 0 ? void 0 : options.applyLocally) !== null && _a !== void 0 ? _a : true;\n var deferred = new Deferred();\n\n var promiseComplete = function promiseComplete(error, committed, node) {\n var dataSnapshot = null;\n\n if (error) {\n deferred.reject(error);\n } else {\n dataSnapshot = new DataSnapshot(node, new ReferenceImpl(ref._repo, ref._path), PRIORITY_INDEX);\n deferred.resolve(new TransactionResult(committed, dataSnapshot));\n }\n }; // Add a watch to make sure we get server updates.\n\n\n var unwatcher = onValue(ref, function () {});\n repoStartTransaction(ref._repo, ref._path, transactionUpdate, promiseComplete, unwatcher, applyLocally);\n return deferred.promise;\n}\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\n\n\nPersistentConnection; // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\nPersistentConnection.prototype.simpleListen = function (pathString, onComplete) {\n this.sendRequest('q', {\n p: pathString\n }, onComplete);\n}; // eslint-disable-next-line @typescript-eslint/no-explicit-any\n\n\nPersistentConnection.prototype.echo = function (data, onEcho) {\n this.sendRequest('echo', {\n d: data\n }, onEcho);\n}; // RealTimeConnection properties that we use in tests.\n\n\nConnection;\n/**\r\n * @internal\r\n */\n\nvar hijackHash = function hijackHash(newHash) {\n var oldPut = PersistentConnection.prototype.put;\n\n PersistentConnection.prototype.put = function (pathString, data, onComplete, hash) {\n if (hash !== undefined) {\n hash = newHash();\n }\n\n oldPut.call(this, pathString, data, onComplete, hash);\n };\n\n return function () {\n PersistentConnection.prototype.put = oldPut;\n };\n};\n\nRepoInfo;\n/**\r\n * Forces the RepoManager to create Repos that use ReadonlyRestClient instead of PersistentConnection.\r\n * @internal\r\n */\n\nvar forceRestClient = function forceRestClient(_forceRestClient) {\n repoManagerForceRestClient(_forceRestClient);\n};\n/**\r\n * Firebase Realtime Database\r\n *\r\n * @packageDocumentation\r\n */\n\n\nregisterDatabase();\nexport { DataSnapshot, Database, OnDisconnect, QueryConstraint, TransactionResult, QueryImpl as _QueryImpl, QueryParams as _QueryParams, ReferenceImpl as _ReferenceImpl, forceRestClient as _TEST_ACCESS_forceRestClient, hijackHash as _TEST_ACCESS_hijackHash, repoManagerDatabaseFromApp as _repoManagerDatabaseFromApp, setSDKVersion as _setSDKVersion, validatePathString as _validatePathString, validateWritablePath as _validateWritablePath, _child9 as child, connectDatabaseEmulator, enableLogging, endAt, endBefore, equalTo, get, getDatabase, goOffline, goOnline, increment, limitToFirst, limitToLast, off, onChildAdded, onChildChanged, onChildMoved, onChildRemoved, onDisconnect, onValue, orderByChild, orderByKey, orderByPriority, orderByValue, push, query, ref, refFromURL, remove, runTransaction, serverTimestamp, set, setPriority, setWithPriority, startAfter, startAt, update };"],"names":["_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Boolean","prototype","valueOf","call","e","_isNativeReflectConstruct","result","Super","NewTarget","this","constructor","arguments","apply","_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","minLen","_arrayLikeToArray","n","Object","toString","slice","name","from","test","_unsupportedIterableToArray","length","i","F","s","done","value","_e","f","TypeError","err","normalCompletion","didErr","step","next","_e2","return","arr","len","arr2","version","SDK_VERSION","id","DOMStorageWrapper","domStorage_","prefix_","key","removeItem","prefixedName_","setItem","storedVal","getItem","MemoryStorage","cache_","isInMemoryStorage","createStoragefor","domStorageName","window","domStorage","PersistentStorage","SessionStorage","logClient","LUIDGenerator","sha1","str","utf8Bytes","update","sha1Bytes","digest","buildLogMessage_","message","arg","undefined","logger","firstLog_","enableLogging$1","logger_","persistent","logLevel","log","bind","set","remove","get","_len","varArgs","_key2","logWrapper","prefix","_len2","_key3","concat","error","fatal","Error","warn","isInvalidJSONNumber","data","Number","POSITIVE_INFINITY","NEGATIVE_INFINITY","MIN_NAME","MAX_NAME","nameCompare","a","b","aAsInt","tryParseInt","bAsInt","stringCompare","requireKey","obj","ObjectToUniqueKey","keys","k","push","sort","splitStringBySize","segsize","dataSegs","c","substring","each","fn","hasOwnProperty","doubleToIEEE754String","v","ln","bias","Infinity","Math","abs","pow","min","floor","LN2","round","bits","reverse","join","hexByteString","hexByte","parseInt","substr","toLowerCase","INTEGER_REGEXP_","RegExp","INTEGER_32_MIN","INTEGER_32_MAX","intVal","exceptionGuard","setTimeout","stack","setTimeoutNonBlocking","time","timeout","AppCheckTokenProvider","appName_","appCheckProvider","_this","appCheck","getImmediate","optional","then","forceRefresh","_this2","getToken","Promise","resolve","reject","listener","_a","addTokenListener","FirebaseAuthTokenProvider","firebaseOptions_","authProvider_","_this3","auth_","onInit","auth","_this4","catch","code","addAuthTokenListener","removeAuthTokenListener","errorMessage","EmulatorTokenProvider","accessToken","OWNER","PROTOCOL_VERSION","FORGE_DOMAIN_RE","WEBSOCKET","LONG_POLLING","RepoInfo","host","secure","namespace","webSocketOnly","nodeAdmin","persistenceKey","includeNamespaceInQueryParams","_host","_domain","indexOf","internalHost","newHost","isCacheableHost","toURLString","protocol","query","repoInfoConnectionURL","repoInfo","type","params","connURL","isCustomHost","repoInfoNeedsQueryParam","pairs","StatsCollection","counters_","amount","collections","reporters","statsManagerGetCollection","hashString","PacketReceiver","onMessage_","pendingResponses","currentResponseNum","closeAfterResponse","onClose","responseNum","callback","requestNum","_this5","_loop","toProcess","_loop2","FIREBASE_LONGPOLL_START_PARAM","FIREBASE_LONGPOLL_CLOSE_COMMAND","BrowserPollConnection","connId","applicationId","appCheckToken","authToken","transportSessionId","lastSessionId","_this6","bytesSent","bytesReceived","everConnected_","log_","stats_","urlFn","onMessage","onDisconnect","_this7","curSegmentNum","onDisconnect_","myPacketOrderer","isClosed_","connectTimeoutTimer_","onClosed_","document","readyState","called","wrappedFn","body","addEventListener","attachEvent","executeWhenDOMReady","scriptTagHolder","FirebaseIFrameScriptHolder","_len3","args","_key4","command","arg1","arg2","incrementIncomingBytes_","clearTimeout","password","sendNewPolls","closeAfter","_len4","_key5","pN","handleResponse","urlParams","random","uniqueCallbackIdentifier","location","hostname","connectURL","addTag","startLongPoll","addDisconnectPingFrame","close","myDisconnFrame","removeChild","shutdown_","dataStr","incrementCounter","base64data","MAX_URL_DATA_SIZE","enqueueSegment","pw","createElement","src","style","display","appendChild","forceAllow_","forceDisallow_","href","Windows","UI","commandCB","onMessageCB","outstandingRequests","Set","pendingSegs","currentSerial","myIFrame","createIFrame_","script","domain","iframeContents","doc","open","write","_this8","alive","innerHTML","myID","myPW","newRequest_","size","theURL","curDataString","d","theSeg","shift","seg","ts","addLongPollTag_","segnum","totalsegs","url","serial","_this9","add","doNewRequest","delete","keepaliveTimeout","loadCB","_this10","doNodeLongPoll","newScript","async","onload","onreadystatechange","rstate","parentNode","onerror","iframe","contentWindow","contentDocument","WebSocketImpl","MozWebSocket","WebSocket","WebSocketConnection","keepaliveTimer","frames","totalFrames","connectionURL_","_this11","device","options","headers","process","platform","env","proxy","origin","mySock","_options","_error","onopen","onclose","onmessage","m","handleIncomingFrame","fullMess","jsonMess","frameCount","isNaN","handleNewFrameCount_","mess","resetKeepAlive","appendFrame_","remainingData","extractFrameCount_","sendString_","String","clearInterval","_this12","setInterval","send","isOldAndroid","navigator","userAgent","oldAndroidMatch","match","parseFloat","responsesRequiredToBeHealthy","healthyTimeout","TransportManager","initTransports_","isWebSocketsAvailable","isSkipPollConnection","previouslyFailed","transports_","_step","transports","_iterator","ALL_TRANSPORTS","transport","Connection","repoInfo_","applicationId_","appCheckToken_","authToken_","onReady_","onKill_","connectionCount","pendingDataMessages","state_","transportManager_","start_","_this13","conn","initialTransport","conn_","nextTransportId_","primaryResponsesRequired_","onMessageReceived","connReceiver_","onConnectionLost","disconnReceiver_","tx_","rx_","secondaryConn_","isHealthy_","healthyTimeoutMS","healthyTimeout_","markConnectionHealthy","_this14","everConnected","onConnectionLost_","onSecondaryConnectionLost_","_this15","onPrimaryMessageReceived_","onSecondaryMessageReceived_","dataMsg","msg","t","sendData_","controlData","cmd","upgradeIfSecondaryHealthy_","secondaryResponsesRequired_","parsedData","layer","onSecondaryControl_","proceedWithUpgrade_","start","tryCleanupConnection","onControl_","onDataMessage_","onPrimaryResponse_","payload","onHandshake_","onConnectionShutdown_","onReset_","sendPingOnPrimaryIfNecessary_","handshake","timestamp","h","sessionId","onConnectionEstablished_","tryStartUpgrade_","upgradeTransport","startUpgrade_","_this16","closeConnections_","_this17","reason","ServerActions","pathString","onComplete","hash","token","stats","EventEmitter","allowedEvents_","listeners_","eventType","listeners","_len5","_key6","context","validateEventType_","eventData","getInitialEvent","splice","find","et","OnlineMonitor","_EventEmitter","_super","_this18","online_","trigger","Path","pathOrString","pieceNum","pieces_","split","copyTo","pieceNum_","newEmptyPath","pathGetFront","path","pathGetLength","pathPopFront","pathGetBack","pathSlice","begin","pathParent","pieces","pathChild","childPathObj","_i","childPieces","_i2","pathIsEmpty","newRelativePath","outerPath","innerPath","outer","inner","pathEquals","other","j","pathContains","ValidationPath","errorPrefix_","parts_","byteLength_","max","validationPathCheckValid","validationPath","validationPathToErrorString","VisibilityMonitor","_EventEmitter2","_super2","_this19","hidden","visibilityChange","visible_","visible","RECONNECT_MIN_DELAY","PersistentConnection","_ServerActions","_establishConnection_","_super3","onDataUpdate_","onConnectStatus_","onServerInfoUpdate_","authTokenProvider_","appCheckTokenProvider_","authOverride_","_this20","nextPersistentConnectionId_","interruptReasons_","listens","Map","outstandingPuts_","outstandingGets_","outstandingPutCount_","outstandingGetCount_","onDisconnectRequestQueue_","connected_","reconnectDelay_","maxReconnectDelay_","securityDebugCallback_","establishConnectionTimer_","requestCBHash_","requestNumber_","realtime_","forceTokenRefresh_","invalidAuthTokenCount_","invalidAppCheckTokenCount_","firstConnection_","lastConnectionAttemptTime_","lastConnectionEstablishedTime_","getInstance","on","onVisible_","onOnline_","action","onResponse","curReqNum","r","sendRequest","_this21","initConnection_","deferred","request","p","_path","q","_queryObject","outstandingGet","index","sendGet_","promise","currentHashFn","tag","queryId","_queryIdentifier","has","_queryParams","isDefault","loadsAllData","listenSpec","hashFn","sendListen_","_this22","_this23","req","status","warnOnListenWarnings_","removeListen_","tryAuth","reduceReconnectDelayIfAdminCredential_","credential","tryAppCheck","_this24","authMethod","requestData","cred","res","onAuthRevoked_","_this25","onAppCheckRevoked_","sendUnlisten_","queryObj","sendOnDisconnect_","response","putInternal","sendPut_","_this26","queued","_this27","errorReason","reqNum","onDataPush_","onListenRevoked_","onSecurityDebugPacket_","Date","getTime","handleTimestamp_","sendConnectStats_","restoreState_","_this28","establishConnection_","scheduleConnect_","online","cancelSentTransactions_","shouldReconnect_","timeSinceLastConnectAttempt","reconnectDelay","_callee","onDataMessage","onReady","_onDisconnect","canceled","connection","closeFn","sendRequestFn","_yield$Promise$all","_yield$Promise$all2","_this29","_context","prev","onRealtimeDisconnect_","nextConnectionId_","all","sent","interrupt","t0","stop","delta","serverTimeOffset","put","map","listen","normalizedPathString","_map","statusCode","explanation","notifyForInvalidToken","console","replace","_step2","_iterator2","values","_step3","_iterator3","_i3","clientName","reportStats","currentlyOnline","warnings","indexSpec","getIndex","indexPath","__EMPTY_NODE","NamedNode","node","Index","compare","oldNode","newNode","oldWrapped","newWrapped","MIN","KeyIndex","_Index","_super4","indexValue","val","KEY_INDEX","SortedMapIterator","startKey","comparator","isReverse_","resultGenerator_","nodeStack_","cmp","isEmpty","left","right","pop","LLRBNode","color","RED","SortedMap","EMPTY_NODE","count","inorderTraversal","reverseTraversal","min_","maxKey","copy","insert","fixUp_","isRed_","moveRedLeft_","removeMin_","smallest","rotateRight_","moveRedRight_","rotateLeft_","colorFlip_","nl","nr","blackDepth","check_","BLACK","MAX_NODE$2","LLRBEmptyNode","comparator_","root_","rightParent","minKey","resultGenerator","NAME_ONLY_COMPARATOR","NAME_COMPARATOR","__childrenNodeConstructor","nodeFromJSON$1","MAX_NODE$1","priorityHashText","priority","validatePriorityNode","priorityNode","isLeafNode","getPriority","LeafNode","value_","priorityNode_","lazyHash_","newPriorityNode","childName","childNode","newChildNode","updatePriority","updateImmediateChild","front","updateChild","exportFormat","getValue","toHash","compareToLeafNode_","otherLeaf","otherLeafType","thisLeafType","otherIndex","VALUE_TYPE_ORDER","thisIndex","equals","_defaultIndexMap","PriorityIndex","_Index2","_super5","aPriority","bPriority","indexCmp","compareTo","PRIORITY_INDEX","LOG_2","Base12Num","num","current_","mask","bits_","buildChildSet","childList","keyFn","mapSortFn","buildBalancedTree","low","high","namedNode","middle","root","base12","buildPennant","chunkSize","childTree","attachPennant","pennant","isOne","nextBitIsOne","buildFrom12Array","fallbackObject","IndexMap","indexes_","indexSet_","indexKey","sortedMap","indexDefinition","existingChildren","newIndex","sawIndexedValue","iter","getIterator","Wrap","getNext","isDefinedOn","getCompare","indexName","newIndexSet","assign","newIndexes","_this30","indexedChildren","existingSnap","newChildren","ChildrenNode","children_","indexMap_","_child","getImmediateChild","getChild","newIndexMap","removeFromIndexes","addToIndexes","newPriority","newImmediateChild","numKeys","allIntegerKeys","forEachChild","array","childHash","idx","resolveIndex_","_predecessor","getPredecessorKey","getFirstChildName","getLastChildName","wrappedNode","getIteratorFrom","minPost","startPost","peek","getReverseIteratorFrom","maxPost","endPost","MAX_NODE","hasIndex","addIndex","otherChildrenNode","thisIter","otherIter","thisCurrent","otherCurrent","Default","_ChildrenNode","MaxNode","_super6","defineProperties","MAX","setMaxNode","nodeFromJSON","json","jsonLeaf","childData","children","childrenHavePriority","hinzeJsonObj","child","childSet","sortedChildSet","setNodeFromJSON","lastPushTime","lastRandChars","PathIndex","_Index3","_super7","indexPath_","_this31","snap","aChild","extractChild","bChild","valueNode","ValueIndex","_Index4","_super8","VALUE_INDEX","PUSH_CHARS","nextPushId","now","duplicateTime","timeStampChars","charAt","changeValue","snapshotNode","changeChildAdded","changeChildRemoved","changeChildChanged","oldSnap","QueryParams","limitSet_","startSet_","startNameSet_","startAfterSet_","endSet_","endNameSet_","endBeforeSet_","limit_","viewFrom_","indexStartValue_","indexStartName_","indexEndValue_","indexEndName_","index_","queryParamsToRestQueryStringParameters","queryParams","orderBy","qs","isViewFromLeft","queryParamsGetQueryObject","viewFrom","ReadonlyRestClient","_ServerActions2","_super9","_this32","listens_","_this33","listenId","getListenId_","thisListen","queryStringParameters","restRequest_","_this34","_this35","_ref","_ref2","xhr","XMLHttpRequest","responseText","SnapshotHolder","rootNode_","newSnapshotNode","newSparseSnapshotTree","sparseSnapshotTreeRemember","sparseSnapshotTree","clear","childKey","sparseSnapshotTreeForEachTree","prefixPath","func","forEach","tree","sparseSnapshotTreeForEachChild","OperationType","StatsListener","collection_","last_","newStats","stat","StatsReporter","collection","server_","statsToReport_","statsListener_","reportStats_","_this36","reportedStats","haveStatsToReport","newOperationSourceServerTaggedQuery","fromUser","fromServer","tagged","emptyChildrenSingleton","AckUserWrite","affectedTree","revert","ACK_USER_WRITE","source","subtree","Overwrite","OVERWRITE","Merge","MERGE","CacheNode","node_","fullyInitialized_","filtered_","isFullyInitialized","isCompleteForChild","hasChild","eventGeneratorGenerateEventsForType","eventGenerator","events","changes","registrations","eventCache","filteredChanges","filter","change","aWrapped","bWrapped","eventGeneratorCompareChanges","materializedChange","prevName","getPredecessorChildName","eventGeneratorMaterializeSingleChange","registration","respondsTo","createEvent","query_","newViewCache","serverCache","viewCacheUpdateEventSnap","viewCache","eventSnap","complete","filtered","viewCacheUpdateServerSnap","serverSnap","viewCacheGetCompleteEventSnap","getNode","viewCacheGetCompleteServerSnap","EmptyChildren","ImmutableTree","relativePath","predicate","_child3","childExistingPathAndValue","findRootMostMatchingPathAndValue","toSet","newChild","_child5","_child6","newTree","setTree","fold_","pathSoFar","accum","findOnPath_","pathToFollow","nextChild","foreachOnPath_","currentRelativePath","foreach_","childPath","childSnap","CompoundWrite","writeTree_","compoundWriteAddWrite","compoundWrite","rootmost","findRootMostValueAndPath","rootMostPath","_newWriteTree","compoundWriteAddWrites","updates","newWrite","compoundWriteRemoveWrite","empty","_newWriteTree2","compoundWriteHasCompleteWrite","compoundWriteGetCompleteNode","compoundWriteGetCompleteChildren","compoundWriteChildCompoundWrite","shadowingNode","compoundWriteIsEmpty","compoundWriteApply","applySubtreeWrite","writeTree","priorityWrite","writeTreeChildWrites","newWriteTreeRef","writeTreeGetWrite","writeId","allWrites","record","writeTreeRemoveWrite","findIndex","writeToRemove","removedWriteWasVisible","removedWriteOverlapsWithOtherWrites","currentWrite","writeTreeRecordContainsPath_","visibleWrites","writeTreeLayerTree_","writeTreeDefaultFilter_","lastWriteId","writeTreeResetTree_","writeRecord","writes","treeRoot","writePath","_child8","deepNode","writeTreeCalcCompleteEventCache","treePath","completeServerCache","writeIdsToExclude","includeHiddenWrites","merge","subMerge","writeTreeRefCalcCompleteEventCache","writeTreeRef","writeTreeRefCalcCompleteEventChildren","completeServerChildren","completeChildren","topLevelSet","writeTreeCalcCompleteEventChildren","writeTreeRefCalcEventCacheAfterServerOverwrite","existingEventSnap","existingServerSnap","childMerge","writeTreeCalcEventCacheAfterServerOverwrite","writeTreeRefShadowingWrite","writeTreeShadowingWrite","writeTreeRefCalcIndexedSlice","completeServerData","toIterate","withIndex","nodes","writeTreeCalcIndexedSlice","writeTreeRefCalcCompleteChild","existingServerCache","writeTreeCalcCompleteChild","writeTreeRefChild","ChildChangeAccumulator","changeMap","oldChange","oldType","NO_COMPLETE_CHILD_SOURCE","NoCompleteChildSource_","WriteTreeCompleteChildSource","writes_","viewCache_","optCompleteServerCache_","serverNode","viewProcessorApplyOperation","viewProcessor","oldViewCache","operation","writesCache","completeCache","filterServerNode","accumulator","overwrite","viewProcessorApplyUserOverwrite","isFiltered","viewProcessorApplyServerOverwrite","changedChildren","curViewCache","foreach","viewProcessorCacheHasChild","viewProcessorApplyUserMerge","viewProcessorApplyServerMerge","ackUserWrite","newEventCache","oldEventCache","serverChildren","updateFullNode","filtersNodes","viewProcessorRevertUserWrite","ackPath","isCompleteForPath","_changedChildren","mergePath","serverCachePath","viewProcessorAckUserWrite","LISTEN_COMPLETE","oldServerNode","viewProcessorGenerateEventCacheAfterServerEvent","viewProcessorListenComplete","getChanges","isLeafOrEmpty","oldCompleteSnap","viewProcessorMaybeAddValueEvent","changePath","oldEventSnap","completeEventChildren","completeNode","oldEventNode","updatedPriority","newEventChild","childChangePath","eventChildUpdate","changedSnap","newServerCache","oldServerSnap","serverFilter","getIndexedFilter","newServerNode","oldChild","getCompleteChild","viewProcessorApplyMerge","viewMergeTree","childMergeTree","isUnknownDeepMerge","referenceConstructor$1","viewGetCompleteServerCache","view","cache","viewApplyOperation","processor_","isIndexed","viewGenerateEventsForChanges_","eventRegistration","eventRegistrations_","eventRegistrations","moves","indexedValueChanged","eventGeneratorGenerateEventsForChanges","eventGenerator_","referenceConstructor","syncPointApplyOperation","syncPoint","optCompleteServerCache","views","_step4","_iterator5","_view","syncPointGetCompleteServerCache","_step7","_iterator8","SyncTree","listenProvider_","syncPointTree_","pendingWriteTree_","tagToQueryMap","queryToTagMap","syncTreeApplyUserOverwrite","syncTree","newData","writeTreeAddOverwrite","syncTreeApplyOperationToSyncPoints_","syncTreeAckUserWrite","needToReevaluate","syncTreeApplyServerOverwrite","syncTreeCalcCompleteEventCache","findOnPath","syncTreeApplyOperationHelper_","syncPointTree","syncTreeApplyOperationDescendantsHelper_","childOperation","operationForChild","childServerCache","childWritesCache","syncTreeQueryKeyForTag_","syncTreeParseQueryKey_","queryKey","splitIndex","syncTreeApplyTaggedOperation_","queryPath","ExistingValueProvider","DeferredValueProvider","syncTree_","path_","resolveDeferredLeafValue","existingVal","serverValues","resolveScalarDeferredValue","resolveComplexDeferredValue","JSON","stringify","op","existing","unused","existingNode","resolveDeferredValueTree","resolveDeferredValue","resolveDeferredValueSnapshot","rawPri","leafNode","childrenNode","Tree","parent","childCount","treeSubTree","pathObj","treeGetValue","treeSetValue","treeUpdateParents","treeHasChildren","treeForEachChild","treeForEachDescendant","includeSelf","childrenFirst","treeGetPath","childEmpty","treeIsEmpty","childExists","treeUpdateChild","INVALID_KEY_REGEX_","INVALID_PATH_REGEX_","MAX_LEAF_SIZE_","isValidKey","isValidPathString","validateFirebaseDataArg","fnName","validateFirebaseData","errorPrefix","hasDotValue","hasActualChild","last","validationPathPop","validatePathString","argumentName","validateWritablePath","validateUrl","parsedUrl","isValidRootPathString","EventQueue","eventLists_","recursionDepth_","eventQueueQueueEvents","eventQueue","eventDataList","currList","getPath","eventQueueRaiseEventsForChangedPath","changedPath","eventQueueRaiseQueuedEventsMatchingPredicate","eventPath","sentAll","eventList","eventListRaise","eventFn","getEventRunner","INTERRUPT_REASON","Repo","forceRestClient_","appCheckProvider_","dataUpdateCount","eventQueue_","nextWriteId_","interceptServerDataCallback_","transactionQueueTree_","persistentConnection_","repoStart","repo","appId","authOverride","search","isMerge","repoOnDataUpdate","repoOnConnectStatus","connectStatus","repoUpdateInfo","repoOnServerInfoUpdate","creatorFunction","addTokenChangeListener","refreshAuthToken","refreshAppCheckToken","statsReporter_","infoData_","infoSyncTree_","startListening","infoEvents","stopListening","serverSyncTree_","unlisten","repoServerTime","offset","repoGenerateServerValues","taggedChildren","raw","changeTree","fromObject","syncTreeApplyTaggedQueryMerge","taggedSnap","syncTreeApplyTaggedQueryOverwrite","syncTreeApplyServerMerge","affectedPath","repoRerunTransactions","repoLog","resolvedOnDisconnectTree","resolved","repoAbortTransactions","repoRunOnDisconnectEvents","updateSnapshot","repoGetNextWriteId","repoSetWithPriority","newVal","newNodeUnresolved","success","clearEvents","repoCallOnCompleteCallback","repoInterrupt","_len6","_key7","toUpperCase","_error3","repoGetLatestState","excludeSets","repoSendReadyTransactions","repoPruneCompletedTransactionsBelowNode","queue","repoBuildTransactionQueue","allRun","every","transaction","repoSendTransactionQueue","setsToIgnore","txn","currentWriteId","latestState","snapToSend","latestHash","retryCount","currentOutputSnapshotRaw","dataToSend","pathToSend","callbacks","_loop3","_i5","currentOutputSnapshotResolved","unwatcher","_i6","_i7","_i8","abortReason","rootMostTransactionNode","repoGetAncestorTransactionNode","_loop4","abortTransaction","currentNode","currentInputSnapshot","newDataNode","oldWriteId","newNodeResolved","applyLocally","_i9","repoRerunTransactionQueue","transactionNode","transactionQueue","repoAggregateTransactionQueuesForNode","order","nodeQueue","to","treeForEachAncestor","repoAbortTransactionsOnNode","lastSent","_i10","parseRepoInfo","dataURL","parseDatabaseURL","scheme","subdomain","port","colonInd","slashInd","questionMarkInd","pathStringDecoded","piece","decodeURIComponent","decodePath","queryString","results","_step9","_iterator10","segment","kv","decodeQuery","hostWithoutPort","dotInd","QueryImpl","_repo","_orderByCalled","ReferenceImpl","sameRepo","samePath","sameQueryIdentifier","encodeURIComponent","pathToUrlEncodedString","_QueryImpl","_super10","parentPath","ref","db","_checkNotDeleted","_child9","_root","thennablePushRef","pushRef","wrapCallback","syncPointSetReferenceConstructor","syncTreeSetReferenceConstructor","repos","useRestClient","repoManagerDatabaseFromApp","app","authProvider","dbUrl","databaseURL","projectId","isEmulator","dbEmulatorHost","authTokenProvider","appRepos","repoManagerCreateRepo","Database","_repoInternal","_instanceStarted","_rootInternal","appName","apiName","getDatabase","identifier","simpleListen","echo","onEcho","variant","setSDKVersion","container","_ref3","instanceIdentifier","getProvider","setMultipleInstances"],"sourceRoot":""}