{"version":3,"sources":["webpack:///firebase-app.js","webpack:///webpack/bootstrap 629efb9c24e946b09f23","webpack:///./src/app/shared_promise.ts","webpack:///./src/app/subscribe.ts","webpack:///(webpack)/buildin/global.js","webpack:///./src/app/firebase_app.ts","webpack:///./src/app/deep_copy.ts","webpack:///./src/app.ts","webpack:///./~/process/browser.js","webpack:///./~/promise-polyfill/promise.js","webpack:///./~/setimmediate/setImmediate.js","webpack:///./~/timers-browserify/main.js","webpack:///./src/app/errors.ts"],"names":["firebase","window","self","modules","__webpack_require__","moduleId","installedModules","exports","module","i","l","call","parentJsonpFunction","chunkIds","moreModules","executeModules","chunkId","result","resolves","length","installedChunks","push","Object","prototype","hasOwnProperty","shift","s","2","e","onScriptComplete","script","onerror","onload","clearTimeout","timeout","chunk","Error","undefined","Promise","resolve","promise","reject","head","document","getElementsByTagName","createElement","type","charset","async","nc","setAttribute","src","p","setTimeout","appendChild","m","c","value","d","name","getter","o","defineProperty","configurable","enumerable","get","n","__esModule","object","property","oe","err","console","error","10","global","scope","Function","PromiseImpl","local","GoogPromise","17","_classCallCheck","instance","Constructor","TypeError","createSubscribe","executor","onNoObservers","proxy","ObserverProxy","subscribe","bind","fn","onError","_len","arguments","args","Array","_key","LocalPromise","then","apply","catch","implementsAnyMethods","obj","methods","_typeof","_iteratorNormalCompletion","_didIteratorError","_iteratorError","_step","_iterator","Symbol","iterator","next","done","method","return","noop","constructor","_createClass","defineProperties","target","props","descriptor","writable","key","protoProps","staticProps","_shared_promise","_this","this","observers","unsubscribes","observerCount","task","finalized","forEachObserver","observer","_error","close","complete","nextOrObserver","_this2","unsub","unsubscribeOne","finalError","sendOne","_this3","_this4","26","g","eval","27","createFirebaseNamespace","app","DEFAULT_ENTRY_NAME","apps_","getApps","keys","map","callAppHooks","eventName","factories","forEach","serviceName","factoryName","useAsService","appHooks","options","namespace","initializeApp","FirebaseAppImpl","apps","SDK_VERSION","INTERNAL","registerService","createService","serviceProperties","appHook","allowMultipleInstances","serviceNamespace","appArg","_deep_copy","deepExtend","serviceFxn","_getService","extendNamespace","_subscribe","ErrorFactory","_errors","removeApp","patchProperty","code","appErrors","create","tokenListeners","firebase_","isDeleted_","services_","name_","options_","deepCopy","getUid","getToken","addAuthTokenListener","callback","removeAuthTokenListener","filter","listener","checkDestroyed_","services","serviceKey","instanceKey","all","service","delete","instanceIdentifier","instanceSpecifier","extendApp","log","errors","no-app","bad-app-name","duplicate-app","app-deleted","duplicate-service","sa-not-supported","invalid-app-argument","32","source","Date","getTime","prop","4","_firebase_app","default","51","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","runClearTimeout","marker","cachedClearTimeout","cleanUpNextTick","draining","currentQueue","queue","concat","queueIndex","drainQueue","len","run","Item","array","process","nextTick","title","browser","env","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","emit","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","52","setImmediate","root","thisArg","_state","_handled","_value","_deferreds","doResolve","handle","deferred","_immediateFn","cb","onFulfilled","onRejected","ret","newValue","finale","_unhandledRejectionFn","Handler","reason","ex","setTimeoutFunc","prom","arr","slice","res","val","remaining","race","values","warn","_setImmediateFn","_setUnhandledRejectionFn","53","tasksByHandle","nextHandle","registerImmediate","clearImmediate","runIfPresent","currentlyRunningATask","doc","attachTo","getPrototypeOf","toString","postMessage","importScripts","postMessageIsAsynchronous","oldOnMessage","onmessage","messagePrefix","Math","random","onGlobalMessage","event","data","indexOf","addEventListener","attachEvent","MessageChannel","channel","port1","port2","html","documentElement","onreadystatechange","removeChild","54","Timeout","id","clearFn","_id","_clearFn","setInterval","clearInterval","unref","ref","enroll","item","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","9","patchCapture","captureFake","captureStackTrace","FirebaseError","message","stack","pattern","template","fullCode","replace","match"],"mappings":"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","file":"firebase-app.js","sourcesContent":["var firebase = (function() {\n            var window = typeof window === 'undefined' ? self : window;\n          return /******/ (function(modules) { // webpackBootstrap\n/******/ \t// install a JSONP callback for chunk loading\n/******/ \tvar parentJsonpFunction = window[\"webpackJsonpFirebase\"];\n/******/ \twindow[\"webpackJsonpFirebase\"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {\n/******/ \t\t// add \"moreModules\" to the modules object,\n/******/ \t\t// then flag all \"chunkIds\" as loaded and fire callback\n/******/ \t\tvar moduleId, chunkId, i = 0, resolves = [], result;\n/******/ \t\tfor(;i < chunkIds.length; i++) {\n/******/ \t\t\tchunkId = chunkIds[i];\n/******/ \t\t\tif(installedChunks[chunkId]) {\n/******/ \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n/******/ \t\t\t}\n/******/ \t\t\tinstalledChunks[chunkId] = 0;\n/******/ \t\t}\n/******/ \t\tfor(moduleId in moreModules) {\n/******/ \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n/******/ \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n/******/ \t\t\t}\n/******/ \t\t}\n/******/ \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);\n/******/ \t\twhile(resolves.length) {\n/******/ \t\t\tresolves.shift()();\n/******/ \t\t}\n/******/ \t\tif(executeModules) {\n/******/ \t\t\tfor(i=0; i < executeModules.length; i++) {\n/******/ \t\t\t\tresult = __webpack_require__(__webpack_require__.s = executeModules[i]);\n/******/ \t\t\t}\n/******/ \t\t}\n/******/ \t\treturn result;\n/******/ \t};\n/******/\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// objects to store loaded and loading chunks\n/******/ \tvar installedChunks = {\n/******/ \t\t2: 0\n/******/ \t};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/ \t// This file contains only the entry chunk.\n/******/ \t// The chunk loading function for additional chunks\n/******/ \t__webpack_require__.e = function requireEnsure(chunkId) {\n/******/ \t\tif(installedChunks[chunkId] === 0) {\n/******/ \t\t\treturn Promise.resolve();\n/******/ \t\t}\n/******/\n/******/ \t\t// a Promise means \"currently loading\".\n/******/ \t\tif(installedChunks[chunkId]) {\n/******/ \t\t\treturn installedChunks[chunkId][2];\n/******/ \t\t}\n/******/\n/******/ \t\t// setup Promise in chunk cache\n/******/ \t\tvar promise = new Promise(function(resolve, reject) {\n/******/ \t\t\tinstalledChunks[chunkId] = [resolve, reject];\n/******/ \t\t});\n/******/ \t\tinstalledChunks[chunkId][2] = promise;\n/******/\n/******/ \t\t// start chunk loading\n/******/ \t\tvar head = document.getElementsByTagName('head')[0];\n/******/ \t\tvar script = document.createElement('script');\n/******/ \t\tscript.type = 'text/javascript';\n/******/ \t\tscript.charset = 'utf-8';\n/******/ \t\tscript.async = true;\n/******/ \t\tscript.timeout = 120000;\n/******/\n/******/ \t\tif (__webpack_require__.nc) {\n/******/ \t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n/******/ \t\t}\n/******/ \t\tscript.src = __webpack_require__.p + \"\" + chunkId + \".js\";\n/******/ \t\tvar timeout = setTimeout(onScriptComplete, 120000);\n/******/ \t\tscript.onerror = script.onload = onScriptComplete;\n/******/ \t\tfunction onScriptComplete() {\n/******/ \t\t\t// avoid mem leaks in IE.\n/******/ \t\t\tscript.onerror = script.onload = null;\n/******/ \t\t\tclearTimeout(timeout);\n/******/ \t\t\tvar chunk = installedChunks[chunkId];\n/******/ \t\t\tif(chunk !== 0) {\n/******/ \t\t\t\tif(chunk) {\n/******/ \t\t\t\t\tchunk[1](new Error('Loading chunk ' + chunkId + ' failed.'));\n/******/ \t\t\t\t}\n/******/ \t\t\t\tinstalledChunks[chunkId] = undefined;\n/******/ \t\t\t}\n/******/ \t\t};\n/******/ \t\thead.appendChild(script);\n/******/\n/******/ \t\treturn promise;\n/******/ \t};\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// on error function for async loading\n/******/ \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 4);\n/******/ })\n/************************************************************************/\n/******/ ({\n\n/***/ 10:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n/* WEBPACK VAR INJECTION */(function(global) {\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nvar scope = void 0;\nif (typeof global !== 'undefined') {\n    scope = global;\n} else if (typeof self !== 'undefined') {\n    scope = self;\n} else {\n    try {\n        scope = Function('return this')();\n    } catch (e) {\n        throw new Error('polyfill failed because global object is unavailable in this environment');\n    }\n}\nvar PromiseImpl = scope.Promise || __webpack_require__(52);\nvar local = exports.local = {\n    Promise: PromiseImpl,\n    GoogPromise: PromiseImpl\n};\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(26)))\n\n/***/ }),\n\n/***/ 17:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _typeof = typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj; };\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.createSubscribe = createSubscribe;\nexports.async = async;\n\nvar _shared_promise = __webpack_require__(10);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar LocalPromise = _shared_promise.local.Promise;\n/**\n * Helper to make a Subscribe function (just like Promise helps make a\n * Thenable).\n *\n * @param executor Function which can make calls to a single Observer\n *     as a proxy.\n * @param onNoObservers Callback when count of Observers goes to zero.\n */\nfunction createSubscribe(executor, onNoObservers) {\n    var proxy = new ObserverProxy(executor, onNoObservers);\n    return proxy.subscribe.bind(proxy);\n}\n/**\n * Implement fan-out for any number of Observers attached via a subscribe\n * function.\n */\n\nvar ObserverProxy = function () {\n    /**\n     * @param executor Function which can make calls to a single Observer\n     *     as a proxy.\n     * @param onNoObservers Callback when count of Observers goes to zero.\n     */\n    function ObserverProxy(executor, onNoObservers) {\n        var _this = this;\n\n        _classCallCheck(this, ObserverProxy);\n\n        this.observers = [];\n        this.unsubscribes = [];\n        this.observerCount = 0;\n        // Micro-task scheduling by calling task.then().\n        this.task = LocalPromise.resolve();\n        this.finalized = false;\n        this.onNoObservers = onNoObservers;\n        // Call the executor asynchronously so subscribers that are called\n        // synchronously after the creation of the subscribe function\n        // can still receive the very first value generated in the executor.\n        this.task.then(function () {\n            executor(_this);\n        }).catch(function (e) {\n            _this.error(e);\n        });\n    }\n\n    _createClass(ObserverProxy, [{\n        key: 'next',\n        value: function next(value) {\n            this.forEachObserver(function (observer) {\n                observer.next(value);\n            });\n        }\n    }, {\n        key: 'error',\n        value: function error(_error) {\n            this.forEachObserver(function (observer) {\n                observer.error(_error);\n            });\n            this.close(_error);\n        }\n    }, {\n        key: 'complete',\n        value: function complete() {\n            this.forEachObserver(function (observer) {\n                observer.complete();\n            });\n            this.close();\n        }\n        /**\n         * Subscribe function that can be used to add an Observer to the fan-out list.\n         *\n         * - We require that no event is sent to a subscriber sychronously to their\n         *   call to subscribe().\n         */\n\n    }, {\n        key: 'subscribe',\n        value: function subscribe(nextOrObserver, error, complete) {\n            var _this2 = this;\n\n            var observer = void 0;\n            if (nextOrObserver === undefined && error === undefined && complete === undefined) {\n                throw new Error(\"Missing Observer.\");\n            }\n            // Assemble an Observer object when passed as callback functions.\n            if (implementsAnyMethods(nextOrObserver, ['next', 'error', 'complete'])) {\n                observer = nextOrObserver;\n            } else {\n                observer = {\n                    next: nextOrObserver,\n                    error: error,\n                    complete: complete\n                };\n            }\n            if (observer.next === undefined) {\n                observer.next = noop;\n            }\n            if (observer.error === undefined) {\n                observer.error = noop;\n            }\n            if (observer.complete === undefined) {\n                observer.complete = noop;\n            }\n            var unsub = this.unsubscribeOne.bind(this, this.observers.length);\n            // Attempt to subscribe to a terminated Observable - we\n            // just respond to the Observer with the final error or complete\n            // event.\n            if (this.finalized) {\n                this.task.then(function () {\n                    try {\n                        if (_this2.finalError) {\n                            observer.error(_this2.finalError);\n                        } else {\n                            observer.complete();\n                        }\n                    } catch (e) {\n                        // nothing\n                    }\n                });\n            }\n            this.observers.push(observer);\n            return unsub;\n        }\n        // Unsubscribe is synchronous - we guarantee that no events are sent to\n        // any unsubscribed Observer.\n\n    }, {\n        key: 'unsubscribeOne',\n        value: function unsubscribeOne(i) {\n            if (this.observers === undefined || this.observers[i] === undefined) {\n                return;\n            }\n            delete this.observers[i];\n            this.observerCount -= 1;\n            if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n                this.onNoObservers(this);\n            }\n        }\n    }, {\n        key: 'forEachObserver',\n        value: function forEachObserver(fn) {\n            if (this.finalized) {\n                // Already closed by previous event....just eat the additional values.\n                return;\n            }\n            // Since sendOne calls asynchronously - there is no chance that\n            // this.observers will become undefined.\n            for (var i = 0; i < this.observers.length; i++) {\n                this.sendOne(i, fn);\n            }\n        }\n        // Call the Observer via one of it's callback function. We are careful to\n        // confirm that the observe has not been unsubscribed since this asynchronous\n        // function had been queued.\n\n    }, {\n        key: 'sendOne',\n        value: function sendOne(i, fn) {\n            var _this3 = this;\n\n            // Execute the callback asynchronously\n            this.task.then(function () {\n                if (_this3.observers !== undefined && _this3.observers[i] !== undefined) {\n                    try {\n                        fn(_this3.observers[i]);\n                    } catch (e) {\n                        // Ignore exceptions raised in Observers or missing methods of an\n                        // Observer.\n                        // Log error to console. b/31404806\n                        if (typeof console !== \"undefined\" && console.error) {\n                            console.error(e);\n                        }\n                    }\n                }\n            });\n        }\n    }, {\n        key: 'close',\n        value: function close(err) {\n            var _this4 = this;\n\n            if (this.finalized) {\n                return;\n            }\n            this.finalized = true;\n            if (err !== undefined) {\n                this.finalError = err;\n            }\n            // Proxy is no longer needed - garbage collect references\n            this.task.then(function () {\n                _this4.observers = undefined;\n                _this4.onNoObservers = undefined;\n            });\n        }\n    }]);\n\n    return ObserverProxy;\n}();\n/** Turn synchronous function into one called asynchronously. */\n\n\nfunction async(fn, onError) {\n    return function () {\n        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n            args[_key] = arguments[_key];\n        }\n\n        LocalPromise.resolve(true).then(function () {\n            fn.apply(undefined, args);\n        }).catch(function (error) {\n            if (onError) {\n                onError(error);\n            }\n        });\n    };\n}\n/**\n * Return true if the object passed in implements any of the named methods.\n */\nfunction implementsAnyMethods(obj, methods) {\n    if ((typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) !== 'object' || obj === null) {\n        return false;\n    }\n    var _iteratorNormalCompletion = true;\n    var _didIteratorError = false;\n    var _iteratorError = undefined;\n\n    try {\n        for (var _iterator = methods[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {\n            var method = _step.value;\n\n            if (method in obj && typeof obj[method] === 'function') {\n                return true;\n            }\n        }\n    } catch (err) {\n        _didIteratorError = true;\n        _iteratorError = err;\n    } finally {\n        try {\n            if (!_iteratorNormalCompletion && _iterator.return) {\n                _iterator.return();\n            }\n        } finally {\n            if (_didIteratorError) {\n                throw _iteratorError;\n            }\n        }\n    }\n\n    return false;\n}\nfunction noop() {\n    // do nothing\n}\n\n/***/ }),\n\n/***/ 26:\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n\n/***/ 27:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /**\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Copyright 2017 Google Inc.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * you may not use this file except in compliance with the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * You may obtain a copy of the License at\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *   http://www.apache.org/licenses/LICENSE-2.0\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     *\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * Unless required by applicable law or agreed to in writing, software\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * See the License for the specific language governing permissions and\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     * limitations under the License.\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     */\n\n\nexports.createFirebaseNamespace = createFirebaseNamespace;\n\nvar _subscribe = __webpack_require__(17);\n\nvar _errors = __webpack_require__(9);\n\nvar _shared_promise = __webpack_require__(10);\n\nvar _deep_copy = __webpack_require__(32);\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar LocalPromise = _shared_promise.local.Promise;\nvar DEFAULT_ENTRY_NAME = '[DEFAULT]';\n// An array to capture listeners before the true auth functions\n// exist\nvar tokenListeners = [];\n/**\n * Global context object for a collection of services using\n * a shared authentication state.\n */\n\nvar FirebaseAppImpl = function () {\n    function FirebaseAppImpl(options, name, firebase_) {\n        _classCallCheck(this, FirebaseAppImpl);\n\n        this.firebase_ = firebase_;\n        this.isDeleted_ = false;\n        this.services_ = {};\n        this.name_ = name;\n        this.options_ = (0, _deep_copy.deepCopy)(options);\n        this.INTERNAL = {\n            'getUid': function getUid() {\n                return null;\n            },\n            'getToken': function getToken() {\n                return LocalPromise.resolve(null);\n            },\n            'addAuthTokenListener': function addAuthTokenListener(callback) {\n                tokenListeners.push(callback);\n                // Make sure callback is called, asynchronously, in the absence of the auth module\n                setTimeout(function () {\n                    return callback(null);\n                }, 0);\n            },\n            'removeAuthTokenListener': function removeAuthTokenListener(callback) {\n                tokenListeners = tokenListeners.filter(function (listener) {\n                    return listener !== callback;\n                });\n            }\n        };\n    }\n\n    _createClass(FirebaseAppImpl, [{\n        key: 'delete',\n        value: function _delete() {\n            var _this = this;\n\n            return new LocalPromise(function (resolve) {\n                _this.checkDestroyed_();\n                resolve();\n            }).then(function () {\n                _this.firebase_.INTERNAL.removeApp(_this.name_);\n                var services = [];\n                Object.keys(_this.services_).forEach(function (serviceKey) {\n                    Object.keys(_this.services_[serviceKey]).forEach(function (instanceKey) {\n                        services.push(_this.services_[serviceKey][instanceKey]);\n                    });\n                });\n                return LocalPromise.all(services.map(function (service) {\n                    return service.INTERNAL.delete();\n                }));\n            }).then(function () {\n                _this.isDeleted_ = true;\n                _this.services_ = {};\n            });\n        }\n        /**\n         * Return a service instance associated with this app (creating it\n         * on demand), identified by the passed instanceIdentifier.\n         *\n         * NOTE: Currently storage is the only one that is leveraging this\n         * functionality. They invoke it by calling:\n         *\n         * ```javascript\n         * firebase.app().storage('STORAGE BUCKET ID')\n         * ```\n         *\n         * The service name is passed to this already\n         * @internal\n         */\n\n    }, {\n        key: '_getService',\n        value: function _getService(name) {\n            var instanceIdentifier = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_ENTRY_NAME;\n\n            this.checkDestroyed_();\n            if (!this.services_[name]) {\n                this.services_[name] = {};\n            }\n            if (!this.services_[name][instanceIdentifier]) {\n                /**\n                 * If a custom instance has been defined (i.e. not '[DEFAULT]')\n                 * then we will pass that instance on, otherwise we pass `null`\n                 */\n                var instanceSpecifier = instanceIdentifier !== DEFAULT_ENTRY_NAME ? instanceIdentifier : undefined;\n                var service = this.firebase_.INTERNAL.factories[name](this, this.extendApp.bind(this), instanceSpecifier);\n                this.services_[name][instanceIdentifier] = service;\n            }\n            return this.services_[name][instanceIdentifier];\n        }\n        /**\n         * Callback function used to extend an App instance at the time\n         * of service instance creation.\n         */\n\n    }, {\n        key: 'extendApp',\n        value: function extendApp(props) {\n            var _this2 = this;\n\n            // Copy the object onto the FirebaseAppImpl prototype\n            (0, _deep_copy.deepExtend)(this, props);\n            /**\n             * If the app has overwritten the addAuthTokenListener stub, forward\n             * the active token listeners on to the true fxn.\n             *\n             * TODO: This function is required due to our current module\n             * structure. Once we are able to rely strictly upon a single module\n             * implementation, this code should be refactored and Auth should\n             * provide these stubs and the upgrade logic\n             */\n            if (props.INTERNAL && props.INTERNAL.addAuthTokenListener) {\n                tokenListeners.forEach(function (listener) {\n                    _this2.INTERNAL.addAuthTokenListener(listener);\n                });\n                tokenListeners = [];\n            }\n        }\n        /**\n         * This function will throw an Error if the App has already been deleted -\n         * use before performing API actions on the App.\n         */\n\n    }, {\n        key: 'checkDestroyed_',\n        value: function checkDestroyed_() {\n            if (this.isDeleted_) {\n                error('app-deleted', { 'name': this.name_ });\n            }\n        }\n    }, {\n        key: 'name',\n        get: function get() {\n            this.checkDestroyed_();\n            return this.name_;\n        }\n    }, {\n        key: 'options',\n        get: function get() {\n            this.checkDestroyed_();\n            return this.options_;\n        }\n    }]);\n\n    return FirebaseAppImpl;\n}();\n\n// Prevent dead-code elimination of these methods w/o invalid property\n// copying.\nFirebaseAppImpl.prototype.name && FirebaseAppImpl.prototype.options || FirebaseAppImpl.prototype.delete || console.log(\"dc\");\n/**\n * Return a firebase namespace object.\n *\n * In production, this will be called exactly once and the result\n * assigned to the 'firebase' global.  It may be called multiple times\n * in unit tests.\n */\nfunction createFirebaseNamespace() {\n    var apps_ = {};\n    var factories = {};\n    var appHooks = {};\n    // A namespace is a plain JavaScript Object.\n    var namespace = {\n        // Hack to prevent Babel from modifying the object returned\n        // as the firebase namespace.\n        '__esModule': true,\n        'initializeApp':\n        /**\n         * Create a new App instance (name must be unique).\n         */\n        function (options, name) {\n            if (name === undefined) {\n                name = DEFAULT_ENTRY_NAME;\n            } else {\n                if (typeof name !== 'string' || name === '') {\n                    error('bad-app-name', { 'name': name + '' });\n                }\n            }\n            if (apps_[name] !== undefined) {\n                error('duplicate-app', { 'name': name });\n            }\n            var app = new FirebaseAppImpl(options, name, namespace);\n            apps_[name] = app;\n            callAppHooks(app, 'create');\n            return app;\n        }\n        /*\n         * Return an array of all the non-deleted FirebaseApps.\n         */\n        ,\n        'app': app,\n        'apps': null,\n        'Promise': LocalPromise,\n        'SDK_VERSION': '4.1.2',\n        'INTERNAL': {\n            'registerService':\n            /*\n             * Register a Firebase Service.\n             *\n             * firebase.INTERNAL.registerService()\n             *\n             * TODO: Implement serviceProperties.\n             */\n            function (name, createService, serviceProperties, appHook, allowMultipleInstances) {\n                // Cannot re-register a service that already exists\n                if (factories[name]) {\n                    error('duplicate-service', { 'name': name });\n                }\n                // Capture the service factory for later service instantiation\n                factories[name] = createService;\n                // Capture the appHook, if passed\n                if (appHook) {\n                    appHooks[name] = appHook;\n                    // Run the **new** app hook on all existing apps\n                    getApps().forEach(function (app) {\n                        appHook('create', app);\n                    });\n                }\n                // The Service namespace is an accessor function ...\n                var serviceNamespace = function () {\n                    var appArg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : app();\n\n                    if (typeof appArg[name] !== 'function') {\n                        // Invalid argument.\n                        // This happens in the following case: firebase.storage('gs:/')\n                        error('invalid-app-argument', { 'name': name });\n                    }\n                    // Forward service instance lookup to the FirebaseApp.\n                    return appArg[name]();\n                };\n                // ... and a container for service-level properties.\n                if (serviceProperties !== undefined) {\n                    (0, _deep_copy.deepExtend)(serviceNamespace, serviceProperties);\n                }\n                // Monkey-patch the serviceNamespace onto the firebase namespace\n                namespace[name] = serviceNamespace;\n                // Patch the FirebaseAppImpl prototype\n                FirebaseAppImpl.prototype[name] = function () {\n                    var serviceFxn = this._getService.bind(this, name);\n\n                    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {\n                        args[_key] = arguments[_key];\n                    }\n\n                    return serviceFxn.apply(this, allowMultipleInstances ? args : []);\n                };\n                return serviceNamespace;\n            }\n            /**\n             * Patch the top-level firebase namespace with additional properties.\n             *\n             * firebase.INTERNAL.extendNamespace()\n             */\n            ,\n            'createFirebaseNamespace': createFirebaseNamespace,\n            'extendNamespace': function (props) {\n                (0, _deep_copy.deepExtend)(namespace, props);\n            },\n            'createSubscribe': _subscribe.createSubscribe,\n            'ErrorFactory': _errors.ErrorFactory,\n            'removeApp':\n            /**\n             * Called by App.delete() - but before any services associated with the App\n             * are deleted.\n             */\n            function (name) {\n                var app = apps_[name];\n                callAppHooks(app, 'delete');\n                delete apps_[name];\n            }\n            /**\n             * Get the App object for a given name (or DEFAULT).\n             */\n            ,\n            'factories': factories,\n            'useAsService': useAsService,\n            'Promise': _shared_promise.local.GoogPromise,\n            'deepExtend': _deep_copy.deepExtend\n        }\n    };\n    // Inject a circular default export to allow Babel users who were previously\n    // using:\n    //\n    //   import firebase from 'firebase';\n    //   which becomes: var firebase = require('firebase').default;\n    //\n    // instead of\n    //\n    //   import * as firebase from 'firebase';\n    //   which becomes: var firebase = require('firebase');\n    (0, _deep_copy.patchProperty)(namespace, 'default', namespace);\n    // firebase.apps is a read-only getter.\n    Object.defineProperty(namespace, 'apps', {\n        get: getApps\n    });function app(name) {\n        name = name || DEFAULT_ENTRY_NAME;\n        var result = apps_[name];\n        if (result === undefined) {\n            error('no-app', { 'name': name });\n        }\n        return result;\n    }\n    (0, _deep_copy.patchProperty)(app, 'App', FirebaseAppImpl);function getApps() {\n        // Make a copy so caller cannot mutate the apps list.\n        return Object.keys(apps_).map(function (name) {\n            return apps_[name];\n        });\n    }\n    function callAppHooks(app, eventName) {\n        Object.keys(factories).forEach(function (serviceName) {\n            // Ignore virtual services\n            var factoryName = useAsService(app, serviceName);\n            if (factoryName === null) {\n                return;\n            }\n            if (appHooks[factoryName]) {\n                appHooks[factoryName](eventName, app);\n            }\n        });\n    }\n    // Map the requested service to a registered service name\n    // (used to map auth to serverAuth service when needed).\n    function useAsService(app, name) {\n        if (name === 'serverAuth') {\n            return null;\n        }\n        app.options;\n\n        return name;\n    }\n    return namespace;\n}\nfunction error(code, args) {\n    throw appErrors.create(code, args);\n}\n// TypeScript does not support non-string indexes!\n// let errors: {[code: AppError: string} = {\nvar errors = {\n    'no-app': 'No Firebase App \\'{$name}\\' has been created - ' + 'call Firebase App.initializeApp()',\n    'bad-app-name': 'Illegal App name: \\'{$name}',\n    'duplicate-app': 'Firebase App named \\'{$name}\\' already exists',\n    'app-deleted': 'Firebase App named \\'{$name}\\' already deleted',\n    'duplicate-service': 'Firebase service named \\'{$name}\\' already registered',\n    'sa-not-supported': 'Initializing the Firebase SDK with a service ' + 'account is only allowed in a Node.js environment. On client ' + 'devices, you should instead initialize the SDK with an api key and ' + 'auth domain',\n    'invalid-app-argument': 'firebase.{$name}() takes either no argument or a ' + 'Firebase App instance.'\n};\nvar appErrors = new _errors.ErrorFactory('app', 'Firebase', errors);\n\n/***/ }),\n\n/***/ 32:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\nexports.deepCopy = deepCopy;\nexports.deepExtend = deepExtend;\nexports.patchProperty = patchProperty;\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * Do a deep-copy of basic JavaScript Objects or Arrays.\n */\n/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/function deepCopy(value) {\n    return deepExtend(undefined, value);\n}\n/**\n * Copy properties from source to target (recursively allows extension\n * of Objects and Arrays).  Scalar values in the target are over-written.\n * If target is undefined, an object of the appropriate type will be created\n * (and returned).\n *\n * We recursively copy all child properties of plain Objects in the source- so\n * that namespace- like dictionaries are merged.\n *\n * Note that the target can be a function, in which case the properties in\n * the source Object are copied onto it as static properties of the Function.\n */\nfunction deepExtend(target, source) {\n    if (!(source instanceof Object)) {\n        return source;\n    }\n    switch (source.constructor) {\n        case Date:\n            return new Date(source.getTime());\n            // Treat Dates like scalars; if the target date object had any child\n            // properties - they will be lost!\n\n        case Object:\n            if (target === undefined) {\n                target = {};\n            }\n            break;\n        case Array:\n            // Always copy the array source and overwrite the target.\n            target = [];\n            break;\n        default:\n            // Not a plain Object - treat it as a scalar.\n            return source;\n    }\n    for (var prop in source) {\n        if (!source.hasOwnProperty(prop)) {\n            continue;\n        }\n        target[prop] = deepExtend(target[prop], source[prop]);\n    }\n    return target;\n}\n// TODO: Really needed (for JSCompiler type checking)?\nfunction patchProperty(obj, prop, value) {\n    obj[prop] = value;\n}\n\n/***/ }),\n\n/***/ 4:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\n\nvar _firebase_app = __webpack_require__(27);\n\n// Export a single instance of firebase app\nvar firebase = (0, _firebase_app.createFirebaseNamespace)(); /**\n                                                             * Copyright 2017 Google Inc.\n                                                             *\n                                                             * Licensed under the Apache License, Version 2.0 (the \"License\");\n                                                             * you may not use this file except in compliance with the License.\n                                                             * You may obtain a copy of the License at\n                                                             *\n                                                             *   http://www.apache.org/licenses/LICENSE-2.0\n                                                             *\n                                                             * Unless required by applicable law or agreed to in writing, software\n                                                             * distributed under the License is distributed on an \"AS IS\" BASIS,\n                                                             * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n                                                             * See the License for the specific language governing permissions and\n                                                             * limitations under the License.\n                                                             */\n// Import the createFirebaseNamespace function\nexports.default = firebase;\nmodule.exports = exports['default'];\n\n/***/ }),\n\n/***/ 51:\n/***/ (function(module, exports) {\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/***/ }),\n\n/***/ 52:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(setImmediate) {(function (root) {\n\n  // Store setTimeout reference so promise-polyfill will be unaffected by\n  // other code modifying setTimeout (like sinon.useFakeTimers())\n  var setTimeoutFunc = setTimeout;\n\n  function noop() {}\n  \n  // Polyfill for Function.prototype.bind\n  function bind(fn, thisArg) {\n    return function () {\n      fn.apply(thisArg, arguments);\n    };\n  }\n\n  function Promise(fn) {\n    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');\n    if (typeof fn !== 'function') throw new TypeError('not a function');\n    this._state = 0;\n    this._handled = false;\n    this._value = undefined;\n    this._deferreds = [];\n\n    doResolve(fn, this);\n  }\n\n  function handle(self, deferred) {\n    while (self._state === 3) {\n      self = self._value;\n    }\n    if (self._state === 0) {\n      self._deferreds.push(deferred);\n      return;\n    }\n    self._handled = true;\n    Promise._immediateFn(function () {\n      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n      if (cb === null) {\n        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n        return;\n      }\n      var ret;\n      try {\n        ret = cb(self._value);\n      } catch (e) {\n        reject(deferred.promise, e);\n        return;\n      }\n      resolve(deferred.promise, ret);\n    });\n  }\n\n  function resolve(self, newValue) {\n    try {\n      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');\n      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {\n        var then = newValue.then;\n        if (newValue instanceof Promise) {\n          self._state = 3;\n          self._value = newValue;\n          finale(self);\n          return;\n        } else if (typeof then === 'function') {\n          doResolve(bind(then, newValue), self);\n          return;\n        }\n      }\n      self._state = 1;\n      self._value = newValue;\n      finale(self);\n    } catch (e) {\n      reject(self, e);\n    }\n  }\n\n  function reject(self, newValue) {\n    self._state = 2;\n    self._value = newValue;\n    finale(self);\n  }\n\n  function finale(self) {\n    if (self._state === 2 && self._deferreds.length === 0) {\n      Promise._immediateFn(function() {\n        if (!self._handled) {\n          Promise._unhandledRejectionFn(self._value);\n        }\n      });\n    }\n\n    for (var i = 0, len = self._deferreds.length; i < len; i++) {\n      handle(self, self._deferreds[i]);\n    }\n    self._deferreds = null;\n  }\n\n  function Handler(onFulfilled, onRejected, promise) {\n    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n    this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n    this.promise = promise;\n  }\n\n  /**\n   * Take a potentially misbehaving resolver function and make sure\n   * onFulfilled and onRejected are only called once.\n   *\n   * Makes no guarantees about asynchrony.\n   */\n  function doResolve(fn, self) {\n    var done = false;\n    try {\n      fn(function (value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      }, function (reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      });\n    } catch (ex) {\n      if (done) return;\n      done = true;\n      reject(self, ex);\n    }\n  }\n\n  Promise.prototype['catch'] = function (onRejected) {\n    return this.then(null, onRejected);\n  };\n\n  Promise.prototype.then = function (onFulfilled, onRejected) {\n    var prom = new (this.constructor)(noop);\n\n    handle(this, new Handler(onFulfilled, onRejected, prom));\n    return prom;\n  };\n\n  Promise.all = function (arr) {\n    var args = Array.prototype.slice.call(arr);\n\n    return new Promise(function (resolve, reject) {\n      if (args.length === 0) return resolve([]);\n      var remaining = args.length;\n\n      function res(i, val) {\n        try {\n          if (val && (typeof val === 'object' || typeof val === 'function')) {\n            var then = val.then;\n            if (typeof then === 'function') {\n              then.call(val, function (val) {\n                res(i, val);\n              }, reject);\n              return;\n            }\n          }\n          args[i] = val;\n          if (--remaining === 0) {\n            resolve(args);\n          }\n        } catch (ex) {\n          reject(ex);\n        }\n      }\n\n      for (var i = 0; i < args.length; i++) {\n        res(i, args[i]);\n      }\n    });\n  };\n\n  Promise.resolve = function (value) {\n    if (value && typeof value === 'object' && value.constructor === Promise) {\n      return value;\n    }\n\n    return new Promise(function (resolve) {\n      resolve(value);\n    });\n  };\n\n  Promise.reject = function (value) {\n    return new Promise(function (resolve, reject) {\n      reject(value);\n    });\n  };\n\n  Promise.race = function (values) {\n    return new Promise(function (resolve, reject) {\n      for (var i = 0, len = values.length; i < len; i++) {\n        values[i].then(resolve, reject);\n      }\n    });\n  };\n\n  // Use polyfill for setImmediate for performance gains\n  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||\n    function (fn) {\n      setTimeoutFunc(fn, 0);\n    };\n\n  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n    if (typeof console !== 'undefined' && console) {\n      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n    }\n  };\n\n  /**\n   * Set the immediate function to execute callbacks\n   * @param fn {function} Function to execute\n   * @deprecated\n   */\n  Promise._setImmediateFn = function _setImmediateFn(fn) {\n    Promise._immediateFn = fn;\n  };\n\n  /**\n   * Change the function to execute on unhandled rejection\n   * @param {function} fn Function to execute on unhandled rejection\n   * @deprecated\n   */\n  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {\n    Promise._unhandledRejectionFn = fn;\n  };\n  \n  if (typeof module !== 'undefined' && module.exports) {\n    module.exports = Promise;\n  } else if (!root.Promise) {\n    root.Promise = Promise;\n  }\n\n})(this);\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(54).setImmediate))\n\n/***/ }),\n\n/***/ 53:\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(26), __webpack_require__(51)))\n\n/***/ }),\n\n/***/ 54:\n/***/ (function(module, exports, __webpack_require__) {\n\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(53);\nexports.setImmediate = setImmediate;\nexports.clearImmediate = clearImmediate;\n\n\n/***/ }),\n\n/***/ 9:\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nObject.defineProperty(exports, \"__esModule\", {\n    value: true\n});\n\nvar _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();\n\nexports.patchCapture = patchCapture;\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar ERROR_NAME = 'FirebaseError';\nvar captureStackTrace = Error.captureStackTrace;\n// Export for faking in tests\nfunction patchCapture(captureFake) {\n    var result = captureStackTrace;\n    captureStackTrace = captureFake;\n    return result;\n}\n\nvar FirebaseError = exports.FirebaseError = function FirebaseError(code, message) {\n    _classCallCheck(this, FirebaseError);\n\n    this.code = code;\n    this.message = message;\n\n    // We want the stack value, if implemented by Error\n    if (captureStackTrace) {\n        // Patches this.stack, omitted calls above ErrorFactory#create\n        captureStackTrace(this, ErrorFactory.prototype.create);\n    } else {\n        var err = Error.apply(this, arguments);\n        this.name = ERROR_NAME;\n        // Make non-enumerable getter for the property.\n        Object.defineProperty(this, 'stack', {\n            get: function get() {\n                return err.stack;\n            }\n        });\n    }\n};\n// Back-door inheritance\n\n\nFirebaseError.prototype = Object.create(Error.prototype);\nFirebaseError.prototype.constructor = FirebaseError;\nFirebaseError.prototype.name = ERROR_NAME;\n\nvar ErrorFactory = exports.ErrorFactory = function () {\n    function ErrorFactory(service, serviceName, errors) {\n        _classCallCheck(this, ErrorFactory);\n\n        this.service = service;\n        this.serviceName = serviceName;\n        this.errors = errors;\n        // Matches {$name}, by default.\n        this.pattern = /\\{\\$([^}]+)}/g;\n        // empty\n    }\n\n    _createClass(ErrorFactory, [{\n        key: 'create',\n        value: function create(code, data) {\n            if (data === undefined) {\n                data = {};\n            }\n            var template = this.errors[code];\n            var fullCode = this.service + '/' + code;\n            var message = void 0;\n            if (template === undefined) {\n                message = \"Error\";\n            } else {\n                message = template.replace(this.pattern, function (match, key) {\n                    var value = data[key];\n                    return value !== undefined ? value.toString() : '<' + key + '?>';\n                });\n            }\n            // Service: Error message (service/code).\n            message = this.serviceName + ': ' + message + ' (' + fullCode + ').';\n            var err = new FirebaseError(fullCode, message);\n            // Populate the Error object with message parts for programmatic\n            // accesses (e.g., e.file).\n            for (var prop in data) {\n                if (!data.hasOwnProperty(prop) || prop.slice(-1) === '_') {\n                    continue;\n                }\n                err[prop] = data[prop];\n            }\n            return err;\n        }\n    }]);\n\n    return ErrorFactory;\n}();\n\n/***/ })\n\n/******/ });\n          })();\n\n\n// WEBPACK FOOTER //\n// firebase-app.js"," \t// install a JSONP callback for chunk loading\n \tvar parentJsonpFunction = window[\"webpackJsonpFirebase\"];\n \twindow[\"webpackJsonpFirebase\"] = function webpackJsonpCallback(chunkIds, moreModules, executeModules) {\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [], result;\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(chunkIds, moreModules, executeModules);\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n \t\tif(executeModules) {\n \t\t\tfor(i=0; i < executeModules.length; i++) {\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = executeModules[i]);\n \t\t\t}\n \t\t}\n \t\treturn result;\n \t};\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// objects to store loaded and loading chunks\n \tvar installedChunks = {\n \t\t2: 0\n \t};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n \t// This file contains only the entry chunk.\n \t// The chunk loading function for additional chunks\n \t__webpack_require__.e = function requireEnsure(chunkId) {\n \t\tif(installedChunks[chunkId] === 0) {\n \t\t\treturn Promise.resolve();\n \t\t}\n\n \t\t// a Promise means \"currently loading\".\n \t\tif(installedChunks[chunkId]) {\n \t\t\treturn installedChunks[chunkId][2];\n \t\t}\n\n \t\t// setup Promise in chunk cache\n \t\tvar promise = new Promise(function(resolve, reject) {\n \t\t\tinstalledChunks[chunkId] = [resolve, reject];\n \t\t});\n \t\tinstalledChunks[chunkId][2] = promise;\n\n \t\t// start chunk loading\n \t\tvar head = document.getElementsByTagName('head')[0];\n \t\tvar script = document.createElement('script');\n \t\tscript.type = 'text/javascript';\n \t\tscript.charset = 'utf-8';\n \t\tscript.async = true;\n \t\tscript.timeout = 120000;\n\n \t\tif (__webpack_require__.nc) {\n \t\t\tscript.setAttribute(\"nonce\", __webpack_require__.nc);\n \t\t}\n \t\tscript.src = __webpack_require__.p + \"\" + chunkId + \".js\";\n \t\tvar timeout = setTimeout(onScriptComplete, 120000);\n \t\tscript.onerror = script.onload = onScriptComplete;\n \t\tfunction onScriptComplete() {\n \t\t\t// avoid mem leaks in IE.\n \t\t\tscript.onerror = script.onload = null;\n \t\t\tclearTimeout(timeout);\n \t\t\tvar chunk = installedChunks[chunkId];\n \t\t\tif(chunk !== 0) {\n \t\t\t\tif(chunk) {\n \t\t\t\t\tchunk[1](new Error('Loading chunk ' + chunkId + ' failed.'));\n \t\t\t\t}\n \t\t\t\tinstalledChunks[chunkId] = undefined;\n \t\t\t}\n \t\t};\n \t\thead.appendChild(script);\n\n \t\treturn promise;\n \t};\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// identity function for calling harmony imports with the correct context\n \t__webpack_require__.i = function(value) { return value; };\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// on error function for async loading\n \t__webpack_require__.oe = function(err) { console.error(err); throw err; };\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 4);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 629efb9c24e946b09f23","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nlet scope;\n\nif (typeof global !== 'undefined') {\n    scope = global;\n} else if (typeof self !== 'undefined') {\n    scope = self;\n} else {\n    try {\n        scope = Function('return this')();\n    } catch (e) {\n        throw new Error('polyfill failed because global object is unavailable in this environment');\n    }\n}\n\nlet PromiseImpl = scope.Promise || require('promise-polyfill');\n\nexport let local:any = {\n  Promise: PromiseImpl,\n  GoogPromise: PromiseImpl\n};\n\n\n\n// WEBPACK FOOTER //\n// ./src/app/shared_promise.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nexport type NextFn<T> = (value: T) => void;\nexport type ErrorFn = (error: Error) => void;\nexport type CompleteFn = () => void;\n\nexport interface Observer<T> {\n  // Called once for each value in a stream of values.\n  next: NextFn<T>;\n\n  // A stream terminates by a single call to EITHER error() or complete().\n  error: ErrorFn;\n\n  // No events will be sent to next() once complete() is called.\n  complete: CompleteFn;\n}\n\n// Allow for any of the Observer methods to be undefined.\nexport interface PartialObserver<T> {\n  next?: NextFn<T>;\n  error?: ErrorFn;\n  complete?: CompleteFn;\n}\n\n// TODO: Support also Unsubscribe.unsubscribe?\nexport type Unsubscribe = () => void;\n\n/**\n * The Subscribe interface has two forms - passing the inline function\n * callbacks, or a object interface with callback properties.\n */\nexport interface Subscribe<T> {\n  (next?: NextFn<T>, error?: ErrorFn, complete?: CompleteFn): Unsubscribe;\n  (observer: PartialObserver<T>): Unsubscribe;\n}\n\nexport interface Observable<T> {\n  // Subscribe method\n  subscribe: Subscribe<T>;\n}\n\nimport {local} from './shared_promise';\n\nlet LocalPromise = local.Promise as typeof Promise;\n\nexport type Executor<T> = (observer: Observer<T>) => void;\n\n/**\n * Helper to make a Subscribe function (just like Promise helps make a\n * Thenable).\n *\n * @param executor Function which can make calls to a single Observer\n *     as a proxy.\n * @param onNoObservers Callback when count of Observers goes to zero.\n */\nexport function createSubscribe<T>(executor: Executor<T>,\n                                   onNoObservers?: Executor<T>)\n: Subscribe<T> {\n  let proxy = new ObserverProxy<T>(executor, onNoObservers);\n  return proxy.subscribe.bind(proxy);\n}\n\n/**\n * Implement fan-out for any number of Observers attached via a subscribe\n * function.\n */\nclass ObserverProxy<T> implements Observer<T>{\n  private observers: Array<Observer<T>>|undefined = [];\n  private unsubscribes: Unsubscribe[] = [];\n  private onNoObservers: Executor<T>|undefined;\n  private observerCount = 0;\n  // Micro-task scheduling by calling task.then().\n  private task = LocalPromise.resolve();\n  private finalized = false;\n  private finalError: Error;\n\n  /**\n   * @param executor Function which can make calls to a single Observer\n   *     as a proxy.\n   * @param onNoObservers Callback when count of Observers goes to zero.\n   */\n  constructor(executor: Executor<T>, onNoObservers?: Executor<T>) {\n    this.onNoObservers = onNoObservers;\n    // Call the executor asynchronously so subscribers that are called\n    // synchronously after the creation of the subscribe function\n    // can still receive the very first value generated in the executor.\n    this.task\n      .then(() => {\n        executor(this);\n      })\n      .catch((e) => {\n        this.error(e);\n      });\n  }\n\n  next(value: T) {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.next(value);\n    });\n  }\n\n  error(error: Error) {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.error(error);\n    });\n    this.close(error);\n  }\n\n  complete() {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.complete();\n    });\n    this.close();\n  }\n\n  /**\n   * Subscribe function that can be used to add an Observer to the fan-out list.\n   *\n   * - We require that no event is sent to a subscriber sychronously to their\n   *   call to subscribe().\n   */\n  subscribe(nextOrObserver: PartialObserver<T> | Function,\n            error?: ErrorFn,\n            complete?: CompleteFn)\n  : Unsubscribe {\n    let observer: Observer<T>;\n\n    if (nextOrObserver === undefined && error === undefined &&\n        complete === undefined) {\n      throw new Error(\"Missing Observer.\");\n    }\n\n    // Assemble an Observer object when passed as callback functions.\n    if (implementsAnyMethods(nextOrObserver, ['next', 'error', 'complete'])) {\n      observer = nextOrObserver as Observer<T>;\n    } else {\n      observer = {\n        next: (nextOrObserver as any) as NextFn<T>,\n        error: error,\n        complete: complete,\n      } as Observer<T>;\n    }\n\n    if (observer.next === undefined) {\n      observer.next = noop as NextFn<T>;\n    }\n    if (observer.error === undefined) {\n      observer.error = noop as ErrorFn;\n    }\n    if (observer.complete === undefined) {\n      observer.complete = noop as CompleteFn;\n    }\n\n    let unsub = this.unsubscribeOne.bind(this, this.observers!.length);\n\n    // Attempt to subscribe to a terminated Observable - we\n    // just respond to the Observer with the final error or complete\n    // event.\n    if (this.finalized) {\n      this.task.then(() => {\n        try {\n          if (this.finalError) {\n            observer.error(this.finalError);\n          } else {\n            observer.complete();\n          }\n        } catch (e) {\n          // nothing\n        }\n        return;\n      });\n    }\n\n    this.observers!.push(observer as Observer<T>);\n\n    return unsub;\n  }\n\n  // Unsubscribe is synchronous - we guarantee that no events are sent to\n  // any unsubscribed Observer.\n  private unsubscribeOne(i: number) {\n    if (this.observers === undefined || this.observers[i] === undefined) {\n        return;\n    }\n\n    delete this.observers[i];\n\n    this.observerCount -= 1;\n    if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n      this.onNoObservers(this);\n    }\n  }\n\n  private forEachObserver(fn: (observer: Observer<T>) => void): void {\n    if (this.finalized) {\n      // Already closed by previous event....just eat the additional values.\n      return;\n    }\n\n    // Since sendOne calls asynchronously - there is no chance that\n    // this.observers will become undefined.\n    for (let i = 0; i < this.observers!.length; i++) {\n      this.sendOne(i, fn);\n    }\n  }\n\n  // Call the Observer via one of it's callback function. We are careful to\n  // confirm that the observe has not been unsubscribed since this asynchronous\n  // function had been queued.\n  private sendOne(i: number, fn: (observer: Observer<T>) => void): void {\n    // Execute the callback asynchronously\n    this.task.then(() => {\n      if (this.observers !== undefined && this.observers[i] !== undefined) {\n        try {\n          fn(this.observers[i]);\n        } catch (e) {\n          // Ignore exceptions raised in Observers or missing methods of an\n          // Observer.\n          // Log error to console. b/31404806\n          if (typeof console !== \"undefined\" && console.error) {\n            console.error(e);\n          }\n        }\n      }\n    });\n  }\n\n  private close(err?: Error): void {\n    if (this.finalized) {\n      return;\n    }\n    this.finalized = true;\n    if (err !== undefined) {\n      this.finalError = err;\n    }\n    // Proxy is no longer needed - garbage collect references\n    this.task.then(() => {\n      this.observers = undefined;\n      this.onNoObservers = undefined;\n    });\n  }\n}\n\n/** Turn synchronous function into one called asynchronously. */\nexport function async(fn: Function, onError?: ErrorFn): Function {\n  return (...args: any[]) => {\n    LocalPromise.resolve(true)\n      .then(() => {\n        fn(...args);\n      })\n      .catch((error: Error) => {\n        if (onError) {\n          onError(error);\n        }\n      });\n  };\n}\n\n/**\n * Return true if the object passed in implements any of the named methods.\n */\nfunction implementsAnyMethods(obj: any, methods: string[]): boolean {\n  if (typeof(obj) !== 'object' || obj === null) {\n    return false;\n  }\n\n  for (let method of methods) {\n    if (method in obj && typeof obj[method] === 'function') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction noop(): void {\n  // do nothing\n}\n\n\n// WEBPACK FOOTER //\n// ./src/app/subscribe.ts","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 26\n// module chunks = 2","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\nimport { \n  createSubscribe,\n  Observer,\n  Subscribe\n} from './subscribe';\nimport { \n  ErrorFactory,\n  FirebaseError\n} from './errors';\nimport { local } from './shared_promise';\nimport { patchProperty, deepCopy, deepExtend } from './deep_copy';\n\nexport interface FirebaseAuthTokenData { accessToken: string; }\n\nexport interface FirebaseAppInternals {\n  getToken(refreshToken?: boolean): Promise< FirebaseAuthTokenData | null >;\n  getUid(): string|null;\n  addAuthTokenListener(fn: (token: string|null) => void): void;\n  removeAuthTokenListener(fn: (token: string|null) => void): void;\n}\n\nexport type FirebaseOptions = { \n  apiKey?: string,\n  authDomain?: string,\n  databaseURL?: string,\n  projectId?: string,\n  storageBucket?: string,\n  messagingSenderId?: string\n  [name: string]: any \n};\n\n// An instance of the firebase.App\nexport interface FirebaseApp {\n  /**\n   * The (read-only) name (identifier) for this App. '[DEFAULT]' is the default\n   * App.\n   */\n  name: string;\n\n  /**\n   * The (read-only) configuration options from the app initialization.\n   */\n  options: FirebaseOptions;\n\n  /**\n   * Make the given App unusable and free resources.\n   */\n  delete(): Promise<void>;\n\n  INTERNAL: FirebaseAppInternals;\n}\n\nexport interface FirebaseServiceInternals {\n  /**\n   * Delete the service and free it's resources - called from\n   * app.delete().\n   */\n  delete(): Promise<void>;\n}\n\n// Services are exposed through instances - each of which is associated with a\n// FirebaseApp.\nexport interface FirebaseService {\n  app: FirebaseApp;\n  INTERNAL?: FirebaseServiceInternals;\n}\n\nexport type AppHook = (event: string, app: FirebaseApp) => void;\n\n/**\n * Firebase Services create instances given a Firebase App instance and can\n * optionally add properties and methods to each FirebaseApp via the extendApp()\n * function.\n */\nexport interface FirebaseServiceFactory {\n  (app: FirebaseApp, extendApp?: (props: {[prop: string]: any}) => void,\n   instanceString?: string): FirebaseService;\n}\n\n/**\n * All ServiceNamespaces extend from FirebaseServiceNamespace\n */\nexport interface FirebaseServiceNamespace <T extends FirebaseService> {\n  (app?: FirebaseApp): T;\n}\n\nexport interface FirebaseErrorFactory<T> {\n  create(code: T, data?: {[prop: string]: any}): FirebaseError;\n}\n\nexport interface FirebaseErrorFactoryClass {\n  new (service: string, serviceName: string, errors: {[code: string]: string}): FirebaseErrorFactory<any>;\n}\n\nexport interface FirebaseNamespace {\n  /**\n   * Create (and intialize) a FirebaseApp.\n   *\n   * @param options Options to configure the services use in the App.\n   * @param name The optional name of the app to initialize ('[DEFAULT]' if\n   *   none)\n   */\n  initializeApp(options: FirebaseOptions, name?: string): FirebaseApp;\n\n  app: {\n    /**\n     * Retrieve an instance of a FirebaseApp.\n     *\n     * Usage: firebase.app()\n     *\n     * @param name The optional name of the app to return ('[DEFAULT]' if none)\n     */\n    (name?: string): FirebaseApp;\n\n    /**\n     * For testing FirebaseApp instances:\n     *   app() instanceof firebase.app.App\n     * DO NOT call this constuctor directly (use firebase.app() instead).\n     */\n    App: Function;\n  };\n\n  /**\n   * A (read-only) array of all the initialized Apps.\n   */\n  apps: FirebaseApp[];\n\n  // Inherit the type information of our exported Promise implementation from\n  // es6-promises.\n  Promise: typeof Promise;\n\n  // The current SDK version ('4.1.2').\n  SDK_VERSION: string;\n\n  // TODO: Migrate to firebase-app-internal.d.ts\n  INTERNAL: {\n    /**\n     * Internal API to register a Firebase Service into the firebase namespace.\n     *\n     * Each service will create a child namespace (firease.name) which acts as\n     * both a namespace for service specific properties, and also as a service\n     * accessor function (firebase.name() or firebase.name(app)).\n     *\n     * @param name The Firebase Service being registered.\n     * @param createService Factory function to create a service instance.\n     * @param serviceProperties Properties to copy to the service's namespace.\n     * @param appHook All appHooks called before intializeApp returns to caller.\n     * @param allowMultipleInstances Whether the registered service supports\n     *   multiple instances per app. If not specified, the default is false.\n     */\n    registerService(\n        name: string, \n        createService: FirebaseServiceFactory,\n        serviceProperties?: {[prop: string]: any}, \n        appHook?: AppHook,\n        allowMultipleInstances?: boolean): FirebaseServiceNamespace<FirebaseService>;\n\n    /**\n     * Just used for testing to start from a fresh namespace.\n     */\n    createFirebaseNamespace(): FirebaseNamespace;\n\n    /**\n     * Internal API to install properties on the top-level firebase namespace.\n     * @prop props The top level properties of this object are copied to the\n     *   namespace.\n     */\n    extendNamespace(props: {[prop: string]: any}): void;\n\n    /**\n     * Create a Subscribe function.  A proxy Observer is created so that\n     * events can be sent to single Observer to be fanned out automatically.\n     */\n    createSubscribe<T>(\n        executor: (observer: Observer<T>) => void,\n        onNoObservers?: (observer: Observer<T>) => void): Subscribe<T>;\n\n    /**\n     * Utility exposed for internal testing.\n     */\n    deepExtend(target: any, source: any): any;\n\n    /**\n     * Internal API to remove an app from the list of registered apps.\n     */\n    removeApp(name: string): void;\n\n    /**\n     * Service factories for each registered service.\n     */\n    factories: {[name: string]: FirebaseServiceFactory};\n\n    /*\n     * Convert service name to factory name to use.\n     */\n    useAsService(app: FirebaseApp, serviceName: string): string | null;\n\n    /**\n     * Use to construct all thrown FirebaseError's.\n     */\n    ErrorFactory: FirebaseErrorFactoryClass;\n  }\n}\n\nlet LocalPromise = local.Promise as typeof Promise;\n\nconst DEFAULT_ENTRY_NAME = '[DEFAULT]';\n\n// An array to capture listeners before the true auth functions\n// exist\nlet tokenListeners = [];\n\n/**\n * Global context object for a collection of services using\n * a shared authentication state.\n */\nclass FirebaseAppImpl implements FirebaseApp {\n  private options_: FirebaseOptions;\n  private name_: string;\n  private isDeleted_ = false;\n  private services_: {\n    [name: string]: {\n      [serviceName: string]: FirebaseService\n    }\n  } = {};\n\n  public INTERNAL;\n\n  constructor(options: FirebaseOptions,\n              name: string,\n              private firebase_: FirebaseNamespace) {\n    this.name_ = name;\n    this.options_ = deepCopy<FirebaseOptions>(options);\n    this.INTERNAL = {\n      'getUid': () => null,\n      'getToken': () => LocalPromise.resolve(null),\n      'addAuthTokenListener': (callback: (token: string|null) => void) => {\n        tokenListeners.push(callback);\n        // Make sure callback is called, asynchronously, in the absence of the auth module\n        setTimeout(() => callback(null), 0);\n      },\n      'removeAuthTokenListener': (callback) => {\n        tokenListeners = tokenListeners.filter(listener => listener !== callback);\n      },\n    };\n  }\n\n  get name(): string {\n    this.checkDestroyed_();\n    return this.name_;\n  }\n\n  get options(): FirebaseOptions {\n    this.checkDestroyed_();\n    return this.options_;\n  }\n\n  delete(): Promise<void> {\n    return new LocalPromise((resolve) => {\n      this.checkDestroyed_();\n      resolve();\n    })\n      .then(() => {\n        this.firebase_.INTERNAL.removeApp(this.name_);\n        let services: FirebaseService[] = [];\n        Object.keys(this.services_).forEach((serviceKey) => {\n          Object.keys(this.services_[serviceKey]).forEach((instanceKey) => {\n            services.push(this.services_[serviceKey][instanceKey]);\n          });\n        });\n        return LocalPromise.all(services.map((service) => {\n          return service.INTERNAL!.delete();\n        }));\n      })\n      .then((): void => {\n        this.isDeleted_ = true;\n        this.services_ = {};\n      });\n  }\n\n  /**\n   * Return a service instance associated with this app (creating it\n   * on demand), identified by the passed instanceIdentifier.\n   * \n   * NOTE: Currently storage is the only one that is leveraging this\n   * functionality. They invoke it by calling:\n   * \n   * ```javascript\n   * firebase.app().storage('STORAGE BUCKET ID')\n   * ```\n   * \n   * The service name is passed to this already\n   * @internal\n   */\n  _getService(name: string, instanceIdentifier: string = DEFAULT_ENTRY_NAME): FirebaseService {\n    this.checkDestroyed_();\n\n    if (!this.services_[name]) {\n      this.services_[name] = {};\n    }\n\n    if (!this.services_[name][instanceIdentifier]) {\n      /**\n       * If a custom instance has been defined (i.e. not '[DEFAULT]')\n       * then we will pass that instance on, otherwise we pass `null`\n       */\n      const instanceSpecifier = instanceIdentifier !== DEFAULT_ENTRY_NAME ? instanceIdentifier : undefined;\n      const service = this.firebase_.INTERNAL.factories[name](this, this.extendApp.bind(this), instanceSpecifier);\n      this.services_[name][instanceIdentifier] = service;\n    }\n\n    return this.services_[name][instanceIdentifier];\n  }\n\n  /**\n   * Callback function used to extend an App instance at the time\n   * of service instance creation.\n   */\n  private extendApp(props: {[name: string]: any}): void {\n    // Copy the object onto the FirebaseAppImpl prototype\n    deepExtend(this, props);\n\n    /**\n     * If the app has overwritten the addAuthTokenListener stub, forward\n     * the active token listeners on to the true fxn.\n     * \n     * TODO: This function is required due to our current module\n     * structure. Once we are able to rely strictly upon a single module\n     * implementation, this code should be refactored and Auth should \n     * provide these stubs and the upgrade logic\n     */\n    if (props.INTERNAL && props.INTERNAL.addAuthTokenListener) {\n      tokenListeners.forEach(listener => {\n        this.INTERNAL.addAuthTokenListener(listener);\n      });\n      tokenListeners = [];\n    }\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  private checkDestroyed_(): void {\n    if (this.isDeleted_) {\n      error('app-deleted', {'name': this.name_});\n    }\n  }\n};\n\n// Prevent dead-code elimination of these methods w/o invalid property\n// copying.\nFirebaseAppImpl.prototype.name &&\n  FirebaseAppImpl.prototype.options ||\n  FirebaseAppImpl.prototype.delete ||\n  console.log(\"dc\");\n\n/**\n * Return a firebase namespace object.\n *\n * In production, this will be called exactly once and the result\n * assigned to the 'firebase' global.  It may be called multiple times\n * in unit tests.\n */\nexport function createFirebaseNamespace(): FirebaseNamespace {\n  let apps_: {[name: string]: FirebaseApp} = {};\n  let factories: {[service: string]: FirebaseServiceFactory} = {};\n  let appHooks: {[service: string]: AppHook} = {};\n\n  // A namespace is a plain JavaScript Object.\n  let namespace = {\n    // Hack to prevent Babel from modifying the object returned\n    // as the firebase namespace.\n    '__esModule': true,\n    'initializeApp': initializeApp,\n    'app': app as any,\n    'apps': null as any,\n    'Promise': LocalPromise,\n    'SDK_VERSION': '4.1.2',\n    'INTERNAL': {\n      'registerService': registerService,\n      'createFirebaseNamespace': createFirebaseNamespace,\n      'extendNamespace': extendNamespace,\n      'createSubscribe': createSubscribe,\n      'ErrorFactory': ErrorFactory,\n      'removeApp': removeApp,\n      'factories': factories,\n      'useAsService': useAsService,\n      'Promise': local.GoogPromise as typeof Promise,\n      'deepExtend': deepExtend,\n    }\n  };\n\n  // Inject a circular default export to allow Babel users who were previously\n  // using:\n  //\n  //   import firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase').default;\n  //\n  // instead of\n  //\n  //   import * as firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase');\n  patchProperty(namespace, 'default', namespace);\n\n  // firebase.apps is a read-only getter.\n  Object.defineProperty(namespace, 'apps', {\n    get: getApps\n  });\n\n  /**\n   * Called by App.delete() - but before any services associated with the App\n   * are deleted.\n   */\n  function removeApp(name: string): void {\n    let app = apps_[name];\n    callAppHooks(app, 'delete');\n    delete apps_[name];\n  }\n\n  /**\n   * Get the App object for a given name (or DEFAULT).\n   */\n  function app(name?: string): FirebaseApp {\n    name = name || DEFAULT_ENTRY_NAME;\n    let result = apps_[name];\n    if (result === undefined) {\n      error('no-app', {'name': name});\n    }\n    return result;\n  }\n\n  patchProperty(app, 'App', FirebaseAppImpl);\n\n  /**\n   * Create a new App instance (name must be unique).\n   */\n  function initializeApp(options: FirebaseOptions, name?: string): FirebaseApp {\n    if (name === undefined) {\n      name = DEFAULT_ENTRY_NAME;\n    } else {\n      if (typeof name !== 'string' || name === '') {\n        error('bad-app-name', {'name': name + ''});\n      }\n    }\n    if (apps_[name!] !== undefined) {\n      error('duplicate-app', {'name': name});\n    }\n\n    let app = new FirebaseAppImpl(options, name!, namespace as FirebaseNamespace);\n\n    apps_[name!] = app;\n    callAppHooks(app, 'create');\n\n    return app;\n  }\n\n  /*\n   * Return an array of all the non-deleted FirebaseApps.\n   */\n  function getApps(): FirebaseApp[] {\n    // Make a copy so caller cannot mutate the apps list.\n    return Object.keys(apps_).map((name) => apps_[name]);\n  }\n\n  /*\n   * Register a Firebase Service.\n   *\n   * firebase.INTERNAL.registerService()\n   *\n   * TODO: Implement serviceProperties.\n   */\n  function registerService(\n      name: string, \n      createService: FirebaseServiceFactory,\n      serviceProperties?: {[prop: string]: any}, \n      appHook?: AppHook,\n      allowMultipleInstances?: boolean):\n      FirebaseServiceNamespace<FirebaseService> {\n    // Cannot re-register a service that already exists\n    if (factories[name]) {\n      error('duplicate-service', {'name': name});\n    }\n\n    // Capture the service factory for later service instantiation\n    factories[name] = createService;\n    \n    // Capture the appHook, if passed\n    if (appHook) {\n      appHooks[name] = appHook;\n\n      // Run the **new** app hook on all existing apps\n      getApps().forEach(app => {\n        appHook('create', app);\n      });\n    }\n\n    // The Service namespace is an accessor function ...\n    const serviceNamespace = (appArg: FirebaseApp = app()) => {\n      if (typeof(appArg as any)[name] !== 'function') {\n        // Invalid argument.\n        // This happens in the following case: firebase.storage('gs:/')\n        error('invalid-app-argument', {'name': name});\n      }\n\n      // Forward service instance lookup to the FirebaseApp.\n      return (appArg as any)[name]();\n    };\n\n    // ... and a container for service-level properties.\n    if (serviceProperties !== undefined) {\n      deepExtend(serviceNamespace, serviceProperties);\n    }\n\n    // Monkey-patch the serviceNamespace onto the firebase namespace\n    (namespace as any)[name] = serviceNamespace;\n\n    // Patch the FirebaseAppImpl prototype\n    FirebaseAppImpl.prototype[name] = function(...args) {\n      const serviceFxn = this._getService.bind(this, name);\n      return serviceFxn.apply(this, allowMultipleInstances ? args : []);\n    }\n\n    return serviceNamespace;\n  }\n\n  /**\n   * Patch the top-level firebase namespace with additional properties.\n   *\n   * firebase.INTERNAL.extendNamespace()\n   */\n  function extendNamespace(props: {[prop: string]: any}): void {\n    deepExtend(namespace, props);\n  }\n\n  function callAppHooks(app: FirebaseApp, eventName: string) {\n    Object.keys(factories).forEach((serviceName) => {\n      // Ignore virtual services\n      let factoryName = useAsService(app, serviceName);\n      if (factoryName === null) {\n        return;\n      }\n\n      if (appHooks[factoryName]) {\n        appHooks[factoryName](eventName, app);\n      }\n    });\n  }\n\n  // Map the requested service to a registered service name\n  // (used to map auth to serverAuth service when needed).\n  function useAsService(app: FirebaseApp, name: string): string | null {\n    if (name === 'serverAuth') {\n      return null;\n    }\n\n    let useService = name;\n    let options = app.options;\n\n    return useService;\n  }\n\n  return (namespace as any) as FirebaseNamespace;\n}\n\ntype AppError = 'no-app'|'bad-app-name'|'duplicate-app'|'app-deleted'|\n    'duplicate-service'|'sa-not-supported'|'invalid-app-argument';\n\nfunction error(code: AppError, args?: {[name: string]: any}) {\n  throw appErrors.create(code, args);\n}\n\n// TypeScript does not support non-string indexes!\n// let errors: {[code: AppError: string} = {\nlet errors: {[code: string]: string} = {\n  'no-app': 'No Firebase App \\'{$name}\\' has been created - ' +\n      'call Firebase App.initializeApp()',\n  'bad-app-name': 'Illegal App name: \\'{$name}',\n  'duplicate-app': 'Firebase App named \\'{$name}\\' already exists',\n  'app-deleted': 'Firebase App named \\'{$name}\\' already deleted',\n  'duplicate-service': 'Firebase service named \\'{$name}\\' already registered',\n  'sa-not-supported': 'Initializing the Firebase SDK with a service ' +\n      'account is only allowed in a Node.js environment. On client ' +\n      'devices, you should instead initialize the SDK with an api key and ' +\n      'auth domain',\n  'invalid-app-argument': 'firebase.{$name}() takes either no argument or a ' +\n      'Firebase App instance.'\n};\n\nlet appErrors = new ErrorFactory<AppError>('app', 'Firebase', errors);\n\n\n\n// WEBPACK FOOTER //\n// ./src/app/firebase_app.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * Do a deep-copy of basic JavaScript Objects or Arrays.\n */\nexport function deepCopy<T>(value: T): T {\n  return deepExtend(undefined, value);\n}\n\n/**\n * Copy properties from source to target (recursively allows extension\n * of Objects and Arrays).  Scalar values in the target are over-written.\n * If target is undefined, an object of the appropriate type will be created\n * (and returned).\n *\n * We recursively copy all child properties of plain Objects in the source- so\n * that namespace- like dictionaries are merged.\n *\n * Note that the target can be a function, in which case the properties in\n * the source Object are copied onto it as static properties of the Function.\n */\nexport function deepExtend(target: any, source: any): any {\n  if (!(source instanceof Object)) {\n    return source;\n  }\n\n  switch (source.constructor) {\n  case Date:\n    // Treat Dates like scalars; if the target date object had any child\n    // properties - they will be lost!\n    let dateValue = (source as any) as Date;\n    return new Date(dateValue.getTime());\n\n  case Object:\n    if (target === undefined) {\n      target = {};\n    }\n    break;\n\n  case Array:\n    // Always copy the array source and overwrite the target.\n    target = [];\n    break;\n\n  default:\n    // Not a plain Object - treat it as a scalar.\n    return source;\n  }\n\n  for (let prop in source) {\n    if (!source.hasOwnProperty(prop)) {\n      continue;\n    }\n    target[prop] = deepExtend(target[prop], source[prop]);\n  }\n\n  return target;\n}\n\n// TODO: Really needed (for JSCompiler type checking)?\nexport function patchProperty(obj: any, prop: string, value: any) {\n  obj[prop] = value;\n}\n\n\n// WEBPACK FOOTER //\n// ./src/app/deep_copy.ts","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n// Import the createFirebaseNamespace function\nimport { \n  createFirebaseNamespace,\n  FirebaseNamespace\n} from './app/firebase_app';\n\n// Export a single instance of firebase app\nconst firebase: FirebaseNamespace = createFirebaseNamespace();\n\nexport default firebase;\n\n\n// WEBPACK FOOTER //\n// ./src/app.ts","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/process/browser.js\n// module id = 51\n// module chunks = 2","(function (root) {\n\n  // Store setTimeout reference so promise-polyfill will be unaffected by\n  // other code modifying setTimeout (like sinon.useFakeTimers())\n  var setTimeoutFunc = setTimeout;\n\n  function noop() {}\n  \n  // Polyfill for Function.prototype.bind\n  function bind(fn, thisArg) {\n    return function () {\n      fn.apply(thisArg, arguments);\n    };\n  }\n\n  function Promise(fn) {\n    if (typeof this !== 'object') throw new TypeError('Promises must be constructed via new');\n    if (typeof fn !== 'function') throw new TypeError('not a function');\n    this._state = 0;\n    this._handled = false;\n    this._value = undefined;\n    this._deferreds = [];\n\n    doResolve(fn, this);\n  }\n\n  function handle(self, deferred) {\n    while (self._state === 3) {\n      self = self._value;\n    }\n    if (self._state === 0) {\n      self._deferreds.push(deferred);\n      return;\n    }\n    self._handled = true;\n    Promise._immediateFn(function () {\n      var cb = self._state === 1 ? deferred.onFulfilled : deferred.onRejected;\n      if (cb === null) {\n        (self._state === 1 ? resolve : reject)(deferred.promise, self._value);\n        return;\n      }\n      var ret;\n      try {\n        ret = cb(self._value);\n      } catch (e) {\n        reject(deferred.promise, e);\n        return;\n      }\n      resolve(deferred.promise, ret);\n    });\n  }\n\n  function resolve(self, newValue) {\n    try {\n      // Promise Resolution Procedure: https://github.com/promises-aplus/promises-spec#the-promise-resolution-procedure\n      if (newValue === self) throw new TypeError('A promise cannot be resolved with itself.');\n      if (newValue && (typeof newValue === 'object' || typeof newValue === 'function')) {\n        var then = newValue.then;\n        if (newValue instanceof Promise) {\n          self._state = 3;\n          self._value = newValue;\n          finale(self);\n          return;\n        } else if (typeof then === 'function') {\n          doResolve(bind(then, newValue), self);\n          return;\n        }\n      }\n      self._state = 1;\n      self._value = newValue;\n      finale(self);\n    } catch (e) {\n      reject(self, e);\n    }\n  }\n\n  function reject(self, newValue) {\n    self._state = 2;\n    self._value = newValue;\n    finale(self);\n  }\n\n  function finale(self) {\n    if (self._state === 2 && self._deferreds.length === 0) {\n      Promise._immediateFn(function() {\n        if (!self._handled) {\n          Promise._unhandledRejectionFn(self._value);\n        }\n      });\n    }\n\n    for (var i = 0, len = self._deferreds.length; i < len; i++) {\n      handle(self, self._deferreds[i]);\n    }\n    self._deferreds = null;\n  }\n\n  function Handler(onFulfilled, onRejected, promise) {\n    this.onFulfilled = typeof onFulfilled === 'function' ? onFulfilled : null;\n    this.onRejected = typeof onRejected === 'function' ? onRejected : null;\n    this.promise = promise;\n  }\n\n  /**\n   * Take a potentially misbehaving resolver function and make sure\n   * onFulfilled and onRejected are only called once.\n   *\n   * Makes no guarantees about asynchrony.\n   */\n  function doResolve(fn, self) {\n    var done = false;\n    try {\n      fn(function (value) {\n        if (done) return;\n        done = true;\n        resolve(self, value);\n      }, function (reason) {\n        if (done) return;\n        done = true;\n        reject(self, reason);\n      });\n    } catch (ex) {\n      if (done) return;\n      done = true;\n      reject(self, ex);\n    }\n  }\n\n  Promise.prototype['catch'] = function (onRejected) {\n    return this.then(null, onRejected);\n  };\n\n  Promise.prototype.then = function (onFulfilled, onRejected) {\n    var prom = new (this.constructor)(noop);\n\n    handle(this, new Handler(onFulfilled, onRejected, prom));\n    return prom;\n  };\n\n  Promise.all = function (arr) {\n    var args = Array.prototype.slice.call(arr);\n\n    return new Promise(function (resolve, reject) {\n      if (args.length === 0) return resolve([]);\n      var remaining = args.length;\n\n      function res(i, val) {\n        try {\n          if (val && (typeof val === 'object' || typeof val === 'function')) {\n            var then = val.then;\n            if (typeof then === 'function') {\n              then.call(val, function (val) {\n                res(i, val);\n              }, reject);\n              return;\n            }\n          }\n          args[i] = val;\n          if (--remaining === 0) {\n            resolve(args);\n          }\n        } catch (ex) {\n          reject(ex);\n        }\n      }\n\n      for (var i = 0; i < args.length; i++) {\n        res(i, args[i]);\n      }\n    });\n  };\n\n  Promise.resolve = function (value) {\n    if (value && typeof value === 'object' && value.constructor === Promise) {\n      return value;\n    }\n\n    return new Promise(function (resolve) {\n      resolve(value);\n    });\n  };\n\n  Promise.reject = function (value) {\n    return new Promise(function (resolve, reject) {\n      reject(value);\n    });\n  };\n\n  Promise.race = function (values) {\n    return new Promise(function (resolve, reject) {\n      for (var i = 0, len = values.length; i < len; i++) {\n        values[i].then(resolve, reject);\n      }\n    });\n  };\n\n  // Use polyfill for setImmediate for performance gains\n  Promise._immediateFn = (typeof setImmediate === 'function' && function (fn) { setImmediate(fn); }) ||\n    function (fn) {\n      setTimeoutFunc(fn, 0);\n    };\n\n  Promise._unhandledRejectionFn = function _unhandledRejectionFn(err) {\n    if (typeof console !== 'undefined' && console) {\n      console.warn('Possible Unhandled Promise Rejection:', err); // eslint-disable-line no-console\n    }\n  };\n\n  /**\n   * Set the immediate function to execute callbacks\n   * @param fn {function} Function to execute\n   * @deprecated\n   */\n  Promise._setImmediateFn = function _setImmediateFn(fn) {\n    Promise._immediateFn = fn;\n  };\n\n  /**\n   * Change the function to execute on unhandled rejection\n   * @param {function} fn Function to execute on unhandled rejection\n   * @deprecated\n   */\n  Promise._setUnhandledRejectionFn = function _setUnhandledRejectionFn(fn) {\n    Promise._unhandledRejectionFn = fn;\n  };\n  \n  if (typeof module !== 'undefined' && module.exports) {\n    module.exports = Promise;\n  } else if (!root.Promise) {\n    root.Promise = Promise;\n  }\n\n})(this);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/promise-polyfill/promise.js\n// module id = 52\n// module chunks = 2","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/setimmediate/setImmediate.js\n// module id = 53\n// module chunks = 2","var apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, window, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, window, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(window, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\nexports.setImmediate = setImmediate;\nexports.clearImmediate = clearImmediate;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/timers-browserify/main.js\n// module id = 54\n// module chunks = 2","/**\n* Copyright 2017 Google Inc.\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // Typescript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if (e.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\nexport type ErrorList<T> = {[code: string]: string};\n\nconst ERROR_NAME = 'FirebaseError';\n\nexport interface StringLike {\n  toString: () => string;\n}\n\nlet captureStackTrace: (obj: Object, fn?: Function) => void =\n  (Error as any).captureStackTrace;\n\n// Export for faking in tests\nexport function patchCapture(captureFake?: any): any {\n  let result: any = captureStackTrace;\n  captureStackTrace = captureFake;\n  return result;\n}\n\nexport interface FirebaseError {\n  // Unique code for error - format is service/error-code-string\n  code: string,\n\n  // Developer-friendly error message.\n  message: string,\n\n  // Always 'FirebaseError'\n  name: string,\n\n  // Where available - stack backtrace in a string\n  stack: string,\n}\n\nexport class FirebaseError implements FirebaseError {\n  public stack: string;\n  public name: string;\n\n  constructor(public code: string,\n              public message: string) {\n    let stack: string;\n    // We want the stack value, if implemented by Error\n    if (captureStackTrace) {\n      // Patches this.stack, omitted calls above ErrorFactory#create\n      captureStackTrace(this, ErrorFactory.prototype.create);\n    } else {\n      let err = Error.apply(this, arguments);\n      this.name = ERROR_NAME;\n      // Make non-enumerable getter for the property.\n      Object.defineProperty(this, 'stack', {\n        get: function() {\n          return err.stack;\n        }\n      });\n    }\n  }\n}\n\n// Back-door inheritance\nFirebaseError.prototype = Object.create(Error.prototype) as FirebaseError;\nFirebaseError.prototype.constructor = FirebaseError;\n(FirebaseError.prototype as any).name = ERROR_NAME;\n\nexport class ErrorFactory<T extends string> {\n  // Matches {$name}, by default.\n  public pattern = /\\{\\$([^}]+)}/g\n\n  constructor(private service: string,\n              private serviceName: string,\n              private errors: ErrorList<T>) {\n    // empty\n  }\n\n  create(code: T, data?: {[prop: string]: StringLike}): FirebaseError {\n    if (data === undefined) {\n      data = {};\n    }\n\n    let template = this.errors[(code as string)];\n\n    let fullCode = this.service + '/' + code;\n    let message: string;\n\n    if (template === undefined) {\n      message = \"Error\";\n    } else {\n      message = template.replace(this.pattern, (match, key) => {\n        let value = data![key];\n        return value !== undefined ? value.toString()\n          : '<' + key + '?>';\n      });\n    }\n\n    // Service: Error message (service/code).\n    message = this.serviceName + ': ' + message + ' (' + fullCode + ').';\n    let err = new FirebaseError(fullCode, message);\n\n    // Populate the Error object with message parts for programmatic\n    // accesses (e.g., e.file).\n    for (let prop in data) {\n      if (!data.hasOwnProperty(prop) || prop.slice(-1) === '_') {\n        continue;\n      }\n      (err as any)[prop] = data[prop];\n    }\n\n    return err;\n  }\n}\n\n\n// WEBPACK FOOTER //\n// ./src/app/errors.ts"],"sourceRoot":""}