favesalon-embed 1.0.0 → 1.0.2

package/dist/{esm/services-40a3e622.js → favesalon-embed/services-7cb8f2a6.js}

@@ -1,4 +1,4 @@
-import { c as commonjsGlobal, a as createCommonjsModule } from './_commonjsHelpers-098d5b27.js';
+import { c as commonjsGlobal, a as createCommonjsModule } from './_commonjsHelpers-a4f66ccd.js';
 import { C as Colors } from './colors-ea36347a.js';
 
 /**
@@ -1181,12 +1181,12 @@ var _baseGet = baseGet;
  * _.get(object, 'a.b.c', 'default');
  * // => 'default'
  */
-function get(object, path, defaultValue) {
+function get$1(object, path, defaultValue) {
   var result = object == null ? undefined : _baseGet(object, path);
   return result === undefined ? defaultValue : result;
 }
 
-var get_1 = get;
+var get_1 = get$1;
 
 /**
  * A specialized version of `_.forEach` for arrays without support for
@@ -1344,7 +1344,7 @@ var stubFalse_1 = stubFalse;
 
 var isBuffer_1 = createCommonjsModule(function (module, exports) {
 /** Detect free variable `exports`. */
-var freeExports = exports && !exports.nodeType && exports;
+var freeExports = 'object' == 'object' && exports && !exports.nodeType && exports;
 
 /** Detect free variable `module`. */
 var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
@@ -1516,7 +1516,7 @@ var _baseUnary = baseUnary;
 
 var _nodeUtil = createCommonjsModule(function (module, exports) {
 /** Detect free variable `exports`. */
-var freeExports = exports && !exports.nodeType && exports;
+var freeExports = 'object' == 'object' && exports && !exports.nodeType && exports;
 
 /** Detect free variable `module`. */
 var freeModule = freeExports && 'object' == 'object' && module && !module.nodeType && module;
@@ -3499,6 +3499,8 @@ var sortBy = _baseRest(function(collection, iteratees) {
 
 var sortBy_1 = sortBy;
 
+'use strict';
+
 var bind = function bind(fn, thisArg) {
   return function wrap() {
     var args = new Array(arguments.length);
@@ -3509,6 +3511,10 @@ var bind = function bind(fn, thisArg) {
   };
 };
 
+'use strict';
+
+
+
 // utils is a library of generic helper functions non-specific to axios
 
 var toString = Object.prototype.toString;
@@ -3855,6 +3861,10 @@ var utils = {
   stripBOM: stripBOM
 };
 
+'use strict';
+
+
+
 function encode(val) {
   return encodeURIComponent(val).
     replace(/%3A/gi, ':').
@@ -3922,6 +3932,10 @@ var buildURL = function buildURL(url, params, paramsSerializer) {
   return url;
 };
 
+'use strict';
+
+
+
 function InterceptorManager() {
   this.handlers = [];
 }
@@ -3973,6 +3987,10 @@ InterceptorManager.prototype.forEach = function forEach(fn) {
 
 var InterceptorManager_1 = InterceptorManager;
 
+'use strict';
+
+
+
 var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName) {
   utils.forEach(headers, function processHeader(value, name) {
     if (name !== normalizedName && name.toUpperCase() === normalizedName.toUpperCase()) {
@@ -3982,6 +4000,8 @@ var normalizeHeaderName = function normalizeHeaderName(headers, normalizedName)
   });
 };
 
+'use strict';
+
 /**
  * Update an Error with the specified config, error code, and response.
  *
@@ -4024,6 +4044,10 @@ var enhanceError = function enhanceError(error, config, code, request, response)
   return error;
 };
 
+'use strict';
+
+
+
 /**
  * Create an Error with the specified message, config, error code, request and response.
  *
@@ -4039,6 +4063,10 @@ var createError = function createError(message, config, code, request, response)
   return enhanceError(error, config, code, request, response);
 };
 
+'use strict';
+
+
+
 /**
  * Resolve or reject a Promise based on response status.
  *
@@ -4061,6 +4089,10 @@ var settle = function settle(resolve, reject, response) {
   }
 };
 
+'use strict';
+
+
+
 var cookies = (
   utils.isStandardBrowserEnv() ?
 
@@ -4111,6 +4143,8 @@ var cookies = (
     })()
 );
 
+'use strict';
+
 /**
  * Determines whether the specified URL is absolute
  *
@@ -4124,6 +4158,8 @@ var isAbsoluteURL = function isAbsoluteURL(url) {
   return /^([a-z][a-z\d\+\-\.]*:)?\/\//i.test(url);
 };
 
+'use strict';
+
 /**
  * Creates a new URL by combining the specified URLs
  *
@@ -4137,6 +4173,11 @@ var combineURLs = function combineURLs(baseURL, relativeURL) {
     : baseURL;
 };
 
+'use strict';
+
+
+
+
 /**
  * Creates a new URL by combining the baseURL with the requestedURL,
  * only when the requestedURL is not already an absolute URL.
@@ -4153,6 +4194,10 @@ var buildFullPath = function buildFullPath(baseURL, requestedURL) {
   return requestedURL;
 };
 
+'use strict';
+
+
+
 // Headers whose duplicates are ignored by node
 // c.f. https://nodejs.org/api/http.html#http_message_headers
 var ignoreDuplicateOf = [
@@ -4203,6 +4248,10 @@ var parseHeaders = function parseHeaders(headers) {
   return parsed;
 };
 
+'use strict';
+
+
+
 var isURLSameOrigin = (
   utils.isStandardBrowserEnv() ?
 
@@ -4268,6 +4317,8 @@ var isURLSameOrigin = (
     })()
 );
 
+'use strict';
+
 /**
  * A `Cancel` is an object that is thrown when an operation is canceled.
  *
@@ -4286,6 +4337,19 @@ Cancel.prototype.__CANCEL__ = true;
 
 var Cancel_1 = Cancel;
 
+'use strict';
+
+
+
+
+
+
+
+
+
+
+
+
 var xhr = function xhrAdapter(config) {
   return new Promise(function dispatchXhrRequest(resolve, reject) {
     var requestData = config.data;
@@ -4486,6 +4550,12 @@ var xhr = function xhrAdapter(config) {
   });
 };
 
+'use strict';
+
+
+
+
+
 var DEFAULT_CONTENT_TYPE = {
   'Content-Type': 'application/x-www-form-urlencoded'
 };
@@ -4615,6 +4685,11 @@ utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
 
 var defaults_1 = defaults;
 
+'use strict';
+
+
+
+
 /**
  * Transform the data for a request or a response
  *
@@ -4633,10 +4708,20 @@ var transformData = function transformData(data, headers, fns) {
   return data;
 };
 
+'use strict';
+
 var isCancel = function isCancel(value) {
   return !!(value && value.__CANCEL__);
 };
 
+'use strict';
+
+
+
+
+
+
+
 /**
  * Throws a `Cancel` if cancellation has been requested.
  */
@@ -4717,6 +4802,10 @@ var dispatchRequest = function dispatchRequest(config) {
   });
 };
 
+'use strict';
+
+
+
 /**
  * Config-specific merge-function which creates a new config-object
  * by merging two configuration objects together.
@@ -4817,6 +4906,8 @@ var data = {
   "version": "0.22.0"
 };
 
+'use strict';
+
 var VERSION = data.version;
 
 var validators$1 = {};
@@ -4898,6 +4989,15 @@ var validator = {
   validators: validators$1
 };
 
+'use strict';
+
+
+
+
+
+
+
+
 var validators = validator.validators;
 /**
  * Create a new instance of Axios
@@ -5038,6 +5138,10 @@ utils.forEach(['post', 'put', 'patch'], function forEachMethodWithData(method) {
 
 var Axios_1 = Axios;
 
+'use strict';
+
+
+
 /**
  * A `CancelToken` is an object that can be used to request cancellation of an operation.
  *
@@ -5154,6 +5258,8 @@ CancelToken.source = function source() {
 
 var CancelToken_1 = CancelToken;
 
+'use strict';
+
 /**
  * Syntactic sugar for invoking a function and expanding an array for arguments.
  *
@@ -5180,6 +5286,8 @@ var spread = function spread(callback) {
   };
 };
 
+'use strict';
+
 /**
  * Determines whether the payload is an error thrown by Axios
  *
@@ -5190,6 +5298,14 @@ var isAxiosError = function isAxiosError(payload) {
   return (typeof payload === 'object') && (payload.isAxiosError === true);
 };
 
+'use strict';
+
+
+
+
+
+
+
 /**
  * Create an instance of Axios
  *
@@ -5243,9 +5359,16 @@ axios_1.default = _default;
 
 var axios = axios_1;
 
+const timeFormat = 'HH:mm:ss';
+const timeFormatAmPm = 'hh:mm A';
+const dateName = 'dddd';
+const dateFormat = 'YYYY-MM-DD';
 const dateTimeFormat = 'YYYY-MM-DD HH:mm:ss';
+const dateTimeFormatAmPm = 'YYYY-MM-DD hh:mm A';
+const shortDateFormat = 'ddd, MMM DD';
 const shortDateYearFormat = 'ddd, MMM DD YYYY';
 const apiV1Prefix = 'api';
+const apiV2Prefix$1 = 'api-ver2';
 const defaultImage = 'https://res.cloudinary.com/reckon-mini-sites/image/upload/v1636477599/FaveSalon%20Social%20Website/default/default--picture_w3jvfh.png';
 
 var BusinessHourStatus;
@@ -5908,6 +6031,12 @@ const getDefaultEmulatorHostnameAndPort = (productName) => {
  * @public
  */
 const getDefaultAppConfig = () => { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.config; };
+/**
+ * Returns an experimental setting on the __FIREBASE_DEFAULTS__ object (properties
+ * prefixed by "_")
+ * @public
+ */
+const getExperimentalSetting = (name) => { var _a; return (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a[`_${name}`]; };
 
 /**
  * @license
@@ -6053,6 +6182,42 @@ function isMobileCordova() {
         !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&
         /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA()));
 }
+/**
+ * Detect Node.js.
+ *
+ * @return true if Node.js environment is detected or specified.
+ */
+// Node detection logic from: https://github.com/iliakan/detect-node/
+function isNode() {
+    var _a;
+    const forceEnvironment = (_a = getDefaults()) === null || _a === void 0 ? void 0 : _a.forceEnvironment;
+    if (forceEnvironment === 'node') {
+        return true;
+    }
+    else if (forceEnvironment === 'browser') {
+        return false;
+    }
+    try {
+        return (Object.prototype.toString.call(global.process) === '[object process]');
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Detect Browser Environment
+ */
+function isBrowser() {
+    return typeof self === 'object' && self.self === self;
+}
+function isBrowserExtension() {
+    const runtime = typeof chrome === 'object'
+        ? chrome.runtime
+        : typeof browser === 'object'
+            ? browser.runtime
+            : undefined;
+    return typeof runtime === 'object' && runtime.id !== undefined;
+}
 /**
  * Detect React Native.
  *
@@ -6061,13 +6226,32 @@ function isMobileCordova() {
 function isReactNative() {
     return (typeof navigator === 'object' && navigator['product'] === 'ReactNative');
 }
+/** Detects Electron apps. */
+function isElectron() {
+    return getUA().indexOf('Electron/') >= 0;
+}
+/** Detects Internet Explorer. */
+function isIE() {
+    const ua = getUA();
+    return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;
+}
+/** Detects Universal Windows Platform apps. */
+function isUWP() {
+    return getUA().indexOf('MSAppHost/') >= 0;
+}
 /**
  * Detect whether the current SDK build is the Node version.
  *
  * @return true if it's the Node SDK build.
  */
 function isNodeSdk() {
-    return CONSTANTS.NODE_ADMIN === true;
+    return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;
+}
+/** Returns true if we are running in Safari. */
+function isSafari() {
+    return (!isNode() &&
+        navigator.userAgent.includes('Safari') &&
+        !navigator.userAgent.includes('Chrome'));
 }
 /**
  * This method checks if indexedDB is supported by current browser/service worker context
@@ -6115,6 +6299,17 @@ function validateIndexedDBOpenable() {
         }
     });
 }
+/**
+ *
+ * This method checks whether cookie is enabled within current browser
+ * @return true if cookie is enabled within current browser
+ */
+function areCookiesEnabled() {
+    if (typeof navigator === 'undefined' || !navigator.cookieEnabled) {
+        return false;
+    }
+    return true;
+}
 
 /**
  * @license
@@ -6296,6 +6491,53 @@ const decode = function (token) {
         signature
     };
 };
+/**
+ * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the
+ * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.
+ *
+ * Notes:
+ * - May return a false negative if there's no native base64 decoding support.
+ * - Doesn't check if the token is actually valid.
+ */
+const isValidTimestamp = function (token) {
+    const claims = decode(token).claims;
+    const now = Math.floor(new Date().getTime() / 1000);
+    let validSince = 0, validUntil = 0;
+    if (typeof claims === 'object') {
+        if (claims.hasOwnProperty('nbf')) {
+            validSince = claims['nbf'];
+        }
+        else if (claims.hasOwnProperty('iat')) {
+            validSince = claims['iat'];
+        }
+        if (claims.hasOwnProperty('exp')) {
+            validUntil = claims['exp'];
+        }
+        else {
+            // token will expire after 24h by default
+            validUntil = validSince + 86400;
+        }
+    }
+    return (!!now &&
+        !!validSince &&
+        !!validUntil &&
+        now >= validSince &&
+        now <= validUntil);
+};
+/**
+ * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.
+ *
+ * Notes:
+ * - May return null if there's no native base64 decoding support.
+ * - Doesn't check if the token is actually valid.
+ */
+const issuedAtTime = function (token) {
+    const claims = decode(token).claims;
+    if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {
+        return claims['iat'];
+    }
+    return null;
+};
 /**
  * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.
  *
@@ -6398,6 +6640,33 @@ function isObject(thing) {
     return thing !== null && typeof thing === 'object';
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Rejects if the given promise doesn't resolve in timeInMS milliseconds.
+ * @internal
+ */
+function promiseWithTimeout(promise, timeInMS = 2000) {
+    const deferredPromise = new Deferred();
+    setTimeout(() => deferredPromise.reject('timeout!'), timeInMS);
+    promise.then(deferredPromise.resolve, deferredPromise.reject);
+    return deferredPromise.promise;
+}
+
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -6433,6 +6702,32 @@ function querystring(querystringParams) {
     }
     return params.length ? '&' + params.join('&') : '';
 }
+/**
+ * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object
+ * (e.g. {arg: 'val', arg2: 'val2'})
+ */
+function querystringDecode(querystring) {
+    const obj = {};
+    const tokens = querystring.replace(/^\?/, '').split('&');
+    tokens.forEach(token => {
+        if (token) {
+            const [key, value] = token.split('=');
+            obj[decodeURIComponent(key)] = decodeURIComponent(value);
+        }
+    });
+    return obj;
+}
+/**
+ * Extract the query string part of a URL, including the leading question mark (if present).
+ */
+function extractQuerystring(url) {
+    const queryStart = url.indexOf('?');
+    if (!queryStart) {
+        return '';
+    }
+    const fragmentStart = url.indexOf('#', queryStart);
+    return url.substring(queryStart, fragmentStart > 0 ? fragmentStart : undefined);
+}
 
 /**
  * @license
@@ -6689,78 +6984,369 @@ class Sha1 {
         return digest;
     }
 }
-/**
- * Generates a string to prefix an error message about failed argument validation
- *
- * @param fnName The function name
- * @param argName The name of the argument
- * @return The prefix to add to the error thrown for validation.
- */
-function errorPrefix(fnName, argName) {
-    return `${fnName} failed: ${argName} argument `;
-}
 
 /**
- * @license
- * Copyright 2017 Google LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
+ * Helper to make a Subscribe function (just like Promise helps make a
+ * Thenable).
  *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
+ * @param executor Function which can make calls to a single Observer
+ *     as a proxy.
+ * @param onNoObservers Callback when count of Observers goes to zero.
  */
-// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they
-// automatically replaced '\r\n' with '\n', and they didn't handle surrogate pairs,
-// so it's been modified.
-// Note that not all Unicode characters appear as single characters in JavaScript strings.
-// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters
-// use 2 characters in Javascript.  All 4-byte UTF-8 characters begin with a first
-// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate
-// pair).
-// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3
+function createSubscribe(executor, onNoObservers) {
+    const proxy = new ObserverProxy(executor, onNoObservers);
+    return proxy.subscribe.bind(proxy);
+}
 /**
- * @param {string} str
- * @return {Array}
+ * Implement fan-out for any number of Observers attached via a subscribe
+ * function.
  */
-const stringToByteArray = function (str) {
-    const out = [];
-    let p = 0;
-    for (let i = 0; i < str.length; i++) {
-        let c = str.charCodeAt(i);
-        // Is this the lead surrogate in a surrogate pair?
-        if (c >= 0xd800 && c <= 0xdbff) {
-            const high = c - 0xd800; // the high 10 bits.
-            i++;
-            assert(i < str.length, 'Surrogate pair missing trail surrogate.');
-            const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.
-            c = 0x10000 + (high << 10) + low;
+class ObserverProxy {
+    /**
+     * @param executor Function which can make calls to a single Observer
+     *     as a proxy.
+     * @param onNoObservers Callback when count of Observers goes to zero.
+     */
+    constructor(executor, onNoObservers) {
+        this.observers = [];
+        this.unsubscribes = [];
+        this.observerCount = 0;
+        // Micro-task scheduling by calling task.then().
+        this.task = Promise.resolve();
+        this.finalized = false;
+        this.onNoObservers = onNoObservers;
+        // Call the executor asynchronously so subscribers that are called
+        // synchronously after the creation of the subscribe function
+        // can still receive the very first value generated in the executor.
+        this.task
+            .then(() => {
+            executor(this);
+        })
+            .catch(e => {
+            this.error(e);
+        });
+    }
+    next(value) {
+        this.forEachObserver((observer) => {
+            observer.next(value);
+        });
+    }
+    error(error) {
+        this.forEachObserver((observer) => {
+            observer.error(error);
+        });
+        this.close(error);
+    }
+    complete() {
+        this.forEachObserver((observer) => {
+            observer.complete();
+        });
+        this.close();
+    }
+    /**
+     * Subscribe function that can be used to add an Observer to the fan-out list.
+     *
+     * - We require that no event is sent to a subscriber sychronously to their
+     *   call to subscribe().
+     */
+    subscribe(nextOrObserver, error, complete) {
+        let observer;
+        if (nextOrObserver === undefined &&
+            error === undefined &&
+            complete === undefined) {
+            throw new Error('Missing Observer.');
+        }
+        // Assemble an Observer object when passed as callback functions.
+        if (implementsAnyMethods(nextOrObserver, [
+            'next',
+            'error',
+            'complete'
+        ])) {
+            observer = nextOrObserver;
         }
-        if (c < 128) {
-            out[p++] = c;
+        else {
+            observer = {
+                next: nextOrObserver,
+                error,
+                complete
+            };
         }
-        else if (c < 2048) {
-            out[p++] = (c >> 6) | 192;
-            out[p++] = (c & 63) | 128;
+        if (observer.next === undefined) {
+            observer.next = noop;
         }
-        else if (c < 65536) {
-            out[p++] = (c >> 12) | 224;
-            out[p++] = ((c >> 6) & 63) | 128;
-            out[p++] = (c & 63) | 128;
+        if (observer.error === undefined) {
+            observer.error = noop;
         }
-        else {
-            out[p++] = (c >> 18) | 240;
-            out[p++] = ((c >> 12) & 63) | 128;
-            out[p++] = ((c >> 6) & 63) | 128;
-            out[p++] = (c & 63) | 128;
+        if (observer.complete === undefined) {
+            observer.complete = noop;
         }
-    }
+        const unsub = this.unsubscribeOne.bind(this, this.observers.length);
+        // Attempt to subscribe to a terminated Observable - we
+        // just respond to the Observer with the final error or complete
+        // event.
+        if (this.finalized) {
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises
+            this.task.then(() => {
+                try {
+                    if (this.finalError) {
+                        observer.error(this.finalError);
+                    }
+                    else {
+                        observer.complete();
+                    }
+                }
+                catch (e) {
+                    // nothing
+                }
+                return;
+            });
+        }
+        this.observers.push(observer);
+        return unsub;
+    }
+    // Unsubscribe is synchronous - we guarantee that no events are sent to
+    // any unsubscribed Observer.
+    unsubscribeOne(i) {
+        if (this.observers === undefined || this.observers[i] === undefined) {
+            return;
+        }
+        delete this.observers[i];
+        this.observerCount -= 1;
+        if (this.observerCount === 0 && this.onNoObservers !== undefined) {
+            this.onNoObservers(this);
+        }
+    }
+    forEachObserver(fn) {
+        if (this.finalized) {
+            // Already closed by previous event....just eat the additional values.
+            return;
+        }
+        // Since sendOne calls asynchronously - there is no chance that
+        // this.observers will become undefined.
+        for (let i = 0; i < this.observers.length; i++) {
+            this.sendOne(i, fn);
+        }
+    }
+    // Call the Observer via one of it's callback function. We are careful to
+    // confirm that the observe has not been unsubscribed since this asynchronous
+    // function had been queued.
+    sendOne(i, fn) {
+        // Execute the callback asynchronously
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this.task.then(() => {
+            if (this.observers !== undefined && this.observers[i] !== undefined) {
+                try {
+                    fn(this.observers[i]);
+                }
+                catch (e) {
+                    // Ignore exceptions raised in Observers or missing methods of an
+                    // Observer.
+                    // Log error to console. b/31404806
+                    if (typeof console !== 'undefined' && console.error) {
+                        console.error(e);
+                    }
+                }
+            }
+        });
+    }
+    close(err) {
+        if (this.finalized) {
+            return;
+        }
+        this.finalized = true;
+        if (err !== undefined) {
+            this.finalError = err;
+        }
+        // Proxy is no longer needed - garbage collect references
+        // eslint-disable-next-line @typescript-eslint/no-floating-promises
+        this.task.then(() => {
+            this.observers = undefined;
+            this.onNoObservers = undefined;
+        });
+    }
+}
+/** Turn synchronous function into one called asynchronously. */
+// eslint-disable-next-line @typescript-eslint/ban-types
+function async(fn, onError) {
+    return (...args) => {
+        Promise.resolve(true)
+            .then(() => {
+            fn(...args);
+        })
+            .catch((error) => {
+            if (onError) {
+                onError(error);
+            }
+        });
+    };
+}
+/**
+ * Return true if the object passed in implements any of the named methods.
+ */
+function implementsAnyMethods(obj, methods) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    for (const method of methods) {
+        if (method in obj && typeof obj[method] === 'function') {
+            return true;
+        }
+    }
+    return false;
+}
+function noop() {
+    // do nothing
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Check to make sure the appropriate number of arguments are provided for a public function.
+ * Throws an error if it fails.
+ *
+ * @param fnName The function name
+ * @param minCount The minimum number of arguments to allow for the function call
+ * @param maxCount The maximum number of argument to allow for the function call
+ * @param argCount The actual number of arguments provided.
+ */
+const validateArgCount = function (fnName, minCount, maxCount, argCount) {
+    let argError;
+    if (argCount < minCount) {
+        argError = 'at least ' + minCount;
+    }
+    else if (argCount > maxCount) {
+        argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;
+    }
+    if (argError) {
+        const error = fnName +
+            ' failed: Was called with ' +
+            argCount +
+            (argCount === 1 ? ' argument.' : ' arguments.') +
+            ' Expects ' +
+            argError +
+            '.';
+        throw new Error(error);
+    }
+};
+/**
+ * Generates a string to prefix an error message about failed argument validation
+ *
+ * @param fnName The function name
+ * @param argName The name of the argument
+ * @return The prefix to add to the error thrown for validation.
+ */
+function errorPrefix(fnName, argName) {
+    return `${fnName} failed: ${argName} argument `;
+}
+/**
+ * @param fnName
+ * @param argumentNumber
+ * @param namespace
+ * @param optional
+ */
+function validateNamespace(fnName, namespace, optional) {
+    if (optional && !namespace) {
+        return;
+    }
+    if (typeof namespace !== 'string') {
+        //TODO: I should do more validation here. We only allow certain chars in namespaces.
+        throw new Error(errorPrefix(fnName, 'namespace') + 'must be a valid firebase namespace.');
+    }
+}
+function validateCallback(fnName, argumentName, 
+// eslint-disable-next-line @typescript-eslint/ban-types
+callback, optional) {
+    if (optional && !callback) {
+        return;
+    }
+    if (typeof callback !== 'function') {
+        throw new Error(errorPrefix(fnName, argumentName) + 'must be a valid function.');
+    }
+}
+function validateContextObject(fnName, argumentName, context, optional) {
+    if (optional && !context) {
+        return;
+    }
+    if (typeof context !== 'object' || context === null) {
+        throw new Error(errorPrefix(fnName, argumentName) + 'must be a valid context object.');
+    }
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they
+// automatically replaced '\r\n' with '\n', and they didn't handle surrogate pairs,
+// so it's been modified.
+// Note that not all Unicode characters appear as single characters in JavaScript strings.
+// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters
+// use 2 characters in Javascript.  All 4-byte UTF-8 characters begin with a first
+// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate
+// pair).
+// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3
+/**
+ * @param {string} str
+ * @return {Array}
+ */
+const stringToByteArray = function (str) {
+    const out = [];
+    let p = 0;
+    for (let i = 0; i < str.length; i++) {
+        let c = str.charCodeAt(i);
+        // Is this the lead surrogate in a surrogate pair?
+        if (c >= 0xd800 && c <= 0xdbff) {
+            const high = c - 0xd800; // the high 10 bits.
+            i++;
+            assert(i < str.length, 'Surrogate pair missing trail surrogate.');
+            const low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.
+            c = 0x10000 + (high << 10) + low;
+        }
+        if (c < 128) {
+            out[p++] = c;
+        }
+        else if (c < 2048) {
+            out[p++] = (c >> 6) | 192;
+            out[p++] = (c & 63) | 128;
+        }
+        else if (c < 65536) {
+            out[p++] = (c >> 12) | 224;
+            out[p++] = ((c >> 6) & 63) | 128;
+            out[p++] = (c & 63) | 128;
+        }
+        else {
+            out[p++] = (c >> 18) | 240;
+            out[p++] = ((c >> 12) & 63) | 128;
+            out[p++] = ((c >> 6) & 63) | 128;
+            out[p++] = (c & 63) | 128;
+        }
+    }
     return out;
 };
 /**
@@ -6790,6 +7376,143 @@ const stringLength = function (str) {
     return p;
 };
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Copied from https://stackoverflow.com/a/2117523
+ * Generates a new uuid.
+ * @public
+ */
+const uuidv4 = function () {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
+        const r = (Math.random() * 16) | 0, v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+};
+
+/**
+ * @license
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * The amount of milliseconds to exponentially increase.
+ */
+const DEFAULT_INTERVAL_MILLIS = 1000;
+/**
+ * The factor to backoff by.
+ * Should be a number greater than 1.
+ */
+const DEFAULT_BACKOFF_FACTOR = 2;
+/**
+ * The maximum milliseconds to increase to.
+ *
+ * <p>Visible for testing
+ */
+const MAX_VALUE_MILLIS = 4 * 60 * 60 * 1000; // Four hours, like iOS and Android.
+/**
+ * The percentage of backoff time to randomize by.
+ * See
+ * http://go/safe-client-behavior#step-1-determine-the-appropriate-retry-interval-to-handle-spike-traffic
+ * for context.
+ *
+ * <p>Visible for testing
+ */
+const RANDOM_FACTOR = 0.5;
+/**
+ * Based on the backoff method from
+ * https://github.com/google/closure-library/blob/master/closure/goog/math/exponentialbackoff.js.
+ * Extracted here so we don't need to pass metadata and a stateful ExponentialBackoff object around.
+ */
+function calculateBackoffMillis(backoffCount, intervalMillis = DEFAULT_INTERVAL_MILLIS, backoffFactor = DEFAULT_BACKOFF_FACTOR) {
+    // Calculates an exponentially increasing value.
+    // Deviation: calculates value from count and a constant interval, so we only need to save value
+    // and count to restore state.
+    const currBaseValue = intervalMillis * Math.pow(backoffFactor, backoffCount);
+    // A random "fuzz" to avoid waves of retries.
+    // Deviation: randomFactor is required.
+    const randomWait = Math.round(
+    // A fraction of the backoff value to add/subtract.
+    // Deviation: changes multiplication order to improve readability.
+    RANDOM_FACTOR *
+        currBaseValue *
+        // A random float (rounded to int by Math.round above) in the range [-1, 1]. Determines
+        // if we add or subtract.
+        (Math.random() - 0.5) *
+        2);
+    // Limits backoff to max to avoid effectively permanent backoff.
+    return Math.min(MAX_VALUE_MILLIS, currBaseValue + randomWait);
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Provide English ordinal letters after a number
+ */
+function ordinal(i) {
+    if (!Number.isFinite(i)) {
+        return `${i}`;
+    }
+    return i + indicator(i);
+}
+function indicator(i) {
+    i = Math.abs(i);
+    const cent = i % 100;
+    if (cent >= 10 && cent <= 20) {
+        return 'th';
+    }
+    const dec = i % 10;
+    if (dec === 1) {
+        return 'st';
+    }
+    if (dec === 2) {
+        return 'nd';
+    }
+    if (dec === 3) {
+        return 'rd';
+    }
+    return 'th';
+}
+
 /**
  * @license
  * Copyright 2021 Google LLC
@@ -7236,6 +7959,10 @@ class ComponentContainer {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * A container for all of the Logger instances
+ */
+const instances = [];
 /**
  * The JS SDK supports 5 log levels and also allows a user the ability to
  * silence the logs altogether.
@@ -7321,6 +8048,10 @@ class Logger {
          * The optional, additional, user-defined log handler for the Logger instance.
          */
         this._userLogHandler = null;
+        /**
+         * Capture the current instance for later use
+         */
+        instances.push(this);
     }
     get logLevel() {
         return this._logLevel;
@@ -7374,26 +8105,79 @@ class Logger {
         this._userLogHandler && this._userLogHandler(this, LogLevel.ERROR, ...args);
         this._logHandler(this, LogLevel.ERROR, ...args);
     }
-}
-
-const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
-
-let idbProxyableTypes;
-let cursorAdvanceMethods;
-// This is a function to prevent it throwing up in node environments.
-function getIdbProxyableTypes() {
-    return (idbProxyableTypes ||
-        (idbProxyableTypes = [
-            IDBDatabase,
-            IDBObjectStore,
-            IDBIndex,
-            IDBCursor,
-            IDBTransaction,
-        ]));
-}
-// This is a function to prevent it throwing up in node environments.
-function getCursorAdvanceMethods() {
-    return (cursorAdvanceMethods ||
+}
+function setLogLevel$1(level) {
+    instances.forEach(inst => {
+        inst.setLogLevel(level);
+    });
+}
+function setUserLogHandler(logCallback, options) {
+    for (const instance of instances) {
+        let customLogLevel = null;
+        if (options && options.level) {
+            customLogLevel = levelStringToEnum[options.level];
+        }
+        if (logCallback === null) {
+            instance.userLogHandler = null;
+        }
+        else {
+            instance.userLogHandler = (instance, level, ...args) => {
+                const message = args
+                    .map(arg => {
+                    if (arg == null) {
+                        return null;
+                    }
+                    else if (typeof arg === 'string') {
+                        return arg;
+                    }
+                    else if (typeof arg === 'number' || typeof arg === 'boolean') {
+                        return arg.toString();
+                    }
+                    else if (arg instanceof Error) {
+                        return arg.message;
+                    }
+                    else {
+                        try {
+                            return JSON.stringify(arg);
+                        }
+                        catch (ignored) {
+                            return null;
+                        }
+                    }
+                })
+                    .filter(arg => arg)
+                    .join(' ');
+                if (level >= (customLogLevel !== null && customLogLevel !== void 0 ? customLogLevel : instance.logLevel)) {
+                    logCallback({
+                        level: LogLevel[level].toLowerCase(),
+                        message,
+                        args,
+                        type: instance.name
+                    });
+                }
+            };
+        }
+    }
+}
+
+const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+    return (idbProxyableTypes ||
+        (idbProxyableTypes = [
+            IDBDatabase,
+            IDBObjectStore,
+            IDBIndex,
+            IDBCursor,
+            IDBTransaction,
+        ]));
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+    return (cursorAdvanceMethods ||
         (cursorAdvanceMethods = [
             IDBCursor.prototype.advance,
             IDBCursor.prototype.continue,
@@ -7591,6 +8375,20 @@ function openDB(name, version, { blocked, upgrade, blocking, terminated } = {})
         .catch(() => { });
     return openPromise;
 }
+/**
+ * Delete a database.
+ *
+ * @param name Name of the database.
+ */
+function deleteDB(name, { blocked } = {}) {
+    const request = indexedDB.deleteDatabase(name);
+    if (blocked) {
+        request.addEventListener('blocked', (event) => blocked(
+        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+        event.oldVersion, event));
+    }
+    return wrap(request).then(() => undefined);
+}
 
 const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
 const writeMethods = ['put', 'add', 'delete', 'clear'];
@@ -7851,6 +8649,13 @@ function _addComponent(app, component) {
         logger$1.debug(`Component ${component.name} failed to register with FirebaseApp ${app.name}`, e);
     }
 }
+/**
+ *
+ * @internal
+ */
+function _addOrOverwriteComponent(app, component) {
+    app.container.addOrOverwriteComponent(component);
+}
 /**
  *
  * @param component - the component to register
@@ -7889,6 +8694,25 @@ function _getProvider(app, name) {
     }
     return app.container.getProvider(name);
 }
+/**
+ *
+ * @param app - FirebaseApp instance
+ * @param name - service name
+ * @param instanceIdentifier - service instance identifier in case the service supports multiple instances
+ *
+ * @internal
+ */
+function _removeServiceInstance(app, name, instanceIdentifier = DEFAULT_ENTRY_NAME) {
+    _getProvider(app, name).clearInstance(instanceIdentifier);
+}
+/**
+ * Test only
+ *
+ * @internal
+ */
+function _clearComponents() {
+    _components.clear();
+}
 
 /**
  * @license
@@ -8087,6 +8911,40 @@ function getApp(name = DEFAULT_ENTRY_NAME) {
     }
     return app;
 }
+/**
+ * A (read-only) array of all initialized apps.
+ * @public
+ */
+function getApps() {
+    return Array.from(_apps.values());
+}
+/**
+ * Renders this app unusable and frees the resources of all associated
+ * services.
+ *
+ * @example
+ * ```javascript
+ * deleteApp(app)
+ *   .then(function() {
+ *     console.log("App deleted successfully");
+ *   })
+ *   .catch(function(error) {
+ *     console.log("Error deleting app:", error);
+ *   });
+ * ```
+ *
+ * @public
+ */
+async function deleteApp(app) {
+    const name = app.name;
+    if (_apps.has(name)) {
+        _apps.delete(name);
+        await Promise.all(app.container
+            .getProviders()
+            .map(provider => provider.delete()));
+        app.isDeleted = true;
+    }
+}
 /**
  * Registers a library's name and version for platform logging purposes.
  * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)
@@ -8123,6 +8981,31 @@ function registerVersion(libraryKeyOrName, version, variant) {
     }
     _registerComponent(new Component(`${library}-version`, () => ({ library, version }), "VERSION" /* ComponentType.VERSION */));
 }
+/**
+ * Sets log handler for all Firebase SDKs.
+ * @param logCallback - An optional custom log handler that executes user code whenever
+ * the Firebase SDK makes a logging call.
+ *
+ * @public
+ */
+function onLog(logCallback, options) {
+    if (logCallback !== null && typeof logCallback !== 'function') {
+        throw ERROR_FACTORY.create("invalid-log-argument" /* AppError.INVALID_LOG_ARGUMENT */);
+    }
+    setUserLogHandler(logCallback, options);
+}
+/**
+ * Sets log level for all Firebase SDKs.
+ *
+ * All of the log types above the current log level are captured (i.e. if
+ * you set the log level to `info`, errors are logged, but `debug` and
+ * `verbose` logs are not).
+ *
+ * @public
+ */
+function setLogLevel(logLevel) {
+    setLogLevel$1(logLevel);
+}
 
 /**
  * @license
@@ -8832,7 +9715,7 @@ const isInvalidJSONNumber = function (data) {
             data === Number.NEGATIVE_INFINITY));
 };
 const executeWhenDOMReady = function (fn) {
-    if (document.readyState === 'complete') {
+    if (isNodeSdk() || document.readyState === 'complete') {
         fn();
     }
     else {
@@ -9844,7 +10727,10 @@ class BrowserPollConnection {
     }
     // Static method, use string literal so it can be accessed in a generic way
     static isAvailable() {
-        if (BrowserPollConnection.forceAllow_) {
+        if (isNodeSdk()) {
+            return false;
+        }
+        else if (BrowserPollConnection.forceAllow_) {
             return true;
         }
         else {
@@ -9930,6 +10816,9 @@ class BrowserPollConnection {
      * trigger XHR requests in some browsers (everything but Opera basically).
      */
     addDisconnectPingFrame(id, pw) {
+        if (isNodeSdk()) {
+            return;
+        }
         this.myDisconnFrame = document.createElement('iframe');
         const urlParams = {};
         urlParams[FIREBASE_LONGPOLL_DISCONN_FRAME_REQUEST_PARAM] = 't';
@@ -9976,7 +10865,7 @@ class FirebaseIFrameScriptHolder {
         // This gets set to false when we're "closing down" the connection (e.g. we're switching transports but there's still
         // incoming data from the server that we're waiting for).
         this.sendNewPolls = true;
-        {
+        if (!isNodeSdk()) {
             //Each script holder registers a couple of uniquely named callbacks with the window. These are called from the
             //iframes where we put the long-polling script tags. We have two callbacks:
             //   1) Command Callback - Triggered for control issues, like starting a connection.
@@ -10010,6 +10899,10 @@ class FirebaseIFrameScriptHolder {
                 log(e);
             }
         }
+        else {
+            this.commandCB = commandCB;
+            this.onMessageCB = onMessageCB;
+        }
     }
     /**
      * Each browser has its own funny way to handle iframes. Here we mush them all together into one object that I can
@@ -10203,7 +11096,11 @@ class FirebaseIFrameScriptHolder {
      * @param loadCB - A callback to be triggered once the script has loaded.
      */
     addTag(url, loadCB) {
-        {
+        if (isNodeSdk()) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            this.doNodeLongPoll(url, loadCB);
+        }
+        else {
             setTimeout(() => {
                 try {
                     // if we're already closed, don't add this poll
@@ -10308,7 +11205,8 @@ class WebSocketConnection {
     static connectionURL_(repoInfo, transportSessionId, lastSessionId, appCheckToken, applicationId) {
         const urlParams = {};
         urlParams[VERSION_PARAM] = PROTOCOL_VERSION;
-        if (typeof location !== 'undefined' &&
+        if (!isNodeSdk() &&
+            typeof location !== 'undefined' &&
             location.hostname &&
             FORGE_DOMAIN_RE.test(location.hostname)) {
             urlParams[REFERER_PARAM] = FORGE_REF;
@@ -10340,6 +11238,35 @@ class WebSocketConnection {
         PersistentStorage.set('previous_websocket_failure', true);
         try {
             let options;
+            if (isNodeSdk()) {
+                const device = this.nodeAdmin ? 'AdminNode' : 'Node';
+                // UA Format: Firebase/<wire_protocol>/<sdk_version>/<platform>/<device>
+                options = {
+                    headers: {
+                        'User-Agent': `Firebase/${PROTOCOL_VERSION}/${SDK_VERSION}/${process.platform}/${device}`,
+                        'X-Firebase-GMPID': this.applicationId || ''
+                    }
+                };
+                // If using Node with admin creds, AppCheck-related checks are unnecessary.
+                // Note that we send the credentials here even if they aren't admin credentials, which is
+                // not a problem.
+                // Note that this header is just used to bypass appcheck, and the token should still be sent
+                // through the websocket connection once it is established.
+                if (this.authToken) {
+                    options.headers['Authorization'] = `Bearer ${this.authToken}`;
+                }
+                if (this.appCheckToken) {
+                    options.headers['X-Firebase-AppCheck'] = this.appCheckToken;
+                }
+                // Plumb appropriate http_proxy environment variable into faye-websocket if it exists.
+                const env = process['env'];
+                const proxy = this.connURL.indexOf('wss://') === 0
+                    ? env['HTTPS_PROXY'] || env['https_proxy']
+                    : env['HTTP_PROXY'] || env['http_proxy'];
+                if (proxy) {
+                    options['proxy'] = { origin: proxy };
+                }
+            }
             this.mySock = new WebSocketImpl(this.connURL, [], options);
         }
         catch (e) {
@@ -12414,6 +13341,14 @@ class PersistentConnection extends ServerActions {
     sendConnectStats_() {
         const stats = {};
         let clientName = 'js';
+        if (isNodeSdk()) {
+            if (this.repoInfo_.nodeAdmin) {
+                clientName = 'admin_node';
+            }
+            else {
+                clientName = 'node';
+            }
+        }
         stats['sdk.' + clientName + '.' + SDK_VERSION.replace(/\./g, '-')] = 1;
         if (isMobileCordova()) {
             stats['framework.cordova'] = 1;
@@ -15009,6 +15944,81 @@ function queryParamsGetNodeFilter(queryParams) {
         return new RangedFilter(queryParams);
     }
 }
+function queryParamsLimitToFirst(queryParams, newLimit) {
+    const newParams = queryParams.copy();
+    newParams.limitSet_ = true;
+    newParams.limit_ = newLimit;
+    newParams.viewFrom_ = "l" /* WIRE_PROTOCOL_CONSTANTS.VIEW_FROM_LEFT */;
+    return newParams;
+}
+function queryParamsLimitToLast(queryParams, newLimit) {
+    const newParams = queryParams.copy();
+    newParams.limitSet_ = true;
+    newParams.limit_ = newLimit;
+    newParams.viewFrom_ = "r" /* WIRE_PROTOCOL_CONSTANTS.VIEW_FROM_RIGHT */;
+    return newParams;
+}
+function queryParamsStartAt(queryParams, indexValue, key) {
+    const newParams = queryParams.copy();
+    newParams.startSet_ = true;
+    if (indexValue === undefined) {
+        indexValue = null;
+    }
+    newParams.indexStartValue_ = indexValue;
+    if (key != null) {
+        newParams.startNameSet_ = true;
+        newParams.indexStartName_ = key;
+    }
+    else {
+        newParams.startNameSet_ = false;
+        newParams.indexStartName_ = '';
+    }
+    return newParams;
+}
+function queryParamsStartAfter(queryParams, indexValue, key) {
+    let params;
+    if (queryParams.index_ === KEY_INDEX || !!key) {
+        params = queryParamsStartAt(queryParams, indexValue, key);
+    }
+    else {
+        params = queryParamsStartAt(queryParams, indexValue, MAX_NAME);
+    }
+    params.startAfterSet_ = true;
+    return params;
+}
+function queryParamsEndAt(queryParams, indexValue, key) {
+    const newParams = queryParams.copy();
+    newParams.endSet_ = true;
+    if (indexValue === undefined) {
+        indexValue = null;
+    }
+    newParams.indexEndValue_ = indexValue;
+    if (key !== undefined) {
+        newParams.endNameSet_ = true;
+        newParams.indexEndName_ = key;
+    }
+    else {
+        newParams.endNameSet_ = false;
+        newParams.indexEndName_ = '';
+    }
+    return newParams;
+}
+function queryParamsEndBefore(queryParams, indexValue, key) {
+    let params;
+    if (queryParams.index_ === KEY_INDEX || !!key) {
+        params = queryParamsEndAt(queryParams, indexValue, key);
+    }
+    else {
+        params = queryParamsEndAt(queryParams, indexValue, MIN_NAME);
+    }
+    params.endBeforeSet_ = true;
+    return params;
+}
+function queryParamsOrderBy(queryParams, index) {
+    const newParams = queryParams.copy();
+    newParams.index_ = index;
+    return newParams;
+}
 /**
  * Returns a set of REST query string parameters representing this query.
  *
@@ -15356,6 +16366,49 @@ function sparseSnapshotTreeRemember(sparseSnapshotTree, path, data) {
         sparseSnapshotTreeRemember(child, path, data);
     }
 }
+/**
+ * Purge the data at path from the cache.
+ *
+ * @param path - Path to look up snapshot for.
+ * @returns True if this node should now be removed.
+ */
+function sparseSnapshotTreeForget(sparseSnapshotTree, path) {
+    if (pathIsEmpty(path)) {
+        sparseSnapshotTree.value = null;
+        sparseSnapshotTree.children.clear();
+        return true;
+    }
+    else {
+        if (sparseSnapshotTree.value !== null) {
+            if (sparseSnapshotTree.value.isLeafNode()) {
+                // We're trying to forget a node that doesn't exist
+                return false;
+            }
+            else {
+                const value = sparseSnapshotTree.value;
+                sparseSnapshotTree.value = null;
+                value.forEachChild(PRIORITY_INDEX, (key, tree) => {
+                    sparseSnapshotTreeRemember(sparseSnapshotTree, new Path(key), tree);
+                });
+                return sparseSnapshotTreeForget(sparseSnapshotTree, path);
+            }
+        }
+        else if (sparseSnapshotTree.children.size > 0) {
+            const childKey = pathGetFront(path);
+            path = pathPopFront(path);
+            if (sparseSnapshotTree.children.has(childKey)) {
+                const safeToRemove = sparseSnapshotTreeForget(sparseSnapshotTree.children.get(childKey), path);
+                if (safeToRemove) {
+                    sparseSnapshotTree.children.delete(childKey);
+                }
+            }
+            return sparseSnapshotTree.children.size === 0;
+        }
+        else {
+            return true;
+        }
+    }
+}
 /**
  * Recursively iterates through all of the stored tree and calls the
  * callback on each one.
@@ -17475,6 +18528,9 @@ class View {
 function viewGetServerCache(view) {
     return view.viewCache_.serverCache.getNode();
 }
+function viewGetCompleteNode(view) {
+    return viewCacheGetCompleteEventSnap(view.viewCache_);
+}
 function viewGetCompleteServerCache(view, path) {
     const cache = viewCacheGetCompleteServerSnap(view.viewCache_);
     if (cache) {
@@ -18147,6 +19203,33 @@ function syncTreeCalcCompleteEventCache(syncTree, path, writeIdsToExclude) {
     });
     return writeTreeCalcCompleteEventCache(writeTree, path, serverCache, writeIdsToExclude, includeHiddenSets);
 }
+function syncTreeGetServerValue(syncTree, query) {
+    const path = query._path;
+    let serverCache = null;
+    // Any covering writes will necessarily be at the root, so really all we need to find is the server cache.
+    // Consider optimizing this once there's a better understanding of what actual behavior will be.
+    syncTree.syncPointTree_.foreachOnPath(path, (pathToSyncPoint, sp) => {
+        const relativePath = newRelativePath(pathToSyncPoint, path);
+        serverCache =
+            serverCache || syncPointGetCompleteServerCache(sp, relativePath);
+    });
+    let syncPoint = syncTree.syncPointTree_.get(path);
+    if (!syncPoint) {
+        syncPoint = new SyncPoint();
+        syncTree.syncPointTree_ = syncTree.syncPointTree_.set(path, syncPoint);
+    }
+    else {
+        serverCache =
+            serverCache || syncPointGetCompleteServerCache(syncPoint, newEmptyPath());
+    }
+    const serverCacheComplete = serverCache != null;
+    const serverCacheNode = serverCacheComplete
+        ? new CacheNode(serverCache, true, false)
+        : null;
+    const writesCache = writeTreeChildWrites(syncTree.pendingWriteTree_, query._path);
+    const view = syncPointGetView(syncPoint, query, writesCache, serverCacheComplete ? serverCacheNode.getNode() : ChildrenNode.EMPTY_NODE, serverCacheComplete);
+    return viewGetCompleteNode(view);
+}
 /**
  * A helper method that visits all descendant and ancestor SyncPoints, applying the operation.
  *
@@ -18898,6 +19981,36 @@ const validateFirebaseMergeDataArg = function (fnName, data, path, optional) {
     });
     validateFirebaseMergePaths(errorPrefix$1, mergePaths);
 };
+const validatePriority = function (fnName, priority, optional) {
+    if (optional && priority === undefined) {
+        return;
+    }
+    if (isInvalidJSONNumber(priority)) {
+        throw new Error(errorPrefix(fnName, 'priority') +
+            'is ' +
+            priority.toString() +
+            ', but must be a valid Firebase priority (a string, finite number, ' +
+            'server value, or null).');
+    }
+    // Special case to allow importing data with a .sv.
+    if (!isValidPriority(priority)) {
+        throw new Error(errorPrefix(fnName, 'priority') +
+            'must be a valid Firebase priority ' +
+            '(a string, finite number, server value, or null).');
+    }
+};
+const validateKey = function (fnName, argumentName, key, optional) {
+    if (optional && key === undefined) {
+        return;
+    }
+    if (!isValidKey(key)) {
+        throw new Error(errorPrefix(fnName, argumentName) +
+            'was an invalid key = "' +
+            key +
+            '".  Firebase keys must be non-empty strings and ' +
+            'can\'t contain ".", "#", "$", "/", "[", or "]").');
+    }
+};
 /**
  * @internal
  */
@@ -19267,6 +20380,63 @@ function repoUpdateInfo(repo, pathString, value) {
 function repoGetNextWriteId(repo) {
     return repo.nextWriteId_++;
 }
+/**
+ * The purpose of `getValue` is to return the latest known value
+ * satisfying `query`.
+ *
+ * This method will first check for in-memory cached values
+ * belonging to active listeners. If they are found, such values
+ * are considered to be the most up-to-date.
+ *
+ * If the client is not connected, this method will wait until the
+ *  repo has established a connection and then request the value for `query`.
+ * If the client is not able to retrieve the query result for another reason,
+ * it reports an error.
+ *
+ * @param query - The query to surface a value for.
+ */
+function repoGetValue(repo, query, eventRegistration) {
+    // Only active queries are cached. There is no persisted cache.
+    const cached = syncTreeGetServerValue(repo.serverSyncTree_, query);
+    if (cached != null) {
+        return Promise.resolve(cached);
+    }
+    return repo.server_.get(query).then(payload => {
+        const node = nodeFromJSON(payload).withIndex(query._queryParams.getIndex());
+        /**
+         * Below we simulate the actions of an `onlyOnce` `onValue()` event where:
+         * Add an event registration,
+         * Update data at the path,
+         * Raise any events,
+         * Cleanup the SyncTree
+         */
+        syncTreeAddEventRegistration(repo.serverSyncTree_, query, eventRegistration, true);
+        let events;
+        if (query._queryParams.loadsAllData()) {
+            events = syncTreeApplyServerOverwrite(repo.serverSyncTree_, query._path, node);
+        }
+        else {
+            const tag = syncTreeTagForQuery(repo.serverSyncTree_, query);
+            events = syncTreeApplyTaggedQueryOverwrite(repo.serverSyncTree_, query._path, node, tag);
+        }
+        /*
+         * We need to raise events in the scenario where `get()` is called at a parent path, and
+         * while the `get()` is pending, `onValue` is called at a child location. While get() is waiting
+         * for the data, `onValue` will register a new event. Then, get() will come back, and update the syncTree
+         * and its corresponding serverCache, including the child location where `onValue` is called. Then,
+         * `onValue` will receive the event from the server, but look at the syncTree and see that the data received
+         * from the server is already at the SyncPoint, and so the `onValue` callback will never get fired.
+         * Calling `eventQueueRaiseEventsForChangedPath()` is the correct way to propagate the events and
+         * ensure the corresponding child events will get fired.
+         */
+        eventQueueRaiseEventsForChangedPath(repo.eventQueue_, query._path, events);
+        syncTreeRemoveEventRegistration(repo.serverSyncTree_, query, eventRegistration, null, true);
+        return node;
+    }, err => {
+        repoLog(repo, 'get for query ' + stringify(query) + ' failed: ' + err);
+        return Promise.reject(new Error(err));
+    });
+}
 function repoSetWithPriority(repo, path, newVal, newPriority, onComplete) {
     repoLog(repo, 'set', {
         path: path.toString(),
@@ -19352,6 +20522,48 @@ function repoRunOnDisconnectEvents(repo) {
     repo.onDisconnect_ = newSparseSnapshotTree();
     eventQueueRaiseEventsForChangedPath(repo.eventQueue_, newEmptyPath(), events);
 }
+function repoOnDisconnectCancel(repo, path, onComplete) {
+    repo.server_.onDisconnectCancel(path.toString(), (status, errorReason) => {
+        if (status === 'ok') {
+            sparseSnapshotTreeForget(repo.onDisconnect_, path);
+        }
+        repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
+    });
+}
+function repoOnDisconnectSet(repo, path, value, onComplete) {
+    const newNode = nodeFromJSON(value);
+    repo.server_.onDisconnectPut(path.toString(), newNode.val(/*export=*/ true), (status, errorReason) => {
+        if (status === 'ok') {
+            sparseSnapshotTreeRemember(repo.onDisconnect_, path, newNode);
+        }
+        repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
+    });
+}
+function repoOnDisconnectSetWithPriority(repo, path, value, priority, onComplete) {
+    const newNode = nodeFromJSON(value, priority);
+    repo.server_.onDisconnectPut(path.toString(), newNode.val(/*export=*/ true), (status, errorReason) => {
+        if (status === 'ok') {
+            sparseSnapshotTreeRemember(repo.onDisconnect_, path, newNode);
+        }
+        repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
+    });
+}
+function repoOnDisconnectUpdate(repo, path, childrenToMerge, onComplete) {
+    if (isEmpty(childrenToMerge)) {
+        log("onDisconnect().update() called with empty data.  Don't do anything.");
+        repoCallOnCompleteCallback(repo, onComplete, 'ok', undefined);
+        return;
+    }
+    repo.server_.onDisconnectMerge(path.toString(), childrenToMerge, (status, errorReason) => {
+        if (status === 'ok') {
+            each(childrenToMerge, (childName, childNode) => {
+                const newChildNode = nodeFromJSON(childNode);
+                sparseSnapshotTreeRemember(repo.onDisconnect_, pathChild(path, childName), newChildNode);
+            });
+        }
+        repoCallOnCompleteCallback(repo, onComplete, status, errorReason);
+    });
+}
 function repoAddEventCallbackForQuery(repo, query, eventRegistration) {
     let events;
     if (pathGetFront(query._path) === '.info') {
@@ -19379,6 +20591,11 @@ function repoInterrupt(repo) {
         repo.persistentConnection_.interrupt(INTERRUPT_REASON);
     }
 }
+function repoResume(repo) {
+    if (repo.persistentConnection_) {
+        repo.persistentConnection_.resume(INTERRUPT_REASON);
+    }
+}
 function repoLog(repo, ...varArgs) {
     let prefix = '';
     if (repo.persistentConnection_) {
@@ -19406,6 +20623,92 @@ function repoCallOnCompleteCallback(repo, callback, status, errorReason) {
         });
     }
 }
+/**
+ * Creates a new transaction, adds it to the transactions we're tracking, and
+ * sends it to the server if possible.
+ *
+ * @param path - Path at which to do transaction.
+ * @param transactionUpdate - Update callback.
+ * @param onComplete - Completion callback.
+ * @param unwatcher - Function that will be called when the transaction no longer
+ * need data updates for `path`.
+ * @param applyLocally - Whether or not to make intermediate results visible
+ */
+function repoStartTransaction(repo, path, transactionUpdate, onComplete, unwatcher, applyLocally) {
+    repoLog(repo, 'transaction on ' + path);
+    // Initialize transaction.
+    const transaction = {
+        path,
+        update: transactionUpdate,
+        onComplete,
+        // One of TransactionStatus enums.
+        status: null,
+        // Used when combining transactions at different locations to figure out
+        // which one goes first.
+        order: LUIDGenerator(),
+        // Whether to raise local events for this transaction.
+        applyLocally,
+        // Count of how many times we've retried the transaction.
+        retryCount: 0,
+        // Function to call to clean up our .on() listener.
+        unwatcher,
+        // Stores why a transaction was aborted.
+        abortReason: null,
+        currentWriteId: null,
+        currentInputSnapshot: null,
+        currentOutputSnapshotRaw: null,
+        currentOutputSnapshotResolved: null
+    };
+    // Run transaction initially.
+    const currentState = repoGetLatestState(repo, path, undefined);
+    transaction.currentInputSnapshot = currentState;
+    const newVal = transaction.update(currentState.val());
+    if (newVal === undefined) {
+        // Abort transaction.
+        transaction.unwatcher();
+        transaction.currentOutputSnapshotRaw = null;
+        transaction.currentOutputSnapshotResolved = null;
+        if (transaction.onComplete) {
+            transaction.onComplete(null, false, transaction.currentInputSnapshot);
+        }
+    }
+    else {
+        validateFirebaseData('transaction failed: Data returned ', newVal, transaction.path);
+        // Mark as run and add to our queue.
+        transaction.status = 0 /* TransactionStatus.RUN */;
+        const queueNode = treeSubTree(repo.transactionQueueTree_, path);
+        const nodeQueue = treeGetValue(queueNode) || [];
+        nodeQueue.push(transaction);
+        treeSetValue(queueNode, nodeQueue);
+        // Update visibleData and raise events
+        // Note: We intentionally raise events after updating all of our
+        // transaction state, since the user could start new transactions from the
+        // event callbacks.
+        let priorityForNode;
+        if (typeof newVal === 'object' &&
+            newVal !== null &&
+            contains(newVal, '.priority')) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            priorityForNode = safeGet(newVal, '.priority');
+            assert(isValidPriority(priorityForNode), 'Invalid priority returned by transaction. ' +
+                'Priority must be a valid string, finite number, server value, or null.');
+        }
+        else {
+            const currentNode = syncTreeCalcCompleteEventCache(repo.serverSyncTree_, path) ||
+                ChildrenNode.EMPTY_NODE;
+            priorityForNode = currentNode.getPriority().val();
+        }
+        const serverValues = repoGenerateServerValues(repo);
+        const newNodeUnresolved = nodeFromJSON(newVal, priorityForNode);
+        const newNode = resolveDeferredValueSnapshot(newNodeUnresolved, currentState, serverValues);
+        transaction.currentOutputSnapshotRaw = newNodeUnresolved;
+        transaction.currentOutputSnapshotResolved = newNode;
+        transaction.currentWriteId = repoGetNextWriteId(repo);
+        const events = syncTreeApplyUserOverwrite(repo.serverSyncTree_, path, newNode, transaction.currentWriteId, transaction.applyLocally);
+        eventQueueRaiseEventsForChangedPath(repo.eventQueue_, path, events);
+        repoSendReadyTransactions(repo, repo.transactionQueueTree_);
+    }
+}
 /**
  * @param excludeSets - A specific set to exclude
  */
@@ -20123,7 +21426,7 @@ class CallbackContext {
 
 /**
  * @license
- * Copyright 2020 Google LLC
+ * Copyright 2021 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20138,11 +21441,149 @@ class CallbackContext {
  * limitations under the License.
  */
 /**
- * @internal
+ * The `onDisconnect` class allows you to write or clear data when your client
+ * disconnects from the Database server. These updates occur whether your
+ * client disconnects cleanly or not, so you can rely on them to clean up data
+ * even if a connection is dropped or a client crashes.
+ *
+ * The `onDisconnect` class is most commonly used to manage presence in
+ * applications where it is useful to detect how many clients are connected and
+ * when other clients disconnect. See
+ * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
+ * for more information.
+ *
+ * To avoid problems when a connection is dropped before the requests can be
+ * transferred to the Database server, these functions should be called before
+ * writing any data.
+ *
+ * Note that `onDisconnect` operations are only triggered once. If you want an
+ * operation to occur each time a disconnect occurs, you'll need to re-establish
+ * the `onDisconnect` operations each time you reconnect.
  */
-class QueryImpl {
-    /**
-     * @hideconstructor
+class OnDisconnect {
+    /** @hideconstructor */
+    constructor(_repo, _path) {
+        this._repo = _repo;
+        this._path = _path;
+    }
+    /**
+     * Cancels all previously queued `onDisconnect()` set or update events for this
+     * location and all children.
+     *
+     * If a write has been queued for this location via a `set()` or `update()` at a
+     * parent location, the write at this location will be canceled, though writes
+     * to sibling locations will still occur.
+     *
+     * @returns Resolves when synchronization to the server is complete.
+     */
+    cancel() {
+        const deferred = new Deferred();
+        repoOnDisconnectCancel(this._repo, this._path, deferred.wrapCallback(() => { }));
+        return deferred.promise;
+    }
+    /**
+     * Ensures the data at this location is deleted when the client is disconnected
+     * (due to closing the browser, navigating to a new page, or network issues).
+     *
+     * @returns Resolves when synchronization to the server is complete.
+     */
+    remove() {
+        validateWritablePath('OnDisconnect.remove', this._path);
+        const deferred = new Deferred();
+        repoOnDisconnectSet(this._repo, this._path, null, deferred.wrapCallback(() => { }));
+        return deferred.promise;
+    }
+    /**
+     * Ensures the data at this location is set to the specified value when the
+     * client is disconnected (due to closing the browser, navigating to a new page,
+     * or network issues).
+     *
+     * `set()` is especially useful for implementing "presence" systems, where a
+     * value should be changed or cleared when a user disconnects so that they
+     * appear "offline" to other users. See
+     * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
+     * for more information.
+     *
+     * Note that `onDisconnect` operations are only triggered once. If you want an
+     * operation to occur each time a disconnect occurs, you'll need to re-establish
+     * the `onDisconnect` operations each time.
+     *
+     * @param value - The value to be written to this location on disconnect (can
+     * be an object, array, string, number, boolean, or null).
+     * @returns Resolves when synchronization to the Database is complete.
+     */
+    set(value) {
+        validateWritablePath('OnDisconnect.set', this._path);
+        validateFirebaseDataArg('OnDisconnect.set', value, this._path, false);
+        const deferred = new Deferred();
+        repoOnDisconnectSet(this._repo, this._path, value, deferred.wrapCallback(() => { }));
+        return deferred.promise;
+    }
+    /**
+     * Ensures the data at this location is set to the specified value and priority
+     * when the client is disconnected (due to closing the browser, navigating to a
+     * new page, or network issues).
+     *
+     * @param value - The value to be written to this location on disconnect (can
+     * be an object, array, string, number, boolean, or null).
+     * @param priority - The priority to be written (string, number, or null).
+     * @returns Resolves when synchronization to the Database is complete.
+     */
+    setWithPriority(value, priority) {
+        validateWritablePath('OnDisconnect.setWithPriority', this._path);
+        validateFirebaseDataArg('OnDisconnect.setWithPriority', value, this._path, false);
+        validatePriority('OnDisconnect.setWithPriority', priority, false);
+        const deferred = new Deferred();
+        repoOnDisconnectSetWithPriority(this._repo, this._path, value, priority, deferred.wrapCallback(() => { }));
+        return deferred.promise;
+    }
+    /**
+     * Writes multiple values at this location when the client is disconnected (due
+     * to closing the browser, navigating to a new page, or network issues).
+     *
+     * The `values` argument contains multiple property-value pairs that will be
+     * written to the Database together. Each child property can either be a simple
+     * property (for example, "name") or a relative path (for example, "name/first")
+     * from the current location to the data to update.
+     *
+     * As opposed to the `set()` method, `update()` can be use to selectively update
+     * only the referenced properties at the current location (instead of replacing
+     * all the child properties at the current location).
+     *
+     * @param values - Object containing multiple values.
+     * @returns Resolves when synchronization to the Database is complete.
+     */
+    update(values) {
+        validateWritablePath('OnDisconnect.update', this._path);
+        validateFirebaseMergeDataArg('OnDisconnect.update', values, this._path, false);
+        const deferred = new Deferred();
+        repoOnDisconnectUpdate(this._repo, this._path, values, deferred.wrapCallback(() => { }));
+        return deferred.promise;
+    }
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * @internal
+ */
+class QueryImpl {
+    /**
+     * @hideconstructor
      */
     constructor(_repo, _path, _queryParams, _orderByCalled) {
         this._repo = _repo;
@@ -20189,6 +21630,80 @@ class QueryImpl {
         return this._repo.toString() + pathToUrlEncodedString(this._path);
     }
 }
+/**
+ * Validates that no other order by call has been made
+ */
+function validateNoPreviousOrderByCall(query, fnName) {
+    if (query._orderByCalled === true) {
+        throw new Error(fnName + ": You can't combine multiple orderBy calls.");
+    }
+}
+/**
+ * Validates start/end values for queries.
+ */
+function validateQueryEndpoints(params) {
+    let startNode = null;
+    let endNode = null;
+    if (params.hasStart()) {
+        startNode = params.getIndexStartValue();
+    }
+    if (params.hasEnd()) {
+        endNode = params.getIndexEndValue();
+    }
+    if (params.getIndex() === KEY_INDEX) {
+        const tooManyArgsError = 'Query: When ordering by key, you may only pass one argument to ' +
+            'startAt(), endAt(), or equalTo().';
+        const wrongArgTypeError = 'Query: When ordering by key, the argument passed to startAt(), startAfter(), ' +
+            'endAt(), endBefore(), or equalTo() must be a string.';
+        if (params.hasStart()) {
+            const startName = params.getIndexStartName();
+            if (startName !== MIN_NAME) {
+                throw new Error(tooManyArgsError);
+            }
+            else if (typeof startNode !== 'string') {
+                throw new Error(wrongArgTypeError);
+            }
+        }
+        if (params.hasEnd()) {
+            const endName = params.getIndexEndName();
+            if (endName !== MAX_NAME) {
+                throw new Error(tooManyArgsError);
+            }
+            else if (typeof endNode !== 'string') {
+                throw new Error(wrongArgTypeError);
+            }
+        }
+    }
+    else if (params.getIndex() === PRIORITY_INDEX) {
+        if ((startNode != null && !isValidPriority(startNode)) ||
+            (endNode != null && !isValidPriority(endNode))) {
+            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).');
+        }
+    }
+    else {
+        assert(params.getIndex() instanceof PathIndex ||
+            params.getIndex() === VALUE_INDEX, 'unknown index type.');
+        if ((startNode != null && typeof startNode === 'object') ||
+            (endNode != null && typeof endNode === 'object')) {
+            throw new Error('Query: First argument passed to startAt(), startAfter(), endAt(), endBefore(), or ' +
+                'equalTo() cannot be an object.');
+        }
+    }
+}
+/**
+ * Validates that limit* has been called with the correct combination of parameters
+ */
+function validateLimit(params) {
+    if (params.hasStart() &&
+        params.hasEnd() &&
+        params.hasLimit() &&
+        !params.hasAnchoredLimit()) {
+        throw new Error("Query: Can't combine startAt(), startAfter(), endAt(), endBefore(), and limit(). Use " +
+            'limitToFirst() or limitToLast() instead.');
+    }
+}
 /**
  * @internal
  */
@@ -20406,6 +21921,40 @@ function ref(db, path) {
     db._checkNotDeleted('ref');
     return path !== undefined ? child(db._root, path) : db._root;
 }
+/**
+ * Returns a `Reference` representing the location in the Database
+ * corresponding to the provided Firebase URL.
+ *
+ * An exception is thrown if the URL is not a valid Firebase Database URL or it
+ * has a different domain than the current `Database` instance.
+ *
+ * Note that all query parameters (`orderBy`, `limitToLast`, etc.) are ignored
+ * and are not applied to the returned `Reference`.
+ *
+ * @param db - The database instance to obtain a reference for.
+ * @param url - The Firebase URL at which the returned `Reference` will
+ *   point.
+ * @returns A `Reference` pointing to the provided
+ *   Firebase URL.
+ */
+function refFromURL(db, url) {
+    db = getModularInstance(db);
+    db._checkNotDeleted('refFromURL');
+    const parsedURL = parseRepoInfo(url, db._repo.repoInfo_.nodeAdmin);
+    validateUrl('refFromURL', parsedURL);
+    const repoInfo = parsedURL.repoInfo;
+    if (!db._repo.repoInfo_.isCustomHost() &&
+        repoInfo.host !== db._repo.repoInfo_.host) {
+        fatal('refFromURL' +
+            ': Host name does not match the current database: ' +
+            '(found ' +
+            repoInfo.host +
+            ' but expected ' +
+            db._repo.repoInfo_.host +
+            ')');
+    }
+    return ref(db, parsedURL.path.toString());
+}
 /**
  * Gets a `Reference` for the location at the specified relative path.
  *
@@ -20427,6 +21976,17 @@ function child(parent, path) {
     }
     return new ReferenceImpl(parent._repo, pathChild(parent._path, path));
 }
+/**
+ * Returns an `OnDisconnect` object - see
+ * {@link https://firebase.google.com/docs/database/web/offline-capabilities | Enabling Offline Capabilities in JavaScript}
+ * for more information on how to use it.
+ *
+ * @param ref - The reference to add OnDisconnect triggers for.
+ */
+function onDisconnect(ref) {
+    ref = getModularInstance(ref);
+    return new OnDisconnect(ref._repo, ref._path);
+}
 /**
  * Generates a new child location using a unique key and returns its
  * `Reference`.
@@ -20475,6 +22035,24 @@ function push(parent, value) {
     thennablePushRef.catch = promise.then.bind(promise, undefined);
     return thennablePushRef;
 }
+/**
+ * Removes the data at this Database location.
+ *
+ * Any data at child locations will also be deleted.
+ *
+ * The effect of the remove will be visible immediately and the corresponding
+ * event 'value' will be triggered. Synchronization of the remove to the
+ * Firebase servers will also be started, and the returned Promise will resolve
+ * when complete. If provided, the onComplete callback will be called
+ * asynchronously after synchronization has finished.
+ *
+ * @param ref - The location to remove.
+ * @returns Resolves when remove on server is complete.
+ */
+function remove(ref) {
+    validateWritablePath('remove', ref._path);
+    return set(ref, null);
+}
 /**
  * Writes data to this Database location.
  *
@@ -20513,6 +22091,52 @@ function set(ref, value) {
     /*priority=*/ null, deferred.wrapCallback(() => { }));
     return deferred.promise;
 }
+/**
+ * Sets a priority for the data at this Database location.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}
+ * ).
+ *
+ * @param ref - The location to write to.
+ * @param priority - The priority to be written (string, number, or null).
+ * @returns Resolves when write to server is complete.
+ */
+function setPriority(ref, priority) {
+    ref = getModularInstance(ref);
+    validateWritablePath('setPriority', ref._path);
+    validatePriority('setPriority', priority, false);
+    const deferred = new Deferred();
+    repoSetWithPriority(ref._repo, pathChild(ref._path, '.priority'), priority, null, deferred.wrapCallback(() => { }));
+    return deferred.promise;
+}
+/**
+ * Writes data the Database location. Like `set()` but also specifies the
+ * priority for that data.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sorting_and_filtering_data | Sorting and filtering data}
+ * ).
+ *
+ * @param ref - The location to write to.
+ * @param value - The value to be written (string, number, boolean, object,
+ *   array, or null).
+ * @param priority - The priority to be written (string, number, or null).
+ * @returns Resolves when write to server is complete.
+ */
+function setWithPriority(ref, value, priority) {
+    validateWritablePath('setWithPriority', ref._path);
+    validateFirebaseDataArg('setWithPriority', value, ref._path, false);
+    validatePriority('setWithPriority', priority, false);
+    if (ref.key === '.length' || ref.key === '.keys') {
+        throw 'setWithPriority failed: ' + ref.key + ' is a read-only object.';
+    }
+    const deferred = new Deferred();
+    repoSetWithPriority(ref._repo, ref._path, value, priority, deferred.wrapCallback(() => { }));
+    return deferred.promise;
+}
 /**
  * Writes multiple values to the Database at once.
  *
@@ -20554,6 +22178,22 @@ function update(ref, values) {
     repoUpdate(ref._repo, ref._path, values, deferred.wrapCallback(() => { }));
     return deferred.promise;
 }
+/**
+ * Gets the most up-to-date result for this query.
+ *
+ * @param query - The query to run.
+ * @returns A `Promise` which resolves to the resulting DataSnapshot if a value is
+ * available, or rejects if the client is unable to return a value (e.g., if the
+ * server is unreachable and there is nothing cached).
+ */
+function get(query) {
+    query = getModularInstance(query);
+    const callbackContext = new CallbackContext(() => { });
+    const container = new ValueEventRegistration(callbackContext);
+    return repoGetValue(query._repo, query, container).then(node => {
+        return new DataSnapshot(node, new ReferenceImpl(query._repo, query._path), query._queryParams.getIndex());
+    });
+}
 /**
  * Represents registration for 'value' events.
  */
@@ -20678,6 +22318,479 @@ function addEventListener(query, eventType, callback, cancelCallbackOrListenOpti
 function onValue(query, callback, cancelCallbackOrListenOptions, options) {
     return addEventListener(query, 'value', callback, cancelCallbackOrListenOptions, options);
 }
+function onChildAdded(query, callback, cancelCallbackOrListenOptions, options) {
+    return addEventListener(query, 'child_added', callback, cancelCallbackOrListenOptions, options);
+}
+function onChildChanged(query, callback, cancelCallbackOrListenOptions, options) {
+    return addEventListener(query, 'child_changed', callback, cancelCallbackOrListenOptions, options);
+}
+function onChildMoved(query, callback, cancelCallbackOrListenOptions, options) {
+    return addEventListener(query, 'child_moved', callback, cancelCallbackOrListenOptions, options);
+}
+function onChildRemoved(query, callback, cancelCallbackOrListenOptions, options) {
+    return addEventListener(query, 'child_removed', callback, cancelCallbackOrListenOptions, options);
+}
+/**
+ * Detaches a callback previously attached with the corresponding `on*()` (`onValue`, `onChildAdded`) listener.
+ * Note: This is not the recommended way to remove a listener. Instead, please use the returned callback function from
+ * the respective `on*` callbacks.
+ *
+ * Detach a callback previously attached with `on*()`. Calling `off()` on a parent listener
+ * will not automatically remove listeners registered on child nodes, `off()`
+ * must also be called on any child listeners to remove the callback.
+ *
+ * If a callback is not specified, all callbacks for the specified eventType
+ * will be removed. Similarly, if no eventType is specified, all callbacks
+ * for the `Reference` will be removed.
+ *
+ * Individual listeners can also be removed by invoking their unsubscribe
+ * callbacks.
+ *
+ * @param query - The query that the listener was registered with.
+ * @param eventType - One of the following strings: "value", "child_added",
+ * "child_changed", "child_removed", or "child_moved." If omitted, all callbacks
+ * for the `Reference` will be removed.
+ * @param callback - The callback function that was passed to `on()` or
+ * `undefined` to remove all callbacks.
+ */
+function off(query, eventType, callback) {
+    let container = null;
+    const expCallback = callback ? new CallbackContext(callback) : null;
+    if (eventType === 'value') {
+        container = new ValueEventRegistration(expCallback);
+    }
+    else if (eventType) {
+        container = new ChildEventRegistration(eventType, expCallback);
+    }
+    repoRemoveEventCallbackForQuery(query._repo, query, container);
+}
+/**
+ * A `QueryConstraint` is used to narrow the set of documents returned by a
+ * Database query. `QueryConstraint`s are created by invoking {@link endAt},
+ * {@link endBefore}, {@link startAt}, {@link startAfter}, {@link
+ * limitToFirst}, {@link limitToLast}, {@link orderByChild},
+ * {@link orderByChild}, {@link orderByKey} , {@link orderByPriority} ,
+ * {@link orderByValue}  or {@link equalTo} and
+ * can then be passed to {@link query} to create a new query instance that
+ * also contains this `QueryConstraint`.
+ */
+class QueryConstraint {
+}
+class QueryEndAtConstraint extends QueryConstraint {
+    constructor(_value, _key) {
+        super();
+        this._value = _value;
+        this._key = _key;
+    }
+    _apply(query) {
+        validateFirebaseDataArg('endAt', this._value, query._path, true);
+        const newParams = queryParamsEndAt(query._queryParams, this._value, this._key);
+        validateLimit(newParams);
+        validateQueryEndpoints(newParams);
+        if (query._queryParams.hasEnd()) {
+            throw new Error('endAt: Starting point was already set (by another call to endAt, ' +
+                'endBefore or equalTo).');
+        }
+        return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
+    }
+}
+/**
+ * Creates a `QueryConstraint` with the specified ending point.
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The ending point is inclusive, so children with exactly the specified value
+ * will be included in the query. The optional key argument can be used to
+ * further limit the range of the query. If it is specified, then children that
+ * have exactly the specified value must also have a key name less than or equal
+ * to the specified key.
+ *
+ * You can read more about `endAt()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param value - The value to end at. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to end at, among the children with the previously
+ * specified priority. This argument is only allowed if ordering by child,
+ * value, or priority.
+ */
+function endAt(value, key) {
+    validateKey('endAt', 'key', key, true);
+    return new QueryEndAtConstraint(value, key);
+}
+class QueryEndBeforeConstraint extends QueryConstraint {
+    constructor(_value, _key) {
+        super();
+        this._value = _value;
+        this._key = _key;
+    }
+    _apply(query) {
+        validateFirebaseDataArg('endBefore', this._value, query._path, false);
+        const newParams = queryParamsEndBefore(query._queryParams, this._value, this._key);
+        validateLimit(newParams);
+        validateQueryEndpoints(newParams);
+        if (query._queryParams.hasEnd()) {
+            throw new Error('endBefore: Starting point was already set (by another call to endAt, ' +
+                'endBefore or equalTo).');
+        }
+        return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
+    }
+}
+/**
+ * Creates a `QueryConstraint` with the specified ending point (exclusive).
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The ending point is exclusive. If only a value is provided, children
+ * with a value less than the specified value will be included in the query.
+ * If a key is specified, then children must have a value less than or equal
+ * to the specified value and a key name less than the specified key.
+ *
+ * @param value - The value to end before. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to end before, among the children with the
+ * previously specified priority. This argument is only allowed if ordering by
+ * child, value, or priority.
+ */
+function endBefore(value, key) {
+    validateKey('endBefore', 'key', key, true);
+    return new QueryEndBeforeConstraint(value, key);
+}
+class QueryStartAtConstraint extends QueryConstraint {
+    constructor(_value, _key) {
+        super();
+        this._value = _value;
+        this._key = _key;
+    }
+    _apply(query) {
+        validateFirebaseDataArg('startAt', this._value, query._path, true);
+        const newParams = queryParamsStartAt(query._queryParams, this._value, this._key);
+        validateLimit(newParams);
+        validateQueryEndpoints(newParams);
+        if (query._queryParams.hasStart()) {
+            throw new Error('startAt: Starting point was already set (by another call to startAt, ' +
+                'startBefore or equalTo).');
+        }
+        return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
+    }
+}
+/**
+ * Creates a `QueryConstraint` with the specified starting point.
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The starting point is inclusive, so children with exactly the specified value
+ * will be included in the query. The optional key argument can be used to
+ * further limit the range of the query. If it is specified, then children that
+ * have exactly the specified value must also have a key name greater than or
+ * equal to the specified key.
+ *
+ * You can read more about `startAt()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param value - The value to start at. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to start at. This argument is only allowed if
+ * ordering by child, value, or priority.
+ */
+function startAt(value = null, key) {
+    validateKey('startAt', 'key', key, true);
+    return new QueryStartAtConstraint(value, key);
+}
+class QueryStartAfterConstraint extends QueryConstraint {
+    constructor(_value, _key) {
+        super();
+        this._value = _value;
+        this._key = _key;
+    }
+    _apply(query) {
+        validateFirebaseDataArg('startAfter', this._value, query._path, false);
+        const newParams = queryParamsStartAfter(query._queryParams, this._value, this._key);
+        validateLimit(newParams);
+        validateQueryEndpoints(newParams);
+        if (query._queryParams.hasStart()) {
+            throw new Error('startAfter: Starting point was already set (by another call to startAt, ' +
+                'startAfter, or equalTo).');
+        }
+        return new QueryImpl(query._repo, query._path, newParams, query._orderByCalled);
+    }
+}
+/**
+ * Creates a `QueryConstraint` with the specified starting point (exclusive).
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The starting point is exclusive. If only a value is provided, children
+ * with a value greater than the specified value will be included in the query.
+ * If a key is specified, then children must have a value greater than or equal
+ * to the specified value and a a key name greater than the specified key.
+ *
+ * @param value - The value to start after. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to start after. This argument is only allowed if
+ * ordering by child, value, or priority.
+ */
+function startAfter(value, key) {
+    validateKey('startAfter', 'key', key, true);
+    return new QueryStartAfterConstraint(value, key);
+}
+class QueryLimitToFirstConstraint extends QueryConstraint {
+    constructor(_limit) {
+        super();
+        this._limit = _limit;
+    }
+    _apply(query) {
+        if (query._queryParams.hasLimit()) {
+            throw new Error('limitToFirst: Limit was already set (by another call to limitToFirst ' +
+                'or limitToLast).');
+        }
+        return new QueryImpl(query._repo, query._path, queryParamsLimitToFirst(query._queryParams, this._limit), query._orderByCalled);
+    }
+}
+/**
+ * Creates a new `QueryConstraint` that if limited to the first specific number
+ * of children.
+ *
+ * The `limitToFirst()` method is used to set a maximum number of children to be
+ * synced for a given callback. If we set a limit of 100, we will initially only
+ * receive up to 100 `child_added` events. If we have fewer than 100 messages
+ * stored in our Database, a `child_added` event will fire for each message.
+ * However, if we have over 100 messages, we will only receive a `child_added`
+ * event for the first 100 ordered messages. As items change, we will receive
+ * `child_removed` events for each item that drops out of the active list so
+ * that the total number stays at 100.
+ *
+ * You can read more about `limitToFirst()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param limit - The maximum number of nodes to include in this query.
+ */
+function limitToFirst(limit) {
+    if (typeof limit !== 'number' || Math.floor(limit) !== limit || limit <= 0) {
+        throw new Error('limitToFirst: First argument must be a positive integer.');
+    }
+    return new QueryLimitToFirstConstraint(limit);
+}
+class QueryLimitToLastConstraint extends QueryConstraint {
+    constructor(_limit) {
+        super();
+        this._limit = _limit;
+    }
+    _apply(query) {
+        if (query._queryParams.hasLimit()) {
+            throw new Error('limitToLast: Limit was already set (by another call to limitToFirst ' +
+                'or limitToLast).');
+        }
+        return new QueryImpl(query._repo, query._path, queryParamsLimitToLast(query._queryParams, this._limit), query._orderByCalled);
+    }
+}
+/**
+ * Creates a new `QueryConstraint` that is limited to return only the last
+ * specified number of children.
+ *
+ * The `limitToLast()` method is used to set a maximum number of children to be
+ * synced for a given callback. If we set a limit of 100, we will initially only
+ * receive up to 100 `child_added` events. If we have fewer than 100 messages
+ * stored in our Database, a `child_added` event will fire for each message.
+ * However, if we have over 100 messages, we will only receive a `child_added`
+ * event for the last 100 ordered messages. As items change, we will receive
+ * `child_removed` events for each item that drops out of the active list so
+ * that the total number stays at 100.
+ *
+ * You can read more about `limitToLast()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param limit - The maximum number of nodes to include in this query.
+ */
+function limitToLast(limit) {
+    if (typeof limit !== 'number' || Math.floor(limit) !== limit || limit <= 0) {
+        throw new Error('limitToLast: First argument must be a positive integer.');
+    }
+    return new QueryLimitToLastConstraint(limit);
+}
+class QueryOrderByChildConstraint extends QueryConstraint {
+    constructor(_path) {
+        super();
+        this._path = _path;
+    }
+    _apply(query) {
+        validateNoPreviousOrderByCall(query, 'orderByChild');
+        const parsedPath = new Path(this._path);
+        if (pathIsEmpty(parsedPath)) {
+            throw new Error('orderByChild: cannot pass in empty path. Use orderByValue() instead.');
+        }
+        const index = new PathIndex(parsedPath);
+        const newParams = queryParamsOrderBy(query._queryParams, index);
+        validateQueryEndpoints(newParams);
+        return new QueryImpl(query._repo, query._path, newParams, 
+        /*orderByCalled=*/ true);
+    }
+}
+/**
+ * Creates a new `QueryConstraint` that orders by the specified child key.
+ *
+ * Queries can only order by one key at a time. Calling `orderByChild()`
+ * multiple times on the same query is an error.
+ *
+ * Firebase queries allow you to order your data by any child key on the fly.
+ * However, if you know in advance what your indexes will be, you can define
+ * them via the .indexOn rule in your Security Rules for better performance. See
+ * the{@link https://firebase.google.com/docs/database/security/indexing-data}
+ * rule for more information.
+ *
+ * You can read more about `orderByChild()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
+ *
+ * @param path - The path to order by.
+ */
+function orderByChild(path) {
+    if (path === '$key') {
+        throw new Error('orderByChild: "$key" is invalid.  Use orderByKey() instead.');
+    }
+    else if (path === '$priority') {
+        throw new Error('orderByChild: "$priority" is invalid.  Use orderByPriority() instead.');
+    }
+    else if (path === '$value') {
+        throw new Error('orderByChild: "$value" is invalid.  Use orderByValue() instead.');
+    }
+    validatePathString('orderByChild', 'path', path, false);
+    return new QueryOrderByChildConstraint(path);
+}
+class QueryOrderByKeyConstraint extends QueryConstraint {
+    _apply(query) {
+        validateNoPreviousOrderByCall(query, 'orderByKey');
+        const newParams = queryParamsOrderBy(query._queryParams, KEY_INDEX);
+        validateQueryEndpoints(newParams);
+        return new QueryImpl(query._repo, query._path, newParams, 
+        /*orderByCalled=*/ true);
+    }
+}
+/**
+ * Creates a new `QueryConstraint` that orders by the key.
+ *
+ * Sorts the results of a query by their (ascending) key values.
+ *
+ * You can read more about `orderByKey()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
+ */
+function orderByKey() {
+    return new QueryOrderByKeyConstraint();
+}
+class QueryOrderByPriorityConstraint extends QueryConstraint {
+    _apply(query) {
+        validateNoPreviousOrderByCall(query, 'orderByPriority');
+        const newParams = queryParamsOrderBy(query._queryParams, PRIORITY_INDEX);
+        validateQueryEndpoints(newParams);
+        return new QueryImpl(query._repo, query._path, newParams, 
+        /*orderByCalled=*/ true);
+    }
+}
+/**
+ * Creates a new `QueryConstraint` that orders by priority.
+ *
+ * Applications need not use priority but can order collections by
+ * ordinary properties (see
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}
+ * for alternatives to priority.
+ */
+function orderByPriority() {
+    return new QueryOrderByPriorityConstraint();
+}
+class QueryOrderByValueConstraint extends QueryConstraint {
+    _apply(query) {
+        validateNoPreviousOrderByCall(query, 'orderByValue');
+        const newParams = queryParamsOrderBy(query._queryParams, VALUE_INDEX);
+        validateQueryEndpoints(newParams);
+        return new QueryImpl(query._repo, query._path, newParams, 
+        /*orderByCalled=*/ true);
+    }
+}
+/**
+ * Creates a new `QueryConstraint` that orders by value.
+ *
+ * If the children of a query are all scalar values (string, number, or
+ * boolean), you can order the results by their (ascending) values.
+ *
+ * You can read more about `orderByValue()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#sort_data | Sort data}.
+ */
+function orderByValue() {
+    return new QueryOrderByValueConstraint();
+}
+class QueryEqualToValueConstraint extends QueryConstraint {
+    constructor(_value, _key) {
+        super();
+        this._value = _value;
+        this._key = _key;
+    }
+    _apply(query) {
+        validateFirebaseDataArg('equalTo', this._value, query._path, false);
+        if (query._queryParams.hasStart()) {
+            throw new Error('equalTo: Starting point was already set (by another call to startAt/startAfter or ' +
+                'equalTo).');
+        }
+        if (query._queryParams.hasEnd()) {
+            throw new Error('equalTo: Ending point was already set (by another call to endAt/endBefore or ' +
+                'equalTo).');
+        }
+        return new QueryEndAtConstraint(this._value, this._key)._apply(new QueryStartAtConstraint(this._value, this._key)._apply(query));
+    }
+}
+/**
+ * Creates a `QueryConstraint` that includes children that match the specified
+ * value.
+ *
+ * Using `startAt()`, `startAfter()`, `endBefore()`, `endAt()` and `equalTo()`
+ * allows you to choose arbitrary starting and ending points for your queries.
+ *
+ * The optional key argument can be used to further limit the range of the
+ * query. If it is specified, then children that have exactly the specified
+ * value must also have exactly the specified key as their key name. This can be
+ * used to filter result sets with many matches for the same value.
+ *
+ * You can read more about `equalTo()` in
+ * {@link https://firebase.google.com/docs/database/web/lists-of-data#filtering_data | Filtering data}.
+ *
+ * @param value - The value to match for. The argument type depends on which
+ * `orderBy*()` function was used in this query. Specify a value that matches
+ * the `orderBy*()` type. When used in combination with `orderByKey()`, the
+ * value must be a string.
+ * @param key - The child key to start at, among the children with the
+ * previously specified priority. This argument is only allowed if ordering by
+ * child, value, or priority.
+ */
+function equalTo(value, key) {
+    validateKey('equalTo', 'key', key, true);
+    return new QueryEqualToValueConstraint(value, key);
+}
+/**
+ * Creates a new immutable instance of `Query` that is extended to also include
+ * additional query constraints.
+ *
+ * @param query - The Query instance to use as a base for the new constraints.
+ * @param queryConstraints - The list of `QueryConstraint`s to apply.
+ * @throws if any of the provided query constraints cannot be combined with the
+ * existing or new constraints.
+ */
+function query(query, ...queryConstraints) {
+    let queryImpl = getModularInstance(query);
+    for (const constraint of queryConstraints) {
+        queryImpl = constraint._apply(queryImpl);
+    }
+    return queryImpl;
+}
 /**
  * Define reference constructor in various modules
  *
@@ -20806,6 +22919,12 @@ function repoManagerCreateRepo(repoInfo, app, authTokenProvider, appCheckProvide
     appRepos[repoInfo.toURLString()] = repo;
     return repo;
 }
+/**
+ * Forces us to use ReadonlyRestClient instead of PersistentConnection for new Repos.
+ */
+function repoManagerForceRestClient(forceRestClient) {
+    useRestClient = forceRestClient;
+}
 /**
  * Class representing a Firebase Realtime Database.
  */
@@ -20848,6 +22967,26 @@ class Database {
         }
     }
 }
+function checkTransportInit() {
+    if (TransportManager.IS_TRANSPORT_INITIALIZED) {
+        warn('Transport has already been initialized. Please call this function before calling ref or setting up a listener');
+    }
+}
+/**
+ * Force the use of websockets instead of longPolling.
+ */
+function forceWebSockets() {
+    checkTransportInit();
+    BrowserPollConnection.forceDisallow();
+}
+/**
+ * Force the use of longPolling instead of websockets. This will be ignored if websocket protocol is used in databaseURL.
+ */
+function forceLongPolling() {
+    checkTransportInit();
+    WebSocketConnection.forceDisallow();
+    BrowserPollConnection.forceAllow();
+}
 /**
  * Returns the instance of the Realtime Database SDK that is associated
  * with the provided {@link @firebase/app#FirebaseApp}. Initializes a new instance with
@@ -20906,6 +23045,51 @@ function connectDatabaseEmulator(db, host, port, options = {}) {
     // Modify the repo to apply emulator settings
     repoManagerApplyEmulatorSettings(repo, host, port, tokenProvider);
 }
+/**
+ * Disconnects from the server (all Database operations will be completed
+ * offline).
+ *
+ * The client automatically maintains a persistent connection to the Database
+ * server, which will remain active indefinitely and reconnect when
+ * disconnected. However, the `goOffline()` and `goOnline()` methods may be used
+ * to control the client connection in cases where a persistent connection is
+ * undesirable.
+ *
+ * While offline, the client will no longer receive data updates from the
+ * Database. However, all Database operations performed locally will continue to
+ * immediately fire events, allowing your application to continue behaving
+ * normally. Additionally, each operation performed locally will automatically
+ * be queued and retried upon reconnection to the Database server.
+ *
+ * To reconnect to the Database and begin receiving remote events, see
+ * `goOnline()`.
+ *
+ * @param db - The instance to disconnect.
+ */
+function goOffline(db) {
+    db = getModularInstance(db);
+    db._checkNotDeleted('goOffline');
+    repoInterrupt(db._repo);
+}
+/**
+ * Reconnects to the server and synchronizes the offline Database state
+ * with the server state.
+ *
+ * This method should be used after disabling the active connection with
+ * `goOffline()`. Once reconnected, the client will transmit the proper data
+ * and fire the appropriate events so that your client "catches up"
+ * automatically.
+ *
+ * @param db - The instance to reconnect.
+ */
+function goOnline(db) {
+    db = getModularInstance(db);
+    db._checkNotDeleted('goOnline');
+    repoResume(db._repo);
+}
+function enableLogging(logger, persistent) {
+    enableLogging$1(logger, persistent);
+}
 
 /**
  * @license
@@ -20935,6 +23119,164 @@ function registerDatabase(variant) {
     // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
     registerVersion(name, version, 'esm2017');
 }
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const SERVER_TIMESTAMP = {
+    '.sv': 'timestamp'
+};
+/**
+ * Returns a placeholder value for auto-populating the current timestamp (time
+ * since the Unix epoch, in milliseconds) as determined by the Firebase
+ * servers.
+ */
+function serverTimestamp() {
+    return SERVER_TIMESTAMP;
+}
+/**
+ * Returns a placeholder value that can be used to atomically increment the
+ * current database value by the provided delta.
+ *
+ * @param delta - the amount to modify the current value atomically.
+ * @returns A placeholder value for modifying data atomically server-side.
+ */
+function increment(delta) {
+    return {
+        '.sv': {
+            'increment': delta
+        }
+    };
+}
+
+/**
+ * @license
+ * Copyright 2020 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * A type for the resolve value of {@link runTransaction}.
+ */
+class TransactionResult {
+    /** @hideconstructor */
+    constructor(
+    /** Whether the transaction was successfully committed. */
+    committed, 
+    /** The resulting data snapshot. */
+    snapshot) {
+        this.committed = committed;
+        this.snapshot = snapshot;
+    }
+    /** Returns a JSON-serializable representation of this object. */
+    toJSON() {
+        return { committed: this.committed, snapshot: this.snapshot.toJSON() };
+    }
+}
+/**
+ * Atomically modifies the data at this location.
+ *
+ * Atomically modify the data at this location. Unlike a normal `set()`, which
+ * just overwrites the data regardless of its previous value, `runTransaction()` is
+ * used to modify the existing value to a new value, ensuring there are no
+ * conflicts with other clients writing to the same location at the same time.
+ *
+ * To accomplish this, you pass `runTransaction()` an update function which is
+ * used to transform the current value into a new value. If another client
+ * writes to the location before your new value is successfully written, your
+ * update function will be called again with the new current value, and the
+ * write will be retried. This will happen repeatedly until your write succeeds
+ * without conflict or you abort the transaction by not returning a value from
+ * your update function.
+ *
+ * Note: Modifying data with `set()` will cancel any pending transactions at
+ * that location, so extreme care should be taken if mixing `set()` and
+ * `runTransaction()` to update the same data.
+ *
+ * Note: When using transactions with Security and Firebase Rules in place, be
+ * aware that a client needs `.read` access in addition to `.write` access in
+ * order to perform a transaction. This is because the client-side nature of
+ * transactions requires the client to read the data in order to transactionally
+ * update it.
+ *
+ * @param ref - The location to atomically modify.
+ * @param transactionUpdate - A developer-supplied function which will be passed
+ * the current data stored at this location (as a JavaScript object). The
+ * function should return the new value it would like written (as a JavaScript
+ * object). If `undefined` is returned (i.e. you return with no arguments) the
+ * transaction will be aborted and the data at this location will not be
+ * modified.
+ * @param options - An options object to configure transactions.
+ * @returns A `Promise` that can optionally be used instead of the `onComplete`
+ * callback to handle success and failure.
+ */
+function runTransaction(ref, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+transactionUpdate, options) {
+    var _a;
+    ref = getModularInstance(ref);
+    validateWritablePath('Reference.transaction', ref._path);
+    if (ref.key === '.length' || ref.key === '.keys') {
+        throw ('Reference.transaction failed: ' + ref.key + ' is a read-only object.');
+    }
+    const applyLocally = (_a = options === null || options === void 0 ? void 0 : options.applyLocally) !== null && _a !== void 0 ? _a : true;
+    const deferred = new Deferred();
+    const promiseComplete = (error, committed, node) => {
+        let dataSnapshot = null;
+        if (error) {
+            deferred.reject(error);
+        }
+        else {
+            dataSnapshot = new DataSnapshot(node, new ReferenceImpl(ref._repo, ref._path), PRIORITY_INDEX);
+            deferred.resolve(new TransactionResult(committed, dataSnapshot));
+        }
+    };
+    // Add a watch to make sure we get server updates.
+    const unwatcher = onValue(ref, () => { });
+    repoStartTransaction(ref._repo, ref._path, transactionUpdate, promiseComplete, unwatcher, applyLocally);
+    return deferred.promise;
+}
+
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+PersistentConnection;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 PersistentConnection.prototype.simpleListen = function (pathString, onComplete) {
     this.sendRequest('q', { p: pathString }, onComplete);
@@ -20943,6 +23285,31 @@ PersistentConnection.prototype.simpleListen = function (pathString, onComplete)
 PersistentConnection.prototype.echo = function (data, onEcho) {
     this.sendRequest('echo', { d: data }, onEcho);
 };
+// RealTimeConnection properties that we use in tests.
+Connection;
+/**
+ * @internal
+ */
+const hijackHash = function (newHash) {
+    const oldPut = PersistentConnection.prototype.put;
+    PersistentConnection.prototype.put = function (pathString, data, onComplete, hash) {
+        if (hash !== undefined) {
+            hash = newHash();
+        }
+        oldPut.call(this, pathString, data, onComplete, hash);
+    };
+    return function () {
+        PersistentConnection.prototype.put = oldPut;
+    };
+};
+RepoInfo;
+/**
+ * Forces the RepoManager to create Repos that use ReadonlyRestClient instead of PersistentConnection.
+ * @internal
+ */
+const forceRestClient = function (forceRestClient) {
+    repoManagerForceRestClient(forceRestClient);
+};
 
 /**
  * Firebase Realtime Database
@@ -20952,7 +23319,7 @@ PersistentConnection.prototype.echo = function (data, onEcho) {
 registerDatabase();
 
 var dayjs_min = createCommonjsModule(function (module, exports) {
-!function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",f="month",h="quarter",c="year",d="date",$="Invalid Date",l=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_")},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},g={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return -t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,f),s=n-i<0,u=e.clone().add(r+(s?-1:1),f);return +(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return {M:f,y:c,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:h}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},D="en",v={};v[D]=M;var p=function(t){return t instanceof _},S=function(t,e,n){var r;if(!t)return D;if("string"==typeof t)v[t]&&(r=t),e&&(v[t]=e,r=t);else {var i=t.name;v[i]=t,r=i;}return !n&&r&&(D=r),r||!n&&D},w=function(t,e){if(p(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},O=g;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=S(t.locale,null,!0),this.parse(t);}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match(l);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return O},m.isValid=function(){return !(this.$d.toString()===$)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,h=O.p(t),$=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},l=function(t,e){return O.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,g="set"+(this.$u?"UTC":"");switch(h){case c:return r?$(1,0):$(31,11);case f:return r?$(1,M):$(0,M+1);case o:var D=this.$locale().weekStart||0,v=(y<D?y+7:y)-D;return $(r?m-v:m+(6-v),M);case a:case d:return l(g+"Hours",0);case u:return l(g+"Minutes",1);case s:return l(g+"Seconds",2);case i:return l(g+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=O.p(t),h="set"+(this.$u?"UTC":""),$=(n={},n[a]=h+"Date",n[d]=h+"Date",n[f]=h+"Month",n[c]=h+"FullYear",n[u]=h+"Hours",n[s]=h+"Minutes",n[i]=h+"Seconds",n[r]=h+"Milliseconds",n)[o],l=o===a?this.$D+(e-this.$W):e;if(o===f||o===c){var y=this.clone().set(d,1);y.$d[$](l),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d;}else $&&this.$d[$](l);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,h){var d,$=this;r=Number(r);var l=O.p(h),y=function(t){var e=w($);return O.w(e.date(e.date()+Math.round(t*r)),$)};if(l===f)return this.set(f,this.$M+r);if(l===c)return this.set(c,this.$y+r);if(l===a)return y(1);if(l===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[l]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||$;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,f=n.months,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].substr(0,s)},c=function(t){return O.s(s%12||12,t,"0")},d=n.meridiem||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r},l={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:O.s(a+1,2,"0"),MMM:h(n.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:O.s(this.$D,2,"0"),d:String(this.$W),dd:h(n.weekdaysMin,this.$W,o,2),ddd:h(n.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:O.s(s,2,"0"),h:c(1),hh:c(2),a:d(s,u,!0),A:d(s,u,!1),m:String(u),mm:O.s(u,2,"0"),s:String(this.$s),ss:O.s(this.$s,2,"0"),SSS:O.s(this.$ms,3,"0"),Z:i};return r.replace(y,(function(t,e){return e||l[t]||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,$){var l,y=O.p(d),M=w(r),m=(M.utcOffset()-this.utcOffset())*e,g=this-M,D=O.m(this,M);return D=(l={},l[c]=D/12,l[f]=D,l[h]=D/3,l[o]=(g-m)/6048e5,l[a]=(g-m)/864e5,l[u]=g/n,l[s]=g/e,l[i]=g/t,l)[y]||g,$?D:O.a(D)},m.daysInMonth=function(){return this.endOf(f).$D},m.$locale=function(){return v[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),b=_.prototype;return w.prototype=b,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",f],["$y",c],["$D",d]].forEach((function(t){b[t[1]]=function(e){return this.$g(e,t[0],t[1])};})),w.extend=function(t,e){return t.$i||(t(e,_,w),t.$i=!0),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=v[D],w.Ls=v,w.p={},w}));
+!function(t,e){"object"=='object'&&"undefined"!='object'?module.exports=e():"function"==typeof undefined&&undefined.amd?undefined(e):(t="undefined"!=typeof globalThis?globalThis:t||self).dayjs=e();}(commonjsGlobal,(function(){"use strict";var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",f="month",h="quarter",c="year",d="date",$="Invalid Date",l=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_")},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},g={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()<n.date())return -t(n,e);var r=12*(n.year()-e.year())+(n.month()-e.month()),i=e.clone().add(r,f),s=n-i<0,u=e.clone().add(r+(s?-1:1),f);return +(-(r+(n-i)/(s?i-u:u-i))||0)},a:function(t){return t<0?Math.ceil(t)||0:Math.floor(t)},p:function(t){return {M:f,y:c,w:o,d:a,D:d,h:u,m:s,s:i,ms:r,Q:h}[t]||String(t||"").toLowerCase().replace(/s$/,"")},u:function(t){return void 0===t}},D="en",v={};v[D]=M;var p=function(t){return t instanceof _},S=function(t,e,n){var r;if(!t)return D;if("string"==typeof t)v[t]&&(r=t),e&&(v[t]=e,r=t);else {var i=t.name;v[i]=t,r=i;}return !n&&r&&(D=r),r||!n&&D},w=function(t,e){if(p(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},O=g;O.l=S,O.i=p,O.w=function(t,e){return w(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=S(t.locale,null,!0),this.parse(t);}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(O.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match(l);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.$x=t.x||{},this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return O},m.isValid=function(){return !(this.$d.toString()===$)},m.isSame=function(t,e){var n=w(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return w(t)<this.startOf(e)},m.isBefore=function(t,e){return this.endOf(e)<w(t)},m.$g=function(t,e,n){return O.u(t)?this[e]:this.set(n,t)},m.unix=function(){return Math.floor(this.valueOf()/1e3)},m.valueOf=function(){return this.$d.getTime()},m.startOf=function(t,e){var n=this,r=!!O.u(e)||e,h=O.p(t),$=function(t,e){var i=O.w(n.$u?Date.UTC(n.$y,e,t):new Date(n.$y,e,t),n);return r?i:i.endOf(a)},l=function(t,e){return O.w(n.toDate()[t].apply(n.toDate("s"),(r?[0,0,0,0]:[23,59,59,999]).slice(e)),n)},y=this.$W,M=this.$M,m=this.$D,g="set"+(this.$u?"UTC":"");switch(h){case c:return r?$(1,0):$(31,11);case f:return r?$(1,M):$(0,M+1);case o:var D=this.$locale().weekStart||0,v=(y<D?y+7:y)-D;return $(r?m-v:m+(6-v),M);case a:case d:return l(g+"Hours",0);case u:return l(g+"Minutes",1);case s:return l(g+"Seconds",2);case i:return l(g+"Milliseconds",3);default:return this.clone()}},m.endOf=function(t){return this.startOf(t,!1)},m.$set=function(t,e){var n,o=O.p(t),h="set"+(this.$u?"UTC":""),$=(n={},n[a]=h+"Date",n[d]=h+"Date",n[f]=h+"Month",n[c]=h+"FullYear",n[u]=h+"Hours",n[s]=h+"Minutes",n[i]=h+"Seconds",n[r]=h+"Milliseconds",n)[o],l=o===a?this.$D+(e-this.$W):e;if(o===f||o===c){var y=this.clone().set(d,1);y.$d[$](l),y.init(),this.$d=y.set(d,Math.min(this.$D,y.daysInMonth())).$d;}else $&&this.$d[$](l);return this.init(),this},m.set=function(t,e){return this.clone().$set(t,e)},m.get=function(t){return this[O.p(t)]()},m.add=function(r,h){var d,$=this;r=Number(r);var l=O.p(h),y=function(t){var e=w($);return O.w(e.date(e.date()+Math.round(t*r)),$)};if(l===f)return this.set(f,this.$M+r);if(l===c)return this.set(c,this.$y+r);if(l===a)return y(1);if(l===o)return y(7);var M=(d={},d[s]=e,d[u]=n,d[i]=t,d)[l]||1,m=this.$d.getTime()+r*M;return O.w(m,this)},m.subtract=function(t,e){return this.add(-1*t,e)},m.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return n.invalidDate||$;var r=t||"YYYY-MM-DDTHH:mm:ssZ",i=O.z(this),s=this.$H,u=this.$m,a=this.$M,o=n.weekdays,f=n.months,h=function(t,n,i,s){return t&&(t[n]||t(e,r))||i[n].substr(0,s)},c=function(t){return O.s(s%12||12,t,"0")},d=n.meridiem||function(t,e,n){var r=t<12?"AM":"PM";return n?r.toLowerCase():r},l={YY:String(this.$y).slice(-2),YYYY:this.$y,M:a+1,MM:O.s(a+1,2,"0"),MMM:h(n.monthsShort,a,f,3),MMMM:h(f,a),D:this.$D,DD:O.s(this.$D,2,"0"),d:String(this.$W),dd:h(n.weekdaysMin,this.$W,o,2),ddd:h(n.weekdaysShort,this.$W,o,3),dddd:o[this.$W],H:String(s),HH:O.s(s,2,"0"),h:c(1),hh:c(2),a:d(s,u,!0),A:d(s,u,!1),m:String(u),mm:O.s(u,2,"0"),s:String(this.$s),ss:O.s(this.$s,2,"0"),SSS:O.s(this.$ms,3,"0"),Z:i};return r.replace(y,(function(t,e){return e||l[t]||i.replace(":","")}))},m.utcOffset=function(){return 15*-Math.round(this.$d.getTimezoneOffset()/15)},m.diff=function(r,d,$){var l,y=O.p(d),M=w(r),m=(M.utcOffset()-this.utcOffset())*e,g=this-M,D=O.m(this,M);return D=(l={},l[c]=D/12,l[f]=D,l[h]=D/3,l[o]=(g-m)/6048e5,l[a]=(g-m)/864e5,l[u]=g/n,l[s]=g/e,l[i]=g/t,l)[y]||g,$?D:O.a(D)},m.daysInMonth=function(){return this.endOf(f).$D},m.$locale=function(){return v[this.$L]},m.locale=function(t,e){if(!t)return this.$L;var n=this.clone(),r=S(t,e,!0);return r&&(n.$L=r),n},m.clone=function(){return O.w(this.$d,this)},m.toDate=function(){return new Date(this.valueOf())},m.toJSON=function(){return this.isValid()?this.toISOString():null},m.toISOString=function(){return this.$d.toISOString()},m.toString=function(){return this.$d.toUTCString()},M}(),b=_.prototype;return w.prototype=b,[["$ms",r],["$s",i],["$m",s],["$H",u],["$W",a],["$M",f],["$y",c],["$D",d]].forEach((function(t){b[t[1]]=function(e){return this.$g(e,t[0],t[1])};})),w.extend=function(t,e){return t.$i||(t(e,_,w),t.$i=!0),w},w.locale=S,w.isDayjs=p,w.unix=function(t){return w(1e3*t)},w.en=v[D],w.Ls=v,w.p={},w}));
 });
 
 function createService(blob) {
@@ -21153,6 +23520,8 @@ function createReviewPhoto(blob) {
     imageUrlThumb: blob.full_image_url_thumb,
   };
 }
+class Review {
+}
 function createReview(blob) {
   const reviewPhotos = blob.review_photo || [];
   const [createdDay, createdTime] = String(blob.create_date).split(' ');
@@ -21184,7 +23553,7 @@ function createChatMessage(blob) {
     message: blob.message,
     timestamp: blob.timestamp,
     unRead: blob.unRead,
-    senderId: blob.senderId,
+    senderId: Number(blob.senderId),
   };
 }
 class ChatRoom {
@@ -21443,7 +23812,7 @@ class HttpService {
         const roomMessagesRef = ref(this.firebaseDatabase, `${firebaseMessagesNode}/${roomId}`);
         const updates = {};
         roomMessages.forEach(message => {
-          const nestedMessage = __rest(message, ["uid"]);
+          const { uid } = message, nestedMessage = __rest(message, ["uid"]);
           updates[`${message.uid}`] = Object.assign(Object.assign({}, nestedMessage), { unRead: 0 });
         });
         return update(roomMessagesRef, updates);