![](\"./img/concatMap.png\")
\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. Each new inner Observable is\n * concatenated with the previous inner Observable.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMap` is equivalent to `mergeMap` with concurrency parameter set\n * to `1`.\n *\n * @example ![](\"./img/combineLatest.png\")
\n *\n * `combineLatest` combines the values from this Observable with values from\n * Observables passed as arguments. This is done by subscribing to each\n * Observable, in order, and collecting an array of each of the most recent\n * values any time any of the input Observables emits, then either taking that\n * array and passing it as arguments to an optional `project` function and\n * emitting the return value of that, or just emitting the array of recent\n * values directly if there is no `project` function.\n *\n * @example ![](\"./img/buffer.png\")
\n *\n * Buffers the incoming Observable values until the given `closingNotifier`\n * Observable emits a value, at which point it emits the buffer on the output\n * Observable and starts a new buffer internally, awaiting the next time\n * `closingNotifier` emits.\n *\n * @example ![](\"./img/materialize.png\")
\n *\n * `materialize` returns an Observable that emits a `next` notification for each\n * `next`, `error`, or `complete` emission of the source Observable. When the\n * source Observable emits `complete`, the output Observable will emit `next` as\n * a Notification of type \"complete\", and then it will emit `complete` as well.\n * When the source Observable emits `error`, the output will emit `next` as a\n * Notification of type \"error\", and then `complete`.\n *\n * This operator is useful for producing metadata of the source Observable, to\n * be consumed as `next` emissions. Use it in conjunction with\n * {@link dematerialize}.\n *\n * @example ![](\"./img/timeoutWith.png\")
\n *\n * `timeoutWith` is a variation of `timeout` operator. It behaves exactly the same,\n * still accepting as a first argument either a number or a Date, which control - respectively -\n * when values of source Observable should be emitted or when it should complete.\n *\n * The only difference is that it accepts a second, required parameter. This parameter\n * should be an Observable which will be subscribed when source Observable fails any timeout check.\n * So whenever regular `timeout` would emit an error, `timeoutWith` will instead start re-emitting\n * values from second Observable. Note that this fallback Observable is not checked for timeouts\n * itself, so it can emit values and complete at arbitrary points in time. From the moment of a second\n * subscription, Observable returned from `timeoutWith` simply mirrors fallback stream. When that\n * stream completes, it completes as well.\n *\n * Scheduler, which in case of `timeout` is provided as as second argument, can be still provided\n * here - as a third, optional parameter. It still is used to schedule timeout checks and -\n * as a consequence - when second Observable will be subscribed, since subscription happens\n * immediately after failing check.\n *\n * @example \n *
`})\n * export class Zippy {\n * visible: boolean = true;\n * \\@Output() open: EventEmitterToggle
\n * \n *
\n * Demo: NgZone
\n *\n *Progress: {{progress}}%
\n *= 100\">Done processing {{label}} of Angular zone!
\n *\n * \n * \n * `,\n * })\n * export class NgZoneDemo {\n * progress: number = 0;\n * label: string;\n *\n * constructor(private _ngZone: NgZone) {}\n *\n * // Loop inside the Angular zone\n * // so the UI DOES refresh after each setTimeout cycle\n * processWithinAngularZone() {\n * this.label = 'inside';\n * this.progress = 0;\n * this._increaseProgress(() => console.log('Inside Done!'));\n * }\n *\n * // Loop outside of the Angular zone\n * // so the UI DOES NOT refresh after each setTimeout cycle\n * processOutsideOfAngularZone() {\n * this.label = 'outside';\n * this.progress = 0;\n * this._ngZone.runOutsideAngular(() => {\n * this._increaseProgress(() => {\n * // reenter the Angular zone and display done\n * this._ngZone.run(() => {console.log('Outside Done!') });\n * }}));\n * }\n *\n * _increaseProgress(doneCallback: () => void) {\n * this.progress += 1;\n * console.log(`Current progress: ${this.progress}%`);\n *\n * if (this.progress < 100) {\n * window.setTimeout(() => this._increaseProgress(doneCallback)), 10)\n * } else {\n * doneCallback();\n * }\n * }\n * }\n * ```\n *\n * \\@experimental\n */\nvar NgZone = (function () {\n /**\n * @param {?} __0\n */\n function NgZone(_a) {\n var _b = _a.enableLongStackTrace, enableLongStackTrace = _b === void 0 ? false : _b;\n this.hasPendingMicrotasks = false;\n this.hasPendingMacrotasks = false;\n /**\n * Whether there are no outstanding microtasks or macrotasks.\n */\n this.isStable = true;\n /**\n * Notifies when code enters Angular Zone. This gets fired first on VM Turn.\n */\n this.onUnstable = new EventEmitter(false);\n /**\n * Notifies when there is no more microtasks enqueue in the current VM Turn.\n * This is a hint for Angular to do change detection, which may enqueue more microtasks.\n * For this reason this event can fire multiple times per VM Turn.\n */\n this.onMicrotaskEmpty = new EventEmitter(false);\n /**\n * Notifies when the last `onMicrotaskEmpty` has run and there are no more microtasks, which\n * implies we are about to relinquish VM turn.\n * This event gets called just once.\n */\n this.onStable = new EventEmitter(false);\n /**\n * Notifies that an error has been delivered.\n */\n this.onError = new EventEmitter(false);\n if (typeof Zone == 'undefined') {\n throw new Error('Angular requires Zone.js prolyfill.');\n }\n Zone.assertZonePatched();\n var self = this;\n self._nesting = 0;\n self._outer = self._inner = Zone.current;\n if (Zone['wtfZoneSpec']) {\n self._inner = self._inner.fork(Zone['wtfZoneSpec']);\n }\n if (enableLongStackTrace && Zone['longStackTraceZoneSpec']) {\n self._inner = self._inner.fork(Zone['longStackTraceZoneSpec']);\n }\n forkInnerZoneWithAngularBehavior(self);\n }\n /**\n * @return {?}\n */\n NgZone.isInAngularZone = function () { return Zone.current.get('isAngularZone') === true; };\n /**\n * @return {?}\n */\n NgZone.assertInAngularZone = function () {\n if (!NgZone.isInAngularZone()) {\n throw new Error('Expected to be in Angular Zone, but it is not!');\n }\n };\n /**\n * @return {?}\n */\n NgZone.assertNotInAngularZone = function () {\n if (NgZone.isInAngularZone()) {\n throw new Error('Expected to not be in Angular Zone, but it is!');\n }\n };\n /**\n * Executes the `fn` function synchronously within the Angular zone and returns value returned by\n * the function.\n *\n * Running functions via `run` allows you to reenter Angular zone from a task that was executed\n * outside of the Angular zone (typically started via {\\@link #runOutsideAngular}).\n *\n * Any future tasks or microtasks scheduled from within this function will continue executing from\n * within the Angular zone.\n *\n * If a synchronous error happens it will be rethrown and not reported via `onError`.\n * @param {?} fn\n * @return {?}\n */\n NgZone.prototype.run = function (fn) { return (((this)))._inner.run(fn); };\n /**\n * Same as `run`, except that synchronous errors are caught and forwarded via `onError` and not\n * rethrown.\n * @param {?} fn\n * @return {?}\n */\n NgZone.prototype.runGuarded = function (fn) { return (((this)))._inner.runGuarded(fn); };\n /**\n * Executes the `fn` function synchronously in Angular's parent zone and returns value returned by\n * the function.\n *\n * Running functions via {\\@link #runOutsideAngular} allows you to escape Angular's zone and do\n * work that\n * doesn't trigger Angular change-detection or is subject to Angular's error handling.\n *\n * Any future tasks or microtasks scheduled from within this function will continue executing from\n * outside of the Angular zone.\n *\n * Use {\\@link #run} to reenter the Angular zone and do work that updates the application model.\n * @param {?} fn\n * @return {?}\n */\n NgZone.prototype.runOutsideAngular = function (fn) { return (((this)))._outer.run(fn); };\n return NgZone;\n}());\n/**\n * @param {?} zone\n * @return {?}\n */\nfunction checkStable(zone) {\n if (zone._nesting == 0 && !zone.hasPendingMicrotasks && !zone.isStable) {\n try {\n zone._nesting++;\n zone.onMicrotaskEmpty.emit(null);\n }\n finally {\n zone._nesting--;\n if (!zone.hasPendingMicrotasks) {\n try {\n zone.runOutsideAngular(function () { return zone.onStable.emit(null); });\n }\n finally {\n zone.isStable = true;\n }\n }\n }\n }\n}\n/**\n * @param {?} zone\n * @return {?}\n */\nfunction forkInnerZoneWithAngularBehavior(zone) {\n zone._inner = zone._inner.fork({\n name: 'angular',\n properties: /** @type {?} */ ({ 'isAngularZone': true }),\n onInvokeTask: function (delegate, current, target, task, applyThis, applyArgs) {\n try {\n onEnter(zone);\n return delegate.invokeTask(target, task, applyThis, applyArgs);\n }\n finally {\n onLeave(zone);\n }\n },\n onInvoke: function (delegate, current, target, callback, applyThis, applyArgs, source) {\n try {\n onEnter(zone);\n return delegate.invoke(target, callback, applyThis, applyArgs, source);\n }\n finally {\n onLeave(zone);\n }\n },\n onHasTask: function (delegate, current, target, hasTaskState) {\n delegate.hasTask(target, hasTaskState);\n if (current === target) {\n // We are only interested in hasTask events which originate from our zone\n // (A child hasTask event is not interesting to us)\n if (hasTaskState.change == 'microTask') {\n zone.hasPendingMicrotasks = hasTaskState.microTask;\n checkStable(zone);\n }\n else if (hasTaskState.change == 'macroTask') {\n zone.hasPendingMacrotasks = hasTaskState.macroTask;\n }\n }\n },\n onHandleError: function (delegate, current, target, error) {\n delegate.handleError(target, error);\n zone.runOutsideAngular(function () { return zone.onError.emit(error); });\n return false;\n }\n });\n}\n/**\n * @param {?} zone\n * @return {?}\n */\nfunction onEnter(zone) {\n zone._nesting++;\n if (zone.isStable) {\n zone.isStable = false;\n zone.onUnstable.emit(null);\n }\n}\n/**\n * @param {?} zone\n * @return {?}\n */\nfunction onLeave(zone) {\n zone._nesting--;\n checkStable(zone);\n}\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * The Testability service provides testing hooks that can be accessed from\n * the browser and by services such as Protractor. Each bootstrapped Angular\n * application on the page will have an instance of Testability.\n * \\@experimental\n */\nvar Testability = (function () {\n /**\n * @param {?} _ngZone\n */\n function Testability(_ngZone) {\n this._ngZone = _ngZone;\n /**\n * \\@internal\n */\n this._pendingCount = 0;\n /**\n * \\@internal\n */\n this._isZoneStable = true;\n /**\n * Whether any work was done since the last 'whenStable' callback. This is\n * useful to detect if this could have potentially destabilized another\n * component while it is stabilizing.\n * \\@internal\n */\n this._didWork = false;\n /**\n * \\@internal\n */\n this._callbacks = [];\n this._watchAngularEvents();\n }\n /**\n * \\@internal\n * @return {?}\n */\n Testability.prototype._watchAngularEvents = function () {\n var _this = this;\n this._ngZone.onUnstable.subscribe({\n next: function () {\n _this._didWork = true;\n _this._isZoneStable = false;\n }\n });\n this._ngZone.runOutsideAngular(function () {\n _this._ngZone.onStable.subscribe({\n next: function () {\n NgZone.assertNotInAngularZone();\n scheduleMicroTask(function () {\n _this._isZoneStable = true;\n _this._runCallbacksIfReady();\n });\n }\n });\n });\n };\n /**\n * @return {?}\n */\n Testability.prototype.increasePendingRequestCount = function () {\n this._pendingCount += 1;\n this._didWork = true;\n return this._pendingCount;\n };\n /**\n * @return {?}\n */\n Testability.prototype.decreasePendingRequestCount = function () {\n this._pendingCount -= 1;\n if (this._pendingCount < 0) {\n throw new Error('pending async requests below zero');\n }\n this._runCallbacksIfReady();\n return this._pendingCount;\n };\n /**\n * @return {?}\n */\n Testability.prototype.isStable = function () {\n return this._isZoneStable && this._pendingCount == 0 && !this._ngZone.hasPendingMacrotasks;\n };\n /**\n * \\@internal\n * @return {?}\n */\n Testability.prototype._runCallbacksIfReady = function () {\n var _this = this;\n if (this.isStable()) {\n // Schedules the call backs in a new frame so that it is always async.\n scheduleMicroTask(function () {\n while (_this._callbacks.length !== 0) {\n (((_this._callbacks.pop())))(_this._didWork);\n }\n _this._didWork = false;\n });\n }\n else {\n // Not Ready\n this._didWork = true;\n }\n };\n /**\n * @param {?} callback\n * @return {?}\n */\n Testability.prototype.whenStable = function (callback) {\n this._callbacks.push(callback);\n this._runCallbacksIfReady();\n };\n /**\n * @return {?}\n */\n Testability.prototype.getPendingRequestCount = function () { return this._pendingCount; };\n /**\n * @deprecated use findProviders\n * @param {?} using\n * @param {?} provider\n * @param {?} exactMatch\n * @return {?}\n */\n Testability.prototype.findBindings = function (using, provider, exactMatch) {\n // TODO(juliemr): implement.\n return [];\n };\n /**\n * @param {?} using\n * @param {?} provider\n * @param {?} exactMatch\n * @return {?}\n */\n Testability.prototype.findProviders = function (using, provider, exactMatch) {\n // TODO(juliemr): implement.\n return [];\n };\n return Testability;\n}());\nTestability.decorators = [\n { type: Injectable },\n];\n/**\n * @nocollapse\n */\nTestability.ctorParameters = function () { return [\n { type: NgZone, },\n]; };\n/**\n * A global registry of {\\@link Testability} instances for specific elements.\n * \\@experimental\n */\nvar TestabilityRegistry = (function () {\n function TestabilityRegistry() {\n /**\n * \\@internal\n */\n this._applications = new Map();\n _testabilityGetter.addToWindow(this);\n }\n /**\n * @param {?} token\n * @param {?} testability\n * @return {?}\n */\n TestabilityRegistry.prototype.registerApplication = function (token, testability) {\n this._applications.set(token, testability);\n };\n /**\n * @param {?} elem\n * @return {?}\n */\n TestabilityRegistry.prototype.getTestability = function (elem) { return this._applications.get(elem) || null; };\n /**\n * @return {?}\n */\n TestabilityRegistry.prototype.getAllTestabilities = function () { return Array.from(this._applications.values()); };\n /**\n * @return {?}\n */\n TestabilityRegistry.prototype.getAllRootElements = function () { return Array.from(this._applications.keys()); };\n /**\n * @param {?} elem\n * @param {?=} findInAncestors\n * @return {?}\n */\n TestabilityRegistry.prototype.findTestabilityInTree = function (elem, findInAncestors) {\n if (findInAncestors === void 0) { findInAncestors = true; }\n return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);\n };\n return TestabilityRegistry;\n}());\nTestabilityRegistry.decorators = [\n { type: Injectable },\n];\n/**\n * @nocollapse\n */\nTestabilityRegistry.ctorParameters = function () { return []; };\nvar _NoopGetTestability = (function () {\n function _NoopGetTestability() {\n }\n /**\n * @param {?} registry\n * @return {?}\n */\n _NoopGetTestability.prototype.addToWindow = function (registry) { };\n /**\n * @param {?} registry\n * @param {?} elem\n * @param {?} findInAncestors\n * @return {?}\n */\n _NoopGetTestability.prototype.findTestabilityInTree = function (registry, elem, findInAncestors) {\n return null;\n };\n return _NoopGetTestability;\n}());\n/**\n * Set the {\\@link GetTestability} implementation used by the Angular testing framework.\n * \\@experimental\n * @param {?} getter\n * @return {?}\n */\nfunction setTestabilityGetter(getter) {\n _testabilityGetter = getter;\n}\nvar _testabilityGetter = new _NoopGetTestability();\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nvar _devMode = true;\nvar _runModeLocked = false;\nvar _platform;\nvar ALLOW_MULTIPLE_PLATFORMS = new InjectionToken('AllowMultipleToken');\n/**\n * Disable Angular's development mode, which turns off assertions and other\n * checks within the framework.\n *\n * One important assertion this disables verifies that a change detection pass\n * does not result in additional changes to any bindings (also known as\n * unidirectional data flow).\n *\n * \\@stable\n * @return {?}\n */\nfunction enableProdMode() {\n if (_runModeLocked) {\n throw new Error('Cannot enable prod mode after platform setup.');\n }\n _devMode = false;\n}\n/**\n * Returns whether Angular is in development mode. After called once,\n * the value is locked and won't change any more.\n *\n * By default, this is true, unless a user calls `enableProdMode` before calling this.\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @return {?}\n */\nfunction isDevMode() {\n _runModeLocked = true;\n return _devMode;\n}\n/**\n * A token for third-party components that can register themselves with NgProbe.\n *\n * \\@experimental\n */\nvar NgProbeToken = (function () {\n /**\n * @param {?} name\n * @param {?} token\n */\n function NgProbeToken(name, token) {\n this.name = name;\n this.token = token;\n }\n return NgProbeToken;\n}());\n/**\n * Creates a platform.\n * Platforms have to be eagerly created via this function.\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @param {?} injector\n * @return {?}\n */\nfunction createPlatform(injector) {\n if (_platform && !_platform.destroyed &&\n !_platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n throw new Error('There can be only one platform. Destroy the previous one to create a new one.');\n }\n _platform = injector.get(PlatformRef);\n var /** @type {?} */ inits = injector.get(PLATFORM_INITIALIZER, null);\n if (inits)\n inits.forEach(function (init) { return init(); });\n return _platform;\n}\n/**\n * Creates a factory for a platform\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @param {?} parentPlatformFactory\n * @param {?} name\n * @param {?=} providers\n * @return {?}\n */\nfunction createPlatformFactory(parentPlatformFactory, name, providers) {\n if (providers === void 0) { providers = []; }\n var /** @type {?} */ marker = new InjectionToken(\"Platform: \" + name);\n return function (extraProviders) {\n if (extraProviders === void 0) { extraProviders = []; }\n var /** @type {?} */ platform = getPlatform();\n if (!platform || platform.injector.get(ALLOW_MULTIPLE_PLATFORMS, false)) {\n if (parentPlatformFactory) {\n parentPlatformFactory(providers.concat(extraProviders).concat({ provide: marker, useValue: true }));\n }\n else {\n createPlatform(ReflectiveInjector.resolveAndCreate(providers.concat(extraProviders).concat({ provide: marker, useValue: true })));\n }\n }\n return assertPlatform(marker);\n };\n}\n/**\n * Checks that there currently is a platform which contains the given token as a provider.\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @param {?} requiredToken\n * @return {?}\n */\nfunction assertPlatform(requiredToken) {\n var /** @type {?} */ platform = getPlatform();\n if (!platform) {\n throw new Error('No platform exists!');\n }\n if (!platform.injector.get(requiredToken, null)) {\n throw new Error('A platform with a different configuration has been created. Please destroy it first.');\n }\n return platform;\n}\n/**\n * Destroy the existing platform.\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @return {?}\n */\nfunction destroyPlatform() {\n if (_platform && !_platform.destroyed) {\n _platform.destroy();\n }\n}\n/**\n * Returns the current platform.\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @return {?}\n */\nfunction getPlatform() {\n return _platform && !_platform.destroyed ? _platform : null;\n}\n/**\n * The Angular platform is the entry point for Angular on a web page. Each page\n * has exactly one platform, and services (such as reflection) which are common\n * to every Angular application running on the page are bound in its scope.\n *\n * A page's platform is initialized implicitly when a platform is created via a platform factory\n * (e.g. {\\@link platformBrowser}), or explicitly by calling the {\\@link createPlatform} function.\n *\n * \\@stable\n * @abstract\n */\nvar PlatformRef = (function () {\n function PlatformRef() {\n }\n /**\n * Creates an instance of an `\\@NgModule` for the given platform\n * for offline compilation.\n *\n * ## Simple Example\n *\n * ```typescript\n * my_module.ts:\n *\n * \\@NgModule({\n * imports: [BrowserModule]\n * })\n * class MyModule {}\n *\n * main.ts:\n * import {MyModuleNgFactory} from './my_module.ngfactory';\n * import {platformBrowser} from '\\@angular/platform-browser';\n *\n * let moduleRef = platformBrowser().bootstrapModuleFactory(MyModuleNgFactory);\n * ```\n *\n * \\@experimental APIs related to application bootstrap are currently under review.\n * @abstract\n * @template M\n * @param {?} moduleFactory\n * @return {?}\n */\n PlatformRef.prototype.bootstrapModuleFactory = function (moduleFactory) { };\n /**\n * Creates an instance of an `\\@NgModule` for a given platform using the given runtime compiler.\n *\n * ## Simple Example\n *\n * ```typescript\n * \\@NgModule({\n * imports: [BrowserModule]\n * })\n * class MyModule {}\n *\n * let moduleRef = platformBrowser().bootstrapModule(MyModule);\n * ```\n * \\@stable\n * @abstract\n * @template M\n * @param {?} moduleType\n * @param {?=} compilerOptions\n * @return {?}\n */\n PlatformRef.prototype.bootstrapModule = function (moduleType, compilerOptions) { };\n /**\n * Register a listener to be called when the platform is disposed.\n * @abstract\n * @param {?} callback\n * @return {?}\n */\n PlatformRef.prototype.onDestroy = function (callback) { };\n /**\n * Retrieve the platform {\\@link Injector}, which is the parent injector for\n * every Angular application on the page and provides singleton providers.\n * @abstract\n * @return {?}\n */\n PlatformRef.prototype.injector = function () { };\n /**\n * Destroy the Angular platform and all Angular applications on the page.\n * @abstract\n * @return {?}\n */\n PlatformRef.prototype.destroy = function () { };\n /**\n * @abstract\n * @return {?}\n */\n PlatformRef.prototype.destroyed = function () { };\n return PlatformRef;\n}());\n/**\n * @param {?} errorHandler\n * @param {?} ngZone\n * @param {?} callback\n * @return {?}\n */\nfunction _callAndReportToErrorHandler(errorHandler, ngZone, callback) {\n try {\n var /** @type {?} */ result = callback();\n if (isPromise(result)) {\n return result.catch(function (e) {\n ngZone.runOutsideAngular(function () { return errorHandler.handleError(e); });\n // rethrow as the exception handler might not do it\n throw e;\n });\n }\n return result;\n }\n catch (e) {\n ngZone.runOutsideAngular(function () { return errorHandler.handleError(e); });\n // rethrow as the exception handler might not do it\n throw e;\n }\n}\n/**\n * workaround https://github.com/angular/tsickle/issues/350\n * @suppress {checkTypes}\n */\nvar PlatformRef_ = (function (_super) {\n __WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __extends */](PlatformRef_, _super);\n /**\n * @param {?} _injector\n */\n function PlatformRef_(_injector) {\n var _this = _super.call(this) || this;\n _this._injector = _injector;\n _this._modules = [];\n _this._destroyListeners = [];\n _this._destroyed = false;\n return _this;\n }\n /**\n * @param {?} callback\n * @return {?}\n */\n PlatformRef_.prototype.onDestroy = function (callback) { this._destroyListeners.push(callback); };\n Object.defineProperty(PlatformRef_.prototype, \"injector\", {\n /**\n * @return {?}\n */\n get: function () { return this._injector; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(PlatformRef_.prototype, \"destroyed\", {\n /**\n * @return {?}\n */\n get: function () { return this._destroyed; },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n PlatformRef_.prototype.destroy = function () {\n if (this._destroyed) {\n throw new Error('The platform has already been destroyed!');\n }\n this._modules.slice().forEach(function (module) { return module.destroy(); });\n this._destroyListeners.forEach(function (listener) { return listener(); });\n this._destroyed = true;\n };\n /**\n * @template M\n * @param {?} moduleFactory\n * @return {?}\n */\n PlatformRef_.prototype.bootstrapModuleFactory = function (moduleFactory) {\n return this._bootstrapModuleFactoryWithZone(moduleFactory);\n };\n /**\n * @template M\n * @param {?} moduleFactory\n * @param {?=} ngZone\n * @return {?}\n */\n PlatformRef_.prototype._bootstrapModuleFactoryWithZone = function (moduleFactory, ngZone) {\n var _this = this;\n // Note: We need to create the NgZone _before_ we instantiate the module,\n // as instantiating the module creates some providers eagerly.\n // So we create a mini parent injector that just contains the new NgZone and\n // pass that as parent to the NgModuleFactory.\n if (!ngZone)\n ngZone = new NgZone({ enableLongStackTrace: isDevMode() });\n // Attention: Don't use ApplicationRef.run here,\n // as we want to be sure that all possible constructor calls are inside `ngZone.run`!\n return ngZone.run(function () {\n var /** @type {?} */ ngZoneInjector = ReflectiveInjector.resolveAndCreate([{ provide: NgZone, useValue: ngZone }], _this.injector);\n var /** @type {?} */ moduleRef = (moduleFactory.create(ngZoneInjector));\n var /** @type {?} */ exceptionHandler = moduleRef.injector.get(ErrorHandler, null);\n if (!exceptionHandler) {\n throw new Error('No ErrorHandler. Is platform module (BrowserModule) included?');\n }\n moduleRef.onDestroy(function () { return remove(_this._modules, moduleRef); }); /** @type {?} */\n ((ngZone)).runOutsideAngular(function () { return ((ngZone)).onError.subscribe({ next: function (error) { exceptionHandler.handleError(error); } }); });\n return _callAndReportToErrorHandler(exceptionHandler, /** @type {?} */ ((ngZone)), function () {\n var /** @type {?} */ initStatus = moduleRef.injector.get(ApplicationInitStatus);\n initStatus.runInitializers();\n return initStatus.donePromise.then(function () {\n _this._moduleDoBootstrap(moduleRef);\n return moduleRef;\n });\n });\n });\n };\n /**\n * @template M\n * @param {?} moduleType\n * @param {?=} compilerOptions\n * @return {?}\n */\n PlatformRef_.prototype.bootstrapModule = function (moduleType, compilerOptions) {\n if (compilerOptions === void 0) { compilerOptions = []; }\n return this._bootstrapModuleWithZone(moduleType, compilerOptions);\n };\n /**\n * @template M\n * @param {?} moduleType\n * @param {?=} compilerOptions\n * @param {?=} ngZone\n * @return {?}\n */\n PlatformRef_.prototype._bootstrapModuleWithZone = function (moduleType, compilerOptions, ngZone) {\n var _this = this;\n if (compilerOptions === void 0) { compilerOptions = []; }\n var /** @type {?} */ compilerFactory = this.injector.get(CompilerFactory);\n var /** @type {?} */ compiler = compilerFactory.createCompiler(Array.isArray(compilerOptions) ? compilerOptions : [compilerOptions]);\n return compiler.compileModuleAsync(moduleType)\n .then(function (moduleFactory) { return _this._bootstrapModuleFactoryWithZone(moduleFactory, ngZone); });\n };\n /**\n * @param {?} moduleRef\n * @return {?}\n */\n PlatformRef_.prototype._moduleDoBootstrap = function (moduleRef) {\n var /** @type {?} */ appRef = (moduleRef.injector.get(ApplicationRef));\n if (moduleRef._bootstrapComponents.length > 0) {\n moduleRef._bootstrapComponents.forEach(function (f) { return appRef.bootstrap(f); });\n }\n else if (moduleRef.instance.ngDoBootstrap) {\n moduleRef.instance.ngDoBootstrap(appRef);\n }\n else {\n throw new Error(\"The module \" + stringify(moduleRef.instance.constructor) + \" was bootstrapped, but it does not declare \\\"@NgModule.bootstrap\\\" components nor a \\\"ngDoBootstrap\\\" method. \" +\n \"Please define one of these.\");\n }\n this._modules.push(moduleRef);\n };\n return PlatformRef_;\n}(PlatformRef));\nPlatformRef_.decorators = [\n { type: Injectable },\n];\n/**\n * @nocollapse\n */\nPlatformRef_.ctorParameters = function () { return [\n { type: Injector, },\n]; };\n/**\n * A reference to an Angular application running on a page.\n *\n * \\@stable\n * @abstract\n */\nvar ApplicationRef = (function () {\n function ApplicationRef() {\n }\n /**\n * Bootstrap a new component at the root level of the application.\n *\n * ### Bootstrap process\n *\n * When bootstrapping a new root component into an application, Angular mounts the\n * specified application component onto DOM elements identified by the [componentType]'s\n * selector and kicks off automatic change detection to finish initializing the component.\n *\n * Optionally, a component can be mounted onto a DOM element that does not match the\n * [componentType]'s selector.\n *\n * ### Example\n * {\\@example core/ts/platform/platform.ts region='longform'}\n * @abstract\n * @template C\n * @param {?} componentFactory\n * @param {?=} rootSelectorOrNode\n * @return {?}\n */\n ApplicationRef.prototype.bootstrap = function (componentFactory, rootSelectorOrNode) { };\n /**\n * Invoke this method to explicitly process change detection and its side-effects.\n *\n * In development mode, `tick()` also performs a second change detection cycle to ensure that no\n * further changes are detected. If additional changes are picked up during this second cycle,\n * bindings in the app have side-effects that cannot be resolved in a single change detection\n * pass.\n * In this case, Angular throws an error, since an Angular application can only have one change\n * detection pass during which all change detection must complete.\n * @abstract\n * @return {?}\n */\n ApplicationRef.prototype.tick = function () { };\n /**\n * Get a list of component types registered to this application.\n * This list is populated even before the component is created.\n * @abstract\n * @return {?}\n */\n ApplicationRef.prototype.componentTypes = function () { };\n /**\n * Get a list of components registered to this application.\n * @abstract\n * @return {?}\n */\n ApplicationRef.prototype.components = function () { };\n /**\n * Attaches a view so that it will be dirty checked.\n * The view will be automatically detached when it is destroyed.\n * This will throw if the view is already attached to a ViewContainer.\n * @abstract\n * @param {?} view\n * @return {?}\n */\n ApplicationRef.prototype.attachView = function (view) { };\n /**\n * Detaches a view from dirty checking again.\n * @abstract\n * @param {?} view\n * @return {?}\n */\n ApplicationRef.prototype.detachView = function (view) { };\n /**\n * Returns the number of attached views.\n * @abstract\n * @return {?}\n */\n ApplicationRef.prototype.viewCount = function () { };\n /**\n * Returns an Observable that indicates when the application is stable or unstable.\n * @abstract\n * @return {?}\n */\n ApplicationRef.prototype.isStable = function () { };\n return ApplicationRef;\n}());\n/**\n * workaround https://github.com/angular/tsickle/issues/350\n * @suppress {checkTypes}\n */\nvar ApplicationRef_ = (function (_super) {\n __WEBPACK_IMPORTED_MODULE_0_tslib__[\"a\" /* __extends */](ApplicationRef_, _super);\n /**\n * @param {?} _zone\n * @param {?} _console\n * @param {?} _injector\n * @param {?} _exceptionHandler\n * @param {?} _componentFactoryResolver\n * @param {?} _initStatus\n */\n function ApplicationRef_(_zone, _console, _injector, _exceptionHandler, _componentFactoryResolver, _initStatus) {\n var _this = _super.call(this) || this;\n _this._zone = _zone;\n _this._console = _console;\n _this._injector = _injector;\n _this._exceptionHandler = _exceptionHandler;\n _this._componentFactoryResolver = _componentFactoryResolver;\n _this._initStatus = _initStatus;\n _this._bootstrapListeners = [];\n _this._rootComponents = [];\n _this._rootComponentTypes = [];\n _this._views = [];\n _this._runningTick = false;\n _this._enforceNoNewChanges = false;\n _this._stable = true;\n _this._enforceNoNewChanges = isDevMode();\n _this._zone.onMicrotaskEmpty.subscribe({ next: function () { _this._zone.run(function () { _this.tick(); }); } });\n var isCurrentlyStable = new __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__[\"Observable\"](function (observer) {\n _this._stable = _this._zone.isStable && !_this._zone.hasPendingMacrotasks &&\n !_this._zone.hasPendingMicrotasks;\n _this._zone.runOutsideAngular(function () {\n observer.next(_this._stable);\n observer.complete();\n });\n });\n var isStable = new __WEBPACK_IMPORTED_MODULE_1_rxjs_Observable__[\"Observable\"](function (observer) {\n // Create the subscription to onStable outside the Angular Zone so that\n // the callback is run outside the Angular Zone.\n var stableSub;\n _this._zone.runOutsideAngular(function () {\n stableSub = _this._zone.onStable.subscribe(function () {\n NgZone.assertNotInAngularZone();\n // Check whether there are no pending macro/micro tasks in the next tick\n // to allow for NgZone to update the state.\n scheduleMicroTask(function () {\n if (!_this._stable && !_this._zone.hasPendingMacrotasks &&\n !_this._zone.hasPendingMicrotasks) {\n _this._stable = true;\n observer.next(true);\n }\n });\n });\n });\n var unstableSub = _this._zone.onUnstable.subscribe(function () {\n NgZone.assertInAngularZone();\n if (_this._stable) {\n _this._stable = false;\n _this._zone.runOutsideAngular(function () { observer.next(false); });\n }\n });\n return function () {\n stableSub.unsubscribe();\n unstableSub.unsubscribe();\n };\n });\n _this._isStable = Object(__WEBPACK_IMPORTED_MODULE_2_rxjs_observable_merge__[\"merge\"])(isCurrentlyStable, __WEBPACK_IMPORTED_MODULE_3_rxjs_operator_share__[\"share\"].call(isStable));\n return _this;\n }\n /**\n * @param {?} viewRef\n * @return {?}\n */\n ApplicationRef_.prototype.attachView = function (viewRef) {\n var /** @type {?} */ view = ((viewRef));\n this._views.push(view);\n view.attachToAppRef(this);\n };\n /**\n * @param {?} viewRef\n * @return {?}\n */\n ApplicationRef_.prototype.detachView = function (viewRef) {\n var /** @type {?} */ view = ((viewRef));\n remove(this._views, view);\n view.detachFromAppRef();\n };\n /**\n * @template C\n * @param {?} componentOrFactory\n * @param {?=} rootSelectorOrNode\n * @return {?}\n */\n ApplicationRef_.prototype.bootstrap = function (componentOrFactory, rootSelectorOrNode) {\n var _this = this;\n if (!this._initStatus.done) {\n throw new Error('Cannot bootstrap as there are still asynchronous initializers running. Bootstrap components in the `ngDoBootstrap` method of the root module.');\n }\n var /** @type {?} */ componentFactory;\n if (componentOrFactory instanceof ComponentFactory) {\n componentFactory = componentOrFactory;\n }\n else {\n componentFactory = ((this._componentFactoryResolver.resolveComponentFactory(componentOrFactory)));\n }\n this._rootComponentTypes.push(componentFactory.componentType);\n // Create a factory associated with the current module if it's not bound to some other\n var /** @type {?} */ ngModule = componentFactory instanceof ComponentFactoryBoundToModule ?\n null :\n this._injector.get(NgModuleRef);\n var /** @type {?} */ selectorOrNode = rootSelectorOrNode || componentFactory.selector;\n var /** @type {?} */ compRef = componentFactory.create(Injector.NULL, [], selectorOrNode, ngModule);\n compRef.onDestroy(function () { _this._unloadComponent(compRef); });\n var /** @type {?} */ testability = compRef.injector.get(Testability, null);\n if (testability) {\n compRef.injector.get(TestabilityRegistry)\n .registerApplication(compRef.location.nativeElement, testability);\n }\n this._loadComponent(compRef);\n if (isDevMode()) {\n this._console.log(\"Angular is running in the development mode. Call enableProdMode() to enable the production mode.\");\n }\n return compRef;\n };\n /**\n * @param {?} componentRef\n * @return {?}\n */\n ApplicationRef_.prototype._loadComponent = function (componentRef) {\n this.attachView(componentRef.hostView);\n this.tick();\n this._rootComponents.push(componentRef);\n // Get the listeners lazily to prevent DI cycles.\n var /** @type {?} */ listeners = this._injector.get(APP_BOOTSTRAP_LISTENER, []).concat(this._bootstrapListeners);\n listeners.forEach(function (listener) { return listener(componentRef); });\n };\n /**\n * @param {?} componentRef\n * @return {?}\n */\n ApplicationRef_.prototype._unloadComponent = function (componentRef) {\n this.detachView(componentRef.hostView);\n remove(this._rootComponents, componentRef);\n };\n /**\n * @return {?}\n */\n ApplicationRef_.prototype.tick = function () {\n var _this = this;\n if (this._runningTick) {\n throw new Error('ApplicationRef.tick is called recursively');\n }\n var /** @type {?} */ scope = ApplicationRef_._tickScope();\n try {\n this._runningTick = true;\n this._views.forEach(function (view) { return view.detectChanges(); });\n if (this._enforceNoNewChanges) {\n this._views.forEach(function (view) { return view.checkNoChanges(); });\n }\n }\n catch (e) {\n // Attention: Don't rethrow as it could cancel subscriptions to Observables!\n this._zone.runOutsideAngular(function () { return _this._exceptionHandler.handleError(e); });\n }\n finally {\n this._runningTick = false;\n wtfLeave(scope);\n }\n };\n /**\n * @return {?}\n */\n ApplicationRef_.prototype.ngOnDestroy = function () {\n // TODO(alxhub): Dispose of the NgZone.\n this._views.slice().forEach(function (view) { return view.destroy(); });\n };\n Object.defineProperty(ApplicationRef_.prototype, \"viewCount\", {\n /**\n * @return {?}\n */\n get: function () { return this._views.length; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ApplicationRef_.prototype, \"componentTypes\", {\n /**\n * @return {?}\n */\n get: function () { return this._rootComponentTypes; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ApplicationRef_.prototype, \"components\", {\n /**\n * @return {?}\n */\n get: function () { return this._rootComponents; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ApplicationRef_.prototype, \"isStable\", {\n /**\n * @return {?}\n */\n get: function () { return this._isStable; },\n enumerable: true,\n configurable: true\n });\n return ApplicationRef_;\n}(ApplicationRef));\n/**\n * \\@internal\n */\nApplicationRef_._tickScope = wtfCreateScope('ApplicationRef#tick()');\nApplicationRef_.decorators = [\n { type: Injectable },\n];\n/**\n * @nocollapse\n */\nApplicationRef_.ctorParameters = function () { return [\n { type: NgZone, },\n { type: Console, },\n { type: Injector, },\n { type: ErrorHandler, },\n { type: ComponentFactoryResolver, },\n { type: ApplicationInitStatus, },\n]; };\n/**\n * @template T\n * @param {?} list\n * @param {?} el\n * @return {?}\n */\nfunction remove(list, el) {\n var /** @type {?} */ index = list.indexOf(el);\n if (index > -1) {\n list.splice(index, 1);\n }\n}\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Public API for Zone\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @deprecated Use `RendererType2` (and `Renderer2`) instead.\n */\nvar RenderComponentType = (function () {\n /**\n * @param {?} id\n * @param {?} templateUrl\n * @param {?} slotCount\n * @param {?} encapsulation\n * @param {?} styles\n * @param {?} animations\n */\n function RenderComponentType(id, templateUrl, slotCount, encapsulation, styles, animations) {\n this.id = id;\n this.templateUrl = templateUrl;\n this.slotCount = slotCount;\n this.encapsulation = encapsulation;\n this.styles = styles;\n this.animations = animations;\n }\n return RenderComponentType;\n}());\n/**\n * @deprecated Debug info is handeled internally in the view engine now.\n * @abstract\n */\nvar RenderDebugInfo = (function () {\n function RenderDebugInfo() {\n }\n /**\n * @abstract\n * @return {?}\n */\n RenderDebugInfo.prototype.injector = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RenderDebugInfo.prototype.component = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RenderDebugInfo.prototype.providerTokens = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RenderDebugInfo.prototype.references = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RenderDebugInfo.prototype.context = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RenderDebugInfo.prototype.source = function () { };\n return RenderDebugInfo;\n}());\n/**\n * @deprecated Use the `Renderer2` instead.\n * @abstract\n */\nvar Renderer = (function () {\n function Renderer() {\n }\n /**\n * @abstract\n * @param {?} selectorOrNode\n * @param {?=} debugInfo\n * @return {?}\n */\n Renderer.prototype.selectRootElement = function (selectorOrNode, debugInfo) { };\n /**\n * @abstract\n * @param {?} parentElement\n * @param {?} name\n * @param {?=} debugInfo\n * @return {?}\n */\n Renderer.prototype.createElement = function (parentElement, name, debugInfo) { };\n /**\n * @abstract\n * @param {?} hostElement\n * @return {?}\n */\n Renderer.prototype.createViewRoot = function (hostElement) { };\n /**\n * @abstract\n * @param {?} parentElement\n * @param {?=} debugInfo\n * @return {?}\n */\n Renderer.prototype.createTemplateAnchor = function (parentElement, debugInfo) { };\n /**\n * @abstract\n * @param {?} parentElement\n * @param {?} value\n * @param {?=} debugInfo\n * @return {?}\n */\n Renderer.prototype.createText = function (parentElement, value, debugInfo) { };\n /**\n * @abstract\n * @param {?} parentElement\n * @param {?} nodes\n * @return {?}\n */\n Renderer.prototype.projectNodes = function (parentElement, nodes) { };\n /**\n * @abstract\n * @param {?} node\n * @param {?} viewRootNodes\n * @return {?}\n */\n Renderer.prototype.attachViewAfter = function (node, viewRootNodes) { };\n /**\n * @abstract\n * @param {?} viewRootNodes\n * @return {?}\n */\n Renderer.prototype.detachView = function (viewRootNodes) { };\n /**\n * @abstract\n * @param {?} hostElement\n * @param {?} viewAllNodes\n * @return {?}\n */\n Renderer.prototype.destroyView = function (hostElement, viewAllNodes) { };\n /**\n * @abstract\n * @param {?} renderElement\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\n Renderer.prototype.listen = function (renderElement, name, callback) { };\n /**\n * @abstract\n * @param {?} target\n * @param {?} name\n * @param {?} callback\n * @return {?}\n */\n Renderer.prototype.listenGlobal = function (target, name, callback) { };\n /**\n * @abstract\n * @param {?} renderElement\n * @param {?} propertyName\n * @param {?} propertyValue\n * @return {?}\n */\n Renderer.prototype.setElementProperty = function (renderElement, propertyName, propertyValue) { };\n /**\n * @abstract\n * @param {?} renderElement\n * @param {?} attributeName\n * @param {?} attributeValue\n * @return {?}\n */\n Renderer.prototype.setElementAttribute = function (renderElement, attributeName, attributeValue) { };\n /**\n * Used only in debug mode to serialize property changes to dom nodes as attributes.\n * @abstract\n * @param {?} renderElement\n * @param {?} propertyName\n * @param {?} propertyValue\n * @return {?}\n */\n Renderer.prototype.setBindingDebugInfo = function (renderElement, propertyName, propertyValue) { };\n /**\n * @abstract\n * @param {?} renderElement\n * @param {?} className\n * @param {?} isAdd\n * @return {?}\n */\n Renderer.prototype.setElementClass = function (renderElement, className, isAdd) { };\n /**\n * @abstract\n * @param {?} renderElement\n * @param {?} styleName\n * @param {?} styleValue\n * @return {?}\n */\n Renderer.prototype.setElementStyle = function (renderElement, styleName, styleValue) { };\n /**\n * @abstract\n * @param {?} renderElement\n * @param {?} methodName\n * @param {?=} args\n * @return {?}\n */\n Renderer.prototype.invokeElementMethod = function (renderElement, methodName, args) { };\n /**\n * @abstract\n * @param {?} renderNode\n * @param {?} text\n * @return {?}\n */\n Renderer.prototype.setText = function (renderNode, text) { };\n /**\n * @abstract\n * @param {?} element\n * @param {?} startingStyles\n * @param {?} keyframes\n * @param {?} duration\n * @param {?} delay\n * @param {?} easing\n * @param {?=} previousPlayers\n * @return {?}\n */\n Renderer.prototype.animate = function (element, startingStyles, keyframes, duration, delay, easing, previousPlayers) { };\n return Renderer;\n}());\nvar Renderer2Interceptor = new InjectionToken('Renderer2Interceptor');\n/**\n * Injectable service that provides a low-level interface for modifying the UI.\n *\n * Use this service to bypass Angular's templating and make custom UI changes that can't be\n * expressed declaratively. For example if you need to set a property or an attribute whose name is\n * not statically known, use {\\@link Renderer#setElementProperty} or {\\@link\n * Renderer#setElementAttribute}\n * respectively.\n *\n * If you are implementing a custom renderer, you must implement this interface.\n *\n * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.\n *\n * @deprecated Use `RendererFactory2` instead.\n * @abstract\n */\nvar RootRenderer = (function () {\n function RootRenderer() {\n }\n /**\n * @abstract\n * @param {?} componentType\n * @return {?}\n */\n RootRenderer.prototype.renderComponent = function (componentType) { };\n return RootRenderer;\n}());\n/**\n * \\@experimental\n * @abstract\n */\nvar RendererFactory2 = (function () {\n function RendererFactory2() {\n }\n /**\n * @abstract\n * @param {?} hostElement\n * @param {?} type\n * @return {?}\n */\n RendererFactory2.prototype.createRenderer = function (hostElement, type) { };\n /**\n * @abstract\n * @return {?}\n */\n RendererFactory2.prototype.begin = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RendererFactory2.prototype.end = function () { };\n /**\n * @abstract\n * @return {?}\n */\n RendererFactory2.prototype.whenRenderingDone = function () { };\n return RendererFactory2;\n}());\nvar RendererStyleFlags2 = {};\nRendererStyleFlags2.Important = 1;\nRendererStyleFlags2.DashCase = 2;\nRendererStyleFlags2[RendererStyleFlags2.Important] = \"Important\";\nRendererStyleFlags2[RendererStyleFlags2.DashCase] = \"DashCase\";\n/**\n * \\@experimental\n * @abstract\n */\nvar Renderer2 = (function () {\n function Renderer2() {\n }\n /**\n * This field can be used to store arbitrary data on this renderer instance.\n * This is useful for renderers that delegate to other renderers.\n * @abstract\n * @return {?}\n */\n Renderer2.prototype.data = function () { };\n /**\n * @abstract\n * @return {?}\n */\n Renderer2.prototype.destroy = function () { };\n /**\n * @abstract\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\n Renderer2.prototype.createElement = function (name, namespace) { };\n /**\n * @abstract\n * @param {?} value\n * @return {?}\n */\n Renderer2.prototype.createComment = function (value) { };\n /**\n * @abstract\n * @param {?} value\n * @return {?}\n */\n Renderer2.prototype.createText = function (value) { };\n /**\n * @abstract\n * @param {?} parent\n * @param {?} newChild\n * @return {?}\n */\n Renderer2.prototype.appendChild = function (parent, newChild) { };\n /**\n * @abstract\n * @param {?} parent\n * @param {?} newChild\n * @param {?} refChild\n * @return {?}\n */\n Renderer2.prototype.insertBefore = function (parent, newChild, refChild) { };\n /**\n * @abstract\n * @param {?} parent\n * @param {?} oldChild\n * @return {?}\n */\n Renderer2.prototype.removeChild = function (parent, oldChild) { };\n /**\n * @abstract\n * @param {?} selectorOrNode\n * @return {?}\n */\n Renderer2.prototype.selectRootElement = function (selectorOrNode) { };\n /**\n * Attention: On WebWorkers, this will always return a value,\n * as we are asking for a result synchronously. I.e.\n * the caller can't rely on checking whether this is null or not.\n * @abstract\n * @param {?} node\n * @return {?}\n */\n Renderer2.prototype.parentNode = function (node) { };\n /**\n * Attention: On WebWorkers, this will always return a value,\n * as we are asking for a result synchronously. I.e.\n * the caller can't rely on checking whether this is null or not.\n * @abstract\n * @param {?} node\n * @return {?}\n */\n Renderer2.prototype.nextSibling = function (node) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @param {?=} namespace\n * @return {?}\n */\n Renderer2.prototype.setAttribute = function (el, name, value, namespace) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\n Renderer2.prototype.removeAttribute = function (el, name, namespace) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\n Renderer2.prototype.addClass = function (el, name) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\n Renderer2.prototype.removeClass = function (el, name) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} style\n * @param {?} value\n * @param {?=} flags\n * @return {?}\n */\n Renderer2.prototype.setStyle = function (el, style, value, flags) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} style\n * @param {?=} flags\n * @return {?}\n */\n Renderer2.prototype.removeStyle = function (el, style, flags) { };\n /**\n * @abstract\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\n Renderer2.prototype.setProperty = function (el, name, value) { };\n /**\n * @abstract\n * @param {?} node\n * @param {?} value\n * @return {?}\n */\n Renderer2.prototype.setValue = function (node, value) { };\n /**\n * @abstract\n * @param {?} target\n * @param {?} eventName\n * @param {?} callback\n * @return {?}\n */\n Renderer2.prototype.listen = function (target, eventName, callback) { };\n return Renderer2;\n}());\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n// Public API for render\nvar ElementRef = (function () {\n /**\n * @param {?} nativeElement\n */\n function ElementRef(nativeElement) {\n this.nativeElement = nativeElement;\n }\n return ElementRef;\n}());\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * Used to load ng module factories.\n * \\@stable\n * @abstract\n */\nvar NgModuleFactoryLoader = (function () {\n function NgModuleFactoryLoader() {\n }\n /**\n * @abstract\n * @param {?} path\n * @return {?}\n */\n NgModuleFactoryLoader.prototype.load = function (path) { };\n return NgModuleFactoryLoader;\n}());\nvar moduleFactories = new Map();\n/**\n * Registers a loaded module. Should only be called from generated NgModuleFactory code.\n * \\@experimental\n * @param {?} id\n * @param {?} factory\n * @return {?}\n */\nfunction registerModuleFactory(id, factory) {\n var /** @type {?} */ existing = moduleFactories.get(id);\n if (existing) {\n throw new Error(\"Duplicate module registered for \" + id + \" - \" + existing.moduleType.name + \" vs \" + factory.moduleType.name);\n }\n moduleFactories.set(id, factory);\n}\n/**\n * @return {?}\n */\n/**\n * Returns the NgModuleFactory with the given id, if it exists and has been loaded.\n * Factories for modules that do not specify an `id` cannot be retrieved. Throws if the module\n * cannot be found.\n * \\@experimental\n * @param {?} id\n * @return {?}\n */\nfunction getModuleFactory(id) {\n var /** @type {?} */ factory = moduleFactories.get(id);\n if (!factory)\n throw new Error(\"No module with ID \" + id + \" loaded\");\n return factory;\n}\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * An unmodifiable list of items that Angular keeps up to date when the state\n * of the application changes.\n *\n * The type of object that {\\@link ViewChildren}, {\\@link ContentChildren}, and {\\@link QueryList}\n * provide.\n *\n * Implements an iterable interface, therefore it can be used in both ES6\n * javascript `for (var i of items)` loops as well as in Angular templates with\n * `*ngFor=\"let i of myList\"`.\n *\n * Changes can be observed by subscribing to the changes `Observable`.\n *\n * NOTE: In the future this class will implement an `Observable` interface.\n *\n * ### Example ([live demo](http://plnkr.co/edit/RX8sJnQYl9FWuSCWme5z?p=preview))\n * ```typescript\n * \\@Component({...})\n * class Container {\n * \\@ViewChildren(Item) items:QueryList- \n *
- {{item}} \n *
- \n *
- \n *
- first \n *
- second \n *
...
\n * ```\n *\n * ## Disable Animations\n * A special animation control binding called `\\@.disabled` can be placed on an element which will\n * then disable animations for any inner animation triggers situated within the element as well as\n * any animations on the element itself.\n *\n * When true, the `\\@.disabled` binding will prevent all animations from rendering. The example\n * below shows how to use this feature:\n *\n * ```ts\n * \\@Component({\n * selector: 'my-component',\n * template: `\n * \n * \n *
\n * `,\n * animations: [\n * trigger(\"childAnimation\", [\n * // ...\n * ])\n * ]\n * })\n * class MyComponent {\n * isDisabled = true;\n * exp = '...';\n * }\n * ```\n *\n * The `\\@childAnimation` trigger will not animate because `\\@.disabled` prevents it from happening\n * (when true).\n *\n * Note that `\\@.disbled` will only disable all animations (this means any animations running on\n * the same element will also be disabled).\n *\n * ### Disabling Animations Application-wide\n * When an area of the template is set to have animations disabled, **all** inner components will\n * also have their animations disabled as well. This means that all animations for an angular\n * application can be disabled by placing a host binding set on `\\@.disabled` on the topmost Angular\n * component.\n *\n * ```ts\n * import {Component, HostBinding} from '\\@angular/core';\n *\n * \\@Component({\n * selector: 'app-component',\n * templateUrl: 'app.component.html',\n * })\n * class AppComponent {\n * \\@HostBinding('\\@.disabled')\n * public animationsDisabled = true;\n * }\n * ```\n *\n * ### What about animations that us `query()` and `animateChild()`?\n * Despite inner animations being disabled, a parent animation can {\\@link query query} for inner\n * elements located in disabled areas of the template and still animate them as it sees fit. This is\n * also the case for when a sub animation is queried by a parent and then later animated using {\\@link\n * animateChild animateChild}.\n *\n * \\@experimental Animation support is experimental.\n * @param {?} name\n * @param {?} definitions\n * @return {?}\n */\nfunction trigger$1(name, definitions) {\n return { type: 7 /* Trigger */, name: name, definitions: definitions, options: {} };\n}\n/**\n * `animate` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `animate` specifies an animation step that will apply the provided `styles` data for a given\n * amount of time based on the provided `timing` expression value. Calls to `animate` are expected\n * to be used within {\\@link sequence an animation sequence}, {\\@link group group}, or {\\@link\n * transition transition}.\n *\n * ### Usage\n *\n * The `animate` function accepts two input parameters: `timing` and `styles`:\n *\n * - `timing` is a string based value that can be a combination of a duration with optional delay\n * and easing values. The format for the expression breaks down to `duration delay easing`\n * (therefore a value such as `1s 100ms ease-out` will be parse itself into `duration=1000,\n * delay=100, easing=ease-out`. If a numeric value is provided then that will be used as the\n * `duration` value in millisecond form.\n * - `styles` is the style input data which can either be a call to {\\@link style style} or {\\@link\n * keyframes keyframes}. If left empty then the styles from the destination state will be collected\n * and used (this is useful when describing an animation step that will complete an animation by\n * {\\@link transition#the-final-animate-call animating to the final state}).\n *\n * ```typescript\n * // various functions for specifying timing data\n * animate(500, style(...))\n * animate(\"1s\", style(...))\n * animate(\"100ms 0.5s\", style(...))\n * animate(\"5s ease\", style(...))\n * animate(\"5s 10ms cubic-bezier(.17,.67,.88,.1)\", style(...))\n *\n * // either style() of keyframes() can be used\n * animate(500, style({ background: \"red\" }))\n * animate(500, keyframes([\n * style({ background: \"blue\" })),\n * style({ background: \"red\" }))\n * ])\n * ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} timings\n * @param {?=} styles\n * @return {?}\n */\nfunction animate$1(timings, styles) {\n if (styles === void 0) { styles = null; }\n return { type: 4 /* Animate */, styles: styles, timings: timings };\n}\n/**\n * `group` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `group` specifies a list of animation steps that are all run in parallel. Grouped animations are\n * useful when a series of styles must be animated/closed off at different starting/ending times.\n *\n * The `group` function can either be used within a {\\@link sequence sequence} or a {\\@link transition\n * transition} and it will only continue to the next instruction once all of the inner animation\n * steps have completed.\n *\n * ### Usage\n *\n * The `steps` data that is passed into the `group` animation function can either consist of {\\@link\n * style style} or {\\@link animate animate} function calls. Each call to `style()` or `animate()`\n * within a group will be executed instantly (use {\\@link keyframes keyframes} or a {\\@link\n * animate#usage animate() with a delay value} to offset styles to be applied at a later time).\n *\n * ```typescript\n * group([\n * animate(\"1s\", { background: \"black\" }))\n * animate(\"2s\", { color: \"white\" }))\n * ])\n * ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} steps\n * @param {?=} options\n * @return {?}\n */\nfunction group$1(steps, options) {\n if (options === void 0) { options = null; }\n return { type: 3 /* Group */, steps: steps, options: options };\n}\n/**\n * `sequence` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `sequence` Specifies a list of animation steps that are run one by one. (`sequence` is used by\n * default when an array is passed as animation data into {\\@link transition transition}.)\n *\n * The `sequence` function can either be used within a {\\@link group group} or a {\\@link transition\n * transition} and it will only continue to the next instruction once each of the inner animation\n * steps have completed.\n *\n * To perform animation styling in parallel with other animation steps then have a look at the\n * {\\@link group group} animation function.\n *\n * ### Usage\n *\n * The `steps` data that is passed into the `sequence` animation function can either consist of\n * {\\@link style style} or {\\@link animate animate} function calls. A call to `style()` will apply the\n * provided styling data immediately while a call to `animate()` will apply its styling data over a\n * given time depending on its timing data.\n *\n * ```typescript\n * sequence([\n * style({ opacity: 0 })),\n * animate(\"1s\", { opacity: 1 }))\n * ])\n * ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} steps\n * @param {?=} options\n * @return {?}\n */\nfunction sequence$1(steps, options) {\n if (options === void 0) { options = null; }\n return { type: 2 /* Sequence */, steps: steps, options: options };\n}\n/**\n * `style` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `style` declares a key/value object containing CSS properties/styles that can then be used for\n * {\\@link state animation states}, within an {\\@link sequence animation sequence}, or as styling data\n * for both {\\@link animate animate} and {\\@link keyframes keyframes}.\n *\n * ### Usage\n *\n * `style` takes in a key/value string map as data and expects one or more CSS property/value pairs\n * to be defined.\n *\n * ```typescript\n * // string values are used for css properties\n * style({ background: \"red\", color: \"blue\" })\n *\n * // numerical (pixel) values are also supported\n * style({ width: 100, height: 0 })\n * ```\n *\n * #### Auto-styles (using `*`)\n *\n * When an asterix (`*`) character is used as a value then it will be detected from the element\n * being animated and applied as animation data when the animation starts.\n *\n * This feature proves useful for a state depending on layout and/or environment factors; in such\n * cases the styles are calculated just before the animation starts.\n *\n * ```typescript\n * // the steps below will animate from 0 to the\n * // actual height of the element\n * style({ height: 0 }),\n * animate(\"1s\", style({ height: \"*\" }))\n * ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} tokens\n * @return {?}\n */\nfunction style$1(tokens) {\n return { type: 6 /* Style */, styles: tokens, offset: null };\n}\n/**\n * `state` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `state` declares an animation state within the given trigger. When a state is active within a\n * component then its associated styles will persist on the element that the trigger is attached to\n * (even when the animation ends).\n *\n * To animate between states, have a look at the animation {\\@link transition transition} DSL\n * function. To register states to an animation trigger please have a look at the {\\@link trigger\n * trigger} function.\n *\n * #### The `void` state\n *\n * The `void` state value is a reserved word that angular uses to determine when the element is not\n * apart of the application anymore (e.g. when an `ngIf` evaluates to false then the state of the\n * associated element is void).\n *\n * #### The `*` (default) state\n *\n * The `*` state (when styled) is a fallback state that will be used if the state that is being\n * animated is not declared within the trigger.\n *\n * ### Usage\n *\n * `state` will declare an animation state with its associated styles\n * within the given trigger.\n *\n * - `stateNameExpr` can be one or more state names separated by commas.\n * - `styles` refers to the {\\@link style styling data} that will be persisted on the element once\n * the state has been reached.\n *\n * ```typescript\n * // \"void\" is a reserved name for a state and is used to represent\n * // the state in which an element is detached from from the application.\n * state(\"void\", style({ height: 0 }))\n *\n * // user-defined states\n * state(\"closed\", style({ height: 0 }))\n * state(\"open, visible\", style({ height: \"*\" }))\n * ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} name\n * @param {?} styles\n * @param {?=} options\n * @return {?}\n */\nfunction state$1(name, styles, options) {\n return { type: 0 /* State */, name: name, styles: styles, options: options };\n}\n/**\n * `keyframes` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `keyframes` specifies a collection of {\\@link style style} entries each optionally characterized\n * by an `offset` value.\n *\n * ### Usage\n *\n * The `keyframes` animation function is designed to be used alongside the {\\@link animate animate}\n * animation function. Instead of applying animations from where they are currently to their\n * destination, keyframes can describe how each style entry is applied and at what point within the\n * animation arc (much like CSS Keyframe Animations do).\n *\n * For each `style()` entry an `offset` value can be set. Doing so allows to specifiy at what\n * percentage of the animate time the styles will be applied.\n *\n * ```typescript\n * // the provided offset values describe when each backgroundColor value is applied.\n * animate(\"5s\", keyframes([\n * style({ backgroundColor: \"red\", offset: 0 }),\n * style({ backgroundColor: \"blue\", offset: 0.2 }),\n * style({ backgroundColor: \"orange\", offset: 0.3 }),\n * style({ backgroundColor: \"black\", offset: 1 })\n * ]))\n * ```\n *\n * Alternatively, if there are no `offset` values used within the style entries then the offsets\n * will be calculated automatically.\n *\n * ```typescript\n * animate(\"5s\", keyframes([\n * style({ backgroundColor: \"red\" }) // offset = 0\n * style({ backgroundColor: \"blue\" }) // offset = 0.33\n * style({ backgroundColor: \"orange\" }) // offset = 0.66\n * style({ backgroundColor: \"black\" }) // offset = 1\n * ]))\n * ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} steps\n * @return {?}\n */\nfunction keyframes$1(steps) {\n return { type: 5 /* Keyframes */, steps: steps };\n}\n/**\n * `transition` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations component animations metadata page} to gain a better understanding of\n * how animations in Angular are used.\n *\n * `transition` declares the {\\@link sequence sequence of animation steps} that will be run when the\n * provided `stateChangeExpr` value is satisfied. The `stateChangeExpr` consists of a `state1 =>\n * state2` which consists of two known states (use an asterix (`*`) to refer to a dynamic starting\n * and/or ending state).\n *\n * A function can also be provided as the `stateChangeExpr` argument for a transition and this\n * function will be executed each time a state change occurs. If the value returned within the\n * function is true then the associated animation will be run.\n *\n * Animation transitions are placed within an {\\@link trigger animation trigger}. For an transition\n * to animate to a state value and persist its styles then one or more {\\@link state animation\n * states} is expected to be defined.\n *\n * ### Usage\n *\n * An animation transition is kicked off the `stateChangeExpr` predicate evaluates to true based on\n * what the previous state is and what the current state has become. In other words, if a transition\n * is defined that matches the old/current state criteria then the associated animation will be\n * triggered.\n *\n * ```typescript\n * // all transition/state changes are defined within an animation trigger\n * trigger(\"myAnimationTrigger\", [\n * // if a state is defined then its styles will be persisted when the\n * // animation has fully completed itself\n * state(\"on\", style({ background: \"green\" })),\n * state(\"off\", style({ background: \"grey\" })),\n *\n * // a transition animation that will be kicked off when the state value\n * // bound to \"myAnimationTrigger\" changes from \"on\" to \"off\"\n * transition(\"on => off\", animate(500)),\n *\n * // it is also possible to do run the same animation for both directions\n * transition(\"on <=> off\", animate(500)),\n *\n * // or to define multiple states pairs separated by commas\n * transition(\"on => off, off => void\", animate(500)),\n *\n * // this is a catch-all state change for when an element is inserted into\n * // the page and the destination state is unknown\n * transition(\"void => *\", [\n * style({ opacity: 0 }),\n * animate(500)\n * ]),\n *\n * // this will capture a state change between any states\n * transition(\"* => *\", animate(\"1s 0s\")),\n *\n * // you can also go full out and include a function\n * transition((fromState, toState) => {\n * // when `true` then it will allow the animation below to be invoked\n * return fromState == \"off\" && toState == \"on\";\n * }, animate(\"1s 0s\"))\n * ])\n * ```\n *\n * The template associated with this component will make use of the `myAnimationTrigger` animation\n * trigger by binding to an element within its template code.\n *\n * ```html\n * \n * ...
\n * ```\n *\n * #### The final `animate` call\n *\n * If the final step within the transition steps is a call to `animate()` that **only** uses a\n * timing value with **no style data** then it will be automatically used as the final animation arc\n * for the element to animate itself to the final state. This involves an automatic mix of\n * adding/removing CSS styles so that the element will be in the exact state it should be for the\n * applied state to be presented correctly.\n *\n * ```\n * // start off by hiding the element, but make sure that it animates properly to whatever state\n * // is currently active for \"myAnimationTrigger\"\n * transition(\"void => *\", [\n * style({ opacity: 0 }),\n * animate(500)\n * ])\n * ```\n *\n * ### Transition Aliases (`:enter` and `:leave`)\n *\n * Given that enter (insertion) and leave (removal) animations are so common, the `transition`\n * function accepts both `:enter` and `:leave` values which are aliases for the `void => *` and `*\n * => void` state changes.\n *\n * ```\n * transition(\":enter\", [\n * style({ opacity: 0 }),\n * animate(500, style({ opacity: 1 }))\n * ])\n * transition(\":leave\", [\n * animate(500, style({ opacity: 0 }))\n * ])\n * ```\n *\n * ### Boolean values\n * if a trigger binding value is a boolean value then it can be matched using a transition\n * expression that compares `true` and `false` or `1` and `0`.\n *\n * ```\n * // in the template\n * ...
\n *\n * // in the component metadata\n * trigger('openClose', [\n * state('true', style({ height: '*' })),\n * state('false', style({ height: '0px' })),\n * transition('false <=> true', animate(500))\n * ])\n * ```\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} stateChangeExpr\n * @param {?} steps\n * @param {?=} options\n * @return {?}\n */\nfunction transition$1(stateChangeExpr, steps, options) {\n if (options === void 0) { options = null; }\n return { type: 1 /* Transition */, expr: stateChangeExpr, animation: steps, options: options };\n}\n/**\n * `animation` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language.\n *\n * `var myAnimation = animation(...)` is designed to produce a reusable animation that can be later\n * invoked in another animation or sequence. Reusable animations are designed to make use of\n * animation parameters and the produced animation can be used via the `useAnimation` method.\n *\n * ```\n * var fadeAnimation = animation([\n * style({ opacity: '{{ start }}' }),\n * animate('{{ time }}',\n * style({ opacity: '{{ end }}'}))\n * ], { params: { time: '1000ms', start: 0, end: 1 }});\n * ```\n *\n * If parameters are attached to an animation then they act as **default parameter values**. When an\n * animation is invoked via `useAnimation` then parameter values are allowed to be passed in\n * directly. If any of the passed in parameter values are missing then the default values will be\n * used.\n *\n * ```\n * useAnimation(fadeAnimation, {\n * params: {\n * time: '2s',\n * start: 1,\n * end: 0\n * }\n * })\n * ```\n *\n * If one or more parameter values are missing before animated then an error will be thrown.\n *\n * \\@experimental Animation support is experimental.\n * @param {?} steps\n * @param {?=} options\n * @return {?}\n */\n/**\n * `animateChild` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. It works by allowing a queried element to execute its own\n * animation within the animation sequence.\n *\n * Each time an animation is triggered in angular, the parent animation\n * will always get priority and any child animations will be blocked. In order\n * for a child animation to run, the parent animation must query each of the elements\n * containing child animations and then allow the animations to run using `animateChild`.\n *\n * The example HTML code below shows both parent and child elements that have animation\n * triggers that will execute at the same time.\n *\n * ```html\n * \n * \n * \n *\n *
\n * Hello \n *
\n * ```\n *\n * Now when the `exp` value changes to true, only the `parentAnimation` animation will animate\n * because it has priority. However, using `query` and `animateChild` each of the inner animations\n * can also fire:\n *\n * ```ts\n * // parent-child.component.ts\n * import {trigger, transition, animate, style, query, animateChild} from '\\@angular/animations';\n * \\@Component({\n * selector: 'parent-child-component',\n * animations: [\n * trigger('parentAnimation', [\n * transition('false => true', [\n * query('header', [\n * style({ opacity: 0 }),\n * animate(500, style({ opacity: 1 }))\n * ]),\n * query('\\@childAnimation', [\n * animateChild()\n * ])\n * ])\n * ]),\n * trigger('childAnimation', [\n * transition('false => true', [\n * style({ opacity: 0 }),\n * animate(500, style({ opacity: 1 }))\n * ])\n * ])\n * ]\n * })\n * class ParentChildCmp {\n * exp: boolean = false;\n * }\n * ```\n *\n * In the animation code above, when the `parentAnimation` transition kicks off it first queries to\n * find the header element and fades it in. It then finds each of the sub elements that contain the\n * `\\@childAnimation` trigger and then allows for their animations to fire.\n *\n * This example can be further extended by using stagger:\n *\n * ```ts\n * query('\\@childAnimation', stagger(100, [\n * animateChild()\n * ]))\n * ```\n *\n * Now each of the sub animations start off with respect to the `100ms` staggering step.\n *\n * ## The first frame of child animations\n * When sub animations are executed using `animateChild` the animation engine will always apply the\n * first frame of every sub animation immediately at the start of the animation sequence. This way\n * the parent animation does not need to set any initial styling data on the sub elements before the\n * sub animations kick off.\n *\n * In the example above the first frame of the `childAnimation`'s `false => true` transition\n * consists of a style of `opacity: 0`. This is applied immediately when the `parentAnimation`\n * animation transition sequence starts. Only then when the `\\@childAnimation` is queried and called\n * with `animateChild` will it then animate to its destination of `opacity: 1`.\n *\n * Note that this feature designed to be used alongside {\\@link query query()} and it will only work\n * with animations that are assigned using the Angular animation DSL (this means that CSS keyframes\n * and transitions are not handled by this API).\n *\n * \\@experimental Animation support is experimental.\n * @param {?=} options\n * @return {?}\n */\n/**\n * `useAnimation` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. It is used to kick off a reusable animation that is created using {\\@link\n * animation animation()}.\n *\n * \\@experimental Animation support is experimental.\n * @param {?} animation\n * @param {?=} options\n * @return {?}\n */\n/**\n * `query` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language.\n *\n * query() is used to find one or more inner elements within the current element that is\n * being animated within the sequence. The provided animation steps are applied\n * to the queried element (by default, an array is provided, then this will be\n * treated as an animation sequence).\n *\n * ### Usage\n *\n * query() is designed to collect mutiple elements and works internally by using\n * `element.querySelectorAll`. An additional options object can be provided which\n * can be used to limit the total amount of items to be collected.\n *\n * ```js\n * query('div', [\n * animate(...),\n * animate(...)\n * ], { limit: 1 })\n * ```\n *\n * query(), by default, will throw an error when zero items are found. If a query\n * has the `optional` flag set to true then this error will be ignored.\n *\n * ```js\n * query('.some-element-that-may-not-be-there', [\n * animate(...),\n * animate(...)\n * ], { optional: true })\n * ```\n *\n * ### Special Selector Values\n *\n * The selector value within a query can collect elements that contain angular-specific\n * characteristics\n * using special pseudo-selectors tokens.\n *\n * These include:\n *\n * - Querying for newly inserted/removed elements using `query(\":enter\")`/`query(\":leave\")`\n * - Querying all currently animating elements using `query(\":animating\")`\n * - Querying elements that contain an animation trigger using `query(\"\\@triggerName\")`\n * - Querying all elements that contain an animation triggers using `query(\"\\@*\")`\n * - Including the current element into the animation sequence using `query(\":self\")`\n *\n *\n * Each of these pseudo-selector tokens can be merged together into a combined query selector\n * string:\n *\n * ```\n * query(':self, .record:enter, .record:leave, \\@subTrigger', [...])\n * ```\n *\n * ### Demo\n *\n * ```\n * \\@Component({\n * selector: 'inner',\n * template: `\n * \n * one\n *
\n * \n * two\n *
\n * \n * three\n *
\n * \n *
\n * `,\n * animations: [\n * trigger('queryAnimation', [\n * transition('* => goAnimate', [\n * // hide the inner elements\n * query('h1', style({ opacity: 0 })),\n * query('.content', style({ opacity: 0 })),\n *\n * // animate the inner elements in, one by one\n * query('h1', animate(1000, style({ opacity: 1 })),\n * query('.content', animate(1000, style({ opacity: 1 })),\n * ])\n * ])\n * ]\n * })\n * class Cmp {\n * exp = '';\n *\n * goAnimate() {\n * this.exp = 'goAnimate';\n * }\n * }\n * ```\n *\n * \\@experimental Animation support is experimental.\n * @param {?} selector\n * @param {?} animation\n * @param {?=} options\n * @return {?}\n */\n/**\n * `stagger` is an animation-specific function that is designed to be used inside of Angular's\n * animation DSL language. It is designed to be used inside of an animation {\\@link query query()}\n * and works by issuing a timing gap between after each queried item is animated.\n *\n * ### Usage\n *\n * In the example below there is a container element that wraps a list of items stamped out\n * by an ngFor. The container element contains an animation trigger that will later be set\n * to query for each of the inner items.\n *\n * ```html\n * \n * \n * Title
\n *\n * Blah blah blah\n *
\n * \n *
\n *
\n * ```\n *\n * The component code for this looks as such:\n *\n * ```ts\n * import {trigger, transition, style, animate, query, stagger} from '\\@angular/animations';\n * \\@Component({\n * templateUrl: 'list.component.html',\n * animations: [\n * trigger('listAnimation', [\n * //...\n * ])\n * ]\n * })\n * class ListComponent {\n * items = [];\n *\n * showItems() {\n * this.items = [0,1,2,3,4];\n * }\n *\n * hideItems() {\n * this.items = [];\n * }\n *\n * toggle() {\n * this.items.length ? this.hideItems() : this.showItems();\n * }\n * }\n * ```\n *\n * And now for the animation trigger code:\n *\n * ```ts\n * trigger('listAnimation', [\n * transition('* => *', [ // each time the binding value changes\n * query(':leave', [\n * stagger(100, [\n * animate('0.5s', style({ opacity: 0 }))\n * ])\n * ]),\n * query(':enter', [\n * style({ opacity: 0 }),\n * stagger(100, [\n * animate('0.5s', style({ opacity: 1 }))\n * ])\n * ])\n * ])\n * ])\n * ```\n *\n * Now each time the items are added/removed then either the opacity\n * fade-in animation will run or each removed item will be faded out.\n * When either of these animations occur then a stagger effect will be\n * applied after each item's animation is started.\n *\n * \\@experimental Animation support is experimental.\n * @param {?} timings\n * @param {?} animation\n * @return {?}\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n */\nvar AUTO_STYLE$$1 = '*';\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} name\n * @param {?} definitions\n * @return {?}\n */\nfunction trigger$$1(name, definitions) {\n return trigger$1(name, definitions);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} timings\n * @param {?=} styles\n * @return {?}\n */\nfunction animate$$1(timings, styles) {\n return animate$1(timings, styles);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} steps\n * @return {?}\n */\nfunction group$$1(steps) {\n return group$1(steps);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} steps\n * @return {?}\n */\nfunction sequence$$1(steps) {\n return sequence$1(steps);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} tokens\n * @return {?}\n */\nfunction style$$1(tokens) {\n return style$1(tokens);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} name\n * @param {?} styles\n * @return {?}\n */\nfunction state$$1(name, styles) {\n return state$1(name, styles);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} steps\n * @return {?}\n */\nfunction keyframes$$1(steps) {\n return keyframes$1(steps);\n}\n/**\n * @deprecated This symbol has moved. Please Import from \\@angular/animations instead!\n * @param {?} stateChangeExpr\n * @param {?} steps\n * @return {?}\n */\nfunction transition$$1(stateChangeExpr, steps) {\n return transition$1(stateChangeExpr, steps);\n}\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @module\n * @description\n * Entry point from which you should import all public core APIs.\n */\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @module\n * @description\n * Entry point for all public APIs of the core package.\n */\n// This file only reexports content of the `src` folder. Keep it that way.\n/**\n * Generated bundle index. Do not edit.\n */\n\n//# sourceMappingURL=core.es5.js.map\n\n/* WEBPACK VAR INJECTION */}.call(__webpack_exports__, __webpack_require__(\"GTd5\")))\n\n/***/ }),\n\n/***/ \"/sy+\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* unused harmony export RenderType_CalendarTooltipWindowComponent */\n/* unused harmony export View_CalendarTooltipWindowComponent_0 */\n/* unused harmony export View_CalendarTooltipWindowComponent_Host_0 */\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return CalendarTooltipWindowComponentNgFactory; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(\"/oeL\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__angular_common__ = __webpack_require__(\"qbdv\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_2_angular_calendar_dist_esm_src_directives_calendarTooltip_directive__ = __webpack_require__(\"Hx83\");\n/**\n * @fileoverview This file is generated by the Angular template compiler.\n * Do not edit.\n * @suppress {suspiciousCode,uselessCode,missingProperties,missingOverride}\n */\n/* tslint:disable */\n\n\n\nvar styles_CalendarTooltipWindowComponent = [];\nvar RenderType_CalendarTooltipWindowComponent = __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵcrt\"]({ encapsulation: 2,\n styles: styles_CalendarTooltipWindowComponent, data: {} });\nfunction View_CalendarTooltipWindowComponent_1(_l) {\n return __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵvid\"](0, [(_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n '])), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵeld\"](1, 0, null, null, 6, 'div', [['class', 'cal-tooltip']], null, null, null, null, null)), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵdid\"](2, 278528, null, 0, __WEBPACK_IMPORTED_MODULE_1__angular_common__[\"NgClass\"], [__WEBPACK_IMPORTED_MODULE_0__angular_core__[\"IterableDiffers\"], __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"KeyValueDiffers\"], __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ElementRef\"], __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Renderer\"]], { klass: [0, 'klass'], ngClass: [1, 'ngClass'] }, null), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n '])), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵeld\"](4, 0, null, null, 0, 'div', [['class', 'cal-tooltip-arrow']], null, null, null, null, null)), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n '])),\n (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵeld\"](6, 0, null, null, 0, 'div', [['class', 'cal-tooltip-inner']], [[8, 'innerHTML', 1]], null, null, null, null)),\n (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n '])), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n ']))], function (_ck, _v) {\n var currVal_0 = 'cal-tooltip';\n var currVal_1 = ('cal-tooltip-' + _v.context.placement);\n _ck(_v, 2, 0, currVal_0, currVal_1);\n }, function (_ck, _v) {\n var currVal_2 = _v.context.contents;\n _ck(_v, 6, 0, currVal_2);\n });\n}\nfunction View_CalendarTooltipWindowComponent_2(_l) {\n return __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵvid\"](0, [(_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n ']))], null, null);\n}\nfunction View_CalendarTooltipWindowComponent_0(_l) {\n return __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵvid\"](0, [(_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n '])), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵand\"](0, [['defaultTemplate', 2]], null, 0, null, View_CalendarTooltipWindowComponent_1)),\n (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n '])), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵand\"](16777216, null, null, 2, null, View_CalendarTooltipWindowComponent_2)), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵdid\"](4, 540672, null, 0, __WEBPACK_IMPORTED_MODULE_1__angular_common__[\"NgTemplateOutlet\"], [__WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ViewContainerRef\"]], { ngTemplateOutletContext: [0,\n 'ngTemplateOutletContext'], ngTemplateOutlet: [1, 'ngTemplateOutlet'] }, null), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵpod\"](5, { contents: 0, placement: 1, event: 2 }), (_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵted\"](-1, null, ['\\n ']))], function (_ck, _v) {\n var _co = _v.component;\n var currVal_0 = _ck(_v, 5, 0, _co.contents, _co.placement, _co.event);\n var currVal_1 = (_co.customTemplate || __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵnov\"](_v, 1));\n _ck(_v, 4, 0, currVal_0, currVal_1);\n }, null);\n}\nfunction View_CalendarTooltipWindowComponent_Host_0(_l) {\n return __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵvid\"](0, [(_l()(), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵeld\"](0, 0, null, null, 1, 'ng-component', [], null, null, null, View_CalendarTooltipWindowComponent_0, RenderType_CalendarTooltipWindowComponent)), __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵdid\"](1, 49152, null, 0, __WEBPACK_IMPORTED_MODULE_2_angular_calendar_dist_esm_src_directives_calendarTooltip_directive__[\"b\" /* CalendarTooltipWindowComponent */], [], null, null)], null, null);\n}\nvar CalendarTooltipWindowComponentNgFactory = __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ɵccf\"]('ng-component', __WEBPACK_IMPORTED_MODULE_2_angular_calendar_dist_esm_src_directives_calendarTooltip_directive__[\"b\" /* CalendarTooltipWindowComponent */], View_CalendarTooltipWindowComponent_Host_0, { contents: 'contents',\n placement: 'placement', event: 'event', customTemplate: 'customTemplate' }, {}, []);\n//# sourceMappingURL=data:application/json;base64,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\n//# sourceMappingURL=calendarTooltip.directive.ngfactory.js.map\n\n/***/ }),\n\n/***/ \"/vpO\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n\n// EXTERNAL MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/src/effects.js\nvar effects = __webpack_require__(\"n0Ed\");\n\n// EXTERNAL MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/src/actions.js\nvar actions = __webpack_require__(\"uwGy\");\n\n// EXTERNAL MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/src/effects.module.js\nvar effects_module = __webpack_require__(\"Wgxb\");\n\n// EXTERNAL MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/src/effects-subscription.js\nvar effects_subscription = __webpack_require__(\"BYzQ\");\n\n// CONCATENATED MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/src/util.js\nfunction toPayload(action) {\n return action.payload;\n}\n//# sourceMappingURL=util.js.map\n// EXTERNAL MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/src/bootstrap-listener.js\nvar bootstrap_listener = __webpack_require__(\"5Ewt\");\n\n// CONCATENATED MODULE: /Users/jason/src/matrix/client/node_modules/@ngrx/effects/index.js\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"b\", function() { return effects[\"a\" /* Effect */]; });\n/* unused concated harmony import mergeEffects */\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, false, function() { return effects[\"b\" /* mergeEffects */]; });\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, \"a\", function() { return actions[\"a\" /* Actions */]; });\n/* unused concated harmony import EffectsModule */\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, false, function() { return effects_module[\"a\" /* EffectsModule */]; });\n/* unused concated harmony import EffectsSubscription */\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, false, function() { return effects_subscription[\"a\" /* EffectsSubscription */]; });\n/* unused concated harmony import toPayload */\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, false, function() { return toPayload; });\n/* unused concated harmony import runAfterBootstrapEffects */\n/* concated harmony reexport */__webpack_require__.d(__webpack_exports__, false, function() { return bootstrap_listener[\"b\" /* runAfterBootstrapEffects */]; });\n\n\n\n\n\n\n//# sourceMappingURL=index.js.map\n\n/***/ }),\n\n/***/ \"/zHi\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(\"bKpL\");\nvar of_1 = __webpack_require__(\"+zVg\");\nObservable_1.Observable.of = of_1.of;\n//# sourceMappingURL=of.js.map\n\n/***/ }),\n\n/***/ \"0I3B\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar zip_1 = __webpack_require__(\"SBOU\");\n/* tslint:enable:max-line-length */\n/**\n * @param observables\n * @return {Observable\n * {{ item }}\n *
\n * ![](\"./img/find.png\")
\n *\n * `find` searches for the first item in the source Observable that matches the\n * specified condition embodied by the `predicate`, and returns the first\n * occurrence in the source. Unlike {@link first}, the `predicate` is required\n * in `find`, and does not emit an error if a valid value is not found.\n *\n * @example ![](\"./img/switchMapTo.png\")
\n *\n * Maps each source value to the given Observable `innerObservable` regardless\n * of the source value, and then flattens those resulting Observables into one\n * single Observable, which is the output Observable. The output Observables\n * emits values only from the most recently emitted instance of\n * `innerObservable`.\n *\n * @example ![](\"./img/concatMapTo.png\")
\n *\n * Maps each source value to the given Observable `innerObservable` regardless\n * of the source value, and then flattens those resulting Observables into one\n * single Observable, which is the output Observable. Each new `innerObservable`\n * instance emitted on the output Observable is concatenated with the previous\n * `innerObservable` instance.\n *\n * __Warning:__ if source values arrive endlessly and faster than their\n * corresponding inner Observables can complete, it will result in memory issues\n * as inner Observables amass in an unbounded buffer waiting for their turn to\n * be subscribed to.\n *\n * Note: `concatMapTo` is equivalent to `mergeMapTo` with concurrency parameter\n * set to `1`.\n *\n * @example ![](\"./img/min.png\")
\n *\n * @example ![](\"./img/first.png\")
\n *\n * If called with no arguments, `first` emits the first value of the source\n * Observable, then completes. If called with a `predicate` function, `first`\n * emits the first value of the source that matches the specified condition. It\n * may also take a `resultSelector` function to produce the output value from\n * the input value, and a `defaultValue` to emit in case the source completes\n * before it is able to emit a valid value. Throws an error if `defaultValue`\n * was not provided and a matching element is not found.\n *\n * @example ![](\"./img/mapTo.png\")
\n *\n * Takes a constant `value` as argument, and emits that whenever the source\n * Observable emits a value. In other words, ignores the actual source value,\n * and simply uses the emission moment to know when to emit the given `value`.\n *\n * @example ![](\"./img/skipUntil.png\")
\n *\n * @param {Observable} notifier - The second Observable that has to emit an item before the source Observable's elements begin to\n * be mirrored by the resulting Observable.\n * @return {Observable![](\"./img/timeout.png\")
\n *\n * `timeout` operator accepts as an argument either a number or a Date.\n *\n * If number was provided, it returns an Observable that behaves like a source\n * Observable, unless there is a period of time where there is no value emitted.\n * So if you provide `100` as argument and first value comes after 50ms from\n * the moment of subscription, this value will be simply re-emitted by the resulting\n * Observable. If however after that 100ms passes without a second value being emitted,\n * stream will end with an error and source Observable will be unsubscribed.\n * These checks are performed throughout whole lifecycle of Observable - from the moment\n * it was subscribed to, until it completes or errors itself. Thus every value must be\n * emitted within specified period since previous value.\n *\n * If provided argument was Date, returned Observable behaves differently. It throws\n * if Observable did not complete before provided Date. This means that periods between\n * emission of particular values do not matter in this case. If Observable did not complete\n * before provided Date, source Observable will be unsubscribed. Other than that, resulting\n * stream behaves just as source Observable.\n *\n * `timeout` accepts also a Scheduler as a second parameter. It is used to schedule moment (or moments)\n * when returned Observable will check if source stream emitted value or completed.\n *\n * @example ![](\"./img/debounce.png\")
\n *\n * `debounce` delays values emitted by the source Observable, but drops previous\n * pending delayed emissions if a new value arrives on the source Observable.\n * This operator keeps track of the most recent value from the source\n * Observable, and spawns a duration Observable by calling the\n * `durationSelector` function. The value is emitted only when the duration\n * Observable emits a value or completes, and if no other value was emitted on\n * the source Observable since the duration Observable was spawned. If a new\n * value appears before the duration Observable emits, the previous value will\n * be dropped and will not be emitted on the output Observable.\n *\n * Like {@link debounceTime}, this is a rate-limiting operator, and also a\n * delay-like operator since output emissions do not necessarily occur at the\n * same time as they did on the source Observable.\n *\n * @example ![](\"./img/window.png\")
\n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable emits connected, non-overlapping\n * windows. It emits the current window and opens a new one whenever the\n * Observable `windowBoundaries` emits an item. Because each window is an\n * Observable, the output is a higher-order Observable.\n *\n * @example ![](\"./img/filter.png\")
\n *\n * Similar to the well-known `Array.prototype.filter` method, this operator\n * takes values from the source Observable, passes them through a `predicate`\n * function and only emits those values that yielded `true`.\n *\n * @example ![](\"./img/do.png\")
\n *\n * Returns a mirrored Observable of the source Observable, but modified so that\n * the provided Observer is called to perform a side effect for every value,\n * error, and completion emitted by the source. Any errors that are thrown in\n * the aforementioned Observer or handlers are safely sent down the error path\n * of the output Observable.\n *\n * This operator is useful for debugging your Observables for the correct values\n * or performing other side effects.\n *\n * Note: this is different to a `subscribe` on the Observable. If the Observable\n * returned by `do` is not subscribed, the side effects specified by the\n * Observer will never happen. `do` therefore simply spies on existing\n * execution, it does not trigger an execution to happen like `subscribe` does.\n *\n * @example \\n \\n \\n
\\n \"\n },] },\n ];\n /** @nocollapse */\n CalendarMonthViewComponent.ctorParameters = function () { return [\n { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ChangeDetectorRef\"], },\n { type: __WEBPACK_IMPORTED_MODULE_10__providers_calendarUtils_provider__[\"a\" /* CalendarUtils */], },\n { type: undefined, decorators: [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Inject\"], args: [__WEBPACK_IMPORTED_MODULE_0__angular_core__[\"LOCALE_ID\"],] },] },\n ]; };\n CalendarMonthViewComponent.propDecorators = {\n 'viewDate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'events': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'excludeDays': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'activeDayIsOpen': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'refresh': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'locale': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'tooltipPlacement': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'tooltipTemplate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'tooltipAppendToBody': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'weekStartsOn': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'headerTemplate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'cellTemplate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'openDayEventsTemplate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'eventTitleTemplate': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'weekendDays': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'beforeViewRender': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'dayClicked': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'eventClicked': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'eventTimesChanged': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n };\n return CalendarMonthViewComponent;\n}());\n\n//# sourceMappingURL=calendarMonthView.component.js.map\n\n/***/ }),\n\n/***/ \"4jgQ\":\n/***/ (function(module, exports) {\n\n/**\n * @category Common Helpers\n * @summary Is the given argument an instance of Date?\n *\n * @description\n * Is the given argument an instance of Date?\n *\n * @param {*} argument - the argument to check\n * @returns {Boolean} the given argument is an instance of Date\n *\n * @example\n * // Is 'mayonnaise' a Date?\n * var result = isDate('mayonnaise')\n * //=> false\n */\nfunction isDate (argument) {\n return argument instanceof Date\n}\n\nmodule.exports = isDate\n\n\n/***/ }),\n\n/***/ \"56vs\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar skipWhile_1 = __webpack_require__(\"aL6N\");\n/**\n * Returns an Observable that skips all items emitted by the source Observable as long as a specified condition holds\n * true, but emits all further source items as soon as the condition becomes false.\n *\n * \\n
\\n \\n \\n \\n
\\n \\n \\n \\n
\\n ![](\"./img/skipWhile.png\")
\n *\n * @param {Function} predicate - A function to test each item emitted from the source Observable.\n * @return {Observable![](\"./img/bufferCount.png\")
\n *\n * Buffers a number of values from the source Observable by `bufferSize` then\n * emits the buffer and clears it, and starts a new buffer each\n * `startBufferEvery` values. If `startBufferEvery` is not provided or is\n * `null`, then new buffers are started immediately at the start of the source\n * and when each buffer closes and is emitted.\n *\n * @example ![](\"./img/retry.png\")
\n *\n * Any and all items emitted by the source Observable will be emitted by the resulting Observable, even those emitted\n * during failed subscriptions. For example, if an Observable fails at first but emits [1, 2] then succeeds the second\n * time and emits: [1, 2, 3, 4, 5] then the complete stream of emissions and notifications\n * would be: [1, 2, 1, 2, 3, 4, 5, `complete`].\n * @param {number} count - Number of retry attempts before failing.\n * @return {Observable} The source Observable modified with the retry logic.\n * @method retry\n * @owner Observable\n */\nfunction retry(count) {\n if (count === void 0) { count = -1; }\n return function (source) { return source.lift(new RetryOperator(count, source)); };\n}\nexports.retry = retry;\nvar RetryOperator = (function () {\n function RetryOperator(count, source) {\n this.count = count;\n this.source = source;\n }\n RetryOperator.prototype.call = function (subscriber, source) {\n return source.subscribe(new RetrySubscriber(subscriber, this.count, this.source));\n };\n return RetryOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar RetrySubscriber = (function (_super) {\n __extends(RetrySubscriber, _super);\n function RetrySubscriber(destination, count, source) {\n _super.call(this, destination);\n this.count = count;\n this.source = source;\n }\n RetrySubscriber.prototype.error = function (err) {\n if (!this.isStopped) {\n var _a = this, source = _a.source, count = _a.count;\n if (count === 0) {\n return _super.prototype.error.call(this, err);\n }\n else if (count > -1) {\n this.count = count - 1;\n }\n source.subscribe(this._unsubscribeAndRecycle());\n }\n };\n return RetrySubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=retry.js.map\n\n/***/ }),\n\n/***/ \"5uCp\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(\"bKpL\");\nvar take_1 = __webpack_require__(\"Lqs2\");\nObservable_1.Observable.prototype.take = take_1.take;\n//# sourceMappingURL=take.js.map\n\n/***/ }),\n\n/***/ \"5v8a\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(\"bKpL\");\nvar map_1 = __webpack_require__(\"lx+J\");\nObservable_1.Observable.prototype.map = map_1.map;\n//# sourceMappingURL=map.js.map\n\n/***/ }),\n\n/***/ \"5x23\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar __extends = (this && this.__extends) || function (d, b) {\n for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];\n function __() { this.constructor = d; }\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n};\nvar Subscriber_1 = __webpack_require__(\"T14+\");\n/**\n * Emits values emitted by the source Observable so long as each value satisfies\n * the given `predicate`, and then completes as soon as this `predicate` is not\n * satisfied.\n *\n * Takes values from the source only while they pass the\n * condition given. When the first value does not satisfy, it completes.\n *\n * ![](\"./img/takeWhile.png\")
\n *\n * `takeWhile` subscribes and begins mirroring the source Observable. Each value\n * emitted on the source is given to the `predicate` function which returns a\n * boolean, representing a condition to be satisfied by the source values. The\n * output Observable emits the source values until such time as the `predicate`\n * returns false, at which point `takeWhile` stops mirroring the source\n * Observable and completes the output Observable.\n *\n * @example ![](\"./img/sampleTime.png\")
\n *\n * `sampleTime` periodically looks at the source Observable and emits whichever\n * value it has most recently emitted since the previous sampling, unless the\n * source has not emitted anything since the previous sampling. The sampling\n * happens periodically in time every `period` milliseconds (or the time unit\n * defined by the optional `scheduler` argument). The sampling starts as soon as\n * the output Observable is subscribed.\n *\n * @example ![](\"./img/repeatWhen.png\")
\n *\n * @param {function(notifications: Observable): Observable} notifier - Receives an Observable of notifications with\n * which a user can `complete` or `error`, aborting the repetition.\n * @return {Observable} The source Observable modified with repeat logic.\n * @method repeatWhen\n * @owner Observable\n */\nfunction repeatWhen(notifier) {\n return repeatWhen_1.repeatWhen(notifier)(this);\n}\nexports.repeatWhen = repeatWhen;\n//# sourceMappingURL=repeatWhen.js.map\n\n/***/ }),\n\n/***/ \"66qj\":\n/***/ (function(module, __webpack_exports__, __webpack_require__) {\n\n\"use strict\";\n/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, \"a\", function() { return ResizeHandleDirective; });\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_0__angular_core__ = __webpack_require__(\"/oeL\");\n/* harmony import */ var __WEBPACK_IMPORTED_MODULE_1__resizable_directive__ = __webpack_require__(\"Yie4\");\n\n\n/**\n * An element placed inside a `mwlResizable` directive to be used as a drag and resize handle\n *\n * For example\n *\n * ```html\n * \n * \n *
\n * ```\n */\nvar ResizeHandleDirective = /** @class */ (function () {\n function ResizeHandleDirective(renderer, element, zone, resizable) {\n this.renderer = renderer;\n this.element = element;\n this.zone = zone;\n this.resizable = resizable;\n /**\n * The `Edges` object that contains the edges of the parent element that dragging the handle will trigger a resize on\n */\n this.resizeEdges = {};\n this.eventListeners = {};\n }\n ResizeHandleDirective.prototype.ngOnDestroy = function () {\n this.unsubscribeEventListeners();\n };\n /**\n * @private\n */\n ResizeHandleDirective.prototype.onMousedown = function (event, clientX, clientY) {\n var _this = this;\n event.preventDefault();\n this.zone.runOutsideAngular(function () {\n if (!_this.eventListeners.touchmove) {\n _this.eventListeners.touchmove = _this.renderer.listen(_this.element.nativeElement, 'touchmove', function (touchMoveEvent) {\n _this.onMousemove(touchMoveEvent, touchMoveEvent.targetTouches[0].clientX, touchMoveEvent.targetTouches[0].clientY);\n });\n }\n if (!_this.eventListeners.mousemove) {\n _this.eventListeners.mousemove = _this.renderer.listen(_this.element.nativeElement, 'mousemove', function (mouseMoveEvent) {\n _this.onMousemove(mouseMoveEvent, mouseMoveEvent.clientX, mouseMoveEvent.clientY);\n });\n }\n _this.resizable.mousedown.next({\n clientX: clientX,\n clientY: clientY,\n edges: _this.resizeEdges\n });\n });\n };\n /**\n * @private\n */\n ResizeHandleDirective.prototype.onMouseup = function (clientX, clientY) {\n var _this = this;\n this.zone.runOutsideAngular(function () {\n _this.unsubscribeEventListeners();\n _this.resizable.mouseup.next({\n clientX: clientX,\n clientY: clientY,\n edges: _this.resizeEdges\n });\n });\n };\n ResizeHandleDirective.prototype.onMousemove = function (event, clientX, clientY) {\n this.resizable.mousemove.next({\n clientX: clientX,\n clientY: clientY,\n edges: this.resizeEdges,\n event: event\n });\n };\n ResizeHandleDirective.prototype.unsubscribeEventListeners = function () {\n var _this = this;\n Object.keys(this.eventListeners).forEach(function (type) {\n _this.eventListeners[type]();\n delete _this.eventListeners[type];\n });\n };\n ResizeHandleDirective.decorators = [\n { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Directive\"], args: [{\n selector: '[mwlResizeHandle]'\n },] },\n ];\n /** @nocollapse */\n ResizeHandleDirective.ctorParameters = function () { return [\n { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Renderer2\"], },\n { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ElementRef\"], },\n { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"NgZone\"], },\n { type: __WEBPACK_IMPORTED_MODULE_1__resizable_directive__[\"a\" /* ResizableDirective */], },\n ]; };\n ResizeHandleDirective.propDecorators = {\n 'resizeEdges': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'onMousedown': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"HostListener\"], args: ['touchstart', [\n '$event',\n '$event.touches[0].clientX',\n '$event.touches[0].clientY'\n ],] }, { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"HostListener\"], args: ['mousedown', ['$event', '$event.clientX', '$event.clientY'],] },],\n 'onMouseup': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"HostListener\"], args: ['touchend', [\n '$event.changedTouches[0].clientX',\n '$event.changedTouches[0].clientY'\n ],] }, { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"HostListener\"], args: ['touchcancel', [\n '$event.changedTouches[0].clientX',\n '$event.changedTouches[0].clientY'\n ],] }, { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"HostListener\"], args: ['mouseup', ['$event.clientX', '$event.clientY'],] },],\n };\n return ResizeHandleDirective;\n}());\n\n//# sourceMappingURL=resize-handle.directive.js.map\n\n/***/ }),\n\n/***/ \"67Ck\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(\"bKpL\");\nvar skipWhile_1 = __webpack_require__(\"56vs\");\nObservable_1.Observable.prototype.skipWhile = skipWhile_1.skipWhile;\n//# sourceMappingURL=skipWhile.js.map\n\n/***/ }),\n\n/***/ \"6DBm\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar Observable_1 = __webpack_require__(\"bKpL\");\nvar combineLatest_1 = __webpack_require__(\"+c7d\");\nObservable_1.Observable.prototype.combineLatest = combineLatest_1.combineLatest;\n//# sourceMappingURL=combineLatest.js.map\n\n/***/ }),\n\n/***/ \"6JjX\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar switchAll_1 = __webpack_require__(\"rhfi\");\n/**\n * Converts a higher-order Observable into a first-order Observable by\n * subscribing to only the most recently emitted of those inner Observables.\n *\n * Flattens an Observable-of-Observables by dropping the\n * previous inner Observable once a new one appears.\n *\n * ![](\"./img/switch.png\")
\n *\n * `switch` subscribes to an Observable that emits Observables, also known as a\n * higher-order Observable. Each time it observes one of these emitted inner\n * Observables, the output Observable subscribes to the inner Observable and\n * begins emitting the items emitted by that. So far, it behaves\n * like {@link mergeAll}. However, when a new inner Observable is emitted,\n * `switch` unsubscribes from the earlier-emitted inner Observable and\n * subscribes to the new inner Observable and begins emitting items from it. It\n * continues to behave like this for subsequent inner Observables.\n *\n * @example \n *\n * `combineLatest` combines the values from all the Observables passed as\n * arguments. This is done by subscribing to each Observable in order and,\n * whenever any Observable emits, collecting an array of the most recent\n * values from each Observable. So if you pass `n` Observables to operator,\n * returned Observable will always emit an array of `n` values, in order\n * corresponding to order of passed Observables (value from the first Observable\n * on the first place and so on).\n *\n * Static version of `combineLatest` accepts either an array of Observables\n * or each Observable can be put directly as an argument. Note that array of\n * Observables is good choice, if you don't know beforehand how many Observables\n * you will combine. Passing empty array will result in Observable that\n * completes immediately.\n *\n * To ensure output array has always the same length, `combineLatest` will\n * actually wait for all input Observables to emit at least once,\n * before it starts emitting results. This means if some Observable emits\n * values before other Observables started emitting, all that values but last\n * will be lost. On the other hand, is some Observable does not emit value but\n * completes, resulting Observable will complete at the same moment without\n * emitting anything, since it will be now impossible to include value from\n * completed Observable in resulting array. Also, if some input Observable does\n * not emit any value and never completes, `combineLatest` will also never emit\n * and never complete, since, again, it will wait for all streams to emit some\n * value.\n *\n * If at least one Observable was passed to `combineLatest` and all passed Observables\n * emitted something, resulting Observable will complete when all combined\n * streams complete. So even if some Observable completes, result of\n * `combineLatest` will still emit values when other Observables do. In case\n * of completed Observable, its value from now on will always be the last\n * emitted value. On the other hand, if any Observable errors, `combineLatest`\n * will error immediately as well, and all other Observables will be unsubscribed.\n *\n * `combineLatest` accepts as optional parameter `project` function, which takes\n * as arguments all values that would normally be emitted by resulting Observable.\n * `project` can return any kind of value, which will be then emitted by Observable\n * instead of default array. Note that `project` does not take as argument that array\n * of values, but values themselves. That means default `project` can be imagined\n * as function that takes all its arguments and puts them into an array.\n *\n *\n * @example ![](\"./img/bufferToggle.png\")
\n *\n * Buffers values from the source by opening the buffer via signals from an\n * Observable provided to `openings`, and closing and sending the buffers when\n * a Subscribable or Promise returned by the `closingSelector` function emits.\n *\n * @example \n *\n * Takes a constant `value` as argument, and emits that whenever the source\n * Observable emits a value. In other words, ignores the actual source value,\n * and simply uses the emission moment to know when to emit the given `value`.\n *\n * @example ![](\"./img/concat.png\")
\n *\n * `concat` joins multiple Observables together, by subscribing to them one at a time and\n * merging their results into the output Observable. You can pass either an array of\n * Observables, or put them directly as arguments. Passing an empty array will result\n * in Observable that completes immediately.\n *\n * `concat` will subscribe to first input Observable and emit all its values, without\n * changing or affecting them in any way. When that Observable completes, it will\n * subscribe to then next Observable passed and, again, emit its values. This will be\n * repeated, until the operator runs out of Observables. When last input Observable completes,\n * `concat` will complete as well. At any given moment only one Observable passed to operator\n * emits values. If you would like to emit values from passed Observables concurrently, check out\n * {@link merge} instead, especially with optional `concurrent` parameter. As a matter of fact,\n * `concat` is an equivalent of `merge` operator with `concurrent` parameter set to `1`.\n *\n * Note that if some input Observable never completes, `concat` will also never complete\n * and Observables following the one that did not complete will never be subscribed. On the other\n * hand, if some Observable simply completes immediately after it is subscribed, it will be\n * invisible for `concat`, which will just move on to the next Observable.\n *\n * If any Observable in chain errors, instead of passing control to the next Observable,\n * `concat` will error immediately as well. Observables that would be subscribed after\n * the one that emitted error, never will.\n *\n * If you pass to `concat` the same Observable many times, its stream of values\n * will be \"replayed\" on every subscription, which means you can repeat given Observable\n * as many times as you like. If passing the same Observable to `concat` 1000 times becomes tedious,\n * you can always use {@link repeat}.\n *\n * @example \n *\n * Returns an Observable that emits windows of items it collects from the source\n * Observable. The output Observable emits connected, non-overlapping\n * windows. It emits the current window and opens a new one whenever the\n * Observable `windowBoundaries` emits an item. Because each window is an\n * Observable, the output is a higher-order Observable.\n *\n * @example ![](\"./img/groupBy.png\")
\n *\n * @example ![](\"./img/takeUntil.png\")
\n *\n * `takeUntil` subscribes and begins mirroring the source Observable. It also\n * monitors a second Observable, `notifier` that you provide. If the `notifier`\n * emits a value, the output Observable stops mirroring the source Observable\n * and completes.\n *\n * @example ![](\"./img/bufferTime.png\")
\n *\n * Buffers values from the source for a specific time duration `bufferTimeSpan`.\n * Unless the optional argument `bufferCreationInterval` is given, it emits and\n * resets the buffer every `bufferTimeSpan` milliseconds. If\n * `bufferCreationInterval` is given, this operator opens the buffer every\n * `bufferCreationInterval` milliseconds and closes (emits and resets) the\n * buffer every `bufferTimeSpan` milliseconds. When the optional argument\n * `maxBufferSize` is specified, the buffer will be closed either after\n * `bufferTimeSpan` milliseconds or when it contains `maxBufferSize` elements.\n *\n * @example ![](\"./img/mergeAll.png\")
\n *\n * `mergeAll` subscribes to an Observable that emits Observables, also known as\n * a higher-order Observable. Each time it observes one of these emitted inner\n * Observables, it subscribes to that and delivers all the values from the\n * inner Observable on the output Observable. The output Observable only\n * completes once all inner Observables have completed. Any error delivered by\n * a inner Observable will be immediately emitted on the output Observable.\n *\n * @example ![](\"./img/pairwise.png\")
\n *\n * The Nth emission from the source Observable will cause the output Observable\n * to emit an array [(N-1)th, Nth] of the previous and the current value, as a\n * pair. For this reason, `pairwise` emits on the second and subsequent\n * emissions from the source Observable, but not on the first emission, because\n * there is no previous value in that case.\n *\n * @example ![](\"./img/exhaustMap.png\")
\n *\n * Returns an Observable that emits items based on applying a function that you\n * supply to each item emitted by the source Observable, where that function\n * returns an (so-called \"inner\") Observable. When it projects a source value to\n * an Observable, the output Observable begins emitting the items emitted by\n * that projected Observable. However, `exhaustMap` ignores every new projected\n * Observable if the previous projected Observable has not yet completed. Once\n * that one completes, it will accept and flatten the next projected Observable\n * and repeat this process.\n *\n * @example \\n 0 ? inputId : null\\\" type=\\\"search\\\" class=\\\"completer-input\\\" ctrInput [ngClass]=\\\"inputClass\\\"\\n [(ngModel)]=\\\"searchStr\\\" (ngModelChange)=\\\"onChange($event)\\\" [attr.name]=\\\"inputName\\\" [placeholder]=\\\"placeholder\\\"\\n [attr.maxlength]=\\\"maxChars\\\" [tabindex]=\\\"fieldTabindex\\\" [disabled]=\\\"disableInput\\\"\\n [clearSelected]=\\\"clearSelected\\\" [clearUnselected]=\\\"clearUnselected\\\"\\n [overrideSuggested]=\\\"overrideSuggested\\\" [openOnFocus]=\\\"openOnFocus\\\" [fillHighlighted]=\\\"fillHighlighted\\\" \\n [openOnClick]=\\\"openOnClick\\\" [selectOnClick]=\\\"selectOnClick\\\" [selectOnFocus]=\\\"selectOnFocus\\\"\\n (blur)=\\\"onBlur()\\\" (focus)=\\\"onFocus()\\\" (keyup)=\\\"onKeyup($event)\\\" (keydown)=\\\"onKeydown($event)\\\" (click)=\\\"onClick($event)\\\"\\n autocomplete=\\\"off\\\" autocorrect=\\\"off\\\" autocapitalize=\\\"off\\\" />\\n\\n
\\n \",\n styles: [\"\\n .completer-dropdown {\\n border-color: #ececec;\\n border-width: 1px;\\n border-style: solid;\\n border-radius: 2px;\\n width: 250px;\\n padding: 6px;\\n cursor: pointer;\\n z-index: 9999;\\n position: absolute;\\n margin-top: -6px;\\n background-color: #ffffff;\\n }\\n\\n .completer-row {\\n padding: 5px;\\n color: #000000;\\n margin-bottom: 4px;\\n clear: both;\\n display: inline-block;\\n width: 103%;\\n }\\n\\n .completer-selected-row {\\n background-color: lightblue;\\n color: #ffffff;\\n }\\n\\n .completer-description {\\n font-size: 14px;\\n }\\n\\n .completer-image-default {\\n width: 16px;\\n height: 16px;\\n background-image: url(\\\"demo/res/img/default.png\\\");\\n }\\n\\n .completer-image-holder {\\n float: left;\\n width: 10%;\\n }\\n .completer-item-text-image {\\n float: right;\\n width: 90%;\\n }\\n \"],\n providers: [COMPLETER_CONTROL_VALUE_ACCESSOR]\n },] },\n ];\n /** @nocollapse */\n CompleterCmp.ctorParameters = function () { return [\n { type: __WEBPACK_IMPORTED_MODULE_3__services_completer_service__[\"a\" /* CompleterService */], },\n { type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ChangeDetectorRef\"], },\n ]; };\n CompleterCmp.propDecorators = {\n 'dataService': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'inputName': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'inputId': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'pause': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'minSearchLength': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'maxChars': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'overrideSuggested': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'clearSelected': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'clearUnselected': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'fillHighlighted': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'placeholder': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'matchClass': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'fieldTabindex': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'autoMatch': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'disableInput': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'inputClass': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'autofocus': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'openOnFocus': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'openOnClick': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'selectOnClick': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'selectOnFocus': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'initialValue': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'autoHighlight': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'selected': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'highlighted': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'blurEvent': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"], args: [\"blur\",] },],\n 'click': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'focusEvent': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"], args: [\"focus\",] },],\n 'opened': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'keyup': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'keydown': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Output\"] },],\n 'completer': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ViewChild\"], args: [__WEBPACK_IMPORTED_MODULE_2__directives_ctr_completer__[\"a\" /* CtrCompleter */],] },],\n 'ctrInput': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"ViewChild\"], args: [\"ctrInput\",] },],\n 'datasource': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'textNoResults': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n 'textSearching': [{ type: __WEBPACK_IMPORTED_MODULE_0__angular_core__[\"Input\"] },],\n };\n return CompleterCmp;\n}());\n\n//# sourceMappingURL=completer-cmp.js.map\n\n/***/ }),\n\n/***/ \"ALD8\":\n/***/ (function(module, exports, __webpack_require__) {\n\n//! moment.js locale configuration\n\n;(function (global, factory) {\n true ? factory(__webpack_require__(\"ge1L\")) :\n typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n\n var nn = moment.defineLocale('nn', {\n months : 'januar_februar_mars_april_mai_juni_juli_august_september_oktober_november_desember'.split('_'),\n monthsShort : 'jan_feb_mar_apr_mai_jun_jul_aug_sep_okt_nov_des'.split('_'),\n weekdays : 'sundag_måndag_tysdag_onsdag_torsdag_fredag_laurdag'.split('_'),\n weekdaysShort : 'sun_mån_tys_ons_tor_fre_lau'.split('_'),\n weekdaysMin : 'su_må_ty_on_to_fr_lø'.split('_'),\n longDateFormat : {\n LT : 'HH:mm',\n LTS : 'HH:mm:ss',\n L : 'DD.MM.YYYY',\n LL : 'D. MMMM YYYY',\n LLL : 'D. MMMM YYYY [kl.] H:mm',\n LLLL : 'dddd D. MMMM YYYY [kl.] HH:mm'\n },\n calendar : {\n sameDay: '[I dag klokka] LT',\n nextDay: '[I morgon klokka] LT',\n nextWeek: 'dddd [klokka] LT',\n lastDay: '[I går klokka] LT',\n lastWeek: '[Føregåande] dddd [klokka] LT',\n sameElse: 'L'\n },\n relativeTime : {\n future : 'om %s',\n past : '%s sidan',\n s : 'nokre sekund',\n ss : '%d sekund',\n m : 'eit minutt',\n mm : '%d minutt',\n h : 'ein time',\n hh : '%d timar',\n d : 'ein dag',\n dd : '%d dagar',\n M : 'ein månad',\n MM : '%d månader',\n y : 'eit år',\n yy : '%d år'\n },\n dayOfMonthOrdinalParse: /\\d{1,2}\\./,\n ordinal : '%d.',\n week : {\n dow : 1, // Monday is the first day of the week.\n doy : 4 // The week that contains Jan 4th is the first week of the year.\n }\n });\n\n return nn;\n\n})));\n\n\n/***/ }),\n\n/***/ \"ASfG\":\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\nvar BehaviorSubject_1 = __webpack_require__(\"gvep\");\nvar multicast_1 = __webpack_require__(\"P02W\");\n/**\n * @param value\n * @return {ConnectableObservable\\n
\\n 0|| (displayNoResults && !searchActive)) || (searchActive && displaySearching))\\\">\\n
\\n {{_textSearching}}
\\n {{_textNoResults}}
\\n \\n
\\n \\n
\\n \\n ![](\\\"{{item.image}}\\\")
\\n \\n
\\n \\n \\n \\n
\\n ![](\"./img/throttleTime.png\")
\n *\n * `throttleTime` emits the source Observable values on the output Observable\n * when its internal timer is disabled, and ignores source values when the timer\n * is enabled. Initially, the timer is disabled. As soon as the first source\n * value arrives, it is forwarded to the output Observable, and then the timer\n * is enabled. After `duration` milliseconds (or the time unit determined\n * internally by the optional `scheduler`) has passed, the timer is disabled,\n * and this process repeats for the next source value. Optionally takes a\n * {@link IScheduler} for managing timers.\n *\n * @example ![](\"./img/share.png\")
\n *\n * @return {Observable![](\"./img/debounceTime.png\")
\n *\n * `debounceTime` delays values emitted by the source Observable, but drops\n * previous pending delayed emissions if a new value arrives on the source\n * Observable. This operator keeps track of the most recent value from the\n * source Observable, and emits that only when `dueTime` enough time has passed\n * without any other value appearing on the source Observable. If a new value\n * appears before `dueTime` silence occurs, the previous value will be dropped\n * and will not be emitted on the output Observable.\n *\n * This is a rate-limiting operator, because it is impossible for more than one\n * value to be emitted in any time window of duration `dueTime`, but it is also\n * a delay-like operator since output emissions do not occur at the same time as\n * they did on the source Observable. Optionally takes a {@link IScheduler} for\n * managing timers.\n *\n * @example