{"version":3,"sources":["webpack:///./node_modules/@firebase/app/node_modules/@firebase/util/dist/index.cjs.js"],"names":["Object","defineProperty","exports","value","tslib","CONSTANTS","NODE_CLIENT","NODE_ADMIN","SDK_VERSION","assert","assertion","message","assertionError","Error","stringToByteArray","str","out","p","i","length","c","charCodeAt","base64","byteToCharMap_","charToByteMap_","byteToCharMapWebSafe_","charToByteMapWebSafe_","ENCODED_VALS_BASE","this","HAS_NATIVE_SUPPORT","atob","encodeByteArray","input","webSafe","Array","isArray","init_","byteToCharMap","output","byte1","haveByte2","byte2","haveByte3","byte3","outByte1","outByte2","outByte3","outByte4","push","join","encodeString","btoa","decodeString","bytes","pos","c1","String","fromCharCode","c2","u","c3","byteArrayToString","decodeStringToByteArray","charToByteMap","charAt","byte4","ENCODED_VALS","ENCODED_VALS_WEBSAFE","base64Decode","e","console","error","deepExtend","target","source","constructor","Date","getTime","undefined","prop","hasOwnProperty","Deferred","_this","reject","resolve","promise","Promise","prototype","wrapCallback","callback","catch","getUA","navigator","FirebaseError","_super","code","call","name","setPrototypeOf","captureStackTrace","ErrorFactory","create","__extends","service","serviceName","errors","data","_i","arguments","customData","fullCode","template","replaceTemplate","fullMessage","_a","_b","keys","key","slice","warn","replace","PATTERN","_","toString","jsonEval","JSON","parse","decode","token","header","claims","signature","parts","split","Sha1","chain_","buf_","W_","pad_","inbuf_","total_","blockSize","reset","compress_","buf","offset","W","t","f","k","a","b","d","update","lengthMinusBlock","n","inbuf","digest","totalBits","j","ObserverProxy","executor","onNoObservers","observers","unsubscribes","observerCount","task","finalized","then","next","forEachObserver","observer","close","complete","subscribe","nextOrObserver","obj","methods","methods_1","method","implementsAnyMethods","noop","unsub","unsubscribeOne","bind","finalError","fn","sendOne","err","errorPrefix","fnName","argumentNumber","optional","argName","async","onError","args","apply","base64Encode","utf8Bytes","contains","createSubscribe","proxy","deepCopy","isAdmin","isBrowser","self","isBrowserExtension","runtime","chrome","browser","id","isElectron","indexOf","isEmpty","isIE","ua","isMobileCordova","window","test","isNode","global","process","isNodeSdk","isReactNative","isUWP","isValidFormat","isValidTimestamp","now","Math","floor","validSince","validUntil","issuedAtTime","map","contextObj","res","querystring","querystringParams","params","_loop_1","forEach","arrayVal","encodeURIComponent","entries","querystringDecode","safeGet","stringLength","high","stringify","validateArgCount","minCount","maxCount","argCount","argError","validateCallback","validateContextObject","context","validateNamespace","namespace"],"mappings":"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","file":"vendor.firebase~4aec82ab.925b7f5ed702a1f1d537.chunk.js","sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.\r\n */\r\nvar CONSTANTS = {\r\n    /**\r\n     * @define {boolean} Whether this is the client Node.js SDK.\r\n     */\r\n    NODE_CLIENT: false,\r\n    /**\r\n     * @define {boolean} Whether this is the Admin Node.js SDK.\r\n     */\r\n    NODE_ADMIN: false,\r\n    /**\r\n     * Firebase SDK Version\r\n     */\r\n    SDK_VERSION: '${JSCORE_VERSION}'\r\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Throws an error if the provided assertion is falsy\r\n */\r\nvar assert = function (assertion, message) {\r\n    if (!assertion) {\r\n        throw assertionError(message);\r\n    }\r\n};\r\n/**\r\n * Returns an Error object suitable for throwing.\r\n */\r\nvar assertionError = function (message) {\r\n    return new Error('Firebase Database (' +\r\n        CONSTANTS.SDK_VERSION +\r\n        ') INTERNAL ASSERT FAILED: ' +\r\n        message);\r\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nvar stringToByteArray = function (str) {\r\n    // TODO(user): Use native implementations if/when available\r\n    var out = [];\r\n    var p = 0;\r\n    for (var i = 0; i < str.length; i++) {\r\n        var c = str.charCodeAt(i);\r\n        if (c < 128) {\r\n            out[p++] = c;\r\n        }\r\n        else if (c < 2048) {\r\n            out[p++] = (c >> 6) | 192;\r\n            out[p++] = (c & 63) | 128;\r\n        }\r\n        else if ((c & 0xfc00) === 0xd800 &&\r\n            i + 1 < str.length &&\r\n            (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00) {\r\n            // Surrogate Pair\r\n            c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\r\n            out[p++] = (c >> 18) | 240;\r\n            out[p++] = ((c >> 12) & 63) | 128;\r\n            out[p++] = ((c >> 6) & 63) | 128;\r\n            out[p++] = (c & 63) | 128;\r\n        }\r\n        else {\r\n            out[p++] = (c >> 12) | 224;\r\n            out[p++] = ((c >> 6) & 63) | 128;\r\n            out[p++] = (c & 63) | 128;\r\n        }\r\n    }\r\n    return out;\r\n};\r\n/**\r\n * Turns an array of numbers into the string given by the concatenation of the\r\n * characters to which the numbers correspond.\r\n * @param bytes Array of numbers representing characters.\r\n * @return Stringification of the array.\r\n */\r\nvar byteArrayToString = function (bytes) {\r\n    // TODO(user): Use native implementations if/when available\r\n    var out = [];\r\n    var pos = 0, c = 0;\r\n    while (pos < bytes.length) {\r\n        var c1 = bytes[pos++];\r\n        if (c1 < 128) {\r\n            out[c++] = String.fromCharCode(c1);\r\n        }\r\n        else if (c1 > 191 && c1 < 224) {\r\n            var c2 = bytes[pos++];\r\n            out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\r\n        }\r\n        else if (c1 > 239 && c1 < 365) {\r\n            // Surrogate Pair\r\n            var c2 = bytes[pos++];\r\n            var c3 = bytes[pos++];\r\n            var c4 = bytes[pos++];\r\n            var u = (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\r\n                0x10000;\r\n            out[c++] = String.fromCharCode(0xd800 + (u >> 10));\r\n            out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\r\n        }\r\n        else {\r\n            var c2 = bytes[pos++];\r\n            var c3 = bytes[pos++];\r\n            out[c++] = String.fromCharCode(((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));\r\n        }\r\n    }\r\n    return out.join('');\r\n};\r\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\r\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\r\n// Static lookup maps, lazily populated by init_()\r\nvar base64 = {\r\n    /**\r\n     * Maps bytes to characters.\r\n     */\r\n    byteToCharMap_: null,\r\n    /**\r\n     * Maps characters to bytes.\r\n     */\r\n    charToByteMap_: null,\r\n    /**\r\n     * Maps bytes to websafe characters.\r\n     * @private\r\n     */\r\n    byteToCharMapWebSafe_: null,\r\n    /**\r\n     * Maps websafe characters to bytes.\r\n     * @private\r\n     */\r\n    charToByteMapWebSafe_: null,\r\n    /**\r\n     * Our default alphabet, shared between\r\n     * ENCODED_VALS and ENCODED_VALS_WEBSAFE\r\n     */\r\n    ENCODED_VALS_BASE: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\r\n    /**\r\n     * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\r\n     */\r\n    get ENCODED_VALS() {\r\n        return this.ENCODED_VALS_BASE + '+/=';\r\n    },\r\n    /**\r\n     * Our websafe alphabet.\r\n     */\r\n    get ENCODED_VALS_WEBSAFE() {\r\n        return this.ENCODED_VALS_BASE + '-_.';\r\n    },\r\n    /**\r\n     * Whether this browser supports the atob and btoa functions. This extension\r\n     * started at Mozilla but is now implemented by many browsers. We use the\r\n     * ASSUME_* variables to avoid pulling in the full useragent detection library\r\n     * but still allowing the standard per-browser compilations.\r\n     *\r\n     */\r\n    HAS_NATIVE_SUPPORT: typeof atob === 'function',\r\n    /**\r\n     * Base64-encode an array of bytes.\r\n     *\r\n     * @param input An array of bytes (numbers with\r\n     *     value in [0, 255]) to encode.\r\n     * @param webSafe Boolean indicating we should use the\r\n     *     alternative alphabet.\r\n     * @return The base64 encoded string.\r\n     */\r\n    encodeByteArray: function (input, webSafe) {\r\n        if (!Array.isArray(input)) {\r\n            throw Error('encodeByteArray takes an array as a parameter');\r\n        }\r\n        this.init_();\r\n        var byteToCharMap = webSafe\r\n            ? this.byteToCharMapWebSafe_\r\n            : this.byteToCharMap_;\r\n        var output = [];\r\n        for (var i = 0; i < input.length; i += 3) {\r\n            var byte1 = input[i];\r\n            var haveByte2 = i + 1 < input.length;\r\n            var byte2 = haveByte2 ? input[i + 1] : 0;\r\n            var haveByte3 = i + 2 < input.length;\r\n            var byte3 = haveByte3 ? input[i + 2] : 0;\r\n            var outByte1 = byte1 >> 2;\r\n            var outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\r\n            var outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\r\n            var outByte4 = byte3 & 0x3f;\r\n            if (!haveByte3) {\r\n                outByte4 = 64;\r\n                if (!haveByte2) {\r\n                    outByte3 = 64;\r\n                }\r\n            }\r\n            output.push(byteToCharMap[outByte1], byteToCharMap[outByte2], byteToCharMap[outByte3], byteToCharMap[outByte4]);\r\n        }\r\n        return output.join('');\r\n    },\r\n    /**\r\n     * Base64-encode a string.\r\n     *\r\n     * @param input A string to encode.\r\n     * @param webSafe If true, we should use the\r\n     *     alternative alphabet.\r\n     * @return The base64 encoded string.\r\n     */\r\n    encodeString: function (input, webSafe) {\r\n        // Shortcut for Mozilla browsers that implement\r\n        // a native base64 encoder in the form of \"btoa/atob\"\r\n        if (this.HAS_NATIVE_SUPPORT && !webSafe) {\r\n            return btoa(input);\r\n        }\r\n        return this.encodeByteArray(stringToByteArray(input), webSafe);\r\n    },\r\n    /**\r\n     * Base64-decode a string.\r\n     *\r\n     * @param input to decode.\r\n     * @param webSafe True if we should use the\r\n     *     alternative alphabet.\r\n     * @return string representing the decoded value.\r\n     */\r\n    decodeString: function (input, webSafe) {\r\n        // Shortcut for Mozilla browsers that implement\r\n        // a native base64 encoder in the form of \"btoa/atob\"\r\n        if (this.HAS_NATIVE_SUPPORT && !webSafe) {\r\n            return atob(input);\r\n        }\r\n        return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\r\n    },\r\n    /**\r\n     * Base64-decode a string.\r\n     *\r\n     * In base-64 decoding, groups of four characters are converted into three\r\n     * bytes.  If the encoder did not apply padding, the input length may not\r\n     * be a multiple of 4.\r\n     *\r\n     * In this case, the last group will have fewer than 4 characters, and\r\n     * padding will be inferred.  If the group has one or two characters, it decodes\r\n     * to one byte.  If the group has three characters, it decodes to two bytes.\r\n     *\r\n     * @param input Input to decode.\r\n     * @param webSafe True if we should use the web-safe alphabet.\r\n     * @return bytes representing the decoded value.\r\n     */\r\n    decodeStringToByteArray: function (input, webSafe) {\r\n        this.init_();\r\n        var charToByteMap = webSafe\r\n            ? this.charToByteMapWebSafe_\r\n            : this.charToByteMap_;\r\n        var output = [];\r\n        for (var i = 0; i < input.length;) {\r\n            var byte1 = charToByteMap[input.charAt(i++)];\r\n            var haveByte2 = i < input.length;\r\n            var byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\r\n            ++i;\r\n            var haveByte3 = i < input.length;\r\n            var byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\r\n            ++i;\r\n            var haveByte4 = i < input.length;\r\n            var byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\r\n            ++i;\r\n            if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\r\n                throw Error();\r\n            }\r\n            var outByte1 = (byte1 << 2) | (byte2 >> 4);\r\n            output.push(outByte1);\r\n            if (byte3 !== 64) {\r\n                var outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\r\n                output.push(outByte2);\r\n                if (byte4 !== 64) {\r\n                    var outByte3 = ((byte3 << 6) & 0xc0) | byte4;\r\n                    output.push(outByte3);\r\n                }\r\n            }\r\n        }\r\n        return output;\r\n    },\r\n    /**\r\n     * Lazy static initialization function. Called before\r\n     * accessing any of the static map variables.\r\n     * @private\r\n     */\r\n    init_: function () {\r\n        if (!this.byteToCharMap_) {\r\n            this.byteToCharMap_ = {};\r\n            this.charToByteMap_ = {};\r\n            this.byteToCharMapWebSafe_ = {};\r\n            this.charToByteMapWebSafe_ = {};\r\n            // We want quick mappings back and forth, so we precompute two maps.\r\n            for (var i = 0; i < this.ENCODED_VALS.length; i++) {\r\n                this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\r\n                this.charToByteMap_[this.byteToCharMap_[i]] = i;\r\n                this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\r\n                this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\r\n                // Be forgiving when decoding and correctly decode both encodings.\r\n                if (i >= this.ENCODED_VALS_BASE.length) {\r\n                    this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\r\n                    this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\r\n                }\r\n            }\r\n        }\r\n    }\r\n};\r\n/**\r\n * URL-safe base64 encoding\r\n */\r\nvar base64Encode = function (str) {\r\n    var utf8Bytes = stringToByteArray(str);\r\n    return base64.encodeByteArray(utf8Bytes, true);\r\n};\r\n/**\r\n * URL-safe base64 decoding\r\n *\r\n * NOTE: DO NOT use the global atob() function - it does NOT support the\r\n * base64Url variant encoding.\r\n *\r\n * @param str To be decoded\r\n * @return Decoded result, if possible\r\n */\r\nvar base64Decode = function (str) {\r\n    try {\r\n        return base64.decodeString(str, true);\r\n    }\r\n    catch (e) {\r\n        console.error('base64Decode failed: ', e);\r\n    }\r\n    return null;\r\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Do a deep-copy of basic JavaScript Objects or Arrays.\r\n */\r\nfunction deepCopy(value) {\r\n    return deepExtend(undefined, value);\r\n}\r\n/**\r\n * Copy properties from source to target (recursively allows extension\r\n * of Objects and Arrays).  Scalar values in the target are over-written.\r\n * If target is undefined, an object of the appropriate type will be created\r\n * (and returned).\r\n *\r\n * We recursively copy all child properties of plain Objects in the source- so\r\n * that namespace- like dictionaries are merged.\r\n *\r\n * Note that the target can be a function, in which case the properties in\r\n * the source Object are copied onto it as static properties of the Function.\r\n */\r\nfunction deepExtend(target, source) {\r\n    if (!(source instanceof Object)) {\r\n        return source;\r\n    }\r\n    switch (source.constructor) {\r\n        case Date:\r\n            // Treat Dates like scalars; if the target date object had any child\r\n            // properties - they will be lost!\r\n            var dateValue = source;\r\n            return new Date(dateValue.getTime());\r\n        case Object:\r\n            if (target === undefined) {\r\n                target = {};\r\n            }\r\n            break;\r\n        case Array:\r\n            // Always copy the array source and overwrite the target.\r\n            target = [];\r\n            break;\r\n        default:\r\n            // Not a plain Object - treat it as a scalar.\r\n            return source;\r\n    }\r\n    for (var prop in source) {\r\n        if (!source.hasOwnProperty(prop)) {\r\n            continue;\r\n        }\r\n        target[prop] = deepExtend(target[prop], source[prop]);\r\n    }\r\n    return target;\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nvar Deferred = /** @class */ (function () {\r\n    function Deferred() {\r\n        var _this = this;\r\n        this.reject = function () { };\r\n        this.resolve = function () { };\r\n        this.promise = new Promise(function (resolve, reject) {\r\n            _this.resolve = resolve;\r\n            _this.reject = reject;\r\n        });\r\n    }\r\n    /**\r\n     * Our API internals are not promiseified and cannot because our callback APIs have subtle expectations around\r\n     * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\r\n     * and returns a node-style callback which will resolve or reject the Deferred's promise.\r\n     */\r\n    Deferred.prototype.wrapCallback = function (callback) {\r\n        var _this = this;\r\n        return function (error, value) {\r\n            if (error) {\r\n                _this.reject(error);\r\n            }\r\n            else {\r\n                _this.resolve(value);\r\n            }\r\n            if (typeof callback === 'function') {\r\n                // Attaching noop handler just in case developer wasn't expecting\r\n                // promises\r\n                _this.promise.catch(function () { });\r\n                // Some of our callbacks don't expect a value and our own tests\r\n                // assert that the parameter length is 1\r\n                if (callback.length === 1) {\r\n                    callback(error);\r\n                }\r\n                else {\r\n                    callback(error, value);\r\n                }\r\n            }\r\n        };\r\n    };\r\n    return Deferred;\r\n}());\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Returns navigator.userAgent string or '' if it's not defined.\r\n * @return user agent string\r\n */\r\nfunction getUA() {\r\n    if (typeof navigator !== 'undefined' &&\r\n        typeof navigator['userAgent'] === 'string') {\r\n        return navigator['userAgent'];\r\n    }\r\n    else {\r\n        return '';\r\n    }\r\n}\r\n/**\r\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\r\n *\r\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\r\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\r\n * wait for a callback.\r\n */\r\nfunction isMobileCordova() {\r\n    return (typeof window !== 'undefined' &&\r\n        // @ts-ignore Setting up an broadly applicable index signature for Window\r\n        // just to deal with this case would probably be a bad idea.\r\n        !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&\r\n        /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA()));\r\n}\r\n/**\r\n * Detect Node.js.\r\n *\r\n * @return true if Node.js environment is detected.\r\n */\r\n// Node detection logic from: https://github.com/iliakan/detect-node/\r\nfunction isNode() {\r\n    try {\r\n        return (Object.prototype.toString.call(global.process) === '[object process]');\r\n    }\r\n    catch (e) {\r\n        return false;\r\n    }\r\n}\r\n/**\r\n * Detect Browser Environment\r\n */\r\nfunction isBrowser() {\r\n    return typeof self === 'object' && self.self === self;\r\n}\r\nfunction isBrowserExtension() {\r\n    var runtime = typeof chrome === 'object'\r\n        ? chrome.runtime\r\n        : typeof browser === 'object'\r\n            ? browser.runtime\r\n            : undefined;\r\n    return typeof runtime === 'object' && runtime.id !== undefined;\r\n}\r\n/**\r\n * Detect React Native.\r\n *\r\n * @return true if ReactNative environment is detected.\r\n */\r\nfunction isReactNative() {\r\n    return (typeof navigator === 'object' && navigator['product'] === 'ReactNative');\r\n}\r\n/** Detects Electron apps. */\r\nfunction isElectron() {\r\n    return getUA().indexOf('Electron/') >= 0;\r\n}\r\n/** Detects Internet Explorer. */\r\nfunction isIE() {\r\n    var ua = getUA();\r\n    return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\r\n}\r\n/** Detects Universal Windows Platform apps. */\r\nfunction isUWP() {\r\n    return getUA().indexOf('MSAppHost/') >= 0;\r\n}\r\n/**\r\n * Detect whether the current SDK build is the Node version.\r\n *\r\n * @return true if it's the Node SDK build.\r\n */\r\nfunction isNodeSdk() {\r\n    return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nvar ERROR_NAME = 'FirebaseError';\r\n// Based on code from:\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\r\nvar FirebaseError = /** @class */ (function (_super) {\r\n    tslib.__extends(FirebaseError, _super);\r\n    function FirebaseError(code, message) {\r\n        var _this = _super.call(this, message) || this;\r\n        _this.code = code;\r\n        _this.name = ERROR_NAME;\r\n        // Fix For ES5\r\n        // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\r\n        Object.setPrototypeOf(_this, FirebaseError.prototype);\r\n        // Maintains proper stack trace for where our error was thrown.\r\n        // Only available on V8.\r\n        if (Error.captureStackTrace) {\r\n            Error.captureStackTrace(_this, ErrorFactory.prototype.create);\r\n        }\r\n        return _this;\r\n    }\r\n    return FirebaseError;\r\n}(Error));\r\nvar ErrorFactory = /** @class */ (function () {\r\n    function ErrorFactory(service, serviceName, errors) {\r\n        this.service = service;\r\n        this.serviceName = serviceName;\r\n        this.errors = errors;\r\n    }\r\n    ErrorFactory.prototype.create = function (code) {\r\n        var data = [];\r\n        for (var _i = 1; _i < arguments.length; _i++) {\r\n            data[_i - 1] = arguments[_i];\r\n        }\r\n        var customData = data[0] || {};\r\n        var fullCode = this.service + \"/\" + code;\r\n        var template = this.errors[code];\r\n        var message = template ? replaceTemplate(template, customData) : 'Error';\r\n        // Service Name: Error message (service/code).\r\n        var fullMessage = this.serviceName + \": \" + message + \" (\" + fullCode + \").\";\r\n        var error = new FirebaseError(fullCode, fullMessage);\r\n        // Keys with an underscore at the end of their name are not included in\r\n        // error.data for some reason.\r\n        // TODO: Replace with Object.entries when lib is updated to es2017.\r\n        for (var _a = 0, _b = Object.keys(customData); _a < _b.length; _a++) {\r\n            var key = _b[_a];\r\n            if (key.slice(-1) !== '_') {\r\n                if (key in error) {\r\n                    console.warn(\"Overwriting FirebaseError base field \\\"\" + key + \"\\\" can cause unexpected behavior.\");\r\n                }\r\n                error[key] = customData[key];\r\n            }\r\n        }\r\n        return error;\r\n    };\r\n    return ErrorFactory;\r\n}());\r\nfunction replaceTemplate(template, data) {\r\n    return template.replace(PATTERN, function (_, key) {\r\n        var value = data[key];\r\n        return value != null ? value.toString() : \"<\" + key + \"?>\";\r\n    });\r\n}\r\nvar PATTERN = /\\{\\$([^}]+)}/g;\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Evaluates a JSON string into a javascript object.\r\n *\r\n * @param {string} str A string containing JSON.\r\n * @return {*} The javascript object representing the specified JSON.\r\n */\r\nfunction jsonEval(str) {\r\n    return JSON.parse(str);\r\n}\r\n/**\r\n * Returns JSON representing a javascript object.\r\n * @param {*} data Javascript object to be stringified.\r\n * @return {string} The JSON contents of the object.\r\n */\r\nfunction stringify(data) {\r\n    return JSON.stringify(data);\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Decodes a Firebase auth. token into constituent parts.\r\n *\r\n * Notes:\r\n * - May return with invalid / incomplete claims if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\r\nvar decode = function (token) {\r\n    var header = {}, claims = {}, data = {}, signature = '';\r\n    try {\r\n        var parts = token.split('.');\r\n        header = jsonEval(base64Decode(parts[0]) || '');\r\n        claims = jsonEval(base64Decode(parts[1]) || '');\r\n        signature = parts[2];\r\n        data = claims['d'] || {};\r\n        delete claims['d'];\r\n    }\r\n    catch (e) { }\r\n    return {\r\n        header: header,\r\n        claims: claims,\r\n        data: data,\r\n        signature: signature\r\n    };\r\n};\r\n/**\r\n * Decodes a Firebase auth. token and checks the validity of its time-based claims. Will return true if the\r\n * token is within the time window authorized by the 'nbf' (not-before) and 'iat' (issued-at) claims.\r\n *\r\n * Notes:\r\n * - May return a false negative if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\r\nvar isValidTimestamp = function (token) {\r\n    var claims = decode(token).claims;\r\n    var now = Math.floor(new Date().getTime() / 1000);\r\n    var validSince = 0, validUntil = 0;\r\n    if (typeof claims === 'object') {\r\n        if (claims.hasOwnProperty('nbf')) {\r\n            validSince = claims['nbf'];\r\n        }\r\n        else if (claims.hasOwnProperty('iat')) {\r\n            validSince = claims['iat'];\r\n        }\r\n        if (claims.hasOwnProperty('exp')) {\r\n            validUntil = claims['exp'];\r\n        }\r\n        else {\r\n            // token will expire after 24h by default\r\n            validUntil = validSince + 86400;\r\n        }\r\n    }\r\n    return (!!now &&\r\n        !!validSince &&\r\n        !!validUntil &&\r\n        now >= validSince &&\r\n        now <= validUntil);\r\n};\r\n/**\r\n * Decodes a Firebase auth. token and returns its issued at time if valid, null otherwise.\r\n *\r\n * Notes:\r\n * - May return null if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\r\nvar issuedAtTime = function (token) {\r\n    var claims = decode(token).claims;\r\n    if (typeof claims === 'object' && claims.hasOwnProperty('iat')) {\r\n        return claims['iat'];\r\n    }\r\n    return null;\r\n};\r\n/**\r\n * Decodes a Firebase auth. token and checks the validity of its format. Expects a valid issued-at time.\r\n *\r\n * Notes:\r\n * - May return a false negative if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\r\nvar isValidFormat = function (token) {\r\n    var decoded = decode(token), claims = decoded.claims;\r\n    return !!claims && typeof claims === 'object' && claims.hasOwnProperty('iat');\r\n};\r\n/**\r\n * Attempts to peer into an auth token and determine if it's an admin auth token by looking at the claims portion.\r\n *\r\n * Notes:\r\n * - May return a false negative if there's no native base64 decoding support.\r\n * - Doesn't check if the token is actually valid.\r\n */\r\nvar isAdmin = function (token) {\r\n    var claims = decode(token).claims;\r\n    return typeof claims === 'object' && claims['admin'] === true;\r\n};\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\nfunction contains(obj, key) {\r\n    return Object.prototype.hasOwnProperty.call(obj, key);\r\n}\r\nfunction safeGet(obj, key) {\r\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\r\n        return obj[key];\r\n    }\r\n    else {\r\n        return undefined;\r\n    }\r\n}\r\nfunction isEmpty(obj) {\r\n    for (var key in obj) {\r\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\r\n            return false;\r\n        }\r\n    }\r\n    return true;\r\n}\r\nfunction map(obj, fn, contextObj) {\r\n    var res = {};\r\n    for (var key in obj) {\r\n        if (Object.prototype.hasOwnProperty.call(obj, key)) {\r\n            res[key] = fn.call(contextObj, obj[key], key, obj);\r\n        }\r\n    }\r\n    return res;\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Returns a querystring-formatted string (e.g. &arg=val&arg2=val2) from a\r\n * params object (e.g. {arg: 'val', arg2: 'val2'})\r\n * Note: You must prepend it with ? when adding it to a URL.\r\n */\r\nfunction querystring(querystringParams) {\r\n    var params = [];\r\n    var _loop_1 = function (key, value) {\r\n        if (Array.isArray(value)) {\r\n            value.forEach(function (arrayVal) {\r\n                params.push(encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal));\r\n            });\r\n        }\r\n        else {\r\n            params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\r\n        }\r\n    };\r\n    for (var _i = 0, _a = Object.entries(querystringParams); _i < _a.length; _i++) {\r\n        var _b = _a[_i], key = _b[0], value = _b[1];\r\n        _loop_1(key, value);\r\n    }\r\n    return params.length ? '&' + params.join('&') : '';\r\n}\r\n/**\r\n * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object\r\n * (e.g. {arg: 'val', arg2: 'val2'})\r\n */\r\nfunction querystringDecode(querystring) {\r\n    var obj = {};\r\n    var tokens = querystring.replace(/^\\?/, '').split('&');\r\n    tokens.forEach(function (token) {\r\n        if (token) {\r\n            var key = token.split('=');\r\n            obj[key[0]] = key[1];\r\n        }\r\n    });\r\n    return obj;\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * @fileoverview SHA-1 cryptographic hash.\r\n * Variable names follow the notation in FIPS PUB 180-3:\r\n * http://csrc.nist.gov/publications/fips/fips180-3/fips180-3_final.pdf.\r\n *\r\n * Usage:\r\n *   var sha1 = new sha1();\r\n *   sha1.update(bytes);\r\n *   var hash = sha1.digest();\r\n *\r\n * Performance:\r\n *   Chrome 23:   ~400 Mbit/s\r\n *   Firefox 16:  ~250 Mbit/s\r\n *\r\n */\r\n/**\r\n * SHA-1 cryptographic hash constructor.\r\n *\r\n * The properties declared here are discussed in the above algorithm document.\r\n * @constructor\r\n * @final\r\n * @struct\r\n */\r\nvar Sha1 = /** @class */ (function () {\r\n    function Sha1() {\r\n        /**\r\n         * Holds the previous values of accumulated variables a-e in the compress_\r\n         * function.\r\n         * @private\r\n         */\r\n        this.chain_ = [];\r\n        /**\r\n         * A buffer holding the partially computed hash result.\r\n         * @private\r\n         */\r\n        this.buf_ = [];\r\n        /**\r\n         * An array of 80 bytes, each a part of the message to be hashed.  Referred to\r\n         * as the message schedule in the docs.\r\n         * @private\r\n         */\r\n        this.W_ = [];\r\n        /**\r\n         * Contains data needed to pad messages less than 64 bytes.\r\n         * @private\r\n         */\r\n        this.pad_ = [];\r\n        /**\r\n         * @private {number}\r\n         */\r\n        this.inbuf_ = 0;\r\n        /**\r\n         * @private {number}\r\n         */\r\n        this.total_ = 0;\r\n        this.blockSize = 512 / 8;\r\n        this.pad_[0] = 128;\r\n        for (var i = 1; i < this.blockSize; ++i) {\r\n            this.pad_[i] = 0;\r\n        }\r\n        this.reset();\r\n    }\r\n    Sha1.prototype.reset = function () {\r\n        this.chain_[0] = 0x67452301;\r\n        this.chain_[1] = 0xefcdab89;\r\n        this.chain_[2] = 0x98badcfe;\r\n        this.chain_[3] = 0x10325476;\r\n        this.chain_[4] = 0xc3d2e1f0;\r\n        this.inbuf_ = 0;\r\n        this.total_ = 0;\r\n    };\r\n    /**\r\n     * Internal compress helper function.\r\n     * @param buf Block to compress.\r\n     * @param offset Offset of the block in the buffer.\r\n     * @private\r\n     */\r\n    Sha1.prototype.compress_ = function (buf, offset) {\r\n        if (!offset) {\r\n            offset = 0;\r\n        }\r\n        var W = this.W_;\r\n        // get 16 big endian words\r\n        if (typeof buf === 'string') {\r\n            for (var i = 0; i < 16; i++) {\r\n                // TODO(user): [bug 8140122] Recent versions of Safari for Mac OS and iOS\r\n                // have a bug that turns the post-increment ++ operator into pre-increment\r\n                // during JIT compilation.  We have code that depends heavily on SHA-1 for\r\n                // correctness and which is affected by this bug, so I've removed all uses\r\n                // of post-increment ++ in which the result value is used.  We can revert\r\n                // this change once the Safari bug\r\n                // (https://bugs.webkit.org/show_bug.cgi?id=109036) has been fixed and\r\n                // most clients have been updated.\r\n                W[i] =\r\n                    (buf.charCodeAt(offset) << 24) |\r\n                        (buf.charCodeAt(offset + 1) << 16) |\r\n                        (buf.charCodeAt(offset + 2) << 8) |\r\n                        buf.charCodeAt(offset + 3);\r\n                offset += 4;\r\n            }\r\n        }\r\n        else {\r\n            for (var i = 0; i < 16; i++) {\r\n                W[i] =\r\n                    (buf[offset] << 24) |\r\n                        (buf[offset + 1] << 16) |\r\n                        (buf[offset + 2] << 8) |\r\n                        buf[offset + 3];\r\n                offset += 4;\r\n            }\r\n        }\r\n        // expand to 80 words\r\n        for (var i = 16; i < 80; i++) {\r\n            var t = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];\r\n            W[i] = ((t << 1) | (t >>> 31)) & 0xffffffff;\r\n        }\r\n        var a = this.chain_[0];\r\n        var b = this.chain_[1];\r\n        var c = this.chain_[2];\r\n        var d = this.chain_[3];\r\n        var e = this.chain_[4];\r\n        var f, k;\r\n        // TODO(user): Try to unroll this loop to speed up the computation.\r\n        for (var i = 0; i < 80; i++) {\r\n            if (i < 40) {\r\n                if (i < 20) {\r\n                    f = d ^ (b & (c ^ d));\r\n                    k = 0x5a827999;\r\n                }\r\n                else {\r\n                    f = b ^ c ^ d;\r\n                    k = 0x6ed9eba1;\r\n                }\r\n            }\r\n            else {\r\n                if (i < 60) {\r\n                    f = (b & c) | (d & (b | c));\r\n                    k = 0x8f1bbcdc;\r\n                }\r\n                else {\r\n                    f = b ^ c ^ d;\r\n                    k = 0xca62c1d6;\r\n                }\r\n            }\r\n            var t = (((a << 5) | (a >>> 27)) + f + e + k + W[i]) & 0xffffffff;\r\n            e = d;\r\n            d = c;\r\n            c = ((b << 30) | (b >>> 2)) & 0xffffffff;\r\n            b = a;\r\n            a = t;\r\n        }\r\n        this.chain_[0] = (this.chain_[0] + a) & 0xffffffff;\r\n        this.chain_[1] = (this.chain_[1] + b) & 0xffffffff;\r\n        this.chain_[2] = (this.chain_[2] + c) & 0xffffffff;\r\n        this.chain_[3] = (this.chain_[3] + d) & 0xffffffff;\r\n        this.chain_[4] = (this.chain_[4] + e) & 0xffffffff;\r\n    };\r\n    Sha1.prototype.update = function (bytes, length) {\r\n        // TODO(johnlenz): tighten the function signature and remove this check\r\n        if (bytes == null) {\r\n            return;\r\n        }\r\n        if (length === undefined) {\r\n            length = bytes.length;\r\n        }\r\n        var lengthMinusBlock = length - this.blockSize;\r\n        var n = 0;\r\n        // Using local instead of member variables gives ~5% speedup on Firefox 16.\r\n        var buf = this.buf_;\r\n        var inbuf = this.inbuf_;\r\n        // The outer while loop should execute at most twice.\r\n        while (n < length) {\r\n            // When we have no data in the block to top up, we can directly process the\r\n            // input buffer (assuming it contains sufficient data). This gives ~25%\r\n            // speedup on Chrome 23 and ~15% speedup on Firefox 16, but requires that\r\n            // the data is provided in large chunks (or in multiples of 64 bytes).\r\n            if (inbuf === 0) {\r\n                while (n <= lengthMinusBlock) {\r\n                    this.compress_(bytes, n);\r\n                    n += this.blockSize;\r\n                }\r\n            }\r\n            if (typeof bytes === 'string') {\r\n                while (n < length) {\r\n                    buf[inbuf] = bytes.charCodeAt(n);\r\n                    ++inbuf;\r\n                    ++n;\r\n                    if (inbuf === this.blockSize) {\r\n                        this.compress_(buf);\r\n                        inbuf = 0;\r\n                        // Jump to the outer loop so we use the full-block optimization.\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n            else {\r\n                while (n < length) {\r\n                    buf[inbuf] = bytes[n];\r\n                    ++inbuf;\r\n                    ++n;\r\n                    if (inbuf === this.blockSize) {\r\n                        this.compress_(buf);\r\n                        inbuf = 0;\r\n                        // Jump to the outer loop so we use the full-block optimization.\r\n                        break;\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        this.inbuf_ = inbuf;\r\n        this.total_ += length;\r\n    };\r\n    /** @override */\r\n    Sha1.prototype.digest = function () {\r\n        var digest = [];\r\n        var totalBits = this.total_ * 8;\r\n        // Add pad 0x80 0x00*.\r\n        if (this.inbuf_ < 56) {\r\n            this.update(this.pad_, 56 - this.inbuf_);\r\n        }\r\n        else {\r\n            this.update(this.pad_, this.blockSize - (this.inbuf_ - 56));\r\n        }\r\n        // Add # bits.\r\n        for (var i = this.blockSize - 1; i >= 56; i--) {\r\n            this.buf_[i] = totalBits & 255;\r\n            totalBits /= 256; // Don't use bit-shifting here!\r\n        }\r\n        this.compress_(this.buf_);\r\n        var n = 0;\r\n        for (var i = 0; i < 5; i++) {\r\n            for (var j = 24; j >= 0; j -= 8) {\r\n                digest[n] = (this.chain_[i] >> j) & 255;\r\n                ++n;\r\n            }\r\n        }\r\n        return digest;\r\n    };\r\n    return Sha1;\r\n}());\n\n/**\r\n * Helper to make a Subscribe function (just like Promise helps make a\r\n * Thenable).\r\n *\r\n * @param executor Function which can make calls to a single Observer\r\n *     as a proxy.\r\n * @param onNoObservers Callback when count of Observers goes to zero.\r\n */\r\nfunction createSubscribe(executor, onNoObservers) {\r\n    var proxy = new ObserverProxy(executor, onNoObservers);\r\n    return proxy.subscribe.bind(proxy);\r\n}\r\n/**\r\n * Implement fan-out for any number of Observers attached via a subscribe\r\n * function.\r\n */\r\nvar ObserverProxy = /** @class */ (function () {\r\n    /**\r\n     * @param executor Function which can make calls to a single Observer\r\n     *     as a proxy.\r\n     * @param onNoObservers Callback when count of Observers goes to zero.\r\n     */\r\n    function ObserverProxy(executor, onNoObservers) {\r\n        var _this = this;\r\n        this.observers = [];\r\n        this.unsubscribes = [];\r\n        this.observerCount = 0;\r\n        // Micro-task scheduling by calling task.then().\r\n        this.task = Promise.resolve();\r\n        this.finalized = false;\r\n        this.onNoObservers = onNoObservers;\r\n        // Call the executor asynchronously so subscribers that are called\r\n        // synchronously after the creation of the subscribe function\r\n        // can still receive the very first value generated in the executor.\r\n        this.task\r\n            .then(function () {\r\n            executor(_this);\r\n        })\r\n            .catch(function (e) {\r\n            _this.error(e);\r\n        });\r\n    }\r\n    ObserverProxy.prototype.next = function (value) {\r\n        this.forEachObserver(function (observer) {\r\n            observer.next(value);\r\n        });\r\n    };\r\n    ObserverProxy.prototype.error = function (error) {\r\n        this.forEachObserver(function (observer) {\r\n            observer.error(error);\r\n        });\r\n        this.close(error);\r\n    };\r\n    ObserverProxy.prototype.complete = function () {\r\n        this.forEachObserver(function (observer) {\r\n            observer.complete();\r\n        });\r\n        this.close();\r\n    };\r\n    /**\r\n     * Subscribe function that can be used to add an Observer to the fan-out list.\r\n     *\r\n     * - We require that no event is sent to a subscriber sychronously to their\r\n     *   call to subscribe().\r\n     */\r\n    ObserverProxy.prototype.subscribe = function (nextOrObserver, error, complete) {\r\n        var _this = this;\r\n        var observer;\r\n        if (nextOrObserver === undefined &&\r\n            error === undefined &&\r\n            complete === undefined) {\r\n            throw new Error('Missing Observer.');\r\n        }\r\n        // Assemble an Observer object when passed as callback functions.\r\n        if (implementsAnyMethods(nextOrObserver, [\r\n            'next',\r\n            'error',\r\n            'complete'\r\n        ])) {\r\n            observer = nextOrObserver;\r\n        }\r\n        else {\r\n            observer = {\r\n                next: nextOrObserver,\r\n                error: error,\r\n                complete: complete\r\n            };\r\n        }\r\n        if (observer.next === undefined) {\r\n            observer.next = noop;\r\n        }\r\n        if (observer.error === undefined) {\r\n            observer.error = noop;\r\n        }\r\n        if (observer.complete === undefined) {\r\n            observer.complete = noop;\r\n        }\r\n        var unsub = this.unsubscribeOne.bind(this, this.observers.length);\r\n        // Attempt to subscribe to a terminated Observable - we\r\n        // just respond to the Observer with the final error or complete\r\n        // event.\r\n        if (this.finalized) {\r\n            // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n            this.task.then(function () {\r\n                try {\r\n                    if (_this.finalError) {\r\n                        observer.error(_this.finalError);\r\n                    }\r\n                    else {\r\n                        observer.complete();\r\n                    }\r\n                }\r\n                catch (e) {\r\n                    // nothing\r\n                }\r\n                return;\r\n            });\r\n        }\r\n        this.observers.push(observer);\r\n        return unsub;\r\n    };\r\n    // Unsubscribe is synchronous - we guarantee that no events are sent to\r\n    // any unsubscribed Observer.\r\n    ObserverProxy.prototype.unsubscribeOne = function (i) {\r\n        if (this.observers === undefined || this.observers[i] === undefined) {\r\n            return;\r\n        }\r\n        delete this.observers[i];\r\n        this.observerCount -= 1;\r\n        if (this.observerCount === 0 && this.onNoObservers !== undefined) {\r\n            this.onNoObservers(this);\r\n        }\r\n    };\r\n    ObserverProxy.prototype.forEachObserver = function (fn) {\r\n        if (this.finalized) {\r\n            // Already closed by previous event....just eat the additional values.\r\n            return;\r\n        }\r\n        // Since sendOne calls asynchronously - there is no chance that\r\n        // this.observers will become undefined.\r\n        for (var i = 0; i < this.observers.length; i++) {\r\n            this.sendOne(i, fn);\r\n        }\r\n    };\r\n    // Call the Observer via one of it's callback function. We are careful to\r\n    // confirm that the observe has not been unsubscribed since this asynchronous\r\n    // function had been queued.\r\n    ObserverProxy.prototype.sendOne = function (i, fn) {\r\n        var _this = this;\r\n        // Execute the callback asynchronously\r\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n        this.task.then(function () {\r\n            if (_this.observers !== undefined && _this.observers[i] !== undefined) {\r\n                try {\r\n                    fn(_this.observers[i]);\r\n                }\r\n                catch (e) {\r\n                    // Ignore exceptions raised in Observers or missing methods of an\r\n                    // Observer.\r\n                    // Log error to console. b/31404806\r\n                    if (typeof console !== 'undefined' && console.error) {\r\n                        console.error(e);\r\n                    }\r\n                }\r\n            }\r\n        });\r\n    };\r\n    ObserverProxy.prototype.close = function (err) {\r\n        var _this = this;\r\n        if (this.finalized) {\r\n            return;\r\n        }\r\n        this.finalized = true;\r\n        if (err !== undefined) {\r\n            this.finalError = err;\r\n        }\r\n        // Proxy is no longer needed - garbage collect references\r\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\r\n        this.task.then(function () {\r\n            _this.observers = undefined;\r\n            _this.onNoObservers = undefined;\r\n        });\r\n    };\r\n    return ObserverProxy;\r\n}());\r\n/** Turn synchronous function into one called asynchronously. */\r\nfunction async(fn, onError) {\r\n    return function () {\r\n        var args = [];\r\n        for (var _i = 0; _i < arguments.length; _i++) {\r\n            args[_i] = arguments[_i];\r\n        }\r\n        Promise.resolve(true)\r\n            .then(function () {\r\n            fn.apply(void 0, args);\r\n        })\r\n            .catch(function (error) {\r\n            if (onError) {\r\n                onError(error);\r\n            }\r\n        });\r\n    };\r\n}\r\n/**\r\n * Return true if the object passed in implements any of the named methods.\r\n */\r\nfunction implementsAnyMethods(obj, methods) {\r\n    if (typeof obj !== 'object' || obj === null) {\r\n        return false;\r\n    }\r\n    for (var _i = 0, methods_1 = methods; _i < methods_1.length; _i++) {\r\n        var method = methods_1[_i];\r\n        if (method in obj && typeof obj[method] === 'function') {\r\n            return true;\r\n        }\r\n    }\r\n    return false;\r\n}\r\nfunction noop() {\r\n    // do nothing\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * Check to make sure the appropriate number of arguments are provided for a public function.\r\n * Throws an error if it fails.\r\n *\r\n * @param fnName The function name\r\n * @param minCount The minimum number of arguments to allow for the function call\r\n * @param maxCount The maximum number of argument to allow for the function call\r\n * @param argCount The actual number of arguments provided.\r\n */\r\nvar validateArgCount = function (fnName, minCount, maxCount, argCount) {\r\n    var argError;\r\n    if (argCount < minCount) {\r\n        argError = 'at least ' + minCount;\r\n    }\r\n    else if (argCount > maxCount) {\r\n        argError = maxCount === 0 ? 'none' : 'no more than ' + maxCount;\r\n    }\r\n    if (argError) {\r\n        var error = fnName +\r\n            ' failed: Was called with ' +\r\n            argCount +\r\n            (argCount === 1 ? ' argument.' : ' arguments.') +\r\n            ' Expects ' +\r\n            argError +\r\n            '.';\r\n        throw new Error(error);\r\n    }\r\n};\r\n/**\r\n * Generates a string to prefix an error message about failed argument validation\r\n *\r\n * @param fnName The function name\r\n * @param argumentNumber The index of the argument\r\n * @param optional Whether or not the argument is optional\r\n * @return The prefix to add to the error thrown for validation.\r\n */\r\nfunction errorPrefix(fnName, argumentNumber, optional) {\r\n    var argName = '';\r\n    switch (argumentNumber) {\r\n        case 1:\r\n            argName = optional ? 'first' : 'First';\r\n            break;\r\n        case 2:\r\n            argName = optional ? 'second' : 'Second';\r\n            break;\r\n        case 3:\r\n            argName = optional ? 'third' : 'Third';\r\n            break;\r\n        case 4:\r\n            argName = optional ? 'fourth' : 'Fourth';\r\n            break;\r\n        default:\r\n            throw new Error('errorPrefix called with argumentNumber > 4.  Need to update it?');\r\n    }\r\n    var error = fnName + ' failed: ';\r\n    error += argName + ' argument ';\r\n    return error;\r\n}\r\n/**\r\n * @param fnName\r\n * @param argumentNumber\r\n * @param namespace\r\n * @param optional\r\n */\r\nfunction validateNamespace(fnName, argumentNumber, namespace, optional) {\r\n    if (optional && !namespace) {\r\n        return;\r\n    }\r\n    if (typeof namespace !== 'string') {\r\n        //TODO: I should do more validation here. We only allow certain chars in namespaces.\r\n        throw new Error(errorPrefix(fnName, argumentNumber, optional) +\r\n            'must be a valid firebase namespace.');\r\n    }\r\n}\r\nfunction validateCallback(fnName, argumentNumber, callback, optional) {\r\n    if (optional && !callback) {\r\n        return;\r\n    }\r\n    if (typeof callback !== 'function') {\r\n        throw new Error(errorPrefix(fnName, argumentNumber, optional) +\r\n            'must be a valid function.');\r\n    }\r\n}\r\nfunction validateContextObject(fnName, argumentNumber, context, optional) {\r\n    if (optional && !context) {\r\n        return;\r\n    }\r\n    if (typeof context !== 'object' || context === null) {\r\n        throw new Error(errorPrefix(fnName, argumentNumber, optional) +\r\n            'must be a valid context object.');\r\n    }\r\n}\n\n/**\r\n * @license\r\n * Copyright 2017 Google LLC\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n *   http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n// Code originally came from goog.crypt.stringToUtf8ByteArray, but for some reason they\r\n// automatically replaced '\\r\\n' with '\\n', and they didn't handle surrogate pairs,\r\n// so it's been modified.\r\n// Note that not all Unicode characters appear as single characters in JavaScript strings.\r\n// fromCharCode returns the UTF-16 encoding of a character - so some Unicode characters\r\n// use 2 characters in Javascript.  All 4-byte UTF-8 characters begin with a first\r\n// character in the range 0xD800 - 0xDBFF (the first character of a so-called surrogate\r\n// pair).\r\n// See http://www.ecma-international.org/ecma-262/5.1/#sec-15.1.3\r\n/**\r\n * @param {string} str\r\n * @return {Array}\r\n */\r\nvar stringToByteArray$1 = function (str) {\r\n    var out = [];\r\n    var p = 0;\r\n    for (var i = 0; i < str.length; i++) {\r\n        var c = str.charCodeAt(i);\r\n        // Is this the lead surrogate in a surrogate pair?\r\n        if (c >= 0xd800 && c <= 0xdbff) {\r\n            var high = c - 0xd800; // the high 10 bits.\r\n            i++;\r\n            assert(i < str.length, 'Surrogate pair missing trail surrogate.');\r\n            var low = str.charCodeAt(i) - 0xdc00; // the low 10 bits.\r\n            c = 0x10000 + (high << 10) + low;\r\n        }\r\n        if (c < 128) {\r\n            out[p++] = c;\r\n        }\r\n        else if (c < 2048) {\r\n            out[p++] = (c >> 6) | 192;\r\n            out[p++] = (c & 63) | 128;\r\n        }\r\n        else if (c < 65536) {\r\n            out[p++] = (c >> 12) | 224;\r\n            out[p++] = ((c >> 6) & 63) | 128;\r\n            out[p++] = (c & 63) | 128;\r\n        }\r\n        else {\r\n            out[p++] = (c >> 18) | 240;\r\n            out[p++] = ((c >> 12) & 63) | 128;\r\n            out[p++] = ((c >> 6) & 63) | 128;\r\n            out[p++] = (c & 63) | 128;\r\n        }\r\n    }\r\n    return out;\r\n};\r\n/**\r\n * Calculate length without actually converting; useful for doing cheaper validation.\r\n * @param {string} str\r\n * @return {number}\r\n */\r\nvar stringLength = function (str) {\r\n    var p = 0;\r\n    for (var i = 0; i < str.length; i++) {\r\n        var c = str.charCodeAt(i);\r\n        if (c < 128) {\r\n            p++;\r\n        }\r\n        else if (c < 2048) {\r\n            p += 2;\r\n        }\r\n        else if (c >= 0xd800 && c <= 0xdbff) {\r\n            // Lead surrogate of a surrogate pair.  The pair together will take 4 bytes to represent.\r\n            p += 4;\r\n            i++; // skip trail surrogate.\r\n        }\r\n        else {\r\n            p += 3;\r\n        }\r\n    }\r\n    return p;\r\n};\n\nexports.CONSTANTS = CONSTANTS;\nexports.Deferred = Deferred;\nexports.ErrorFactory = ErrorFactory;\nexports.FirebaseError = FirebaseError;\nexports.Sha1 = Sha1;\nexports.assert = assert;\nexports.assertionError = assertionError;\nexports.async = async;\nexports.base64 = base64;\nexports.base64Decode = base64Decode;\nexports.base64Encode = base64Encode;\nexports.contains = contains;\nexports.createSubscribe = createSubscribe;\nexports.decode = decode;\nexports.deepCopy = deepCopy;\nexports.deepExtend = deepExtend;\nexports.errorPrefix = errorPrefix;\nexports.getUA = getUA;\nexports.isAdmin = isAdmin;\nexports.isBrowser = isBrowser;\nexports.isBrowserExtension = isBrowserExtension;\nexports.isElectron = isElectron;\nexports.isEmpty = isEmpty;\nexports.isIE = isIE;\nexports.isMobileCordova = isMobileCordova;\nexports.isNode = isNode;\nexports.isNodeSdk = isNodeSdk;\nexports.isReactNative = isReactNative;\nexports.isUWP = isUWP;\nexports.isValidFormat = isValidFormat;\nexports.isValidTimestamp = isValidTimestamp;\nexports.issuedAtTime = issuedAtTime;\nexports.jsonEval = jsonEval;\nexports.map = map;\nexports.querystring = querystring;\nexports.querystringDecode = querystringDecode;\nexports.safeGet = safeGet;\nexports.stringLength = stringLength;\nexports.stringToByteArray = stringToByteArray$1;\nexports.stringify = stringify;\nexports.validateArgCount = validateArgCount;\nexports.validateCallback = validateCallback;\nexports.validateContextObject = validateContextObject;\nexports.validateNamespace = validateNamespace;\n//# sourceMappingURL=index.cjs.js.map\n"],"sourceRoot":""}