![](\"./img/delay.png\")
\n *\n * If the delay argument is a Number, this operator time shifts the source\n * Observable by that amount of time expressed in milliseconds. The relative\n * time intervals between the values are preserved.\n *\n * If the delay argument is a Date, this operator time shifts the start of the\n * Observable execution until the given date occurs.\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 tslib_1.__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 tslib_1.__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 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 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 = merge(isCurrentlyStable, 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 */\nexport { Class, createPlatform, assertPlatform, destroyPlatform, getPlatform, PlatformRef, ApplicationRef, enableProdMode, isDevMode, createPlatformFactory, NgProbeToken, APP_ID, PACKAGE_ROOT_URL, PLATFORM_INITIALIZER, PLATFORM_ID, APP_BOOTSTRAP_LISTENER, APP_INITIALIZER, ApplicationInitStatus, DebugElement, DebugNode, asNativeElements, getDebugNode, Testability, TestabilityRegistry, setTestabilityGetter, TRANSLATIONS, TRANSLATIONS_FORMAT, LOCALE_ID, MissingTranslationStrategy, ApplicationModule, wtfCreateScope, wtfLeave, wtfStartTimeRange, wtfEndTimeRange, Type, EventEmitter, ErrorHandler, Sanitizer, SecurityContext, ANALYZE_FOR_ENTRY_COMPONENTS, Attribute, ContentChild, ContentChildren, Query, ViewChild, ViewChildren, Component, Directive, HostBinding, HostListener, Input, Output, Pipe, CUSTOM_ELEMENTS_SCHEMA, NO_ERRORS_SCHEMA, NgModule, ViewEncapsulation, Version, VERSION, forwardRef, resolveForwardRef, Injector, ReflectiveInjector, ResolvedReflectiveFactory, ReflectiveKey, InjectionToken, OpaqueToken, Inject, Optional, Injectable, Self, SkipSelf, Host, NgZone, RenderComponentType, Renderer, Renderer2, RendererFactory2, RendererStyleFlags2, RootRenderer, COMPILER_OPTIONS, Compiler, CompilerFactory, ModuleWithComponentFactories, ComponentFactory, ComponentRef, ComponentFactoryResolver, ElementRef, NgModuleFactory, NgModuleRef, NgModuleFactoryLoader, getModuleFactory, QueryList, SystemJsNgModuleLoader, SystemJsNgModuleLoaderConfig, TemplateRef, ViewContainerRef, EmbeddedViewRef, ViewRef, ChangeDetectionStrategy, ChangeDetectorRef, DefaultIterableDiffer, IterableDiffers, KeyValueDiffers, SimpleChange, WrappedValue, platformCore, ALLOW_MULTIPLE_PLATFORMS as ɵALLOW_MULTIPLE_PLATFORMS, APP_ID_RANDOM_PROVIDER as ɵAPP_ID_RANDOM_PROVIDER, ValueUnwrapper as ɵValueUnwrapper, devModeEqual as ɵdevModeEqual, isListLikeIterable as ɵisListLikeIterable, ChangeDetectorStatus as ɵChangeDetectorStatus, isDefaultChangeDetectionStrategy as ɵisDefaultChangeDetectionStrategy, Console as ɵConsole, ERROR_COMPONENT_TYPE as ɵERROR_COMPONENT_TYPE, ComponentFactory as ɵComponentFactory, CodegenComponentFactoryResolver as ɵCodegenComponentFactoryResolver, ViewMetadata as ɵViewMetadata, ReflectionCapabilities as ɵReflectionCapabilities, RenderDebugInfo as ɵRenderDebugInfo, _global as ɵglobal, looseIdentical as ɵlooseIdentical, stringify as ɵstringify, makeDecorator as ɵmakeDecorator, isObservable as ɵisObservable, isPromise as ɵisPromise, clearProviderOverrides as ɵclearProviderOverrides, overrideProvider as ɵoverrideProvider, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, registerModuleFactory as ɵregisterModuleFactory, EMPTY_ARRAY as ɵEMPTY_ARRAY, EMPTY_MAP as ɵEMPTY_MAP, anchorDef as ɵand, createComponentFactory as ɵccf, createNgModuleFactory as ɵcmf, createRendererType2 as ɵcrt, directiveDef as ɵdid, elementDef as ɵeld, elementEventFullName as ɵelementEventFullName, getComponentViewDefinitionFactory as ɵgetComponentViewDefinitionFactory, inlineInterpolate as ɵinlineInterpolate, interpolate as ɵinterpolate, moduleDef as ɵmod, moduleProvideDef as ɵmpd, ngContentDef as ɵncd, nodeValue as ɵnov, pipeDef as ɵpid, providerDef as ɵprd, pureArrayDef as ɵpad, pureObjectDef as ɵpod, purePipeDef as ɵppd, queryDef as ɵqud, textDef as ɵted, unwrapValue as ɵunv, viewDef as ɵvid, AUTO_STYLE$$1 as AUTO_STYLE, trigger$$1 as trigger, animate$$1 as animate, group$$1 as group, sequence$$1 as sequence, style$$1 as style, state$$1 as state, keyframes$$1 as keyframes, transition$$1 as transition, animate$1 as ɵx, group$1 as ɵy, keyframes$1 as ɵbc, sequence$1 as ɵz, state$1 as ɵbb, style$1 as ɵba, transition$1 as ɵbd, trigger$1 as ɵw, _iterableDiffersFactory as ɵk, _keyValueDiffersFactory as ɵl, _localeFactory as ɵm, ApplicationRef_ as ɵe, _appIdRandomProviderFactory as ɵf, defaultIterableDiffers as ɵg, defaultKeyValueDiffers as ɵh, DefaultIterableDifferFactory as ɵi, DefaultKeyValueDifferFactory as ɵj, ReflectiveInjector_ as ɵb, ReflectiveDependency as ɵc, resolveReflectiveProviders as ɵd, wtfEnabled as ɵn, createScope$1 as ɵp, detectWTF as ɵo, endTimeRange as ɵs, leave as ɵq, startTimeRange as ɵr, makeParamDecorator as ɵa, _def as ɵt, DebugContext as ɵu };\n//# sourceMappingURL=core.es5.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/AZURE/ACEP/Acep.Crm.WebPortal/CrmWebPortalGlobal/Membership/AngularApps/PACED/PACEDAngular/node_modules/@angular/core/@angular/core.es5.js\n// module id = /oeL\n// module chunks = 9","/** PURE_IMPORTS_START PURE_IMPORTS_END */\nexport var isArray = Array.isArray || (function (x) { return x && typeof x.length === 'number'; });\n//# sourceMappingURL=isArray.js.map \n\n\n\n//////////////////\n// WEBPACK FOOTER\n// C:/AZURE/ACEP/Acep.Crm.WebPortal/CrmWebPortalGlobal/Membership/AngularApps/PACED/PACEDAngular/node_modules/rxjs/_esm5/util/isArray.js\n// module id = 1j/l\n// module chunks = 9","/** PURE_IMPORTS_START .._operators_reduce PURE_IMPORTS_END */\nimport { reduce as higherOrderReduce } from '../operators/reduce';\n/* tslint:enable:max-line-length */\n/**\n * Applies an accumulator function over the source Observable, and returns the\n * accumulated result when the source completes, given an optional seed value.\n *\n * Combines together all values emitted on the source,\n * using an accumulator function that knows how to join a new source value into\n * the accumulation from the past.\n *\n * \n * {{ item }}\n *
\n * ![](\"./img/reduce.png\")
\n *\n * Like\n * [Array.prototype.reduce()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce),\n * `reduce` applies an `accumulator` function against an accumulation and each\n * value of the source Observable (from the past) to reduce it to a single\n * value, emitted on the output Observable. Note that `reduce` will only emit\n * one value, only when the source Observable completes. It is equivalent to\n * applying operator {@link scan} followed by operator {@link last}.\n *\n * Returns an Observable that applies a specified `accumulator` function to each\n * item emitted by the source Observable. If a `seed` value is specified, then\n * that value will be used as the initial value for the accumulator. If no seed\n * value is specified, the first item of the source is used as the seed.\n *\n * @example ![](\"./img/merge.png\")
\n *\n * `merge` subscribes to each given input Observable (as arguments), and simply\n * forwards (without doing any transformation) all the values from all the input\n * Observables to the output Observable. The output Observable only completes\n * once all input Observables have completed. Any error delivered by an input\n * Observable will be immediately emitted on the output Observable.\n *\n * @example ![](\"./img/defer.png\")
\n *\n * `defer` allows you to create the Observable only when the Observer\n * subscribes, and create a fresh Observable for each Observer. It waits until\n * an Observer subscribes to it, and then it generates an Observable,\n * typically with an Observable factory function. It does this afresh for each\n * subscriber, so although each subscriber may think it is subscribing to the\n * same Observable, in fact each subscriber gets its own individual\n * Observable.\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 or a complete notification, the output Observable stops\n * mirroring the source Observable and completes.\n *\n * @example ![](\"./img/switchMap.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 time it observes one of these\n * inner Observables, the output Observable begins emitting the items emitted by\n * that inner Observable. When a new inner Observable is emitted, `switchMap`\n * stops emitting items from the earlier-emitted inner Observable and begins\n * emitting items from the new one. It continues to behave like this for\n * subsequent inner Observables.\n *\n * @example ![](\"./img/timer.png\")
\n *\n * `timer` returns an Observable that emits an infinite sequence of ascending\n * integers, with a constant interval of time, `period` of your choosing\n * between those emissions. The first emission happens after the specified\n * `initialDelay`. The initial delay may be a {@link Date}. By default, this\n * operator uses the `async` IScheduler to provide a notion of time, but you\n * may pass any IScheduler to it. If `period` is not specified, the output\n * Observable emits only one value, `0`. Otherwise, it emits an infinite\n * sequence.\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