![](\"./img/catch.png\")
\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/share.png\")
\n *\n * @return {Observable![](\"./img/elementAt.png\")
\n *\n * `elementAt` returns an Observable that emits the item at the specified\n * `index` in the source Observable, or a default value if that `index` is out\n * of range and the `default` argument is provided. If the `default` argument is\n * not given and the `index` is out of range, the output Observable will emit an\n * `ArgumentOutOfRangeError` error.\n *\n * @example ![](\"./img/fromEvent.png\")
\n *\n * Creates an Observable by attaching an event listener to an \"event target\",\n * which may be an object with `addEventListener` and `removeEventListener`,\n * a Node.js EventEmitter, a jQuery style EventEmitter, a NodeList from the\n * DOM, or an HTMLCollection from the DOM. The event handler is attached when\n * the output Observable is subscribed, and removed when the Subscription is\n * unsubscribed.\n *\n * @example ![](\"./img/auditTime.png\")
\n *\n * `auditTime` is similar to `throttleTime`, but emits the last value from the\n * silenced time window, instead of the first value. `auditTime` emits the most\n * recent value from the source Observable on the output Observable as soon as\n * its internal timer becomes disabled, and ignores source values while the\n * timer is enabled. Initially, the timer is disabled. As soon as the first\n * source value arrives, the timer is enabled. After `duration` milliseconds (or\n * the time unit determined internally by the optional `scheduler`) has passed,\n * the timer is disabled, then the most recent source value is emitted on the\n * output Observable, and this process repeats for the next source value.\n * Optionally takes a {@link IScheduler} for managing timers.\n *\n * @example ![](\"./img/repeat.png\")
\n *\n * @param {Scheduler} [scheduler] the IScheduler to emit the items on.\n * @param {number} [count] the number of times the source Observable items are repeated, a count of 0 will yield\n * an empty Observable.\n * @return {Observable} an Observable that repeats the stream of items emitted by the source Observable at most\n * count times.\n * @method repeat\n * @owner Observable\n */\nfunction repeat(count) {\n if (count === void 0) { count = -1; }\n if (count === 0) {\n return new EmptyObservable_1.EmptyObservable();\n }\n else if (count < 0) {\n return this.lift(new RepeatOperator(-1, this));\n }\n else {\n return this.lift(new RepeatOperator(count - 1, this));\n }\n}\nexports.repeat = repeat;\nvar RepeatOperator = (function () {\n function RepeatOperator(count, source) {\n this.count = count;\n this.source = source;\n }\n RepeatOperator.prototype.call = function (subscriber, source) {\n return source.subscribe(new RepeatSubscriber(subscriber, this.count, this.source));\n };\n return RepeatOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar RepeatSubscriber = (function (_super) {\n __extends(RepeatSubscriber, _super);\n function RepeatSubscriber(destination, count, source) {\n _super.call(this, destination);\n this.count = count;\n this.source = source;\n }\n RepeatSubscriber.prototype.complete = function () {\n if (!this.isStopped) {\n var _a = this, source = _a.source, count = _a.count;\n if (count === 0) {\n return _super.prototype.complete.call(this);\n }\n else if (count > -1) {\n this.count = count - 1;\n }\n this.unsubscribe();\n this.isStopped = false;\n this.closed = false;\n source.subscribe(this);\n }\n };\n return RepeatSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=repeat.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/repeat.js\n// module id = 0GXu\n// module chunks = 4","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar publishLast_1 = require('../../operator/publishLast');\nObservable_1.Observable.prototype.publishLast = publishLast_1.publishLast;\n//# sourceMappingURL=publishLast.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/add/operator/publishLast.js\n// module id = 0TiQ\n// module chunks = 4","\"use strict\";\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 OuterSubscriber_1 = require('../OuterSubscriber');\nvar subscribeToResult_1 = require('../util/subscribeToResult');\n/**\n * Emits the most recently emitted value from the source Observable whenever\n * another Observable, the `notifier`, emits.\n *\n * It's like {@link sampleTime}, but samples whenever\n * the `notifier` Observable emits something.\n *\n * ![](\"./img/sample.png\")
\n *\n * Whenever the `notifier` Observable emits a value or completes, `sample`\n * looks at the source Observable and emits whichever value it has most recently\n * emitted since the previous sampling, unless the source has not emitted\n * anything since the previous sampling. The `notifier` is subscribed to as soon\n * as the output Observable is subscribed.\n *\n * @example ![](\"./img/delayWhen.png\")
\n *\n * `delayWhen` time shifts each emitted value from the source Observable by a\n * time span determined by another Observable. When the source emits a value,\n * the `delayDurationSelector` function is called with the source value as\n * argument, and should return an Observable, called the \"duration\" Observable.\n * The source value is emitted on the output Observable only when the duration\n * Observable emits a value or completes.\n *\n * Optionally, `delayWhen` takes a second argument, `subscriptionDelay`, which\n * is an Observable. When `subscriptionDelay` emits its first value or\n * completes, the source Observable is subscribed to and starts behaving like\n * described in the previous paragraph. If `subscriptionDelay` is not provided,\n * `delayWhen` will subscribe to the source Observable as soon as the output\n * Observable is subscribed.\n *\n * @example ![](\"./img/bufferWhen.png\")
\n *\n * Opens a buffer immediately, then closes the buffer when the observable\n * returned by calling `closingSelector` function emits a value. When it closes\n * the buffer, it immediately opens a new buffer and repeats the process.\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 * - `...
`\n * - `...
...
\n * {{value}}
\n * \n *
{minIntegerDigits}.{minFractionDigits}-{maxFractionDigits}\n * - `minIntegerDigits` is the minimum number of integer digits to use. Defaults to `1`.\n * - `minFractionDigits` is the minimum number of digits after fraction. Defaults to `0`.\n * - `maxFractionDigits` is the maximum number of digits after fraction. Defaults to `3`.\n *\n * For more information on the acceptable range for each of these numbers and other\n * details see your native internationalization library.\n *\n * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers\n * and may require a polyfill. See {\\@linkDocs guide/browser-support} for details.\n *\n * ### Example\n *\n * {\\@example common/pipes/ts/number_pipe.ts region='NumberPipe'}\n *\n * \\@stable\n */\nvar DecimalPipe = (function () {\n /**\n * @param {?} _locale\n */\n function DecimalPipe(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} digits\n * @return {?}\n */\n DecimalPipe.prototype.transform = function (value, digits) {\n if (digits === void 0) { digits = null; }\n return formatNumber(DecimalPipe, this._locale, value, NumberFormatStyle.Decimal, digits);\n };\n return DecimalPipe;\n}());\nDecimalPipe.decorators = [\n { type: Pipe, args: [{ name: 'number' },] },\n];\n/**\n * @nocollapse\n */\nDecimalPipe.ctorParameters = function () { return [\n { type: undefined, decorators: [{ type: Inject, args: [LOCALE_ID,] },] },\n]; };\n/**\n * \\@ngModule CommonModule\n * \\@whatItDoes Formats a number as a percentage according to locale rules.\n * \\@howToUse `number_expression | percent[:digitInfo]`\n *\n * \\@description\n *\n * Formats a number as percentage.\n *\n * - `digitInfo` See {\\@link DecimalPipe} for detailed description.\n *\n * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers\n * and may require a polyfill. See {\\@linkDocs guide/browser-support} for details.\n *\n * ### Example\n *\n * {\\@example common/pipes/ts/number_pipe.ts region='PercentPipe'}\n *\n * \\@stable\n */\nvar PercentPipe = (function () {\n /**\n * @param {?} _locale\n */\n function PercentPipe(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} digits\n * @return {?}\n */\n PercentPipe.prototype.transform = function (value, digits) {\n if (digits === void 0) { digits = null; }\n return formatNumber(PercentPipe, this._locale, value, NumberFormatStyle.Percent, digits);\n };\n return PercentPipe;\n}());\nPercentPipe.decorators = [\n { type: Pipe, args: [{ name: 'percent' },] },\n];\n/**\n * @nocollapse\n */\nPercentPipe.ctorParameters = function () { return [\n { type: undefined, decorators: [{ type: Inject, args: [LOCALE_ID,] },] },\n]; };\n/**\n * \\@ngModule CommonModule\n * \\@whatItDoes Formats a number as currency using locale rules.\n * \\@howToUse `number_expression | currency[:currencyCode[:symbolDisplay[:digitInfo]]]`\n * \\@description\n *\n * Use `currency` to format a number as currency.\n *\n * - `currencyCode` is the [ISO 4217](https://en.wikipedia.org/wiki/ISO_4217) currency code, such\n * as `USD` for the US dollar and `EUR` for the euro.\n * - `symbolDisplay` is a boolean indicating whether to use the currency symbol or code.\n * - `true`: use symbol (e.g. `$`).\n * - `false`(default): use code (e.g. `USD`).\n * - `digitInfo` See {\\@link DecimalPipe} for detailed description.\n *\n * WARNING: this pipe uses the Internationalization API which is not yet available in all browsers\n * and may require a polyfill. See {\\@linkDocs guide/browser-support} for details.\n *\n * ### Example\n *\n * {\\@example common/pipes/ts/number_pipe.ts region='CurrencyPipe'}\n *\n * \\@stable\n */\nvar CurrencyPipe = (function () {\n /**\n * @param {?} _locale\n */\n function CurrencyPipe(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} currencyCode\n * @param {?=} symbolDisplay\n * @param {?=} digits\n * @return {?}\n */\n CurrencyPipe.prototype.transform = function (value, currencyCode, symbolDisplay, digits) {\n if (currencyCode === void 0) { currencyCode = 'USD'; }\n if (symbolDisplay === void 0) { symbolDisplay = false; }\n if (digits === void 0) { digits = null; }\n return formatNumber(CurrencyPipe, this._locale, value, NumberFormatStyle.Currency, digits, currencyCode, symbolDisplay);\n };\n return CurrencyPipe;\n}());\nCurrencyPipe.decorators = [\n { type: Pipe, args: [{ name: 'currency' },] },\n];\n/**\n * @nocollapse\n */\nCurrencyPipe.ctorParameters = function () { return [\n { type: undefined, decorators: [{ type: Inject, args: [LOCALE_ID,] },] },\n]; };\n/**\n * @param {?} text\n * @return {?}\n */\nfunction parseIntAutoRadix(text) {\n var /** @type {?} */ result = parseInt(text);\n if (isNaN(result)) {\n throw new Error('Invalid integer literal when parsing ' + text);\n }\n return result;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isNumeric(value) {\n return !isNaN(value - parseFloat(value));\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 */\nvar ISO8601_DATE_REGEX = /^(\\d{4})-?(\\d\\d)-?(\\d\\d)(?:T(\\d\\d)(?::?(\\d\\d)(?::?(\\d\\d)(?:\\.(\\d+))?)?)?(Z|([+-])(\\d\\d):?(\\d\\d))?)?$/;\n/**\n * \\@ngModule CommonModule\n * \\@whatItDoes Formats a date according to locale rules.\n * \\@howToUse `date_expression | date[:format]`\n * \\@description\n *\n * Where:\n * - `expression` is a date object or a number (milliseconds since UTC epoch) or an ISO string\n * (https://www.w3.org/TR/NOTE-datetime).\n * - `format` indicates which date/time components to include. The format can be predefined as\n * shown below or custom as shown in the table.\n * - `'medium'`: equivalent to `'yMMMdjms'` (e.g. `Sep 3, 2010, 12:05:08 PM` for `en-US`)\n * - `'short'`: equivalent to `'yMdjm'` (e.g. `9/3/2010, 12:05 PM` for `en-US`)\n * - `'fullDate'`: equivalent to `'yMMMMEEEEd'` (e.g. `Friday, September 3, 2010` for `en-US`)\n * - `'longDate'`: equivalent to `'yMMMMd'` (e.g. `September 3, 2010` for `en-US`)\n * - `'mediumDate'`: equivalent to `'yMMMd'` (e.g. `Sep 3, 2010` for `en-US`)\n * - `'shortDate'`: equivalent to `'yMd'` (e.g. `9/3/2010` for `en-US`)\n * - `'mediumTime'`: equivalent to `'jms'` (e.g. `12:05:08 PM` for `en-US`)\n * - `'shortTime'`: equivalent to `'jm'` (e.g. `12:05 PM` for `en-US`)\n *\n *\n * | Component | Symbol | Narrow | Short Form | Long Form | Numeric | 2-digit |\n * |-----------|:------:|--------|--------------|-------------------|-----------|-----------|\n * | era | G | G (A) | GGG (AD) | GGGG (Anno Domini)| - | - |\n * | year | y | - | - | - | y (2015) | yy (15) |\n * | month | M | L (S) | MMM (Sep) | MMMM (September) | M (9) | MM (09) |\n * | day | d | - | - | - | d (3) | dd (03) |\n * | weekday | E | E (S) | EEE (Sun) | EEEE (Sunday) | - | - |\n * | hour | j | - | - | - | j (13) | jj (13) |\n * | hour12 | h | - | - | - | h (1 PM) | hh (01 PM)|\n * | hour24 | H | - | - | - | H (13) | HH (13) |\n * | minute | m | - | - | - | m (5) | mm (05) |\n * | second | s | - | - | - | s (9) | ss (09) |\n * | timezone | z | - | - | z (Pacific Standard Time)| - | - |\n * | timezone | Z | - | Z (GMT-8:00) | - | - | - |\n * | timezone | a | - | a (PM) | - | - | - |\n *\n * In javascript, only the components specified will be respected (not the ordering,\n * punctuations, ...) and details of the formatting will be dependent on the locale.\n *\n * Timezone of the formatted text will be the local system timezone of the end-user's machine.\n *\n * When the expression is a ISO string without time (e.g. 2016-09-19) the time zone offset is not\n * applied and the formatted text will have the same day, month and year of the expression.\n *\n * WARNINGS:\n * - this pipe is marked as pure hence it will not be re-evaluated when the input is mutated.\n * Instead users should treat the date as an immutable object and change the reference when the\n * pipe needs to re-run (this is to avoid reformatting the date on every change detection run\n * which would be an expensive operation).\n * - this pipe uses the Internationalization API. Therefore it is only reliable in Chrome and Opera\n * browsers.\n *\n * ### Examples\n *\n * Assuming `dateObj` is (year: 2015, month: 6, day: 15, hour: 21, minute: 43, second: 11)\n * in the _local_ time and locale is 'en-US':\n *\n * ```\n * {{ dateObj | date }} // output is 'Jun 15, 2015'\n * {{ dateObj | date:'medium' }} // output is 'Jun 15, 2015, 9:43:11 PM'\n * {{ dateObj | date:'shortTime' }} // output is '9:43 PM'\n * {{ dateObj | date:'mmss' }} // output is '43:11'\n * ```\n *\n * {\\@example common/pipes/ts/date_pipe.ts region='DatePipe'}\n *\n * \\@stable\n */\nvar DatePipe = (function () {\n /**\n * @param {?} _locale\n */\n function DatePipe(_locale) {\n this._locale = _locale;\n }\n /**\n * @param {?} value\n * @param {?=} pattern\n * @return {?}\n */\n DatePipe.prototype.transform = function (value, pattern) {\n if (pattern === void 0) { pattern = 'mediumDate'; }\n var /** @type {?} */ date;\n if (isBlank(value) || value !== value)\n return null;\n if (typeof value === 'string') {\n value = value.trim();\n }\n if (isDate(value)) {\n date = value;\n }\n else if (isNumeric(value)) {\n date = new Date(parseFloat(value));\n }\n else if (typeof value === 'string' && /^(\\d{4}-\\d{1,2}-\\d{1,2})$/.test(value)) {\n /**\n * For ISO Strings without time the day, month and year must be extracted from the ISO String\n * before Date creation to avoid time offset and errors in the new Date.\n * If we only replace '-' with ',' in the ISO String (\"2015,01,01\"), and try to create a new\n * date, some browsers (e.g. IE 9) will throw an invalid Date error\n * If we leave the '-' (\"2015-01-01\") and try to create a new Date(\"2015-01-01\") the timeoffset\n * is applied\n * Note: ISO months are 0 for January, 1 for February, ...\n */\n var _a = value.split('-').map(function (val) { return parseInt(val, 10); }), y = _a[0], m = _a[1], d = _a[2];\n date = new Date(y, m - 1, d);\n }\n else {\n date = new Date(value);\n }\n if (!isDate(date)) {\n var /** @type {?} */ match = void 0;\n if ((typeof value === 'string') && (match = value.match(ISO8601_DATE_REGEX))) {\n date = isoStringToDate(match);\n }\n else {\n throw invalidPipeArgumentError(DatePipe, value);\n }\n }\n return DateFormatter.format(date, this._locale, DatePipe._ALIASES[pattern] || pattern);\n };\n return DatePipe;\n}());\n/**\n * \\@internal\n */\nDatePipe._ALIASES = {\n 'medium': 'yMMMdjms',\n 'short': 'yMdjm',\n 'fullDate': 'yMMMMEEEEd',\n 'longDate': 'yMMMMd',\n 'mediumDate': 'yMMMd',\n 'shortDate': 'yMd',\n 'mediumTime': 'jms',\n 'shortTime': 'jm'\n};\nDatePipe.decorators = [\n { type: Pipe, args: [{ name: 'date', pure: true },] },\n];\n/**\n * @nocollapse\n */\nDatePipe.ctorParameters = function () { return [\n { type: undefined, decorators: [{ type: Inject, args: [LOCALE_ID,] },] },\n]; };\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction isBlank(obj) {\n return obj == null || obj === '';\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction isDate(obj) {\n return obj instanceof Date && !isNaN(obj.valueOf());\n}\n/**\n * @param {?} match\n * @return {?}\n */\nfunction isoStringToDate(match) {\n var /** @type {?} */ date = new Date(0);\n var /** @type {?} */ tzHour = 0;\n var /** @type {?} */ tzMin = 0;\n var /** @type {?} */ dateSetter = match[8] ? date.setUTCFullYear : date.setFullYear;\n var /** @type {?} */ timeSetter = match[8] ? date.setUTCHours : date.setHours;\n if (match[9]) {\n tzHour = toInt(match[9] + match[10]);\n tzMin = toInt(match[9] + match[11]);\n }\n dateSetter.call(date, toInt(match[1]), toInt(match[2]) - 1, toInt(match[3]));\n var /** @type {?} */ h = toInt(match[4] || '0') - tzHour;\n var /** @type {?} */ m = toInt(match[5] || '0') - tzMin;\n var /** @type {?} */ s = toInt(match[6] || '0');\n var /** @type {?} */ ms = Math.round(parseFloat('0.' + (match[7] || 0)) * 1000);\n timeSetter.call(date, h, m, s, ms);\n return date;\n}\n/**\n * @param {?} str\n * @return {?}\n */\nfunction toInt(str) {\n return parseInt(str, 10);\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 */\nvar _INTERPOLATION_REGEXP = /#/g;\n/**\n * \\@ngModule CommonModule\n * \\@whatItDoes Maps a value to a string that pluralizes the value according to locale rules.\n * \\@howToUse `expression | i18nPlural:mapping`\n * \\@description\n *\n * Where:\n * - `expression` is a number.\n * - `mapping` is an object that mimics the ICU format, see\n * http://userguide.icu-project.org/formatparse/messages\n *\n * ## Example\n *\n * {\\@example common/pipes/ts/i18n_pipe.ts region='I18nPluralPipeComponent'}\n *\n * \\@experimental\n */\nvar I18nPluralPipe = (function () {\n /**\n * @param {?} _localization\n */\n function I18nPluralPipe(_localization) {\n this._localization = _localization;\n }\n /**\n * @param {?} value\n * @param {?} pluralMap\n * @return {?}\n */\n I18nPluralPipe.prototype.transform = function (value, pluralMap) {\n if (value == null)\n return '';\n if (typeof pluralMap !== 'object' || pluralMap === null) {\n throw invalidPipeArgumentError(I18nPluralPipe, pluralMap);\n }\n var /** @type {?} */ key = getPluralCategory(value, Object.keys(pluralMap), this._localization);\n return pluralMap[key].replace(_INTERPOLATION_REGEXP, value.toString());\n };\n return I18nPluralPipe;\n}());\nI18nPluralPipe.decorators = [\n { type: Pipe, args: [{ name: 'i18nPlural', pure: true },] },\n];\n/**\n * @nocollapse\n */\nI18nPluralPipe.ctorParameters = function () { return [\n { type: NgLocalization, },\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 * \\@ngModule CommonModule\n * \\@whatItDoes Generic selector that displays the string that matches the current value.\n * \\@howToUse `expression | i18nSelect:mapping`\n * \\@description\n *\n * Where `mapping` is an object that indicates the text that should be displayed\n * for different values of the provided `expression`.\n * If none of the keys of the mapping match the value of the `expression`, then the content\n * of the `other` key is returned when present, otherwise an empty string is returned.\n *\n * ## Example\n *\n * {\\@example common/pipes/ts/i18n_pipe.ts region='I18nSelectPipeComponent'}\n *\n * \\@experimental\n */\nvar I18nSelectPipe = (function () {\n function I18nSelectPipe() {\n }\n /**\n * @param {?} value\n * @param {?} mapping\n * @return {?}\n */\n I18nSelectPipe.prototype.transform = function (value, mapping) {\n if (value == null)\n return '';\n if (typeof mapping !== 'object' || typeof value !== 'string') {\n throw invalidPipeArgumentError(I18nSelectPipe, mapping);\n }\n if (mapping.hasOwnProperty(value)) {\n return mapping[value];\n }\n if (mapping.hasOwnProperty('other')) {\n return mapping['other'];\n }\n return '';\n };\n return I18nSelectPipe;\n}());\nI18nSelectPipe.decorators = [\n { type: Pipe, args: [{ name: 'i18nSelect', pure: true },] },\n];\n/**\n * @nocollapse\n */\nI18nSelectPipe.ctorParameters = function () { return []; };\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 * \\@ngModule CommonModule\n * \\@whatItDoes Converts value into JSON string.\n * \\@howToUse `expression | json`\n * \\@description\n *\n * Converts value into string using `JSON.stringify`. Useful for debugging.\n *\n * ### Example\n * {\\@example common/pipes/ts/json_pipe.ts region='JsonPipe'}\n *\n * \\@stable\n */\nvar JsonPipe = (function () {\n function JsonPipe() {\n }\n /**\n * @param {?} value\n * @return {?}\n */\n JsonPipe.prototype.transform = function (value) { return JSON.stringify(value, null, 2); };\n return JsonPipe;\n}());\nJsonPipe.decorators = [\n { type: Pipe, args: [{ name: 'json', pure: false },] },\n];\n/**\n * @nocollapse\n */\nJsonPipe.ctorParameters = function () { return []; };\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 * \\@ngModule CommonModule\n * \\@whatItDoes Creates a new List or String containing a subset (slice) of the elements.\n * \\@howToUse `array_or_string_expression | slice:start[:end]`\n * \\@description\n *\n * Where the input expression is a `List` or `String`, and:\n * - `start`: The starting index of the subset to return.\n * - **a positive integer**: return the item at `start` index and all items after\n * in the list or string expression.\n * - **a negative integer**: return the item at `start` index from the end and all items after\n * in the list or string expression.\n * - **if positive and greater than the size of the expression**: return an empty list or string.\n * - **if negative and greater than the size of the expression**: return entire list or string.\n * - `end`: The ending index of the subset to return.\n * - **omitted**: return all items until the end.\n * - **if positive**: return all items before `end` index of the list or string.\n * - **if negative**: return all items before `end` index from the end of the list or string.\n *\n * All behavior is based on the expected behavior of the JavaScript API `Array.prototype.slice()`\n * and `String.prototype.slice()`.\n *\n * When operating on a [List], the returned list is always a copy even when all\n * the elements are being returned.\n *\n * When operating on a blank value, the pipe returns the blank value.\n *\n * ## List Example\n *\n * This `ngFor` example:\n *\n * {\\@example common/pipes/ts/slice_pipe.ts region='SlicePipe_list'}\n *\n * produces the following:\n *\n * ![](\"./img/count.png\")
\n *\n * `count` transforms an Observable that emits values into an Observable that\n * emits a single value that represents the number of values emitted by the\n * source Observable. If the source Observable terminates with an error, `count`\n * will pass this error notification along without emitting a value first. If\n * the source Observable does not terminate at all, `count` will neither emit\n * a value nor terminate. This operator takes an optional `predicate` function\n * as argument, in which case the output emission will represent the number of\n * source values that matched `true` with the `predicate`.\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 this._isStable = true;\n this._nesting = 0;\n this._onUnstable = new EventEmitter(false);\n this._onMicrotaskEmpty = new EventEmitter(false);\n this._onStable = new EventEmitter(false);\n this._onErrorEvents = new EventEmitter(false);\n if (typeof Zone == 'undefined') {\n throw new Error('Angular requires Zone.js prolyfill.');\n }\n Zone.assertZonePatched();\n this.outer = this.inner = Zone.current;\n if (Zone['wtfZoneSpec']) {\n this.inner = this.inner.fork(Zone['wtfZoneSpec']);\n }\n if (enableLongStackTrace && Zone['longStackTraceZoneSpec']) {\n this.inner = this.inner.fork(Zone['longStackTraceZoneSpec']);\n }\n this.forkInnerZoneWithAngularBehavior();\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 `runOutsideAngular` allows you to escape Angular's zone and do 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 Object.defineProperty(NgZone.prototype, \"onUnstable\", {\n /**\n * Notifies when code enters Angular Zone. This gets fired first on VM Turn.\n * @return {?}\n */\n get: function () { return this._onUnstable; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgZone.prototype, \"onMicrotaskEmpty\", {\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 * @return {?}\n */\n get: function () { return this._onMicrotaskEmpty; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgZone.prototype, \"onStable\", {\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 * @return {?}\n */\n get: function () { return this._onStable; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgZone.prototype, \"onError\", {\n /**\n * Notify that an error has been delivered.\n * @return {?}\n */\n get: function () { return this._onErrorEvents; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgZone.prototype, \"isStable\", {\n /**\n * Whether there are no outstanding microtasks or macrotasks.\n * @return {?}\n */\n get: function () { return this._isStable; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgZone.prototype, \"hasPendingMicrotasks\", {\n /**\n * @return {?}\n */\n get: function () { return this._hasPendingMicrotasks; },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(NgZone.prototype, \"hasPendingMacrotasks\", {\n /**\n * @return {?}\n */\n get: function () { return this._hasPendingMacrotasks; },\n enumerable: true,\n configurable: true\n });\n /**\n * @return {?}\n */\n NgZone.prototype.checkStable = function () {\n var _this = this;\n if (this._nesting == 0 && !this._hasPendingMicrotasks && !this._isStable) {\n try {\n this._nesting++;\n this._onMicrotaskEmpty.emit(null);\n }\n finally {\n this._nesting--;\n if (!this._hasPendingMicrotasks) {\n try {\n this.runOutsideAngular(function () { return _this._onStable.emit(null); });\n }\n finally {\n this._isStable = true;\n }\n }\n }\n }\n };\n /**\n * @return {?}\n */\n NgZone.prototype.forkInnerZoneWithAngularBehavior = function () {\n var _this = this;\n this.inner = this.inner.fork({\n name: 'angular',\n properties: /** @type {?} */ ({ 'isAngularZone': true }),\n onInvokeTask: function (delegate, current, target, task, applyThis, applyArgs) {\n try {\n _this.onEnter();\n return delegate.invokeTask(target, task, applyThis, applyArgs);\n }\n finally {\n _this.onLeave();\n }\n },\n onInvoke: function (delegate, current, target, callback, applyThis, applyArgs, source) {\n try {\n _this.onEnter();\n return delegate.invoke(target, callback, applyThis, applyArgs, source);\n }\n finally {\n _this.onLeave();\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 _this.setHasMicrotask(hasTaskState.microTask);\n }\n else if (hasTaskState.change == 'macroTask') {\n _this.setHasMacrotask(hasTaskState.macroTask);\n }\n }\n },\n onHandleError: function (delegate, current, target, error) {\n delegate.handleError(target, error);\n _this.triggerError(error);\n return false;\n }\n });\n };\n /**\n * @return {?}\n */\n NgZone.prototype.onEnter = function () {\n this._nesting++;\n if (this._isStable) {\n this._isStable = false;\n this._onUnstable.emit(null);\n }\n };\n /**\n * @return {?}\n */\n NgZone.prototype.onLeave = function () {\n this._nesting--;\n this.checkStable();\n };\n /**\n * @param {?} hasMicrotasks\n * @return {?}\n */\n NgZone.prototype.setHasMicrotask = function (hasMicrotasks) {\n this._hasPendingMicrotasks = hasMicrotasks;\n this.checkStable();\n };\n /**\n * @param {?} hasMacrotasks\n * @return {?}\n */\n NgZone.prototype.setHasMacrotask = function (hasMacrotasks) { this._hasPendingMacrotasks = hasMacrotasks; };\n /**\n * @param {?} error\n * @return {?}\n */\n NgZone.prototype.triggerError = function (error) { this._onErrorEvents.emit(error); };\n return NgZone;\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); };\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 {\\@link bootstrap}() is called, or\n * explicitly by calling {\\@link createPlatform}().\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 {?} callback\n * @return {?}\n */\nfunction _callAndReportToErrorHandler(errorHandler, callback) {\n try {\n var /** @type {?} */ result = callback();\n if (isPromise(result)) {\n return result.catch(function (e) {\n 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 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 __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, null);\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); });\n ngZone.onError.subscribe({ next: function (error) { exceptionHandler.handleError(error); } });\n return _callAndReportToErrorHandler(exceptionHandler, function () {\n var /** @type {?} */ initStatus = moduleRef.injector.get(ApplicationInitStatus);\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, null);\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 if (ngZone === void 0) { ngZone = null; }\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.bootstrapFactories.length > 0) {\n moduleRef.bootstrapFactories.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 * For more about Angular applications, see the documentation for {\\@link bootstrap}.\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 * ### Example\n * {\\@example core/ts/platform/platform.ts region='longform'}\n * @abstract\n * @template C\n * @param {?} componentFactory\n * @return {?}\n */\n ApplicationRef.prototype.bootstrap = function (componentFactory) { };\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 __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 var 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 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 * @return {?}\n */\n ApplicationRef_.prototype.bootstrap = function (componentOrFactory) {\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 {?} */ compRef = componentFactory.create(Injector.NULL, [], componentFactory.selector, 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 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 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 #setElementProperty} or {\\@link #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 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 Query} and {\\@link ViewQueryMetadata} 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 * tools/gulp-tasks/validate-commit-message.js ```\n *\n * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} name\n * @param {?} definitions\n * @return {?}\n */\nfunction trigger$1(name, definitions) {\n return { name: name, definitions: definitions };\n}\n/**\n * `animate` is an animation-specific function that is designed to be used inside of Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 statrting/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 * @return {?}\n */\nfunction group$1(steps) {\n return { type: 3 /* Group */, steps: steps };\n}\n/**\n * `sequence` is an animation-specific function that is designed to be used inside of Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 * @return {?}\n */\nfunction sequence$1(steps) {\n return { type: 2 /* Sequence */, steps: steps };\n}\n/**\n * `style` is an animation-specific function that is designed to be used inside of Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 };\n}\n/**\n * `state` is an animation-specific function that is designed to be used inside of Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 * @return {?}\n */\nfunction state$1(name, styles) {\n return { type: 0 /* State */, name: name, styles: styles };\n}\n/**\n * `keyframes` is an animation-specific function that is designed to be used inside of Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 /* KeyframeSequence */, steps: steps };\n}\n/**\n * `transition` is an animation-specific function that is designed to be used inside of Angular2's\n * animation DSL language. If this information is new, please navigate to the {\\@link\n * Component#animations-anchor component animations metadata page} to gain a better understanding of\n * how animations in Angular2 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 * {\\@example core/animation/ts/dsl/animation_example.ts region='Component'}\n *\n * \\@experimental Animation support is experimental.\n * @param {?} stateChangeExpr\n * @param {?} steps\n * @return {?}\n */\nfunction transition$1(stateChangeExpr, steps) {\n return { type: 1 /* Transition */, expr: stateChangeExpr, animation: 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 * @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 if (styles === void 0) { styles = null; }\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/**\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, LIFECYCLE_HOOKS_VALUES as ɵLIFECYCLE_HOOKS_VALUES, LifecycleHooks as ɵLifecycleHooks, ViewMetadata as ɵViewMetadata, Reflector as ɵReflector, reflector as ɵreflector, ReflectionCapabilities as ɵReflectionCapabilities, ReflectorReader as ɵReflectorReader, RenderDebugInfo as ɵRenderDebugInfo, _global as ɵglobal, looseIdentical as ɵlooseIdentical, stringify as ɵstringify, makeDecorator as ɵmakeDecorator, isObservable as ɵisObservable, isPromise as ɵisPromise, merge$1 as ɵmerge, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR as ɵNOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR, NgModuleInjector as ɵNgModuleInjector, registerModuleFactory as ɵregisterModuleFactory, EMPTY_ARRAY as ɵEMPTY_ARRAY, EMPTY_MAP as ɵEMPTY_MAP, anchorDef as ɵand, createComponentFactory as ɵccf, createRendererType2 as ɵcrt, directiveDef as ɵdid, elementDef as ɵeld, elementEventFullName as ɵelementEventFullName, getComponentViewDefinitionFactory as ɵgetComponentViewDefinitionFactory, inlineInterpolate as ɵinlineInterpolate, interpolate as ɵinterpolate, 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 ɵba, group$1 as ɵbb, keyframes$1 as ɵbf, sequence$1 as ɵbc, state$1 as ɵbe, style$1 as ɵbd, transition$1 as ɵbg, trigger$1 as ɵz, _initViewEngine as ɵo, _iterableDiffersFactory as ɵl, _keyValueDiffersFactory as ɵm, _localeFactory as ɵn, ApplicationRef_ as ɵf, _appIdRandomProviderFactory as ɵg, defaultIterableDiffers as ɵh, defaultKeyValueDiffers as ɵi, DefaultIterableDifferFactory as ɵj, DefaultKeyValueDifferFactory as ɵk, ReflectiveInjector_ as ɵc, ReflectiveDependency as ɵd, resolveReflectiveProviders as ɵe, wtfEnabled as ɵp, createScope$1 as ɵr, detectWTF as ɵq, endTimeRange as ɵu, leave as ɵs, startTimeRange as ɵt, makeParamDecorator as ɵa, makePropDecorator as ɵb, _def as ɵw, DebugContext as ɵx };\n//# sourceMappingURL=core.es5.js.map\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/@angular/core/@angular/core.es5.js\n// module id = 3j3K\n// module chunks = 4","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar race_1 = require('../../operator/race');\nObservable_1.Observable.prototype.race = race_1.race;\n//# sourceMappingURL=race.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/add/operator/race.js\n// module id = 48bo\n// module chunks = 4","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar publish_1 = require('../../operator/publish');\nObservable_1.Observable.prototype.publish = publish_1.publish;\n//# sourceMappingURL=publish.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/add/operator/publish.js\n// module id = 4Ie8\n// module chunks = 4","\"use strict\";\nvar Subject_1 = require('../Subject');\nvar multicast_1 = require('./multicast');\n/* tslint:disable:max-line-length */\n/**\n * Returns a ConnectableObservable, which is a variety of Observable that waits until its connect method is called\n * before it begins emitting items to those Observers that have subscribed to it.\n *\n * ![](\"./img/publish.png\")
\n *\n * @param {Function} Optional selector function which can use the multicasted source sequence as many times as needed,\n * without causing multiple subscriptions to the source sequence.\n * Subscribers to the given source will receive all notifications of the source from the time of the subscription on.\n * @return a ConnectableObservable that upon connection causes the source Observable to emit items to its Observers.\n * @method publish\n * @owner Observable\n */\nfunction publish(selector) {\n return selector ? multicast_1.multicast.call(this, function () { return new Subject_1.Subject(); }, selector) :\n multicast_1.multicast.call(this, new Subject_1.Subject());\n}\nexports.publish = publish;\n//# sourceMappingURL=publish.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/publish.js\n// module id = 52Ty\n// module chunks = 4","\"use strict\";\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 Subject_1 = require('./Subject');\nvar Subscription_1 = require('./Subscription');\n/**\n * @class AsyncSubject![](\"./img/last.png\")
\n *\n * @throws {EmptyError} Delivers an EmptyError to the Observer's `error`\n * callback if the Observable completes before any `next` notification was sent.\n * @param {function} predicate - the condition any source emitted item has to satisfy.\n * @return {Observable} an Observable that emits only the last item satisfying the given condition\n * from the source, or an NoSuchElementException if no such items are emitted.\n * @throws - Throws if no items that match the predicate are emitted by the source Observable.\n * @method last\n * @owner Observable\n */\nfunction last(predicate, resultSelector, defaultValue) {\n return this.lift(new LastOperator(predicate, resultSelector, defaultValue, this));\n}\nexports.last = last;\nvar LastOperator = (function () {\n function LastOperator(predicate, resultSelector, defaultValue, source) {\n this.predicate = predicate;\n this.resultSelector = resultSelector;\n this.defaultValue = defaultValue;\n this.source = source;\n }\n LastOperator.prototype.call = function (observer, source) {\n return source.subscribe(new LastSubscriber(observer, this.predicate, this.resultSelector, this.defaultValue, this.source));\n };\n return LastOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar LastSubscriber = (function (_super) {\n __extends(LastSubscriber, _super);\n function LastSubscriber(destination, predicate, resultSelector, defaultValue, source) {\n _super.call(this, destination);\n this.predicate = predicate;\n this.resultSelector = resultSelector;\n this.defaultValue = defaultValue;\n this.source = source;\n this.hasValue = false;\n this.index = 0;\n if (typeof defaultValue !== 'undefined') {\n this.lastValue = defaultValue;\n this.hasValue = true;\n }\n }\n LastSubscriber.prototype._next = function (value) {\n var index = this.index++;\n if (this.predicate) {\n this._tryPredicate(value, index);\n }\n else {\n if (this.resultSelector) {\n this._tryResultSelector(value, index);\n return;\n }\n this.lastValue = value;\n this.hasValue = true;\n }\n };\n LastSubscriber.prototype._tryPredicate = function (value, index) {\n var result;\n try {\n result = this.predicate(value, index, this.source);\n }\n catch (err) {\n this.destination.error(err);\n return;\n }\n if (result) {\n if (this.resultSelector) {\n this._tryResultSelector(value, index);\n return;\n }\n this.lastValue = value;\n this.hasValue = true;\n }\n };\n LastSubscriber.prototype._tryResultSelector = function (value, index) {\n var result;\n try {\n result = this.resultSelector(value, index);\n }\n catch (err) {\n this.destination.error(err);\n return;\n }\n this.lastValue = result;\n this.hasValue = true;\n };\n LastSubscriber.prototype._complete = function () {\n var destination = this.destination;\n if (this.hasValue) {\n destination.next(this.lastValue);\n destination.complete();\n }\n else {\n destination.error(new EmptyError_1.EmptyError);\n }\n };\n return LastSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=last.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/last.js\n// module id = 7nvF\n// module chunks = 4","\"use strict\";\nvar ForkJoinObservable_1 = require('./ForkJoinObservable');\nexports.forkJoin = ForkJoinObservable_1.ForkJoinObservable.create;\n//# sourceMappingURL=forkJoin.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/forkJoin.js\n// module id = 7rB9\n// module chunks = 4","\"use strict\";\nvar zip_1 = require('../operator/zip');\nexports.zip = zip_1.zipStatic;\n//# sourceMappingURL=zip.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/zip.js\n// module id = 8/gC\n// module chunks = 4","\"use strict\";\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 = require('../Subscriber');\n/**\n * Returns an Observable that emits whether or not every item of the source satisfies the condition specified.\n *\n * @example ![](\"./img/concat.png\")
\n *\n * Joins this Observable with multiple other Observables by subscribing to them\n * one at a time, starting with the source, and merging their results into the\n * output Observable. Will wait for each Observable to complete before moving\n * on to the next.\n *\n * @example \n *\n * Joins multiple Observables together by subscribing to them one at a time and\n * merging their results into the output Observable. Will wait for each\n * Observable to complete before moving on to the next.\n *\n * @example ![](\"./img/repeatWhen.png\")
\n *\n * @param {notificationHandler} receives an Observable of notifications with which a user can `complete` or `error`,\n * aborting the retry.\n * @param {scheduler} the IScheduler on which to subscribe to the source Observable.\n * @return {Observable} the source Observable modified with retry logic.\n * @method repeatWhen\n * @owner Observable\n */\nfunction repeatWhen(notifier) {\n return this.lift(new RepeatWhenOperator(notifier));\n}\nexports.repeatWhen = repeatWhen;\nvar RepeatWhenOperator = (function () {\n function RepeatWhenOperator(notifier) {\n this.notifier = notifier;\n }\n RepeatWhenOperator.prototype.call = function (subscriber, source) {\n return source.subscribe(new RepeatWhenSubscriber(subscriber, this.notifier, source));\n };\n return RepeatWhenOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar RepeatWhenSubscriber = (function (_super) {\n __extends(RepeatWhenSubscriber, _super);\n function RepeatWhenSubscriber(destination, notifier, source) {\n _super.call(this, destination);\n this.notifier = notifier;\n this.source = source;\n this.sourceIsBeingSubscribedTo = true;\n }\n RepeatWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n this.source.subscribe(this);\n this.sourceIsBeingSubscribedTo = true;\n };\n RepeatWhenSubscriber.prototype.notifyComplete = function (innerSub) {\n if (this.sourceIsBeingSubscribedTo === false) {\n return _super.prototype.complete.call(this);\n }\n };\n RepeatWhenSubscriber.prototype.complete = function () {\n this.sourceIsBeingSubscribedTo = false;\n if (!this.isStopped) {\n if (!this.retries) {\n this.subscribeToRetries();\n }\n else if (this.retriesSubscription.closed) {\n return _super.prototype.complete.call(this);\n }\n this.temporarilyUnsubscribe();\n this.notifications.next();\n }\n };\n RepeatWhenSubscriber.prototype._unsubscribe = function () {\n var _a = this, notifications = _a.notifications, retriesSubscription = _a.retriesSubscription;\n if (notifications) {\n notifications.unsubscribe();\n this.notifications = null;\n }\n if (retriesSubscription) {\n retriesSubscription.unsubscribe();\n this.retriesSubscription = null;\n }\n this.retries = null;\n };\n RepeatWhenSubscriber.prototype.subscribeToRetries = function () {\n this.notifications = new Subject_1.Subject();\n var retries = tryCatch_1.tryCatch(this.notifier)(this.notifications);\n if (retries === errorObject_1.errorObject) {\n return _super.prototype.complete.call(this);\n }\n this.retries = retries;\n this.retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries);\n };\n RepeatWhenSubscriber.prototype.temporarilyUnsubscribe = function () {\n var _a = this, notifications = _a.notifications, retries = _a.retries, retriesSubscription = _a.retriesSubscription;\n this.notifications = null;\n this.retries = null;\n this.retriesSubscription = null;\n this.unsubscribe();\n this.isStopped = false;\n this.closed = false;\n this.notifications = notifications;\n this.retries = retries;\n this.retriesSubscription = retriesSubscription;\n };\n return RepeatWhenSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=repeatWhen.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/repeatWhen.js\n// module id = 8T44\n// module chunks = 4","\"use strict\";\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};\n/**\n * An error thrown when an element was queried at a certain index of an\n * Observable, but no such index or position exists in that sequence.\n *\n * @see {@link elementAt}\n * @see {@link take}\n * @see {@link takeLast}\n *\n * @class ArgumentOutOfRangeError\n */\nvar ArgumentOutOfRangeError = (function (_super) {\n __extends(ArgumentOutOfRangeError, _super);\n function ArgumentOutOfRangeError() {\n var err = _super.call(this, 'argument out of range');\n this.name = err.name = 'ArgumentOutOfRangeError';\n this.stack = err.stack;\n this.message = err.message;\n }\n return ArgumentOutOfRangeError;\n}(Error));\nexports.ArgumentOutOfRangeError = ArgumentOutOfRangeError;\n//# sourceMappingURL=ArgumentOutOfRangeError.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/util/ArgumentOutOfRangeError.js\n// module id = 8Z8y\n// module chunks = 4","\"use strict\";\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 = require('../Subscriber');\nvar tryCatch_1 = require('../util/tryCatch');\nvar errorObject_1 = require('../util/errorObject');\n/* tslint:disable:max-line-length */\n/**\n * Returns an Observable that emits all items emitted by the source Observable that are distinct by comparison from the previous item.\n *\n * If a comparator function is provided, then it will be called for each item to test for whether or not that value should be emitted.\n *\n * If a comparator function is not provided, an equality check is used by default.\n *\n * @example ![](\"./img/isEmpty.png\"){kind=spacer}
\n *\n * @return {Observable} an Observable that emits a Boolean.\n * @method isEmpty\n * @owner Observable\n */\nfunction isEmpty() {\n return this.lift(new IsEmptyOperator());\n}\nexports.isEmpty = isEmpty;\nvar IsEmptyOperator = (function () {\n function IsEmptyOperator() {\n }\n IsEmptyOperator.prototype.call = function (observer, source) {\n return source.subscribe(new IsEmptySubscriber(observer));\n };\n return IsEmptyOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar IsEmptySubscriber = (function (_super) {\n __extends(IsEmptySubscriber, _super);\n function IsEmptySubscriber(destination) {\n _super.call(this, destination);\n }\n IsEmptySubscriber.prototype.notifyComplete = function (isEmpty) {\n var destination = this.destination;\n destination.next(isEmpty);\n destination.complete();\n };\n IsEmptySubscriber.prototype._next = function (value) {\n this.notifyComplete(false);\n };\n IsEmptySubscriber.prototype._complete = function () {\n this.notifyComplete(true);\n };\n return IsEmptySubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=isEmpty.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/isEmpty.js\n// module id = 9TuE\n// module chunks = 4","\"use strict\";\nvar Observable_1 = require('../../Observable');\nvar never_1 = require('../../observable/never');\nObservable_1.Observable.never = never_1.never;\n//# sourceMappingURL=never.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/add/observable/never.js\n// module id = 9WjZ\n// module chunks = 4","\"use strict\";\nvar FromEventPatternObservable_1 = require('./FromEventPatternObservable');\nexports.fromEventPattern = FromEventPatternObservable_1.FromEventPatternObservable.create;\n//# sourceMappingURL=fromEventPattern.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/observable/fromEventPattern.js\n// module id = 9oY/\n// module chunks = 4","\"use strict\";\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 = require('../Subscriber');\n/**\n * Emits the given constant value on the output Observable every time the source\n * Observable emits a value.\n *\n * Like {@link map}, but it maps every source value to\n * the same output value every time.\n *\n * ![](\"./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/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 \n \n \n
\n `,\n styles: [`\n .simple-notification-wrapper {\n position: fixed;\n width: 300px;\n z-index: 1000;\n }\n \n .simple-notification-wrapper.left { left: 20px; }\n .simple-notification-wrapper.top { top: 20px; }\n .simple-notification-wrapper.right { right: 20px; }\n .simple-notification-wrapper.bottom { bottom: 20px; }\n \n @media (max-width: 340px) {\n .simple-notification-wrapper {\n width: auto;\n left: 20px;\n right: 20px;\n }\n }\n `]\n})\n\nexport class SimpleNotificationsComponent implements OnInit, OnDestroy {\n\n @Input() set options(opt: Options) {\n this.attachChanges(opt);\n }\n\n @Output() onCreate = new EventEmitter();\n @Output() onDestroy = new EventEmitter();\n\n public notifications: Notification[] = [];\n public position: ['top' | 'bottom', 'right' | 'left'] = ['bottom', 'right'];\n\n private lastNotificationCreated: Notification;\n private listener: Subscription;\n\n // Received values\n private lastOnBottom = true;\n private maxStack = 8;\n private preventLastDuplicates: any = false;\n private preventDuplicates = false;\n\n // Sent values\n public timeOut = 0;\n public maxLength = 0;\n public clickToClose = true;\n public showProgressBar = true;\n public pauseOnHover = true;\n public theClass = '';\n public rtl = false;\n public animate: 'fromRight' | 'fromLeft' | 'rotate' | 'scale' = 'fromRight';\n\n constructor(private _service: NotificationsService) {}\n\n ngOnInit(): void {\n // Listen for changes in the service\n this.listener = this._service.getChangeEmitter()\n .subscribe(item => {\n switch (item.command) {\n case 'cleanAll':\n this.notifications = [];\n break;\n\n case 'clean':\n this.cleanSingle(item.id!);\n break;\n\n case 'set':\n if (item.add) this.add(item.notification!);\n else this.defaultBehavior(item);\n break;\n\n default:\n this.defaultBehavior(item);\n break;\n }\n });\n }\n\n // Default behavior on event\n defaultBehavior(value: any): void {\n this.notifications.splice(this.notifications.indexOf(value.notification), 1);\n this.onDestroy.emit(this.buildEmit(value.notification, false));\n }\n\n\n // Add the new notification to the notification array\n add(item: Notification): void {\n item.createdOn = new Date();\n\n let toBlock: boolean = this.preventLastDuplicates || this.preventDuplicates ? this.block(item) : false;\n\n // Save this as the last created notification\n this.lastNotificationCreated = item;\n\n if (!toBlock) {\n // Check if the notification should be added at the start or the end of the array\n if (this.lastOnBottom) {\n if (this.notifications.length >= this.maxStack) this.notifications.splice(0, 1);\n this.notifications.push(item);\n } else {\n if (this.notifications.length >= this.maxStack) this.notifications.splice(this.notifications.length - 1, 1);\n this.notifications.splice(0, 0, item);\n }\n\n this.onCreate.emit(this.buildEmit(item, true));\n }\n }\n\n // Check if notifications should be prevented\n block(item: Notification): boolean {\n\n let toCheck = item.html ? this.checkHtml : this.checkStandard;\n\n if (this.preventDuplicates && this.notifications.length > 0) {\n for (let i = 0; i < this.notifications.length; i++) {\n if (toCheck(this.notifications[i], item)) {\n return true;\n }\n }\n }\n\n if (this.preventLastDuplicates) {\n\n let comp: Notification;\n\n if (this.preventLastDuplicates === 'visible' && this.notifications.length > 0) {\n if (this.lastOnBottom) {\n comp = this.notifications[this.notifications.length - 1];\n } else {\n comp = this.notifications[0];\n }\n } else if (this.preventLastDuplicates === 'all' && this.lastNotificationCreated) {\n comp = this.lastNotificationCreated;\n } else {\n return false;\n }\n return toCheck(comp, item);\n }\n\n return false;\n }\n\n checkStandard(checker: Notification, item: Notification): boolean {\n return checker.type === item.type && checker.title === item.title && checker.content === item.content;\n }\n\n checkHtml(checker: Notification, item: Notification): boolean {\n return checker.html ? checker.type === item.type && checker.title === item.title && checker.content === item.content && checker.html === item.html : false;\n }\n\n // Attach all the changes received in the options object\n attachChanges(options: any): void {\n Object.keys(options).forEach(a => {\n if (this.hasOwnProperty(a)) {\n (![](\"./img/ignoreElements.png\")
\n *\n * @return {Observable} an empty Observable that only calls `complete`\n * or `error`, based on which one is called by the source Observable.\n * @method ignoreElements\n * @owner Observable\n */\nfunction ignoreElements() {\n return this.lift(new IgnoreElementsOperator());\n}\nexports.ignoreElements = ignoreElements;\n;\nvar IgnoreElementsOperator = (function () {\n function IgnoreElementsOperator() {\n }\n IgnoreElementsOperator.prototype.call = function (subscriber, source) {\n return source.subscribe(new IgnoreElementsSubscriber(subscriber));\n };\n return IgnoreElementsOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar IgnoreElementsSubscriber = (function (_super) {\n __extends(IgnoreElementsSubscriber, _super);\n function IgnoreElementsSubscriber() {\n _super.apply(this, arguments);\n }\n IgnoreElementsSubscriber.prototype._next = function (unused) {\n noop_1.noop();\n };\n return IgnoreElementsSubscriber;\n}(Subscriber_1.Subscriber));\n//# sourceMappingURL=ignoreElements.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/ignoreElements.js\n// module id = C4lF\n// module chunks = 4","\"use strict\";\nvar AsyncAction_1 = require('./AsyncAction');\nvar AsyncScheduler_1 = require('./AsyncScheduler');\nexports.async = new AsyncScheduler_1.AsyncScheduler(AsyncAction_1.AsyncAction);\n//# sourceMappingURL=async.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/scheduler/async.js\n// module id = CGGv\n// module chunks = 4","/*!\n * calendar: a port of the calendar module from Python\n * Copyright(c) 2011 Luciano Ramalho \n \n \n
\n \n {{ currentMonth }} {{ currentYear }}\n
\n ![](\"./img/concatAll.png\")
\n *\n * Joins every Observable emitted by the source (a higher-order Observable), in\n * a serial fashion. It subscribes to each inner Observable only after the\n * previous inner Observable has completed, and merges all of their values into\n * the returned observable.\n *\n * __Warning:__ If the source Observable emits Observables quickly and\n * endlessly, and the inner Observables it emits generally complete slower than\n * the source emits, you can run into memory issues as the incoming Observables\n * collect in an unbounded buffer.\n *\n * Note: `concatAll` is equivalent to `mergeAll` with concurrency parameter set\n * to `1`.\n *\n * @example ![](\"./img/retryWhen.png\")
\n *\n * @param {notificationHandler} receives an Observable of notifications with which a user can `complete` or `error`,\n * aborting the retry.\n * @param {scheduler} the IScheduler on which to subscribe to the source Observable.\n * @return {Observable} the source Observable modified with retry logic.\n * @method retryWhen\n * @owner Observable\n */\nfunction retryWhen(notifier) {\n return this.lift(new RetryWhenOperator(notifier, this));\n}\nexports.retryWhen = retryWhen;\nvar RetryWhenOperator = (function () {\n function RetryWhenOperator(notifier, source) {\n this.notifier = notifier;\n this.source = source;\n }\n RetryWhenOperator.prototype.call = function (subscriber, source) {\n return source.subscribe(new RetryWhenSubscriber(subscriber, this.notifier, this.source));\n };\n return RetryWhenOperator;\n}());\n/**\n * We need this JSDoc comment for affecting ESDoc.\n * @ignore\n * @extends {Ignored}\n */\nvar RetryWhenSubscriber = (function (_super) {\n __extends(RetryWhenSubscriber, _super);\n function RetryWhenSubscriber(destination, notifier, source) {\n _super.call(this, destination);\n this.notifier = notifier;\n this.source = source;\n }\n RetryWhenSubscriber.prototype.error = function (err) {\n if (!this.isStopped) {\n var errors = this.errors;\n var retries = this.retries;\n var retriesSubscription = this.retriesSubscription;\n if (!retries) {\n errors = new Subject_1.Subject();\n retries = tryCatch_1.tryCatch(this.notifier)(errors);\n if (retries === errorObject_1.errorObject) {\n return _super.prototype.error.call(this, errorObject_1.errorObject.e);\n }\n retriesSubscription = subscribeToResult_1.subscribeToResult(this, retries);\n }\n else {\n this.errors = null;\n this.retriesSubscription = null;\n }\n this.unsubscribe();\n this.closed = false;\n this.errors = errors;\n this.retries = retries;\n this.retriesSubscription = retriesSubscription;\n errors.next(err);\n }\n };\n RetryWhenSubscriber.prototype._unsubscribe = function () {\n var _a = this, errors = _a.errors, retriesSubscription = _a.retriesSubscription;\n if (errors) {\n errors.unsubscribe();\n this.errors = null;\n }\n if (retriesSubscription) {\n retriesSubscription.unsubscribe();\n this.retriesSubscription = null;\n }\n this.retries = null;\n };\n RetryWhenSubscriber.prototype.notifyNext = function (outerValue, innerValue, outerIndex, innerIndex, innerSub) {\n var _a = this, errors = _a.errors, retries = _a.retries, retriesSubscription = _a.retriesSubscription;\n this.errors = null;\n this.retries = null;\n this.retriesSubscription = null;\n this.unsubscribe();\n this.isStopped = false;\n this.closed = false;\n this.errors = errors;\n this.retries = retries;\n this.retriesSubscription = retriesSubscription;\n this.source.subscribe(this);\n };\n return RetryWhenSubscriber;\n}(OuterSubscriber_1.OuterSubscriber));\n//# sourceMappingURL=retryWhen.js.map\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/rxjs/operator/retryWhen.js\n// module id = Cx8F\n// module chunks = 4","\"use strict\";\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 async_1 = require('../scheduler/async');\nvar Subscriber_1 = require('../Subscriber');\nvar isScheduler_1 = require('../util/isScheduler');\n/* tslint:disable:max-line-length */\n/**\n * Buffers the source Observable values for a specific time period.\n *\n * Collects values from the past as an array, and emits\n * those arrays periodically in time.\n *\n * ![](\"./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/throw.png\")
\n *\n * This static operator is useful for creating a simple Observable that only\n * emits the error notification. It can be used for composing with other\n * Observables, such as in a {@link mergeMap}.\n *\n * @example \n\n
\n `,\n styles: [`\n .simple-notification {\n width: 100%;\n padding: 10px 20px;\n box-sizing: border-box;\n position: relative;\n float: left;\n margin-bottom: 10px;\n color: #fff;\n cursor: pointer;\n transition: all 0.5s;\n }\n\n .simple-notification .sn-title {\n margin: 0;\n padding: 0 50px 0 0;\n line-height: 30px;\n font-size: 20px;\n }\n\n .simple-notification .sn-content {\n margin: 0;\n font-size: 16px;\n padding: 0 50px 0 0;\n line-height: 20px;\n }\n\n .simple-notification .icon {\n position: absolute;\n box-sizing: border-box;\n top: 0;\n right: 0;\n width: 70px;\n height: 70px;\n padding: 10px;\n }\n\n .simple-notification .icon svg {\n fill: #fff;\n width: 100%;\n height: 100%;\n }\n\n .simple-notification .icon svg g {\n fill: #fff;\n }\n\n .simple-notification.rtl-mode {\n direction: rtl;\n }\n\n .simple-notification.rtl-mode .sn-content {\n padding: 0 0 0 50px;\n }\n\n .simple-notification.rtl-mode svg {\n left: 0;\n right: auto;\n }\n\n .simple-notification.error { background: #F44336; }\n .simple-notification.success { background: #8BC34A; }\n .simple-notification.alert { background: #ffdb5b; }\n .simple-notification.info { background: #03A9F4; }\n .simple-notification.warn { background: #ffdb5b; }\n\n .simple-notification .sn-progress-loader {\n position: absolute;\n top: 0;\n left: 0;\n width: 100%;\n height: 5px;\n }\n\n .simple-notification .sn-progress-loader span {\n float: left;\n height: 100%;\n }\n\n .simple-notification.success .sn-progress-loader span { background: #689F38; }\n .simple-notification.error .sn-progress-loader span { background: #D32F2F; }\n .simple-notification.alert .sn-progress-loader span { background: #edc242; }\n .simple-notification.info .sn-progress-loader span { background: #0288D1; }\n .simple-notification.warn .sn-progress-loader span { background: #edc242; }\n .simple-notification.bare .sn-progress-loader span { background: #ccc; }\n\n .simple-notification.warn div .sn-title { color: #444; }\n .simple-notification.warn div .sn-content { color: #444; }\n `]\n})\n\nexport class NotificationComponent implements OnInit, OnDestroy {\n\n @Input() public timeOut: number;\n @Input() public showProgressBar: boolean;\n @Input() public pauseOnHover: boolean;\n @Input() public clickToClose: boolean;\n @Input() public maxLength: number;\n @Input() public theClass: string;\n @Input() public rtl: boolean;\n @Input() public animate: string;\n @Input() public position: number;\n @Input() public item: Notification;\n\n\n // Progress bar variables\n public progressWidth = 0;\n public safeSvg: SafeHtml;\n\n private stopTime = false;\n private timer: any;\n private steps: number;\n private speed: number;\n private count = 0;\n private start: any;\n\n private diff: any;\n private icon: string;\n\n constructor(\n private notificationService: NotificationsService,\n private domSanitizer: DomSanitizer,\n private zone: NgZone\n ) {}\n\n ngOnInit(): void {\n if (this.animate) {\n this.item.state = this.animate;\n }\n if (this.item.override) {\n this.attachOverrides();\n }\n if (this.timeOut !== 0) {\n this.startTimeOut();\n }\n\n this.safeSvg = this.domSanitizer.bypassSecurityTrustHtml(this.icon || this.item.icon);\n }\n\n startTimeOut(): void {\n this.steps = this.timeOut / 10;\n this.speed = this.timeOut / this.steps;\n this.start = new Date().getTime();\n this.zone.runOutsideAngular(() => this.timer = setTimeout(this.instance, this.speed));\n }\n\n onEnter(): void {\n if (this.pauseOnHover) {\n this.stopTime = true;\n }\n }\n\n onLeave(): void {\n if (this.pauseOnHover) {\n this.stopTime = false;\n setTimeout(this.instance, (this.speed - this.diff));\n }\n }\n\n setPosition(): number {\n return this.position !== 0 ? this.position * 90 : 0;\n }\n\n onClick($e: MouseEvent): void {\n this.item.click!.emit($e);\n\n if (this.clickToClose) {\n this.remove();\n }\n }\n\n // Attach all the overrides\n attachOverrides(): void {\n Object.keys(this.item.override).forEach(a => {\n if (this.hasOwnProperty(a)) {\n (\n
\n \n\n {{item.title}}
\n {{item.content | max:maxLength}}
\n\n \n \n \n
\n\n ![](\"./img/min.png\")
\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