');\n\n\t\t\t\treturn text.join('');\n\t\t\t}\n\t\t}\n\t};\n\n\tChart.Chart = Chart;\n\n\treturn Chart;\n};\n","//! moment.js locale configuration\n//! locale : Albanian [sq]\n//! author : Flakërim Ismani : https://github.com/flakerimi\n//! author : Menelion Elensúle : https://github.com/Oire\n//! author : Oerd Cukalla : https://github.com/oerd\n\n;(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined'\n && typeof require === 'function' ? factory(require('../moment')) :\n typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n //! moment.js locale configuration\n\n var sq = moment.defineLocale('sq', {\n months: 'Janar_Shkurt_Mars_Prill_Maj_Qershor_Korrik_Gusht_Shtator_Tetor_Nëntor_Dhjetor'.split(\n '_'\n ),\n monthsShort: 'Jan_Shk_Mar_Pri_Maj_Qer_Kor_Gus_Sht_Tet_Nën_Dhj'.split('_'),\n weekdays: 'E Diel_E Hënë_E Martë_E Mërkurë_E Enjte_E Premte_E Shtunë'.split(\n '_'\n ),\n weekdaysShort: 'Die_Hën_Mar_Mër_Enj_Pre_Sht'.split('_'),\n weekdaysMin: 'D_H_Ma_Më_E_P_Sh'.split('_'),\n weekdaysParseExact: true,\n meridiemParse: /PD|MD/,\n isPM: function (input) {\n return input.charAt(0) === 'M';\n },\n meridiem: function (hours, minutes, isLower) {\n return hours < 12 ? 'PD' : 'MD';\n },\n longDateFormat: {\n LT: 'HH:mm',\n LTS: 'HH:mm:ss',\n L: 'DD/MM/YYYY',\n LL: 'D MMMM YYYY',\n LLL: 'D MMMM YYYY HH:mm',\n LLLL: 'dddd, D MMMM YYYY HH:mm',\n },\n calendar: {\n sameDay: '[Sot në] LT',\n nextDay: '[Nesër në] LT',\n nextWeek: 'dddd [në] LT',\n lastDay: '[Dje në] LT',\n lastWeek: 'dddd [e kaluar në] LT',\n sameElse: 'L',\n },\n relativeTime: {\n future: 'në %s',\n past: '%s më parë',\n s: 'disa sekonda',\n ss: '%d sekonda',\n m: 'një minutë',\n mm: '%d minuta',\n h: 'një orë',\n hh: '%d orë',\n d: 'një ditë',\n dd: '%d ditë',\n M: 'një muaj',\n MM: '%d muaj',\n y: 'një vit',\n yy: '%d vite',\n },\n dayOfMonthOrdinalParse: /\\d{1,2}\\./,\n ordinal: '%d.',\n week: {\n dow: 1, // Monday is the first day of the week.\n doy: 4, // The week that contains Jan 4th is the first week of the year.\n },\n });\n\n return sq;\n\n})));\n","//! moment.js locale configuration\n//! locale : Talossan [tzl]\n//! author : Robin van der Vliet : https://github.com/robin0van0der0v\n//! author : Iustì Canun\n\n;(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined'\n && typeof require === 'function' ? factory(require('../moment')) :\n typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n //! moment.js locale configuration\n\n // After the year there should be a slash and the amount of years since December 26, 1979 in Roman numerals.\n // This is currently too difficult (maybe even impossible) to add.\n var tzl = moment.defineLocale('tzl', {\n months: 'Januar_Fevraglh_Març_Avrïu_Mai_Gün_Julia_Guscht_Setemvar_Listopäts_Noemvar_Zecemvar'.split(\n '_'\n ),\n monthsShort: 'Jan_Fev_Mar_Avr_Mai_Gün_Jul_Gus_Set_Lis_Noe_Zec'.split('_'),\n weekdays: 'Súladi_Lúneçi_Maitzi_Márcuri_Xhúadi_Viénerçi_Sáturi'.split('_'),\n weekdaysShort: 'Súl_Lún_Mai_Már_Xhú_Vié_Sát'.split('_'),\n weekdaysMin: 'Sú_Lú_Ma_Má_Xh_Vi_Sá'.split('_'),\n longDateFormat: {\n LT: 'HH.mm',\n LTS: 'HH.mm.ss',\n L: 'DD.MM.YYYY',\n LL: 'D. MMMM [dallas] YYYY',\n LLL: 'D. MMMM [dallas] YYYY HH.mm',\n LLLL: 'dddd, [li] D. MMMM [dallas] YYYY HH.mm',\n },\n meridiemParse: /d\\'o|d\\'a/i,\n isPM: function (input) {\n return \"d'o\" === input.toLowerCase();\n },\n meridiem: function (hours, minutes, isLower) {\n if (hours > 11) {\n return isLower ? \"d'o\" : \"D'O\";\n } else {\n return isLower ? \"d'a\" : \"D'A\";\n }\n },\n calendar: {\n sameDay: '[oxhi à] LT',\n nextDay: '[demà à] LT',\n nextWeek: 'dddd [à] LT',\n lastDay: '[ieiri à] LT',\n lastWeek: '[sür el] dddd [lasteu à] LT',\n sameElse: 'L',\n },\n relativeTime: {\n future: 'osprei %s',\n past: 'ja%s',\n s: processRelativeTime,\n ss: processRelativeTime,\n m: processRelativeTime,\n mm: processRelativeTime,\n h: processRelativeTime,\n hh: processRelativeTime,\n d: processRelativeTime,\n dd: processRelativeTime,\n M: processRelativeTime,\n MM: processRelativeTime,\n y: processRelativeTime,\n yy: processRelativeTime,\n },\n dayOfMonthOrdinalParse: /\\d{1,2}\\./,\n ordinal: '%d.',\n week: {\n dow: 1, // Monday is the first day of the week.\n doy: 4, // The week that contains Jan 4th is the first week of the year.\n },\n });\n\n function processRelativeTime(number, withoutSuffix, key, isFuture) {\n var format = {\n s: ['viensas secunds', \"'iensas secunds\"],\n ss: [number + ' secunds', '' + number + ' secunds'],\n m: [\"'n míut\", \"'iens míut\"],\n mm: [number + ' míuts', '' + number + ' míuts'],\n h: [\"'n þora\", \"'iensa þora\"],\n hh: [number + ' þoras', '' + number + ' þoras'],\n d: [\"'n ziua\", \"'iensa ziua\"],\n dd: [number + ' ziuas', '' + number + ' ziuas'],\n M: [\"'n mes\", \"'iens mes\"],\n MM: [number + ' mesen', '' + number + ' mesen'],\n y: [\"'n ar\", \"'iens ar\"],\n yy: [number + ' ars', '' + number + ' ars'],\n };\n return isFuture\n ? format[key][0]\n : withoutSuffix\n ? format[key][0]\n : format[key][1];\n }\n\n return tzl;\n\n})));\n","//! moment.js locale configuration\n//! locale : Klingon [tlh]\n//! author : Dominika Kruk : https://github.com/amaranthrose\n\n;(function (global, factory) {\n typeof exports === 'object' && typeof module !== 'undefined'\n && typeof require === 'function' ? factory(require('../moment')) :\n typeof define === 'function' && define.amd ? define(['../moment'], factory) :\n factory(global.moment)\n}(this, (function (moment) { 'use strict';\n\n //! moment.js locale configuration\n\n var numbersNouns = 'pagh_wa’_cha’_wej_loS_vagh_jav_Soch_chorgh_Hut'.split('_');\n\n function translateFuture(output) {\n var time = output;\n time =\n output.indexOf('jaj') !== -1\n ? time.slice(0, -3) + 'leS'\n : output.indexOf('jar') !== -1\n ? time.slice(0, -3) + 'waQ'\n : output.indexOf('DIS') !== -1\n ? time.slice(0, -3) + 'nem'\n : time + ' pIq';\n return time;\n }\n\n function translatePast(output) {\n var time = output;\n time =\n output.indexOf('jaj') !== -1\n ? time.slice(0, -3) + 'Hu’'\n : output.indexOf('jar') !== -1\n ? time.slice(0, -3) + 'wen'\n : output.indexOf('DIS') !== -1\n ? time.slice(0, -3) + 'ben'\n : time + ' ret';\n return time;\n }\n\n function translate(number, withoutSuffix, string, isFuture) {\n var numberNoun = numberAsNoun(number);\n switch (string) {\n case 'ss':\n return numberNoun + ' lup';\n case 'mm':\n return numberNoun + ' tup';\n case 'hh':\n return numberNoun + ' rep';\n case 'dd':\n return numberNoun + ' jaj';\n case 'MM':\n return numberNoun + ' jar';\n case 'yy':\n return numberNoun + ' DIS';\n }\n }\n\n function numberAsNoun(number) {\n var hundred = Math.floor((number % 1000) / 100),\n ten = Math.floor((number % 100) / 10),\n one = number % 10,\n word = '';\n if (hundred > 0) {\n word += numbersNouns[hundred] + 'vatlh';\n }\n if (ten > 0) {\n word += (word !== '' ? ' ' : '') + numbersNouns[ten] + 'maH';\n }\n if (one > 0) {\n word += (word !== '' ? ' ' : '') + numbersNouns[one];\n }\n return word === '' ? 'pagh' : word;\n }\n\n var tlh = moment.defineLocale('tlh', {\n months: 'tera’ jar wa’_tera’ jar cha’_tera’ jar wej_tera’ jar loS_tera’ jar vagh_tera’ jar jav_tera’ jar Soch_tera’ jar chorgh_tera’ jar Hut_tera’ jar wa’maH_tera’ jar wa’maH wa’_tera’ jar wa’maH cha’'.split(\n '_'\n ),\n monthsShort:\n 'jar wa’_jar cha’_jar wej_jar loS_jar vagh_jar jav_jar Soch_jar chorgh_jar Hut_jar wa’maH_jar wa’maH wa’_jar wa’maH cha’'.split(\n '_'\n ),\n monthsParseExact: true,\n weekdays: 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split(\n '_'\n ),\n weekdaysShort:\n 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),\n weekdaysMin:\n 'lojmItjaj_DaSjaj_povjaj_ghItlhjaj_loghjaj_buqjaj_ghInjaj'.split('_'),\n longDateFormat: {\n LT: 'HH:mm',\n LTS: 'HH:mm:ss',\n L: 'DD.MM.YYYY',\n LL: 'D MMMM YYYY',\n LLL: 'D MMMM YYYY HH:mm',\n LLLL: 'dddd, D MMMM YYYY HH:mm',\n },\n calendar: {\n sameDay: '[DaHjaj] LT',\n nextDay: '[wa’leS] LT',\n nextWeek: 'LLL',\n lastDay: '[wa’Hu’] LT',\n lastWeek: 'LLL',\n sameElse: 'L',\n },\n relativeTime: {\n future: translateFuture,\n past: translatePast,\n s: 'puS lup',\n ss: translate,\n m: 'wa’ tup',\n mm: translate,\n h: 'wa’ rep',\n hh: translate,\n d: 'wa’ jaj',\n dd: translate,\n M: 'wa’ jar',\n MM: translate,\n y: 'wa’ DIS',\n yy: translate,\n },\n dayOfMonthOrdinalParse: /\\d{1,2}\\./,\n ordinal: '%d.',\n week: {\n dow: 1, // Monday is the first day of the week.\n doy: 4, // The week that contains Jan 4th is the first week of the year.\n },\n });\n\n return tlh;\n\n})));\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar isArray_1 = require(\"./util/isArray\");\nvar isObject_1 = require(\"./util/isObject\");\nvar isFunction_1 = require(\"./util/isFunction\");\nvar UnsubscriptionError_1 = require(\"./util/UnsubscriptionError\");\nvar Subscription = (function () {\n function Subscription(unsubscribe) {\n this.closed = false;\n this._parentOrParents = null;\n this._subscriptions = null;\n if (unsubscribe) {\n this._ctorUnsubscribe = true;\n this._unsubscribe = unsubscribe;\n }\n }\n Subscription.prototype.unsubscribe = function () {\n var errors;\n if (this.closed) {\n return;\n }\n var _a = this, _parentOrParents = _a._parentOrParents, _ctorUnsubscribe = _a._ctorUnsubscribe, _unsubscribe = _a._unsubscribe, _subscriptions = _a._subscriptions;\n this.closed = true;\n this._parentOrParents = null;\n this._subscriptions = null;\n if (_parentOrParents instanceof Subscription) {\n _parentOrParents.remove(this);\n }\n else if (_parentOrParents !== null) {\n for (var index = 0; index < _parentOrParents.length; ++index) {\n var parent_1 = _parentOrParents[index];\n parent_1.remove(this);\n }\n }\n if (isFunction_1.isFunction(_unsubscribe)) {\n if (_ctorUnsubscribe) {\n this._unsubscribe = undefined;\n }\n try {\n _unsubscribe.call(this);\n }\n catch (e) {\n errors = e instanceof UnsubscriptionError_1.UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];\n }\n }\n if (isArray_1.isArray(_subscriptions)) {\n var index = -1;\n var len = _subscriptions.length;\n while (++index < len) {\n var sub = _subscriptions[index];\n if (isObject_1.isObject(sub)) {\n try {\n sub.unsubscribe();\n }\n catch (e) {\n errors = errors || [];\n if (e instanceof UnsubscriptionError_1.UnsubscriptionError) {\n errors = errors.concat(flattenUnsubscriptionErrors(e.errors));\n }\n else {\n errors.push(e);\n }\n }\n }\n }\n }\n if (errors) {\n throw new UnsubscriptionError_1.UnsubscriptionError(errors);\n }\n };\n Subscription.prototype.add = function (teardown) {\n var subscription = teardown;\n if (!teardown) {\n return Subscription.EMPTY;\n }\n switch (typeof teardown) {\n case 'function':\n subscription = new Subscription(teardown);\n case 'object':\n if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {\n return subscription;\n }\n else if (this.closed) {\n subscription.unsubscribe();\n return subscription;\n }\n else if (!(subscription instanceof Subscription)) {\n var tmp = subscription;\n subscription = new Subscription();\n subscription._subscriptions = [tmp];\n }\n break;\n default: {\n throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n }\n }\n var _parentOrParents = subscription._parentOrParents;\n if (_parentOrParents === null) {\n subscription._parentOrParents = this;\n }\n else if (_parentOrParents instanceof Subscription) {\n if (_parentOrParents === this) {\n return subscription;\n }\n subscription._parentOrParents = [_parentOrParents, this];\n }\n else if (_parentOrParents.indexOf(this) === -1) {\n _parentOrParents.push(this);\n }\n else {\n return subscription;\n }\n var subscriptions = this._subscriptions;\n if (subscriptions === null) {\n this._subscriptions = [subscription];\n }\n else {\n subscriptions.push(subscription);\n }\n return subscription;\n };\n Subscription.prototype.remove = function (subscription) {\n var subscriptions = this._subscriptions;\n if (subscriptions) {\n var subscriptionIndex = subscriptions.indexOf(subscription);\n if (subscriptionIndex !== -1) {\n subscriptions.splice(subscriptionIndex, 1);\n }\n }\n };\n Subscription.EMPTY = (function (empty) {\n empty.closed = true;\n return empty;\n }(new Subscription()));\n return Subscription;\n}());\nexports.Subscription = Subscription;\nfunction flattenUnsubscriptionErrors(errors) {\n return errors.reduce(function (errs, err) { return errs.concat((err instanceof UnsubscriptionError_1.UnsubscriptionError) ? err.errors : err); }, []);\n}\n//# sourceMappingURL=Subscription.js.map","export function isFunction(x) {\n return typeof x === 'function';\n}\n//# sourceMappingURL=isFunction.js.map","let _enable_super_gross_mode_that_will_cause_bad_things = false;\nexport const config = {\n Promise: undefined,\n set useDeprecatedSynchronousErrorHandling(value) {\n if (value) {\n const error = new Error();\n console.warn('DEPRECATED! RxJS was set to use deprecated synchronous error handling behavior by code at: \\n' + error.stack);\n }\n else if (_enable_super_gross_mode_that_will_cause_bad_things) {\n console.log('RxJS: Back to a better error behavior. Thank you. <3');\n }\n _enable_super_gross_mode_that_will_cause_bad_things = value;\n },\n get useDeprecatedSynchronousErrorHandling() {\n return _enable_super_gross_mode_that_will_cause_bad_things;\n },\n};\n//# sourceMappingURL=config.js.map","export function hostReportError(err) {\n setTimeout(() => { throw err; }, 0);\n}\n//# sourceMappingURL=hostReportError.js.map","import { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nexport const empty = {\n closed: true,\n next(value) { },\n error(err) {\n if (config.useDeprecatedSynchronousErrorHandling) {\n throw err;\n }\n else {\n hostReportError(err);\n }\n },\n complete() { }\n};\n//# sourceMappingURL=Observer.js.map","export const isArray = (() => Array.isArray || ((x) => x && typeof x.length === 'number'))();\n//# sourceMappingURL=isArray.js.map","export function isObject(x) {\n return x !== null && typeof x === 'object';\n}\n//# sourceMappingURL=isObject.js.map","const UnsubscriptionErrorImpl = (() => {\n function UnsubscriptionErrorImpl(errors) {\n Error.call(this);\n this.message = errors ?\n `${errors.length} errors occurred during unsubscription:\n${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\\n ')}` : '';\n this.name = 'UnsubscriptionError';\n this.errors = errors;\n return this;\n }\n UnsubscriptionErrorImpl.prototype = Object.create(Error.prototype);\n return UnsubscriptionErrorImpl;\n})();\nexport const UnsubscriptionError = UnsubscriptionErrorImpl;\n//# sourceMappingURL=UnsubscriptionError.js.map","import { isArray } from './util/isArray';\nimport { isObject } from './util/isObject';\nimport { isFunction } from './util/isFunction';\nimport { UnsubscriptionError } from './util/UnsubscriptionError';\nexport class Subscription {\n constructor(unsubscribe) {\n this.closed = false;\n this._parentOrParents = null;\n this._subscriptions = null;\n if (unsubscribe) {\n this._ctorUnsubscribe = true;\n this._unsubscribe = unsubscribe;\n }\n }\n unsubscribe() {\n let errors;\n if (this.closed) {\n return;\n }\n let { _parentOrParents, _ctorUnsubscribe, _unsubscribe, _subscriptions } = this;\n this.closed = true;\n this._parentOrParents = null;\n this._subscriptions = null;\n if (_parentOrParents instanceof Subscription) {\n _parentOrParents.remove(this);\n }\n else if (_parentOrParents !== null) {\n for (let index = 0; index < _parentOrParents.length; ++index) {\n const parent = _parentOrParents[index];\n parent.remove(this);\n }\n }\n if (isFunction(_unsubscribe)) {\n if (_ctorUnsubscribe) {\n this._unsubscribe = undefined;\n }\n try {\n _unsubscribe.call(this);\n }\n catch (e) {\n errors = e instanceof UnsubscriptionError ? flattenUnsubscriptionErrors(e.errors) : [e];\n }\n }\n if (isArray(_subscriptions)) {\n let index = -1;\n let len = _subscriptions.length;\n while (++index < len) {\n const sub = _subscriptions[index];\n if (isObject(sub)) {\n try {\n sub.unsubscribe();\n }\n catch (e) {\n errors = errors || [];\n if (e instanceof UnsubscriptionError) {\n errors = errors.concat(flattenUnsubscriptionErrors(e.errors));\n }\n else {\n errors.push(e);\n }\n }\n }\n }\n }\n if (errors) {\n throw new UnsubscriptionError(errors);\n }\n }\n add(teardown) {\n let subscription = teardown;\n if (!teardown) {\n return Subscription.EMPTY;\n }\n switch (typeof teardown) {\n case 'function':\n subscription = new Subscription(teardown);\n case 'object':\n if (subscription === this || subscription.closed || typeof subscription.unsubscribe !== 'function') {\n return subscription;\n }\n else if (this.closed) {\n subscription.unsubscribe();\n return subscription;\n }\n else if (!(subscription instanceof Subscription)) {\n const tmp = subscription;\n subscription = new Subscription();\n subscription._subscriptions = [tmp];\n }\n break;\n default: {\n throw new Error('unrecognized teardown ' + teardown + ' added to Subscription.');\n }\n }\n let { _parentOrParents } = subscription;\n if (_parentOrParents === null) {\n subscription._parentOrParents = this;\n }\n else if (_parentOrParents instanceof Subscription) {\n if (_parentOrParents === this) {\n return subscription;\n }\n subscription._parentOrParents = [_parentOrParents, this];\n }\n else if (_parentOrParents.indexOf(this) === -1) {\n _parentOrParents.push(this);\n }\n else {\n return subscription;\n }\n const subscriptions = this._subscriptions;\n if (subscriptions === null) {\n this._subscriptions = [subscription];\n }\n else {\n subscriptions.push(subscription);\n }\n return subscription;\n }\n remove(subscription) {\n const subscriptions = this._subscriptions;\n if (subscriptions) {\n const subscriptionIndex = subscriptions.indexOf(subscription);\n if (subscriptionIndex !== -1) {\n subscriptions.splice(subscriptionIndex, 1);\n }\n }\n }\n}\nSubscription.EMPTY = (function (empty) {\n empty.closed = true;\n return empty;\n}(new Subscription()));\nfunction flattenUnsubscriptionErrors(errors) {\n return errors.reduce((errs, err) => errs.concat((err instanceof UnsubscriptionError) ? err.errors : err), []);\n}\n//# sourceMappingURL=Subscription.js.map","export const rxSubscriber = (() => typeof Symbol === 'function'\n ? Symbol('rxSubscriber')\n : '@@rxSubscriber_' + Math.random())();\nexport const $$rxSubscriber = rxSubscriber;\n//# sourceMappingURL=rxSubscriber.js.map","import { isFunction } from './util/isFunction';\nimport { empty as emptyObserver } from './Observer';\nimport { Subscription } from './Subscription';\nimport { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';\nimport { config } from './config';\nimport { hostReportError } from './util/hostReportError';\nexport class Subscriber extends Subscription {\n constructor(destinationOrNext, error, complete) {\n super();\n this.syncErrorValue = null;\n this.syncErrorThrown = false;\n this.syncErrorThrowable = false;\n this.isStopped = false;\n switch (arguments.length) {\n case 0:\n this.destination = emptyObserver;\n break;\n case 1:\n if (!destinationOrNext) {\n this.destination = emptyObserver;\n break;\n }\n if (typeof destinationOrNext === 'object') {\n if (destinationOrNext instanceof Subscriber) {\n this.syncErrorThrowable = destinationOrNext.syncErrorThrowable;\n this.destination = destinationOrNext;\n destinationOrNext.add(this);\n }\n else {\n this.syncErrorThrowable = true;\n this.destination = new SafeSubscriber(this, destinationOrNext);\n }\n break;\n }\n default:\n this.syncErrorThrowable = true;\n this.destination = new SafeSubscriber(this, destinationOrNext, error, complete);\n break;\n }\n }\n [rxSubscriberSymbol]() { return this; }\n static create(next, error, complete) {\n const subscriber = new Subscriber(next, error, complete);\n subscriber.syncErrorThrowable = false;\n return subscriber;\n }\n next(value) {\n if (!this.isStopped) {\n this._next(value);\n }\n }\n error(err) {\n if (!this.isStopped) {\n this.isStopped = true;\n this._error(err);\n }\n }\n complete() {\n if (!this.isStopped) {\n this.isStopped = true;\n this._complete();\n }\n }\n unsubscribe() {\n if (this.closed) {\n return;\n }\n this.isStopped = true;\n super.unsubscribe();\n }\n _next(value) {\n this.destination.next(value);\n }\n _error(err) {\n this.destination.error(err);\n this.unsubscribe();\n }\n _complete() {\n this.destination.complete();\n this.unsubscribe();\n }\n _unsubscribeAndRecycle() {\n const { _parentOrParents } = this;\n this._parentOrParents = null;\n this.unsubscribe();\n this.closed = false;\n this.isStopped = false;\n this._parentOrParents = _parentOrParents;\n return this;\n }\n}\nexport class SafeSubscriber extends Subscriber {\n constructor(_parentSubscriber, observerOrNext, error, complete) {\n super();\n this._parentSubscriber = _parentSubscriber;\n let next;\n let context = this;\n if (isFunction(observerOrNext)) {\n next = observerOrNext;\n }\n else if (observerOrNext) {\n next = observerOrNext.next;\n error = observerOrNext.error;\n complete = observerOrNext.complete;\n if (observerOrNext !== emptyObserver) {\n context = Object.create(observerOrNext);\n if (isFunction(context.unsubscribe)) {\n this.add(context.unsubscribe.bind(context));\n }\n context.unsubscribe = this.unsubscribe.bind(this);\n }\n }\n this._context = context;\n this._next = next;\n this._error = error;\n this._complete = complete;\n }\n next(value) {\n if (!this.isStopped && this._next) {\n const { _parentSubscriber } = this;\n if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n this.__tryOrUnsub(this._next, value);\n }\n else if (this.__tryOrSetError(_parentSubscriber, this._next, value)) {\n this.unsubscribe();\n }\n }\n }\n error(err) {\n if (!this.isStopped) {\n const { _parentSubscriber } = this;\n const { useDeprecatedSynchronousErrorHandling } = config;\n if (this._error) {\n if (!useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n this.__tryOrUnsub(this._error, err);\n this.unsubscribe();\n }\n else {\n this.__tryOrSetError(_parentSubscriber, this._error, err);\n this.unsubscribe();\n }\n }\n else if (!_parentSubscriber.syncErrorThrowable) {\n this.unsubscribe();\n if (useDeprecatedSynchronousErrorHandling) {\n throw err;\n }\n hostReportError(err);\n }\n else {\n if (useDeprecatedSynchronousErrorHandling) {\n _parentSubscriber.syncErrorValue = err;\n _parentSubscriber.syncErrorThrown = true;\n }\n else {\n hostReportError(err);\n }\n this.unsubscribe();\n }\n }\n }\n complete() {\n if (!this.isStopped) {\n const { _parentSubscriber } = this;\n if (this._complete) {\n const wrappedComplete = () => this._complete.call(this._context);\n if (!config.useDeprecatedSynchronousErrorHandling || !_parentSubscriber.syncErrorThrowable) {\n this.__tryOrUnsub(wrappedComplete);\n this.unsubscribe();\n }\n else {\n this.__tryOrSetError(_parentSubscriber, wrappedComplete);\n this.unsubscribe();\n }\n }\n else {\n this.unsubscribe();\n }\n }\n }\n __tryOrUnsub(fn, value) {\n try {\n fn.call(this._context, value);\n }\n catch (err) {\n this.unsubscribe();\n if (config.useDeprecatedSynchronousErrorHandling) {\n throw err;\n }\n else {\n hostReportError(err);\n }\n }\n }\n __tryOrSetError(parent, fn, value) {\n if (!config.useDeprecatedSynchronousErrorHandling) {\n throw new Error('bad call');\n }\n try {\n fn.call(this._context, value);\n }\n catch (err) {\n if (config.useDeprecatedSynchronousErrorHandling) {\n parent.syncErrorValue = err;\n parent.syncErrorThrown = true;\n return true;\n }\n else {\n hostReportError(err);\n return true;\n }\n }\n return false;\n }\n _unsubscribe() {\n const { _parentSubscriber } = this;\n this._context = null;\n this._parentSubscriber = null;\n _parentSubscriber.unsubscribe();\n }\n}\n//# sourceMappingURL=Subscriber.js.map","export const observable = (() => typeof Symbol === 'function' && Symbol.observable || '@@observable')();\n//# sourceMappingURL=observable.js.map","export function identity(x) {\n return x;\n}\n//# sourceMappingURL=identity.js.map","import { identity } from './identity';\nexport function pipe(...fns) {\n return pipeFromArray(fns);\n}\nexport function pipeFromArray(fns) {\n if (fns.length === 0) {\n return identity;\n }\n if (fns.length === 1) {\n return fns[0];\n }\n return function piped(input) {\n return fns.reduce((prev, fn) => fn(prev), input);\n };\n}\n//# sourceMappingURL=pipe.js.map","import { canReportError } from './util/canReportError';\nimport { toSubscriber } from './util/toSubscriber';\nimport { observable as Symbol_observable } from './symbol/observable';\nimport { pipeFromArray } from './util/pipe';\nimport { config } from './config';\nexport class Observable {\n constructor(subscribe) {\n this._isScalar = false;\n if (subscribe) {\n this._subscribe = subscribe;\n }\n }\n lift(operator) {\n const observable = new Observable();\n observable.source = this;\n observable.operator = operator;\n return observable;\n }\n subscribe(observerOrNext, error, complete) {\n const { operator } = this;\n const sink = toSubscriber(observerOrNext, error, complete);\n if (operator) {\n sink.add(operator.call(sink, this.source));\n }\n else {\n sink.add(this.source || (config.useDeprecatedSynchronousErrorHandling && !sink.syncErrorThrowable) ?\n this._subscribe(sink) :\n this._trySubscribe(sink));\n }\n if (config.useDeprecatedSynchronousErrorHandling) {\n if (sink.syncErrorThrowable) {\n sink.syncErrorThrowable = false;\n if (sink.syncErrorThrown) {\n throw sink.syncErrorValue;\n }\n }\n }\n return sink;\n }\n _trySubscribe(sink) {\n try {\n return this._subscribe(sink);\n }\n catch (err) {\n if (config.useDeprecatedSynchronousErrorHandling) {\n sink.syncErrorThrown = true;\n sink.syncErrorValue = err;\n }\n if (canReportError(sink)) {\n sink.error(err);\n }\n else {\n console.warn(err);\n }\n }\n }\n forEach(next, promiseCtor) {\n promiseCtor = getPromiseCtor(promiseCtor);\n return new promiseCtor((resolve, reject) => {\n let subscription;\n subscription = this.subscribe((value) => {\n try {\n next(value);\n }\n catch (err) {\n reject(err);\n if (subscription) {\n subscription.unsubscribe();\n }\n }\n }, reject, resolve);\n });\n }\n _subscribe(subscriber) {\n const { source } = this;\n return source && source.subscribe(subscriber);\n }\n [Symbol_observable]() {\n return this;\n }\n pipe(...operations) {\n if (operations.length === 0) {\n return this;\n }\n return pipeFromArray(operations)(this);\n }\n toPromise(promiseCtor) {\n promiseCtor = getPromiseCtor(promiseCtor);\n return new promiseCtor((resolve, reject) => {\n let value;\n this.subscribe((x) => value = x, (err) => reject(err), () => resolve(value));\n });\n }\n}\nObservable.create = (subscribe) => {\n return new Observable(subscribe);\n};\nfunction getPromiseCtor(promiseCtor) {\n if (!promiseCtor) {\n promiseCtor = config.Promise || Promise;\n }\n if (!promiseCtor) {\n throw new Error('no Promise impl found');\n }\n return promiseCtor;\n}\n//# sourceMappingURL=Observable.js.map","import { Subscriber } from '../Subscriber';\nimport { rxSubscriber as rxSubscriberSymbol } from '../symbol/rxSubscriber';\nimport { empty as emptyObserver } from '../Observer';\nexport function toSubscriber(nextOrObserver, error, complete) {\n if (nextOrObserver) {\n if (nextOrObserver instanceof Subscriber) {\n return nextOrObserver;\n }\n if (nextOrObserver[rxSubscriberSymbol]) {\n return nextOrObserver[rxSubscriberSymbol]();\n }\n }\n if (!nextOrObserver && !error && !complete) {\n return new Subscriber(emptyObserver);\n }\n return new Subscriber(nextOrObserver, error, complete);\n}\n//# sourceMappingURL=toSubscriber.js.map","import { Subscriber } from '../Subscriber';\nexport function canReportError(observer) {\n while (observer) {\n const { closed, destination, isStopped } = observer;\n if (closed || isStopped) {\n return false;\n }\n else if (destination && destination instanceof Subscriber) {\n observer = destination;\n }\n else {\n observer = null;\n }\n }\n return true;\n}\n//# sourceMappingURL=canReportError.js.map","const ObjectUnsubscribedErrorImpl = (() => {\n function ObjectUnsubscribedErrorImpl() {\n Error.call(this);\n this.message = 'object unsubscribed';\n this.name = 'ObjectUnsubscribedError';\n return this;\n }\n ObjectUnsubscribedErrorImpl.prototype = Object.create(Error.prototype);\n return ObjectUnsubscribedErrorImpl;\n})();\nexport const ObjectUnsubscribedError = ObjectUnsubscribedErrorImpl;\n//# sourceMappingURL=ObjectUnsubscribedError.js.map","import { Subscription } from './Subscription';\nexport class SubjectSubscription extends Subscription {\n constructor(subject, subscriber) {\n super();\n this.subject = subject;\n this.subscriber = subscriber;\n this.closed = false;\n }\n unsubscribe() {\n if (this.closed) {\n return;\n }\n this.closed = true;\n const subject = this.subject;\n const observers = subject.observers;\n this.subject = null;\n if (!observers || observers.length === 0 || subject.isStopped || subject.closed) {\n return;\n }\n const subscriberIndex = observers.indexOf(this.subscriber);\n if (subscriberIndex !== -1) {\n observers.splice(subscriberIndex, 1);\n }\n }\n}\n//# sourceMappingURL=SubjectSubscription.js.map","import { Observable } from './Observable';\nimport { Subscriber } from './Subscriber';\nimport { Subscription } from './Subscription';\nimport { ObjectUnsubscribedError } from './util/ObjectUnsubscribedError';\nimport { SubjectSubscription } from './SubjectSubscription';\nimport { rxSubscriber as rxSubscriberSymbol } from '../internal/symbol/rxSubscriber';\nexport class SubjectSubscriber extends Subscriber {\n constructor(destination) {\n super(destination);\n this.destination = destination;\n }\n}\nexport class Subject extends Observable {\n constructor() {\n super();\n this.observers = [];\n this.closed = false;\n this.isStopped = false;\n this.hasError = false;\n this.thrownError = null;\n }\n [rxSubscriberSymbol]() {\n return new SubjectSubscriber(this);\n }\n lift(operator) {\n const subject = new AnonymousSubject(this, this);\n subject.operator = operator;\n return subject;\n }\n next(value) {\n if (this.closed) {\n throw new ObjectUnsubscribedError();\n }\n if (!this.isStopped) {\n const { observers } = this;\n const len = observers.length;\n const copy = observers.slice();\n for (let i = 0; i < len; i++) {\n copy[i].next(value);\n }\n }\n }\n error(err) {\n if (this.closed) {\n throw new ObjectUnsubscribedError();\n }\n this.hasError = true;\n this.thrownError = err;\n this.isStopped = true;\n const { observers } = this;\n const len = observers.length;\n const copy = observers.slice();\n for (let i = 0; i < len; i++) {\n copy[i].error(err);\n }\n this.observers.length = 0;\n }\n complete() {\n if (this.closed) {\n throw new ObjectUnsubscribedError();\n }\n this.isStopped = true;\n const { observers } = this;\n const len = observers.length;\n const copy = observers.slice();\n for (let i = 0; i < len; i++) {\n copy[i].complete();\n }\n this.observers.length = 0;\n }\n unsubscribe() {\n this.isStopped = true;\n this.closed = true;\n this.observers = null;\n }\n _trySubscribe(subscriber) {\n if (this.closed) {\n throw new ObjectUnsubscribedError();\n }\n else {\n return super._trySubscribe(subscriber);\n }\n }\n _subscribe(subscriber) {\n if (this.closed) {\n throw new ObjectUnsubscribedError();\n }\n else if (this.hasError) {\n subscriber.error(this.thrownError);\n return Subscription.EMPTY;\n }\n else if (this.isStopped) {\n subscriber.complete();\n return Subscription.EMPTY;\n }\n else {\n this.observers.push(subscriber);\n return new SubjectSubscription(this, subscriber);\n }\n }\n asObservable() {\n const observable = new Observable();\n observable.source = this;\n return observable;\n }\n}\nSubject.create = (destination, source) => {\n return new AnonymousSubject(destination, source);\n};\nexport class AnonymousSubject extends Subject {\n constructor(destination, source) {\n super();\n this.destination = destination;\n this.source = source;\n }\n next(value) {\n const { destination } = this;\n if (destination && destination.next) {\n destination.next(value);\n }\n }\n error(err) {\n const { destination } = this;\n if (destination && destination.error) {\n this.destination.error(err);\n }\n }\n complete() {\n const { destination } = this;\n if (destination && destination.complete) {\n this.destination.complete();\n }\n }\n _subscribe(subscriber) {\n const { source } = this;\n if (source) {\n return this.source.subscribe(subscriber);\n }\n else {\n return Subscription.EMPTY;\n }\n }\n}\n//# sourceMappingURL=Subject.js.map","export function isScheduler(value) {\n return value && typeof value.schedule === 'function';\n}\n//# sourceMappingURL=isScheduler.js.map","import { Subscriber } from '../Subscriber';\nexport function map(project, thisArg) {\n return function mapOperation(source) {\n if (typeof project !== 'function') {\n throw new TypeError('argument is not a function. Are you looking for `mapTo()`?');\n }\n return source.lift(new MapOperator(project, thisArg));\n };\n}\nexport class MapOperator {\n constructor(project, thisArg) {\n this.project = project;\n this.thisArg = thisArg;\n }\n call(subscriber, source) {\n return source.subscribe(new MapSubscriber(subscriber, this.project, this.thisArg));\n }\n}\nclass MapSubscriber extends Subscriber {\n constructor(destination, project, thisArg) {\n super(destination);\n this.project = project;\n this.count = 0;\n this.thisArg = thisArg || this;\n }\n _next(value) {\n let result;\n try {\n result = this.project.call(this.thisArg, value, this.count++);\n }\n catch (err) {\n this.destination.error(err);\n return;\n }\n this.destination.next(result);\n }\n}\n//# sourceMappingURL=map.js.map","export const subscribeToArray = (array) => (subscriber) => {\n for (let i = 0, len = array.length; i < len && !subscriber.closed; i++) {\n subscriber.next(array[i]);\n }\n subscriber.complete();\n};\n//# sourceMappingURL=subscribeToArray.js.map","export function getSymbolIterator() {\n if (typeof Symbol !== 'function' || !Symbol.iterator) {\n return '@@iterator';\n }\n return Symbol.iterator;\n}\nexport const iterator = getSymbolIterator();\nexport const $$iterator = iterator;\n//# sourceMappingURL=iterator.js.map","export const isArrayLike = ((x) => x && typeof x.length === 'number' && typeof x !== 'function');\n//# sourceMappingURL=isArrayLike.js.map","export function isPromise(value) {\n return !!value && typeof value.subscribe !== 'function' && typeof value.then === 'function';\n}\n//# sourceMappingURL=isPromise.js.map","import { subscribeToArray } from './subscribeToArray';\nimport { subscribeToPromise } from './subscribeToPromise';\nimport { subscribeToIterable } from './subscribeToIterable';\nimport { subscribeToObservable } from './subscribeToObservable';\nimport { isArrayLike } from './isArrayLike';\nimport { isPromise } from './isPromise';\nimport { isObject } from './isObject';\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport const subscribeTo = (result) => {\n if (!!result && typeof result[Symbol_observable] === 'function') {\n return subscribeToObservable(result);\n }\n else if (isArrayLike(result)) {\n return subscribeToArray(result);\n }\n else if (isPromise(result)) {\n return subscribeToPromise(result);\n }\n else if (!!result && typeof result[Symbol_iterator] === 'function') {\n return subscribeToIterable(result);\n }\n else {\n const value = isObject(result) ? 'an invalid object' : `'${result}'`;\n const msg = `You provided ${value} where a stream was expected.`\n + ' You can provide an Observable, Promise, Array, or Iterable.';\n throw new TypeError(msg);\n }\n};\n//# sourceMappingURL=subscribeTo.js.map","import { observable as Symbol_observable } from '../symbol/observable';\nexport const subscribeToObservable = (obj) => (subscriber) => {\n const obs = obj[Symbol_observable]();\n if (typeof obs.subscribe !== 'function') {\n throw new TypeError('Provided object does not correctly implement Symbol.observable');\n }\n else {\n return obs.subscribe(subscriber);\n }\n};\n//# sourceMappingURL=subscribeToObservable.js.map","import { hostReportError } from './hostReportError';\nexport const subscribeToPromise = (promise) => (subscriber) => {\n promise.then((value) => {\n if (!subscriber.closed) {\n subscriber.next(value);\n subscriber.complete();\n }\n }, (err) => subscriber.error(err))\n .then(null, hostReportError);\n return subscriber;\n};\n//# sourceMappingURL=subscribeToPromise.js.map","import { iterator as Symbol_iterator } from '../symbol/iterator';\nexport const subscribeToIterable = (iterable) => (subscriber) => {\n const iterator = iterable[Symbol_iterator]();\n do {\n let item;\n try {\n item = iterator.next();\n }\n catch (err) {\n subscriber.error(err);\n return subscriber;\n }\n if (item.done) {\n subscriber.complete();\n break;\n }\n subscriber.next(item.value);\n if (subscriber.closed) {\n break;\n }\n } while (true);\n if (typeof iterator.return === 'function') {\n subscriber.add(() => {\n if (iterator.return) {\n iterator.return();\n }\n });\n }\n return subscriber;\n};\n//# sourceMappingURL=subscribeToIterable.js.map","import { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nexport function scheduleArray(input, scheduler) {\n return new Observable(subscriber => {\n const sub = new Subscription();\n let i = 0;\n sub.add(scheduler.schedule(function () {\n if (i === input.length) {\n subscriber.complete();\n return;\n }\n subscriber.next(input[i++]);\n if (!subscriber.closed) {\n sub.add(this.schedule());\n }\n }));\n return sub;\n });\n}\n//# sourceMappingURL=scheduleArray.js.map","import { Observable } from '../Observable';\nimport { subscribeTo } from '../util/subscribeTo';\nimport { scheduled } from '../scheduled/scheduled';\nexport function from(input, scheduler) {\n if (!scheduler) {\n if (input instanceof Observable) {\n return input;\n }\n return new Observable(subscribeTo(input));\n }\n else {\n return scheduled(input, scheduler);\n }\n}\n//# sourceMappingURL=from.js.map","import { scheduleObservable } from './scheduleObservable';\nimport { schedulePromise } from './schedulePromise';\nimport { scheduleArray } from './scheduleArray';\nimport { scheduleIterable } from './scheduleIterable';\nimport { isInteropObservable } from '../util/isInteropObservable';\nimport { isPromise } from '../util/isPromise';\nimport { isArrayLike } from '../util/isArrayLike';\nimport { isIterable } from '../util/isIterable';\nexport function scheduled(input, scheduler) {\n if (input != null) {\n if (isInteropObservable(input)) {\n return scheduleObservable(input, scheduler);\n }\n else if (isPromise(input)) {\n return schedulePromise(input, scheduler);\n }\n else if (isArrayLike(input)) {\n return scheduleArray(input, scheduler);\n }\n else if (isIterable(input) || typeof input === 'string') {\n return scheduleIterable(input, scheduler);\n }\n }\n throw new TypeError((input !== null && typeof input || input) + ' is not observable');\n}\n//# sourceMappingURL=scheduled.js.map","import { observable as Symbol_observable } from '../symbol/observable';\nexport function isInteropObservable(input) {\n return input && typeof input[Symbol_observable] === 'function';\n}\n//# sourceMappingURL=isInteropObservable.js.map","import { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { observable as Symbol_observable } from '../symbol/observable';\nexport function scheduleObservable(input, scheduler) {\n return new Observable(subscriber => {\n const sub = new Subscription();\n sub.add(scheduler.schedule(() => {\n const observable = input[Symbol_observable]();\n sub.add(observable.subscribe({\n next(value) { sub.add(scheduler.schedule(() => subscriber.next(value))); },\n error(err) { sub.add(scheduler.schedule(() => subscriber.error(err))); },\n complete() { sub.add(scheduler.schedule(() => subscriber.complete())); },\n }));\n }));\n return sub;\n });\n}\n//# sourceMappingURL=scheduleObservable.js.map","import { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nexport function schedulePromise(input, scheduler) {\n return new Observable(subscriber => {\n const sub = new Subscription();\n sub.add(scheduler.schedule(() => input.then(value => {\n sub.add(scheduler.schedule(() => {\n subscriber.next(value);\n sub.add(scheduler.schedule(() => subscriber.complete()));\n }));\n }, err => {\n sub.add(scheduler.schedule(() => subscriber.error(err)));\n })));\n return sub;\n });\n}\n//# sourceMappingURL=schedulePromise.js.map","import { iterator as Symbol_iterator } from '../symbol/iterator';\nexport function isIterable(input) {\n return input && typeof input[Symbol_iterator] === 'function';\n}\n//# sourceMappingURL=isIterable.js.map","import { Observable } from '../Observable';\nimport { Subscription } from '../Subscription';\nimport { iterator as Symbol_iterator } from '../symbol/iterator';\nexport function scheduleIterable(input, scheduler) {\n if (!input) {\n throw new Error('Iterable cannot be null');\n }\n return new Observable(subscriber => {\n const sub = new Subscription();\n let iterator;\n sub.add(() => {\n if (iterator && typeof iterator.return === 'function') {\n iterator.return();\n }\n });\n sub.add(scheduler.schedule(() => {\n iterator = input[Symbol_iterator]();\n sub.add(scheduler.schedule(function () {\n if (subscriber.closed) {\n return;\n }\n let value;\n let done;\n try {\n const result = iterator.next();\n value = result.value;\n done = result.done;\n }\n catch (err) {\n subscriber.error(err);\n return;\n }\n if (done) {\n subscriber.complete();\n }\n else {\n subscriber.next(value);\n this.schedule();\n }\n }));\n }));\n return sub;\n });\n}\n//# sourceMappingURL=scheduleIterable.js.map","import { Subscriber } from './Subscriber';\nimport { Observable } from './Observable';\nimport { subscribeTo } from './util/subscribeTo';\nexport class SimpleInnerSubscriber extends Subscriber {\n constructor(parent) {\n super();\n this.parent = parent;\n }\n _next(value) {\n this.parent.notifyNext(value);\n }\n _error(error) {\n this.parent.notifyError(error);\n this.unsubscribe();\n }\n _complete() {\n this.parent.notifyComplete();\n this.unsubscribe();\n }\n}\nexport class ComplexInnerSubscriber extends Subscriber {\n constructor(parent, outerValue, outerIndex) {\n super();\n this.parent = parent;\n this.outerValue = outerValue;\n this.outerIndex = outerIndex;\n }\n _next(value) {\n this.parent.notifyNext(this.outerValue, value, this.outerIndex, this);\n }\n _error(error) {\n this.parent.notifyError(error);\n this.unsubscribe();\n }\n _complete() {\n this.parent.notifyComplete(this);\n this.unsubscribe();\n }\n}\nexport class SimpleOuterSubscriber extends Subscriber {\n notifyNext(innerValue) {\n this.destination.next(innerValue);\n }\n notifyError(err) {\n this.destination.error(err);\n }\n notifyComplete() {\n this.destination.complete();\n }\n}\nexport class ComplexOuterSubscriber extends Subscriber {\n notifyNext(_outerValue, innerValue, _outerIndex, _innerSub) {\n this.destination.next(innerValue);\n }\n notifyError(error) {\n this.destination.error(error);\n }\n notifyComplete(_innerSub) {\n this.destination.complete();\n }\n}\nexport function innerSubscribe(result, innerSubscriber) {\n if (innerSubscriber.closed) {\n return undefined;\n }\n if (result instanceof Observable) {\n return result.subscribe(innerSubscriber);\n }\n let subscription;\n try {\n subscription = subscribeTo(result)(innerSubscriber);\n }\n catch (error) {\n innerSubscriber.error(error);\n }\n return subscription;\n}\n//# sourceMappingURL=innerSubscribe.js.map","import { map } from './map';\nimport { from } from '../observable/from';\nimport { SimpleOuterSubscriber, SimpleInnerSubscriber, innerSubscribe } from '../innerSubscribe';\nexport function mergeMap(project, resultSelector, concurrent = Number.POSITIVE_INFINITY) {\n if (typeof resultSelector === 'function') {\n return (source) => source.pipe(mergeMap((a, i) => from(project(a, i)).pipe(map((b, ii) => resultSelector(a, b, i, ii))), concurrent));\n }\n else if (typeof resultSelector === 'number') {\n concurrent = resultSelector;\n }\n return (source) => source.lift(new MergeMapOperator(project, concurrent));\n}\nexport class MergeMapOperator {\n constructor(project, concurrent = Number.POSITIVE_INFINITY) {\n this.project = project;\n this.concurrent = concurrent;\n }\n call(observer, source) {\n return source.subscribe(new MergeMapSubscriber(observer, this.project, this.concurrent));\n }\n}\nexport class MergeMapSubscriber extends SimpleOuterSubscriber {\n constructor(destination, project, concurrent = Number.POSITIVE_INFINITY) {\n super(destination);\n this.project = project;\n this.concurrent = concurrent;\n this.hasCompleted = false;\n this.buffer = [];\n this.active = 0;\n this.index = 0;\n }\n _next(value) {\n if (this.active < this.concurrent) {\n this._tryNext(value);\n }\n else {\n this.buffer.push(value);\n }\n }\n _tryNext(value) {\n let result;\n const index = this.index++;\n try {\n result = this.project(value, index);\n }\n catch (err) {\n this.destination.error(err);\n return;\n }\n this.active++;\n this._innerSub(result);\n }\n _innerSub(ish) {\n const innerSubscriber = new SimpleInnerSubscriber(this);\n const destination = this.destination;\n destination.add(innerSubscriber);\n const innerSubscription = innerSubscribe(ish, innerSubscriber);\n if (innerSubscription !== innerSubscriber) {\n destination.add(innerSubscription);\n }\n }\n _complete() {\n this.hasCompleted = true;\n if (this.active === 0 && this.buffer.length === 0) {\n this.destination.complete();\n }\n this.unsubscribe();\n }\n notifyNext(innerValue) {\n this.destination.next(innerValue);\n }\n notifyComplete() {\n const buffer = this.buffer;\n this.active--;\n if (buffer.length > 0) {\n this._next(buffer.shift());\n }\n else if (this.active === 0 && this.hasCompleted) {\n this.destination.complete();\n }\n }\n}\nexport const flatMap = mergeMap;\n//# sourceMappingURL=mergeMap.js.map","import { mergeMap } from './mergeMap';\nimport { identity } from '../util/identity';\nexport function mergeAll(concurrent = Number.POSITIVE_INFINITY) {\n return mergeMap(identity, concurrent);\n}\n//# sourceMappingURL=mergeAll.js.map","import { Observable } from '../Observable';\nimport { subscribeToArray } from '../util/subscribeToArray';\nimport { scheduleArray } from '../scheduled/scheduleArray';\nexport function fromArray(input, scheduler) {\n if (!scheduler) {\n return new Observable(subscribeToArray(input));\n }\n else {\n return scheduleArray(input, scheduler);\n }\n}\n//# sourceMappingURL=fromArray.js.map","import { Subscriber } from '../Subscriber';\nexport function refCount() {\n return function refCountOperatorFunction(source) {\n return source.lift(new RefCountOperator(source));\n };\n}\nclass RefCountOperator {\n constructor(connectable) {\n this.connectable = connectable;\n }\n call(subscriber, source) {\n const { connectable } = this;\n connectable._refCount++;\n const refCounter = new RefCountSubscriber(subscriber, connectable);\n const subscription = source.subscribe(refCounter);\n if (!refCounter.closed) {\n refCounter.connection = connectable.connect();\n }\n return subscription;\n }\n}\nclass RefCountSubscriber extends Subscriber {\n constructor(destination, connectable) {\n super(destination);\n this.connectable = connectable;\n }\n _unsubscribe() {\n const { connectable } = this;\n if (!connectable) {\n this.connection = null;\n return;\n }\n this.connectable = null;\n const refCount = connectable._refCount;\n if (refCount <= 0) {\n this.connection = null;\n return;\n }\n connectable._refCount = refCount - 1;\n if (refCount > 1) {\n this.connection = null;\n return;\n }\n const { connection } = this;\n const sharedConnection = connectable._connection;\n this.connection = null;\n if (sharedConnection && (!connection || sharedConnection === connection)) {\n sharedConnection.unsubscribe();\n }\n }\n}\n//# sourceMappingURL=refCount.js.map","import { SubjectSubscriber } from '../Subject';\nimport { Observable } from '../Observable';\nimport { Subscriber } from '../Subscriber';\nimport { Subscription } from '../Subscription';\nimport { refCount as higherOrderRefCount } from '../operators/refCount';\nexport class ConnectableObservable extends Observable {\n constructor(source, subjectFactory) {\n super();\n this.source = source;\n this.subjectFactory = subjectFactory;\n this._refCount = 0;\n this._isComplete = false;\n }\n _subscribe(subscriber) {\n return this.getSubject().subscribe(subscriber);\n }\n getSubject() {\n const subject = this._subject;\n if (!subject || subject.isStopped) {\n this._subject = this.subjectFactory();\n }\n return this._subject;\n }\n connect() {\n let connection = this._connection;\n if (!connection) {\n this._isComplete = false;\n connection = this._connection = new Subscription();\n connection.add(this.source\n .subscribe(new ConnectableSubscriber(this.getSubject(), this)));\n if (connection.closed) {\n this._connection = null;\n connection = Subscription.EMPTY;\n }\n }\n return connection;\n }\n refCount() {\n return higherOrderRefCount()(this);\n }\n}\nexport const connectableObservableDescriptor = (() => {\n const connectableProto = ConnectableObservable.prototype;\n return {\n operator: { value: null },\n _refCount: { value: 0, writable: true },\n _subject: { value: null, writable: true },\n _connection: { value: null, writable: true },\n _subscribe: { value: connectableProto._subscribe },\n _isComplete: { value: connectableProto._isComplete, writable: true },\n getSubject: { value: connectableProto.getSubject },\n connect: { value: connectableProto.connect },\n refCount: { value: connectableProto.refCount }\n };\n})();\nclass ConnectableSubscriber extends SubjectSubscriber {\n constructor(destination, connectable) {\n super(destination);\n this.connectable = connectable;\n }\n _error(err) {\n this._unsubscribe();\n super._error(err);\n }\n _complete() {\n this.connectable._isComplete = true;\n this._unsubscribe();\n super._complete();\n }\n _unsubscribe() {\n const connectable = this.connectable;\n if (connectable) {\n this.connectable = null;\n const connection = connectable._connection;\n connectable._refCount = 0;\n connectable._subject = null;\n connectable._connection = null;\n if (connection) {\n connection.unsubscribe();\n }\n }\n }\n}\nclass RefCountOperator {\n constructor(connectable) {\n this.connectable = connectable;\n }\n call(subscriber, source) {\n const { connectable } = this;\n connectable._refCount++;\n const refCounter = new RefCountSubscriber(subscriber, connectable);\n const subscription = source.subscribe(refCounter);\n if (!refCounter.closed) {\n refCounter.connection = connectable.connect();\n }\n return subscription;\n }\n}\nclass RefCountSubscriber extends Subscriber {\n constructor(destination, connectable) {\n super(destination);\n this.connectable = connectable;\n }\n _unsubscribe() {\n const { connectable } = this;\n if (!connectable) {\n this.connection = null;\n return;\n }\n this.connectable = null;\n const refCount = connectable._refCount;\n if (refCount <= 0) {\n this.connection = null;\n return;\n }\n connectable._refCount = refCount - 1;\n if (refCount > 1) {\n this.connection = null;\n return;\n }\n const { connection } = this;\n const sharedConnection = connectable._connection;\n this.connection = null;\n if (sharedConnection && (!connection || sharedConnection === connection)) {\n sharedConnection.unsubscribe();\n }\n }\n}\n//# sourceMappingURL=ConnectableObservable.js.map","import { multicast } from './multicast';\nimport { refCount } from './refCount';\nimport { Subject } from '../Subject';\nfunction shareSubjectFactory() {\n return new Subject();\n}\nexport function share() {\n return (source) => refCount()(multicast(shareSubjectFactory)(source));\n}\n//# sourceMappingURL=share.js.map","/**\n * @license Angular v8.2.12\n * (c) 2010-2019 Google LLC. https://angular.io/\n * License: MIT\n */\n\nimport { Subject, Subscription, Observable, merge as merge$1 } from 'rxjs';\nimport { share } from 'rxjs/operators';\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 */\nconst ANNOTATIONS = '__annotations__';\nconst PARAMETERS = '__parameters__';\nconst PROP_METADATA = '__prop__metadata__';\n/**\n * @suppress {globalThis}\n */\nfunction makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {\n const metaCtor = makeMetadataCtor(props);\n function DecoratorFactory(...args) {\n if (this instanceof DecoratorFactory) {\n metaCtor.call(this, ...args);\n return this;\n }\n const annotationInstance = new DecoratorFactory(...args);\n return function TypeDecorator(cls) {\n if (typeFn)\n typeFn(cls, ...args);\n // Use of Object.defineProperty is important since it creates non-enumerable property which\n // prevents the property is copied during subclassing.\n const annotations = cls.hasOwnProperty(ANNOTATIONS) ?\n cls[ANNOTATIONS] :\n Object.defineProperty(cls, ANNOTATIONS, { value: [] })[ANNOTATIONS];\n annotations.push(annotationInstance);\n if (additionalProcessing)\n additionalProcessing(cls);\n return cls;\n };\n }\n if (parentClass) {\n DecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n DecoratorFactory.prototype.ngMetadataName = name;\n DecoratorFactory.annotationCls = DecoratorFactory;\n return DecoratorFactory;\n}\nfunction makeMetadataCtor(props) {\n return function ctor(...args) {\n if (props) {\n const values = props(...args);\n for (const propName in values) {\n this[propName] = values[propName];\n }\n }\n };\n}\nfunction makeParamDecorator(name, props, parentClass) {\n const metaCtor = makeMetadataCtor(props);\n function ParamDecoratorFactory(...args) {\n if (this instanceof ParamDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n const annotationInstance = new ParamDecoratorFactory(...args);\n ParamDecorator.annotation = annotationInstance;\n return ParamDecorator;\n function ParamDecorator(cls, unusedKey, index) {\n // Use of Object.defineProperty is important since it creates non-enumerable property which\n // prevents the property is copied during subclassing.\n const parameters = cls.hasOwnProperty(PARAMETERS) ?\n cls[PARAMETERS] :\n Object.defineProperty(cls, PARAMETERS, { value: [] })[PARAMETERS];\n // there might be gaps if some in between parameters do not have annotations.\n // we pad with nulls.\n while (parameters.length <= index) {\n parameters.push(null);\n }\n (parameters[index] = parameters[index] || []).push(annotationInstance);\n return cls;\n }\n }\n if (parentClass) {\n ParamDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n ParamDecoratorFactory.prototype.ngMetadataName = name;\n ParamDecoratorFactory.annotationCls = ParamDecoratorFactory;\n return ParamDecoratorFactory;\n}\nfunction makePropDecorator(name, props, parentClass, additionalProcessing) {\n const metaCtor = makeMetadataCtor(props);\n function PropDecoratorFactory(...args) {\n if (this instanceof PropDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n const decoratorInstance = new PropDecoratorFactory(...args);\n function PropDecorator(target, name) {\n const constructor = target.constructor;\n // Use of Object.defineProperty is important since it creates non-enumerable property which\n // prevents the property is copied during subclassing.\n const meta = constructor.hasOwnProperty(PROP_METADATA) ?\n constructor[PROP_METADATA] :\n Object.defineProperty(constructor, PROP_METADATA, { value: {} })[PROP_METADATA];\n meta[name] = meta.hasOwnProperty(name) && meta[name] || [];\n meta[name].unshift(decoratorInstance);\n if (additionalProcessing)\n additionalProcessing(target, name, ...args);\n }\n return PropDecorator;\n }\n if (parentClass) {\n PropDecoratorFactory.prototype = Object.create(parentClass.prototype);\n }\n PropDecoratorFactory.prototype.ngMetadataName = name;\n PropDecoratorFactory.annotationCls = PropDecoratorFactory;\n return PropDecoratorFactory;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Type of the Inject decorator / constructor function.\n *\n * \\@publicApi\n * @record\n */\nfunction InjectDecorator() { }\n// WARNING: interface has both a type and a value, skipping emit\nconst ɵ0 = /**\n * @param {?} token\n * @return {?}\n */\n(token) => ({ token });\n/**\n * Inject decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Inject = makeParamDecorator('Inject', (ɵ0));\n/**\n * Type of the Optional decorator / constructor function.\n *\n * \\@publicApi\n * @record\n */\nfunction OptionalDecorator() { }\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Optional decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Optional = makeParamDecorator('Optional');\n/**\n * Type of the Self decorator / constructor function.\n *\n * \\@publicApi\n * @record\n */\nfunction SelfDecorator() { }\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Self decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Self = makeParamDecorator('Self');\n/**\n * Type of the SkipSelf decorator / constructor function.\n *\n * \\@publicApi\n * @record\n */\nfunction SkipSelfDecorator() { }\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * SkipSelf decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst SkipSelf = makeParamDecorator('SkipSelf');\n/**\n * Type of the Host decorator / constructor function.\n *\n * \\@publicApi\n * @record\n */\nfunction HostDecorator() { }\n// WARNING: interface has both a type and a value, skipping emit\n/**\n * Host decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Host = makeParamDecorator('Host');\n/**\n * Type of the Attribute decorator / constructor function.\n *\n * \\@publicApi\n * @record\n */\nfunction AttributeDecorator() { }\n// WARNING: interface has both a type and a value, skipping emit\nconst ɵ1 = /**\n * @param {?=} attributeName\n * @return {?}\n */\n(attributeName) => ({ attributeName });\n/**\n * Attribute decorator and metadata.\n *\n * \\@Annotation\n * \\@publicApi\n * @type {?}\n */\nconst Attribute = makeParamDecorator('Attribute', (ɵ1));\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 * Injection flags for DI.\n *\n * @publicApi\n */\nvar InjectFlags;\n(function (InjectFlags) {\n // TODO(alxhub): make this 'const' when ngc no longer writes exports of it into ngfactory files.\n /** Check self and check parent injector if needed */\n InjectFlags[InjectFlags[\"Default\"] = 0] = \"Default\";\n /**\n * Specifies that an injector should retrieve a dependency from any injector until reaching the\n * host element of the current component. (Only used with Element Injector)\n */\n InjectFlags[InjectFlags[\"Host\"] = 1] = \"Host\";\n /** Don't ascend to ancestors of the node requesting injection. */\n InjectFlags[InjectFlags[\"Self\"] = 2] = \"Self\";\n /** Skip the node that is requesting injection. */\n InjectFlags[InjectFlags[\"SkipSelf\"] = 4] = \"SkipSelf\";\n /** Inject `defaultValue` instead if token not found. */\n InjectFlags[InjectFlags[\"Optional\"] = 8] = \"Optional\";\n})(InjectFlags || (InjectFlags = {}));\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 */\nfunction getClosureSafeProperty(objWithPropertyToExtract) {\n for (let key in objWithPropertyToExtract) {\n if (objWithPropertyToExtract[key] === getClosureSafeProperty) {\n return key;\n }\n }\n throw Error('Could not find renamed property on target object.');\n}\n/**\n * Sets properties on a target object from a source object, but only if\n * the property doesn't already exist on the target object.\n * @param target The target to set properties on\n * @param source The source of the property keys and values to set\n */\nfunction fillProperties(target, source) {\n for (const key in source) {\n if (source.hasOwnProperty(key) && !target.hasOwnProperty(key)) {\n target[key] = source[key];\n }\n }\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/**\n * Construct an `InjectableDef` which defines how a token will be constructed by the DI system, and\n * in which injectors (if any) it will be available.\n *\n * This should be assigned to a static `ngInjectableDef` field on a type, which will then be an\n * `InjectableType`.\n *\n * Options:\n * * `providedIn` determines which injectors will include the injectable, by either associating it\n * with an `@NgModule` or other `InjectorType`, or by specifying that this injectable should be\n * provided in the `'root'` injector, which will be the application-level injector in most apps.\n * * `factory` gives the zero argument function which will create an instance of the injectable.\n * The factory can call `inject` to access the `Injector` and request injection of dependencies.\n *\n * @codeGenApi\n */\nfunction ɵɵdefineInjectable(opts) {\n return {\n token: opts.token, providedIn: opts.providedIn || null, factory: opts.factory,\n value: undefined,\n };\n}\n/**\n * @deprecated in v8, delete after v10. This API should be used only be generated code, and that\n * code should now use ɵɵdefineInjectable instead.\n * @publicApi\n */\nconst defineInjectable = ɵɵdefineInjectable;\n/**\n * Construct an `InjectorDef` which configures an injector.\n *\n * This should be assigned to a static `ngInjectorDef` field on a type, which will then be an\n * `InjectorType`.\n *\n * Options:\n *\n * * `factory`: an `InjectorType` is an instantiable type, so a zero argument `factory` function to\n * create the type must be provided. If that factory function needs to inject arguments, it can\n * use the `inject` function.\n * * `providers`: an optional array of providers to add to the injector. Each provider must\n * either have a factory or point to a type which has an `ngInjectableDef` static property (the\n * type must be an `InjectableType`).\n * * `imports`: an optional array of imports of other `InjectorType`s or `InjectorTypeWithModule`s\n * whose providers will also be added to the injector. Locally provided types will override\n * providers from imports.\n *\n * @publicApi\n */\nfunction ɵɵdefineInjector(options) {\n return {\n factory: options.factory, providers: options.providers || [], imports: options.imports || [],\n };\n}\n/**\n * Read the `ngInjectableDef` for `type` in a way which is immune to accidentally reading inherited\n * value.\n *\n * @param type A type which may have its own (non-inherited) `ngInjectableDef`.\n */\nfunction getInjectableDef(type) {\n const def = type[NG_INJECTABLE_DEF];\n // The definition read above may come from a base class. `hasOwnProperty` is not sufficient to\n // distinguish this case, as in older browsers (e.g. IE10) static property inheritance is\n // implemented by copying the properties.\n //\n // Instead, the ngInjectableDef's token is compared to the type, and if they don't match then the\n // property was not defined directly on the type itself, and was likely inherited. The definition\n // is only returned if the type matches the def.token.\n return def && def.token === type ? def : null;\n}\n/**\n * Read the `ngInjectableDef` for `type` or read the `ngInjectableDef` from one of its ancestors.\n *\n * @param type A type which may have `ngInjectableDef`, via inheritance.\n *\n * @deprecated Will be removed in v10, where an error will occur in the scenario if we find the\n * `ngInjectableDef` on an ancestor only.\n */\nfunction getInheritedInjectableDef(type) {\n if (type && type[NG_INJECTABLE_DEF]) {\n // TODO(FW-1307): Re-add ngDevMode when closure can handle it\n // ngDevMode &&\n console.warn(`DEPRECATED: DI is instantiating a token \"${type.name}\" that inherits its @Injectable decorator but does not provide one itself.\\n` +\n `This will become an error in v10. Please add @Injectable() to the \"${type.name}\" class.`);\n return type[NG_INJECTABLE_DEF];\n }\n else {\n return null;\n }\n}\n/**\n * Read the `ngInjectorDef` type in a way which is immune to accidentally reading inherited value.\n *\n * @param type type which may have `ngInjectorDef`\n */\nfunction getInjectorDef(type) {\n return type && type.hasOwnProperty(NG_INJECTOR_DEF) ? type[NG_INJECTOR_DEF] : null;\n}\nconst NG_INJECTABLE_DEF = getClosureSafeProperty({ ngInjectableDef: getClosureSafeProperty });\nconst NG_INJECTOR_DEF = getClosureSafeProperty({ ngInjectorDef: getClosureSafeProperty });\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 */\nfunction stringify(token) {\n if (typeof token === 'string') {\n return token;\n }\n if (token instanceof Array) {\n return '[' + token.map(stringify).join(', ') + ']';\n }\n if (token == null) {\n return '' + token;\n }\n if (token.overriddenName) {\n return `${token.overriddenName}`;\n }\n if (token.name) {\n return `${token.name}`;\n }\n const res = token.toString();\n if (res == null) {\n return '' + res;\n }\n const newLineIndex = res.indexOf('\\n');\n return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An interface that a function passed into {\\@link forwardRef} has to implement.\n *\n * \\@usageNotes\n * ### Example\n *\n * {\\@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref_fn'}\n * \\@publicApi\n * @record\n */\nfunction ForwardRefFn() { }\n/** @type {?} */\nconst __forward_ref__ = getClosureSafeProperty({ __forward_ref__: getClosureSafeProperty });\n/**\n * Allows to refer to references which are not yet defined.\n *\n * For instance, `forwardRef` is used when the `token` which we need to refer to for the purposes of\n * DI is declared, but not yet defined. It is also used when the `token` which we use when creating\n * a query is not yet defined.\n *\n * \\@usageNotes\n * ### Example\n * {\\@example core/di/ts/forward_ref/forward_ref_spec.ts region='forward_ref'}\n * \\@publicApi\n * @param {?} forwardRefFn\n * @return {?}\n */\nfunction forwardRef(forwardRefFn) {\n ((/** @type {?} */ (forwardRefFn))).__forward_ref__ = forwardRef;\n ((/** @type {?} */ (forwardRefFn))).toString = (/**\n * @return {?}\n */\n function () { return stringify(this()); });\n return ((/** @type {?} */ ((/** @type {?} */ (forwardRefFn)))));\n}\n/**\n * Lazily retrieves the reference value from a forwardRef.\n *\n * Acts as the identity function when given a non-forward-ref value.\n *\n * \\@usageNotes\n * ### Example\n *\n * {\\@example core/di/ts/forward_ref/forward_ref_spec.ts region='resolve_forward_ref'}\n *\n * @see `forwardRef`\n * \\@publicApi\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction resolveForwardRef(type) {\n /** @type {?} */\n const fn = type;\n if (typeof fn === 'function' && fn.hasOwnProperty(__forward_ref__) &&\n fn.__forward_ref__ === forwardRef) {\n return fn();\n }\n else {\n return type;\n }\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 */\nconst __globalThis = typeof globalThis !== 'undefined' && globalThis;\nconst __window = typeof window !== 'undefined' && window;\nconst __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n self instanceof WorkerGlobalScope && self;\nconst __global = typeof global !== 'undefined' && global;\n// Always use __globalThis if available, which is the spec-defined global variable across all\n// environments, then fallback to __global first, because in Node tests both __global and\n// __window may be defined and _global should be __global in that case.\nconst _global = __globalThis || __global || __window || __self;\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 R3ResolvedDependencyType;\n(function (R3ResolvedDependencyType) {\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"Token\"] = 0] = \"Token\";\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"Attribute\"] = 1] = \"Attribute\";\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"ChangeDetectorRef\"] = 2] = \"ChangeDetectorRef\";\n})(R3ResolvedDependencyType || (R3ResolvedDependencyType = {}));\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 */\nfunction getCompilerFacade() {\n const globalNg = _global['ng'];\n if (!globalNg || !globalNg.ɵcompilerFacade) {\n throw new Error(`Angular JIT compilation failed: '@angular/compiler' not loaded!\\n` +\n ` - JIT compilation is discouraged for production use-cases! Consider AOT mode instead.\\n` +\n ` - Did you bootstrap using '@angular/platform-browser-dynamic' or '@angular/platform-server'?\\n` +\n ` - Alternatively provide the compiler with 'import \"@angular/compiler\";' before bootstrapping.`);\n }\n return globalNg.ɵcompilerFacade;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Creates a token that can be used in a DI Provider.\n *\n * Use an `InjectionToken` whenever the type you are injecting is not reified (does not have a\n * runtime representation) such as when injecting an interface, callable type, array or\n * parameterized type.\n *\n * `InjectionToken` is parameterized on `T` which is the type of object which will be returned by\n * the `Injector`. This provides additional level of type safety.\n *\n * ```\n * interface MyInterface {...}\n * var myInterface = injector.get(new InjectionToken('SomeToken'));\n * // myInterface is inferred to be MyInterface.\n * ```\n *\n * When creating an `InjectionToken`, you can optionally specify a factory function which returns\n * (possibly by creating) a default value of the parameterized type `T`. This sets up the\n * `InjectionToken` using this factory as a provider as if it was defined explicitly in the\n * application's root injector. If the factory function, which takes zero arguments, needs to inject\n * dependencies, it can do so using the `inject` function. See below for an example.\n *\n * Additionally, if a `factory` is specified you can also specify the `providedIn` option, which\n * overrides the above behavior and marks the token as belonging to a particular `\\@NgModule`. As\n * mentioned above, `'root'` is the default value for `providedIn`.\n *\n * \\@usageNotes\n * ### Basic Example\n *\n * ### Plain InjectionToken\n *\n * {\\@example core/di/ts/injector_spec.ts region='InjectionToken'}\n *\n * ### Tree-shakable InjectionToken\n *\n * {\\@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}\n *\n *\n * \\@publicApi\n * @template T\n */\nclass InjectionToken {\n /**\n * @param {?} _desc\n * @param {?=} options\n */\n constructor(_desc, options) {\n this._desc = _desc;\n /**\n * \\@internal\n */\n this.ngMetadataName = 'InjectionToken';\n /** @nocollapse */ this.ngInjectableDef = undefined;\n if (typeof options == 'number') {\n // This is a special hack to assign __NG_ELEMENT_ID__ to this instance.\n // __NG_ELEMENT_ID__ is Used by Ivy to determine bloom filter id.\n // We are using it to assign `-1` which is used to identify `Injector`.\n ((/** @type {?} */ (this))).__NG_ELEMENT_ID__ = options;\n }\n else if (options !== undefined) {\n /** @nocollapse */ this.ngInjectableDef = ɵɵdefineInjectable({\n token: this,\n providedIn: options.providedIn || 'root',\n factory: options.factory,\n });\n }\n }\n /**\n * @return {?}\n */\n toString() { return `InjectionToken ${this._desc}`; }\n}\nif (false) {\n /**\n * \\@internal\n * @type {?}\n */\n InjectionToken.prototype.ngMetadataName;\n /** @type {?} */\n InjectionToken.prototype.ngInjectableDef;\n /**\n * @type {?}\n * @protected\n */\n InjectionToken.prototype._desc;\n}\n/**\n * @record\n * @template T\n */\nfunction InjectableDefToken() { }\nif (false) {\n /** @type {?} */\n InjectableDefToken.prototype.ngInjectableDef;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * An InjectionToken that gets the current `Injector` for `createInjector()`-style injectors.\n *\n * Requesting this token instead of `Injector` allows `StaticInjector` to be tree-shaken from a\n * project.\n *\n * \\@publicApi\n * @type {?}\n */\nconst INJECTOR = new InjectionToken('INJECTOR', (/** @type {?} */ (-1)));\n/** @type {?} */\nconst _THROW_IF_NOT_FOUND = new Object();\n/** @type {?} */\nconst THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n/** @type {?} */\nconst NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\n/** @type {?} */\nconst NG_TOKEN_PATH = 'ngTokenPath';\n/** @type {?} */\nconst NEW_LINE = /\\n/gm;\n/** @type {?} */\nconst NO_NEW_LINE = 'ɵ';\n/** @type {?} */\nconst SOURCE = '__source';\nconst ɵ0$1 = getClosureSafeProperty;\n/** @type {?} */\nconst USE_VALUE = getClosureSafeProperty({ provide: String, useValue: ɵ0$1 });\n/**\n * Current injector value used by `inject`.\n * - `undefined`: it is an error to call `inject`\n * - `null`: `inject` can be called but there is no injector (limp-mode).\n * - Injector instance: Use the injector for resolution.\n * @type {?}\n */\nlet _currentInjector = undefined;\n/**\n * @param {?} injector\n * @return {?}\n */\nfunction setCurrentInjector(injector) {\n /** @type {?} */\n const former = _currentInjector;\n _currentInjector = injector;\n return former;\n}\n/**\n * Current implementation of inject.\n *\n * By default, it is `injectInjectorOnly`, which makes it `Injector`-only aware. It can be changed\n * to `directiveInject`, which brings in the `NodeInjector` system of ivy. It is designed this\n * way for two reasons:\n * 1. `Injector` should not depend on ivy logic.\n * 2. To maintain tree shake-ability we don't want to bring in unnecessary code.\n * @type {?}\n */\nlet _injectImplementation;\n/**\n * Sets the current inject implementation.\n * @param {?} impl\n * @return {?}\n */\nfunction setInjectImplementation(impl) {\n /** @type {?} */\n const previous = _injectImplementation;\n _injectImplementation = impl;\n return previous;\n}\n/**\n * @template T\n * @param {?} token\n * @param {?=} flags\n * @return {?}\n */\nfunction injectInjectorOnly(token, flags = InjectFlags.Default) {\n if (_currentInjector === undefined) {\n throw new Error(`inject() must be called from an injection context`);\n }\n else if (_currentInjector === null) {\n return injectRootLimpMode(token, undefined, flags);\n }\n else {\n return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);\n }\n}\n/**\n * @template T\n * @param {?} token\n * @param {?=} flags\n * @return {?}\n */\nfunction ɵɵinject(token, flags = InjectFlags.Default) {\n return (_injectImplementation || injectInjectorOnly)(token, flags);\n}\n/**\n * Injects a token from the currently active injector.\n *\n * Must be used in the context of a factory function such as one defined for an\n * `InjectionToken`. Throws an error if not called from such a context.\n *\n * Within such a factory function, using this function to request injection of a dependency\n * is faster and more type-safe than providing an additional array of dependencies\n * (as has been common with `useFactory` providers).\n *\n * \\@param token The injection token for the dependency to be injected.\n * \\@param flags Optional flags that control how injection is executed.\n * The flags correspond to injection strategies that can be specified with\n * parameter decorators `\\@Host`, `\\@Self`, `\\@SkipSef`, and `\\@Optional`.\n * \\@return True if injection is successful, null otherwise.\n *\n * \\@usageNotes\n *\n * ### Example\n *\n * {\\@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}\n *\n * \\@publicApi\n * @type {?}\n */\nconst inject = ɵɵinject;\n/**\n * Injects `root` tokens in limp mode.\n *\n * If no injector exists, we can still inject tree-shakable providers which have `providedIn` set to\n * `\"root\"`. This is known as the limp mode injection. In such case the value is stored in the\n * `InjectableDef`.\n * @template T\n * @param {?} token\n * @param {?} notFoundValue\n * @param {?} flags\n * @return {?}\n */\nfunction injectRootLimpMode(token, notFoundValue, flags) {\n /** @type {?} */\n const injectableDef = getInjectableDef(token);\n if (injectableDef && injectableDef.providedIn == 'root') {\n return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :\n injectableDef.value;\n }\n if (flags & InjectFlags.Optional)\n return null;\n if (notFoundValue !== undefined)\n return notFoundValue;\n throw new Error(`Injector: NOT_FOUND [${stringify(token)}]`);\n}\n/**\n * @param {?} types\n * @return {?}\n */\nfunction injectArgs(types) {\n /** @type {?} */\n const args = [];\n for (let i = 0; i < types.length; i++) {\n /** @type {?} */\n const arg = resolveForwardRef(types[i]);\n if (Array.isArray(arg)) {\n if (arg.length === 0) {\n throw new Error('Arguments array must have arguments.');\n }\n /** @type {?} */\n let type = undefined;\n /** @type {?} */\n let flags = InjectFlags.Default;\n for (let j = 0; j < arg.length; j++) {\n /** @type {?} */\n const meta = arg[j];\n if (meta instanceof Optional || meta.ngMetadataName === 'Optional' || meta === Optional) {\n flags |= InjectFlags.Optional;\n }\n else if (meta instanceof SkipSelf || meta.ngMetadataName === 'SkipSelf' || meta === SkipSelf) {\n flags |= InjectFlags.SkipSelf;\n }\n else if (meta instanceof Self || meta.ngMetadataName === 'Self' || meta === Self) {\n flags |= InjectFlags.Self;\n }\n else if (meta instanceof Inject || meta === Inject) {\n type = meta.token;\n }\n else {\n type = meta;\n }\n }\n args.push(ɵɵinject((/** @type {?} */ (type)), flags));\n }\n else {\n args.push(ɵɵinject(arg));\n }\n }\n return args;\n}\nclass NullInjector {\n /**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\n get(token, notFoundValue = THROW_IF_NOT_FOUND) {\n if (notFoundValue === THROW_IF_NOT_FOUND) {\n // Intentionally left behind: With dev tools open the debugger will stop here. There is no\n // reason why correctly written application should cause this exception.\n // TODO(misko): uncomment the next line once `ngDevMode` works with closure.\n // if(ngDevMode) debugger;\n /** @type {?} */\n const error = new Error(`NullInjectorError: No provider for ${stringify(token)}!`);\n error.name = 'NullInjectorError';\n throw error;\n }\n return notFoundValue;\n }\n}\n/**\n * @param {?} e\n * @param {?} token\n * @param {?} injectorErrorName\n * @param {?} source\n * @return {?}\n */\nfunction catchInjectorError(e, token, injectorErrorName, source) {\n /** @type {?} */\n const tokenPath = e[NG_TEMP_TOKEN_PATH];\n if (token[SOURCE]) {\n tokenPath.unshift(token[SOURCE]);\n }\n e.message = formatError('\\n' + e.message, tokenPath, injectorErrorName, source);\n e[NG_TOKEN_PATH] = tokenPath;\n e[NG_TEMP_TOKEN_PATH] = null;\n throw e;\n}\n/**\n * @param {?} text\n * @param {?} obj\n * @param {?} injectorErrorName\n * @param {?=} source\n * @return {?}\n */\nfunction formatError(text, obj, injectorErrorName, source = null) {\n text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;\n /** @type {?} */\n let context = stringify(obj);\n if (obj instanceof Array) {\n context = obj.map(stringify).join(' -> ');\n }\n else if (typeof obj === 'object') {\n /** @type {?} */\n let parts = (/** @type {?} */ ([]));\n for (let key in obj) {\n if (obj.hasOwnProperty(key)) {\n /** @type {?} */\n let value = obj[key];\n parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n }\n }\n context = `{${parts.join(', ')}}`;\n }\n return `${injectorErrorName}${source ? '(' + source + ')' : ''}[${context}]: ${text.replace(NEW_LINE, '\\n ')}`;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * A mapping of the \\@angular/core API surface used in generated expressions to the actual symbols.\n *\n * This should be kept up to date with the public exports of \\@angular/core.\n * @type {?}\n */\nconst angularCoreDiEnv = {\n 'ɵɵdefineInjectable': ɵɵdefineInjectable,\n 'ɵɵdefineInjector': ɵɵdefineInjector,\n 'ɵɵinject': ɵɵinject,\n 'ɵɵgetFactoryOf': getFactoryOf,\n};\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getFactoryOf(type) {\n /** @type {?} */\n const typeAny = (/** @type {?} */ (type));\n /** @type {?} */\n const def = getInjectableDef(typeAny) || getInjectorDef(typeAny);\n if (!def || def.factory === undefined) {\n return null;\n }\n return def.factory;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * Represents an instance of an NgModule created via a {\\@link NgModuleFactory}.\n *\n * `NgModuleRef` provides access to the NgModule Instance as well other objects related to this\n * NgModule Instance.\n *\n * \\@publicApi\n * @abstract\n * @template T\n */\nclass NgModuleRef {\n}\nif (false) {\n /**\n * The injector that contains all of the providers of the NgModule.\n * @abstract\n * @return {?}\n */\n NgModuleRef.prototype.injector = function () { };\n /**\n * The ComponentFactoryResolver to get hold of the ComponentFactories\n * declared in the `entryComponents` property of the module.\n * @abstract\n * @return {?}\n */\n NgModuleRef.prototype.componentFactoryResolver = function () { };\n /**\n * The NgModule instance.\n * @abstract\n * @return {?}\n */\n NgModuleRef.prototype.instance = function () { };\n /**\n * Destroys the module instance and all of the data structures associated with it.\n * @abstract\n * @return {?}\n */\n NgModuleRef.prototype.destroy = function () { };\n /**\n * Allows to register a callback that will be called when the module is destroyed.\n * @abstract\n * @param {?} callback\n * @return {?}\n */\n NgModuleRef.prototype.onDestroy = function (callback) { };\n}\n/**\n * @record\n * @template T\n */\nfunction InternalNgModuleRef() { }\nif (false) {\n /** @type {?} */\n InternalNgModuleRef.prototype._bootstrapComponents;\n}\n/**\n * \\@publicApi\n * @abstract\n * @template T\n */\nclass NgModuleFactory {\n}\nif (false) {\n /**\n * @abstract\n * @return {?}\n */\n NgModuleFactory.prototype.moduleType = function () { };\n /**\n * @abstract\n * @param {?} parentInjector\n * @return {?}\n */\n NgModuleFactory.prototype.create = function (parentInjector) { };\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/**\n* Equivalent to ES6 spread, add each item to an array.\n*\n* @param items The items to add\n* @param arr The array to which you want to add the items\n*/\nfunction addAllToArray(items, arr) {\n for (let i = 0; i < items.length; i++) {\n arr.push(items[i]);\n }\n}\n/**\n * Flattens an array.\n */\nfunction flatten(list, dst) {\n if (dst === undefined)\n dst = list;\n for (let i = 0; i < list.length; i++) {\n let item = list[i];\n if (Array.isArray(item)) {\n // we need to inline it.\n if (dst === list) {\n // Our assumption that the list was already flat was wrong and\n // we need to clone flat since we need to write to it.\n dst = list.slice(0, i);\n }\n flatten(item, dst);\n }\n else if (dst !== list) {\n dst.push(item);\n }\n }\n return dst;\n}\nfunction deepForEach(input, fn) {\n input.forEach(value => Array.isArray(value) ? deepForEach(value, fn) : fn(value));\n}\nfunction addToArray(arr, index, value) {\n // perf: array.push is faster than array.splice!\n if (index >= arr.length) {\n arr.push(value);\n }\n else {\n arr.splice(index, 0, value);\n }\n}\nfunction removeFromArray(arr, index) {\n // perf: array.pop is faster than array.splice!\n if (index >= arr.length - 1) {\n return arr.pop();\n }\n else {\n return arr.splice(index, 1)[0];\n }\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 */\nfunction assertNumber(actual, msg) {\n if (typeof actual != 'number') {\n throwError(msg);\n }\n}\nfunction assertEqual(actual, expected, msg) {\n if (actual != expected) {\n throwError(msg);\n }\n}\nfunction assertNotEqual(actual, expected, msg) {\n if (actual == expected) {\n throwError(msg);\n }\n}\nfunction assertSame(actual, expected, msg) {\n if (actual !== expected) {\n throwError(msg);\n }\n}\nfunction assertNotSame(actual, expected, msg) {\n if (actual === expected) {\n throwError(msg);\n }\n}\nfunction assertLessThan(actual, expected, msg) {\n if (actual >= expected) {\n throwError(msg);\n }\n}\nfunction assertGreaterThan(actual, expected, msg) {\n if (actual <= expected) {\n throwError(msg);\n }\n}\nfunction assertNotDefined(actual, msg) {\n if (actual != null) {\n throwError(msg);\n }\n}\nfunction assertDefined(actual, msg) {\n if (actual == null) {\n throwError(msg);\n }\n}\nfunction throwError(msg) {\n // tslint:disable-next-line\n debugger; // Left intentionally for better debugger experience.\n throw new Error(`ASSERTION ERROR: ${msg}`);\n}\nfunction assertDomNode(node) {\n // If we're in a worker, `Node` will not be defined.\n assertEqual((typeof Node !== 'undefined' && node instanceof Node) ||\n (typeof node === 'object' && node != null &&\n node.constructor.name === 'WebWorkerRenderNode'), true, `The provided value must be an instance of a DOM Node but got ${stringify(node)}`);\n}\nfunction assertDataInRange(arr, index) {\n const maxLen = arr ? arr.length : 0;\n assertLessThan(index, maxLen, `Index expected to be less than ${maxLen} but got ${index}`);\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 */\nfunction ngDevModeResetPerfCounters() {\n const locationString = typeof location !== 'undefined' ? location.toString() : '';\n const newCounters = {\n namedConstructors: locationString.indexOf('ngDevMode=namedConstructors') != -1,\n firstTemplatePass: 0,\n tNode: 0,\n tView: 0,\n rendererCreateTextNode: 0,\n rendererSetText: 0,\n rendererCreateElement: 0,\n rendererAddEventListener: 0,\n rendererSetAttribute: 0,\n rendererRemoveAttribute: 0,\n rendererSetProperty: 0,\n rendererSetClassName: 0,\n rendererAddClass: 0,\n rendererRemoveClass: 0,\n rendererSetStyle: 0,\n rendererRemoveStyle: 0,\n rendererDestroy: 0,\n rendererDestroyNode: 0,\n rendererMoveNode: 0,\n rendererRemoveNode: 0,\n rendererAppendChild: 0,\n rendererInsertBefore: 0,\n rendererCreateComment: 0,\n styleMap: 0,\n styleMapCacheMiss: 0,\n classMap: 0,\n classMapCacheMiss: 0,\n styleProp: 0,\n stylePropCacheMiss: 0,\n classProp: 0,\n classPropCacheMiss: 0,\n flushStyling: 0,\n classesApplied: 0,\n stylesApplied: 0,\n stylingWritePersistedState: 0,\n stylingReadPersistedState: 0,\n };\n // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.\n const allowNgDevModeTrue = locationString.indexOf('ngDevMode=false') === -1;\n _global['ngDevMode'] = allowNgDevModeTrue && newCounters;\n return newCounters;\n}\n/**\n * This checks to see if the `ngDevMode` has been set. If yes,\n * then we honor it, otherwise we default to dev mode with additional checks.\n *\n * The idea is that unless we are doing production build where we explicitly\n * set `ngDevMode == false` we should be helping the developer by providing\n * as much early warning and errors as possible.\n *\n * NOTE: changes to the `ngDevMode` name must be synced with `compiler-cli/src/tooling.ts`.\n */\nif (typeof ngDevMode === 'undefined' || ngDevMode) {\n ngDevModeResetPerfCounters();\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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/** @enum {number} */\nconst ChangeDetectionStrategy = {\n /**\n * Use the `CheckOnce` strategy, meaning that automatic change detection is deactivated\n * until reactivated by setting the strategy to `Default` (`CheckAlways`).\n * Change detection can still be explicitly invoked.\n * This strategy applies to all child directives and cannot be overridden.\n */\n OnPush: 0,\n /**\n * Use the default `CheckAlways` strategy, in which change detection is automatic until\n * explicitly deactivated.\n */\n Default: 1,\n};\nChangeDetectionStrategy[ChangeDetectionStrategy.OnPush] = 'OnPush';\nChangeDetectionStrategy[ChangeDetectionStrategy.Default] = 'Default';\n/** @enum {number} */\nconst ChangeDetectorStatus = {\n /**\n * A state in which, after calling `detectChanges()`, the change detector\n * state becomes `Checked`, and must be explicitly invoked or reactivated.\n */\n CheckOnce: 0,\n /**\n * A state in which change detection is skipped until the change detector mode\n * becomes `CheckOnce`.\n */\n Checked: 1,\n /**\n * A state in which change detection continues automatically until explicitly\n * deactivated.\n */\n CheckAlways: 2,\n /**\n * A state in which a change detector sub tree is not a part of the main tree and\n * should be skipped.\n */\n Detached: 3,\n /**\n * Indicates that the change detector encountered an error checking a binding\n * or calling a directive lifecycle method and is now in an inconsistent state. Change\n * detectors in this state do not detect changes.\n */\n Errored: 4,\n /**\n * Indicates that the change detector has been destroyed.\n */\n Destroyed: 5,\n};\nChangeDetectorStatus[ChangeDetectorStatus.CheckOnce] = 'CheckOnce';\nChangeDetectorStatus[ChangeDetectorStatus.Checked] = 'Checked';\nChangeDetectorStatus[ChangeDetectorStatus.CheckAlways] = 'CheckAlways';\nChangeDetectorStatus[ChangeDetectorStatus.Detached] = 'Detached';\nChangeDetectorStatus[ChangeDetectorStatus.Errored] = 'Errored';\nChangeDetectorStatus[ChangeDetectorStatus.Destroyed] = 'Destroyed';\n/**\n * Reports whether a given strategy is currently the default for change detection.\n * @see `ChangeDetectorStatus` / `ChangeDetectorRef`\n * @param {?} changeDetectionStrategy The strategy to check.\n * @return {?} True if the given strategy is the current default, false otherwise.\n */\nfunction isDefaultChangeDetectionStrategy(changeDetectionStrategy) {\n return changeDetectionStrategy == null ||\n changeDetectionStrategy === ChangeDetectionStrategy.Default;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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/** @enum {number} */\nconst ViewEncapsulation = {\n /**\n * Emulate `Native` scoping of styles by adding an attribute containing surrogate id to the Host\n * Element and pre-processing the style rules provided via {@link Component#styles styles} or\n * {@link Component#styleUrls styleUrls}, and adding the new Host Element attribute to all\n * selectors.\n *\n * This is the default option.\n */\n Emulated: 0,\n /**\n * @deprecated v6.1.0 - use {ViewEncapsulation.ShadowDom} instead.\n * Use the native encapsulation mechanism of the renderer.\n *\n * For the DOM this means using the deprecated [Shadow DOM\n * v0](https://w3c.github.io/webcomponents/spec/shadow/) and\n * creating a ShadowRoot for Component's Host Element.\n */\n Native: 1,\n /**\n * Don't provide any template or style encapsulation.\n */\n None: 2,\n /**\n * Use Shadow DOM to encapsulate styles.\n *\n * For the DOM this means using modern [Shadow\n * DOM](https://w3c.github.io/webcomponents/spec/shadow/) and\n * creating a ShadowRoot for Component's Host Element.\n */\n ShadowDom: 3,\n};\nViewEncapsulation[ViewEncapsulation.Emulated] = 'Emulated';\nViewEncapsulation[ViewEncapsulation.Native] = 'Native';\nViewEncapsulation[ViewEncapsulation.None] = 'None';\nViewEncapsulation[ViewEncapsulation.ShadowDom] = 'ShadowDom';\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 * Convince closure compiler that the wrapped function has no side-effects.\n *\n * Closure compiler always assumes that `toString` has no side-effects. We use this quirk to\n * allow us to execute a function but have closure compiler mark the call as no-side-effects.\n * It is important that the return value for the `noSideEffects` function be assigned\n * to something which is retained otherwise the call to `noSideEffects` will be removed by closure\n * compiler.\n */\nfunction noSideEffects(fn) {\n return '' + { toString: fn };\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * This file contains reuseable \"empty\" symbols that can be used as default return values\n * in different parts of the rendering code. Because the same symbols are returned, this\n * allows for identity checks against these values to be consistently used by the framework\n * code.\n * @type {?}\n */\nconst EMPTY_OBJ = {};\n/** @type {?} */\nconst EMPTY_ARRAY = [];\n// freezing the values prevents any code from accidentally inserting new values in\nif (typeof ngDevMode !== 'undefined' && ngDevMode) {\n // These property accesses can be ignored because ngDevMode will be set to false\n // when optimizing code and the whole if statement will be dropped.\n // tslint:disable-next-line:no-toplevel-property-access\n Object.freeze(EMPTY_OBJ);\n // tslint:disable-next-line:no-toplevel-property-access\n Object.freeze(EMPTY_ARRAY);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst NG_COMPONENT_DEF = getClosureSafeProperty({ ngComponentDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_DIRECTIVE_DEF = getClosureSafeProperty({ ngDirectiveDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_PIPE_DEF = getClosureSafeProperty({ ngPipeDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_MODULE_DEF = getClosureSafeProperty({ ngModuleDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_LOCALE_ID_DEF = getClosureSafeProperty({ ngLocaleIdDef: getClosureSafeProperty });\n/** @type {?} */\nconst NG_BASE_DEF = getClosureSafeProperty({ ngBaseDef: getClosureSafeProperty });\n// TODO(misko): This is wrong. The NG_ELEMENT_ID should never be minified.\n/**\n * If a directive is diPublic, bloomAdd sets a property on the type with this constant as\n * the key and the directive's unique ID as the value. This allows us to map directives to their\n * bloom filter bit for DI.\n * @type {?}\n */\nconst NG_ELEMENT_ID = getClosureSafeProperty({ __NG_ELEMENT_ID__: getClosureSafeProperty });\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nlet _renderCompCount = 0;\n/**\n * Create a component definition object.\n *\n *\n * # Example\n * ```\n * class MyDirective {\n * // Generated by Angular Template Compiler\n * // [Symbol] syntax will not be supported by TypeScript until v2.7\n * static ngComponentDef = defineComponent({\n * ...\n * });\n * }\n * ```\n * \\@codeGenApi\n * @template T\n * @param {?} componentDefinition\n * @return {?}\n */\nfunction ɵɵdefineComponent(componentDefinition) {\n /** @type {?} */\n const type = componentDefinition.type;\n /** @type {?} */\n const typePrototype = type.prototype;\n /** @type {?} */\n const declaredInputs = (/** @type {?} */ ({}));\n /** @type {?} */\n const def = {\n type: type,\n providersResolver: null,\n consts: componentDefinition.consts,\n vars: componentDefinition.vars,\n factory: componentDefinition.factory,\n template: componentDefinition.template || (/** @type {?} */ (null)),\n ngContentSelectors: componentDefinition.ngContentSelectors,\n hostBindings: componentDefinition.hostBindings || null,\n contentQueries: componentDefinition.contentQueries || null,\n declaredInputs: declaredInputs,\n inputs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n outputs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n exportAs: componentDefinition.exportAs || null,\n onChanges: null,\n onInit: typePrototype.ngOnInit || null,\n doCheck: typePrototype.ngDoCheck || null,\n afterContentInit: typePrototype.ngAfterContentInit || null,\n afterContentChecked: typePrototype.ngAfterContentChecked || null,\n afterViewInit: typePrototype.ngAfterViewInit || null,\n afterViewChecked: typePrototype.ngAfterViewChecked || null,\n onDestroy: typePrototype.ngOnDestroy || null,\n onPush: componentDefinition.changeDetection === ChangeDetectionStrategy.OnPush,\n directiveDefs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n pipeDefs: (/** @type {?} */ (null)),\n // assigned in noSideEffects\n selectors: componentDefinition.selectors,\n viewQuery: componentDefinition.viewQuery || null,\n features: (/** @type {?} */ (componentDefinition.features)) || null,\n data: componentDefinition.data || {},\n // TODO(misko): convert ViewEncapsulation into const enum so that it can be used directly in the\n // next line. Also `None` should be 0 not 2.\n encapsulation: componentDefinition.encapsulation || ViewEncapsulation.Emulated,\n id: 'c',\n styles: componentDefinition.styles || EMPTY_ARRAY,\n _: (/** @type {?} */ (null)),\n setInput: null,\n schemas: componentDefinition.schemas || null,\n tView: null,\n };\n def._ = (/** @type {?} */ (noSideEffects((/**\n * @return {?}\n */\n () => {\n /** @type {?} */\n const directiveTypes = (/** @type {?} */ (componentDefinition.directives));\n /** @type {?} */\n const feature = componentDefinition.features;\n /** @type {?} */\n const pipeTypes = (/** @type {?} */ (componentDefinition.pipes));\n def.id += _renderCompCount++;\n def.inputs = invertObject(componentDefinition.inputs, declaredInputs),\n def.outputs = invertObject(componentDefinition.outputs),\n feature && feature.forEach((/**\n * @param {?} fn\n * @return {?}\n */\n (fn) => fn(def)));\n def.directiveDefs = directiveTypes ?\n (/**\n * @return {?}\n */\n () => (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)\n .map(extractDirectiveDef)) :\n null;\n def.pipeDefs = pipeTypes ?\n (/**\n * @return {?}\n */\n () => (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef)) :\n null;\n // Add ngInjectableDef so components are reachable through the module injector by default\n // (unless it has already been set by the @Injectable decorator). This is mostly to\n // support injecting components in tests. In real application code, components should\n // be retrieved through the node injector, so this isn't a problem.\n if (!type.hasOwnProperty(NG_INJECTABLE_DEF)) {\n ((/** @type {?} */ (type)))[NG_INJECTABLE_DEF] =\n ɵɵdefineInjectable({ token: type, factory: (/** @type {?} */ (componentDefinition.factory)) });\n }\n }))));\n return (/** @type {?} */ (def));\n}\n/**\n * \\@codeGenApi\n * @param {?} type\n * @param {?} directives\n * @param {?} pipes\n * @return {?}\n */\nfunction ɵɵsetComponentScope(type, directives, pipes) {\n /** @type {?} */\n const def = ((/** @type {?} */ (type.ngComponentDef)));\n def.directiveDefs = (/**\n * @return {?}\n */\n () => directives.map(extractDirectiveDef));\n def.pipeDefs = (/**\n * @return {?}\n */\n () => pipes.map(extractPipeDef));\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction extractDirectiveDef(type) {\n /** @type {?} */\n const def = getComponentDef(type) || getDirectiveDef(type);\n if (ngDevMode && !def) {\n throw new Error(`'${type.name}' is neither 'ComponentType' or 'DirectiveType'.`);\n }\n return (/** @type {?} */ (def));\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction extractPipeDef(type) {\n /** @type {?} */\n const def = getPipeDef(type);\n if (ngDevMode && !def) {\n throw new Error(`'${type.name}' is not a 'PipeType'.`);\n }\n return (/** @type {?} */ (def));\n}\n/**\n * \\@codeGenApi\n * @template T\n * @param {?} def\n * @return {?}\n */\nfunction ɵɵdefineNgModule(def) {\n /** @type {?} */\n const res = {\n type: def.type,\n bootstrap: def.bootstrap || EMPTY_ARRAY,\n declarations: def.declarations || EMPTY_ARRAY,\n imports: def.imports || EMPTY_ARRAY,\n exports: def.exports || EMPTY_ARRAY,\n transitiveCompileScopes: null,\n schemas: def.schemas || null,\n id: def.id || null,\n };\n return (/** @type {?} */ (res));\n}\n/**\n * Adds the module metadata that is necessary to compute the module's transitive scope to an\n * existing module definition.\n *\n * Scope metadata of modules is not used in production builds, so calls to this function can be\n * marked pure to tree-shake it from the bundle, allowing for all referenced declarations\n * to become eligible for tree-shaking as well.\n *\n * \\@codeGenApi\n * @param {?} type\n * @param {?} scope\n * @return {?}\n */\nfunction ɵɵsetNgModuleScope(type, scope) {\n return (/** @type {?} */ (noSideEffects((/**\n * @return {?}\n */\n () => {\n /** @type {?} */\n /** @nocollapse */ const ngModuleDef = getNgModuleDef(type, true);\n ngModuleDef.declarations = scope.declarations || EMPTY_ARRAY;\n ngModuleDef.imports = scope.imports || EMPTY_ARRAY;\n ngModuleDef.exports = scope.exports || EMPTY_ARRAY;\n }))));\n}\n/**\n * Inverts an inputs or outputs lookup such that the keys, which were the\n * minified keys, are part of the values, and the values are parsed so that\n * the publicName of the property is the new key\n *\n * e.g. for\n *\n * ```\n * class Comp {\n * \\@Input()\n * propName1: string;\n *\n * \\@Input('publicName2')\n * declaredPropName2: number;\n * }\n * ```\n *\n * will be serialized as\n *\n * ```\n * {\n * propName1: 'propName1',\n * declaredPropName2: ['publicName2', 'declaredPropName2'],\n * }\n * ```\n *\n * which is than translated by the minifier as:\n *\n * ```\n * {\n * minifiedPropName1: 'propName1',\n * minifiedPropName2: ['publicName2', 'declaredPropName2'],\n * }\n * ```\n *\n * becomes: (public name => minifiedName)\n *\n * ```\n * {\n * 'propName1': 'minifiedPropName1',\n * 'publicName2': 'minifiedPropName2',\n * }\n * ```\n *\n * Optionally the function can take `secondary` which will result in: (public name => declared name)\n *\n * ```\n * {\n * 'propName1': 'propName1',\n * 'publicName2': 'declaredPropName2',\n * }\n * ```\n *\n * @template T\n * @param {?=} obj\n * @param {?=} secondary\n * @return {?}\n */\nfunction invertObject(obj, secondary) {\n if (obj == null)\n return (/** @type {?} */ (EMPTY_OBJ));\n /** @type {?} */\n const newLookup = {};\n for (const minifiedKey in obj) {\n if (obj.hasOwnProperty(minifiedKey)) {\n /** @type {?} */\n let publicName = (/** @type {?} */ (obj[minifiedKey]));\n /** @type {?} */\n let declaredName = publicName;\n if (Array.isArray(publicName)) {\n declaredName = publicName[1];\n publicName = publicName[0];\n }\n newLookup[publicName] = minifiedKey;\n if (secondary) {\n (secondary[publicName] = (/** @type {?} */ (declaredName)));\n }\n }\n }\n return newLookup;\n}\n/**\n * Create a base definition\n *\n * # Example\n * ```ts\n * class ShouldBeInherited {\n * static ngBaseDef = ɵɵdefineBase({\n * ...\n * })\n * }\n * ```\n *\n * \\@codeGenApi\n * @template T\n * @param {?} baseDefinition The base definition parameters\n *\n * @return {?}\n */\nfunction ɵɵdefineBase(baseDefinition) {\n /** @type {?} */\n const declaredInputs = (/** @type {?} */ ({}));\n return {\n inputs: invertObject((/** @type {?} */ (baseDefinition.inputs)), declaredInputs),\n declaredInputs: declaredInputs,\n outputs: invertObject((/** @type {?} */ (baseDefinition.outputs))),\n viewQuery: baseDefinition.viewQuery || null,\n contentQueries: baseDefinition.contentQueries || null,\n hostBindings: baseDefinition.hostBindings || null\n };\n}\n/**\n * Create a directive definition object.\n *\n * # Example\n * ```ts\n * class MyDirective {\n * // Generated by Angular Template Compiler\n * // [Symbol] syntax will not be supported by TypeScript until v2.7\n * static ngDirectiveDef = ɵɵdefineDirective({\n * ...\n * });\n * }\n * ```\n *\n * \\@codeGenApi\n * @type {?}\n */\nconst ɵɵdefineDirective = (/** @type {?} */ ((/** @type {?} */ (ɵɵdefineComponent))));\n/**\n * Create a pipe definition object.\n *\n * # Example\n * ```\n * class MyPipe implements PipeTransform {\n * // Generated by Angular Template Compiler\n * static ngPipeDef = definePipe({\n * ...\n * });\n * }\n * ```\n * \\@codeGenApi\n * @template T\n * @param {?} pipeDef Pipe definition generated by the compiler\n *\n * @return {?}\n */\nfunction ɵɵdefinePipe(pipeDef) {\n return (/** @type {?} */ (((/** @type {?} */ ({\n name: pipeDef.name,\n factory: pipeDef.factory,\n pure: pipeDef.pure !== false,\n onDestroy: pipeDef.type.prototype.ngOnDestroy || null\n })))));\n}\n/**\n * The following getter methods retrieve the definition form the type. Currently the retrieval\n * honors inheritance, but in the future we may change the rule to require that definitions are\n * explicit. This would require some sort of migration strategy.\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getComponentDef(type) {\n return ((/** @type {?} */ (type)))[NG_COMPONENT_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getDirectiveDef(type) {\n return ((/** @type {?} */ (type)))[NG_DIRECTIVE_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getPipeDef(type) {\n return ((/** @type {?} */ (type)))[NG_PIPE_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction getBaseDef(type) {\n return ((/** @type {?} */ (type)))[NG_BASE_DEF] || null;\n}\n/**\n * @template T\n * @param {?} type\n * @param {?=} throwNotFound\n * @return {?}\n */\nfunction getNgModuleDef(type, throwNotFound) {\n /** @type {?} */\n /** @nocollapse */ const ngModuleDef = ((/** @type {?} */ (type)))[NG_MODULE_DEF] || null;\n if (!ngModuleDef && throwNotFound === true) {\n throw new Error(`Type ${stringify(type)} does not have 'ngModuleDef' property.`);\n }\n return ngModuleDef;\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction getNgLocaleIdDef(type) {\n return ((/** @type {?} */ (type)))[NG_LOCALE_ID_DEF] || null;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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// Below are constants for LView indices to help us look up LView members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\n/** @type {?} */\nconst HOST = 0;\n/** @type {?} */\nconst TVIEW = 1;\n/** @type {?} */\nconst FLAGS = 2;\n/** @type {?} */\nconst PARENT = 3;\n/** @type {?} */\nconst NEXT = 4;\n/** @type {?} */\nconst QUERIES = 5;\n/** @type {?} */\nconst T_HOST = 6;\n/** @type {?} */\nconst BINDING_INDEX = 7;\n/** @type {?} */\nconst CLEANUP = 8;\n/** @type {?} */\nconst CONTEXT = 9;\n/** @type {?} */\nconst INJECTOR$1 = 10;\n/** @type {?} */\nconst RENDERER_FACTORY = 11;\n/** @type {?} */\nconst RENDERER = 12;\n/** @type {?} */\nconst SANITIZER = 13;\n/** @type {?} */\nconst CHILD_HEAD = 14;\n/** @type {?} */\nconst CHILD_TAIL = 15;\n/** @type {?} */\nconst DECLARATION_VIEW = 16;\n/** @type {?} */\nconst DECLARATION_LCONTAINER = 17;\n/** @type {?} */\nconst PREORDER_HOOK_FLAGS = 18;\n/**\n * Size of LView's header. Necessary to adjust for it when setting slots.\n * @type {?}\n */\nconst HEADER_OFFSET = 19;\n/**\n * @record\n */\nfunction OpaqueViewState() { }\nif (false) {\n /** @type {?} */\n OpaqueViewState.prototype.__brand__;\n}\n/**\n * `LView` stores all of the information needed to process the instructions as\n * they are invoked from the template. Each embedded view and component view has its\n * own `LView`. When processing a particular view, we set the `viewData` to that\n * `LView`. When that view is done processing, the `viewData` is set back to\n * whatever the original `viewData` was before (the parent `LView`).\n *\n * Keeping separate state for each view facilities view insertion / deletion, so we\n * don't have to edit the data array based on which views are present.\n * @record\n */\nfunction LView() { }\nif (false) {\n /* Skipping unnamed member:\n [HOST]: RElement|null;*/\n /* Skipping unnamed member:\n readonly[TVIEW]: TView;*/\n /* Skipping unnamed member:\n [FLAGS]: LViewFlags;*/\n /* Skipping unnamed member:\n [PARENT]: LView|LContainer|null;*/\n /* Skipping unnamed member:\n [NEXT]: LView|LContainer|null;*/\n /* Skipping unnamed member:\n [QUERIES]: LQueries|null;*/\n /* Skipping unnamed member:\n [T_HOST]: TViewNode|TElementNode|null;*/\n /* Skipping unnamed member:\n [BINDING_INDEX]: number;*/\n /* Skipping unnamed member:\n [CLEANUP]: any[]|null;*/\n /* Skipping unnamed member:\n [CONTEXT]: {}|RootContext|null;*/\n /* Skipping unnamed member:\n readonly[INJECTOR]: Injector|null;*/\n /* Skipping unnamed member:\n [RENDERER_FACTORY]: RendererFactory3;*/\n /* Skipping unnamed member:\n [RENDERER]: Renderer3;*/\n /* Skipping unnamed member:\n [SANITIZER]: Sanitizer|null;*/\n /* Skipping unnamed member:\n [CHILD_HEAD]: LView|LContainer|null;*/\n /* Skipping unnamed member:\n [CHILD_TAIL]: LView|LContainer|null;*/\n /* Skipping unnamed member:\n [DECLARATION_VIEW]: LView|null;*/\n /* Skipping unnamed member:\n [DECLARATION_LCONTAINER]: LContainer|null;*/\n /* Skipping unnamed member:\n [PREORDER_HOOK_FLAGS]: PreOrderHookFlags;*/\n}\n/** @enum {number} */\nconst LViewFlags = {\n /** The state of the init phase on the first 2 bits */\n InitPhaseStateIncrementer: 1,\n InitPhaseStateMask: 3,\n /**\n * Whether or not the view is in creationMode.\n *\n * This must be stored in the view rather than using `data` as a marker so that\n * we can properly support embedded views. Otherwise, when exiting a child view\n * back into the parent view, `data` will be defined and `creationMode` will be\n * improperly reported as false.\n */\n CreationMode: 4,\n /**\n * Whether or not this LView instance is on its first processing pass.\n *\n * An LView instance is considered to be on its \"first pass\" until it\n * has completed one creation mode run and one update mode run. At this\n * time, the flag is turned off.\n */\n FirstLViewPass: 8,\n /** Whether this view has default change detection strategy (checks always) or onPush */\n CheckAlways: 16,\n /**\n * Whether or not manual change detection is turned on for onPush components.\n *\n * This is a special mode that only marks components dirty in two cases:\n * 1) There has been a change to an @Input property\n * 2) `markDirty()` has been called manually by the user\n *\n * Note that in this mode, the firing of events does NOT mark components\n * dirty automatically.\n *\n * Manual mode is turned off by default for backwards compatibility, as events\n * automatically mark OnPush components dirty in View Engine.\n *\n * TODO: Add a public API to ChangeDetectionStrategy to turn this mode on\n */\n ManualOnPush: 32,\n /** Whether or not this view is currently dirty (needing check) */\n Dirty: 64,\n /** Whether or not this view is currently attached to change detection tree. */\n Attached: 128,\n /** Whether or not this view is destroyed. */\n Destroyed: 256,\n /** Whether or not this view is the root view */\n IsRoot: 512,\n /**\n * Index of the current init phase on last 22 bits\n */\n IndexWithinInitPhaseIncrementer: 1024,\n IndexWithinInitPhaseShift: 10,\n IndexWithinInitPhaseReset: 1023,\n};\n/** @enum {number} */\nconst InitPhaseState = {\n OnInitHooksToBeRun: 0,\n AfterContentInitHooksToBeRun: 1,\n AfterViewInitHooksToBeRun: 2,\n InitPhaseCompleted: 3,\n};\n/** @enum {number} */\nconst PreOrderHookFlags = {\n /** The index of the next pre-order hook to be called in the hooks array, on the first 16\n bits */\n IndexOfTheNextPreOrderHookMaskMask: 65535,\n /**\n * The number of init hooks that have already been called, on the last 16 bits\n */\n NumberOfInitHooksCalledIncrementer: 65536,\n NumberOfInitHooksCalledShift: 16,\n NumberOfInitHooksCalledMask: 4294901760,\n};\n/**\n * Set of instructions used to process host bindings efficiently.\n *\n * See VIEW_DATA.md for more information.\n * @record\n */\nfunction ExpandoInstructions() { }\n/**\n * The static data for an LView (shared between all templates of a\n * given type).\n *\n * Stored on the `ComponentDef.tView`.\n * @record\n */\nfunction TView() { }\nif (false) {\n /**\n * ID for inline views to determine whether a view is the same as the previous view\n * in a certain position. If it's not, we know the new view needs to be inserted\n * and the one that exists needs to be removed (e.g. if/else statements)\n *\n * If this is -1, then this is a component view or a dynamically created view.\n * @type {?}\n */\n TView.prototype.id;\n /**\n * This is a blueprint used to generate LView instances for this TView. Copying this\n * blueprint is faster than creating a new LView from scratch.\n * @type {?}\n */\n TView.prototype.blueprint;\n /**\n * The template function used to refresh the view of dynamically created views\n * and components. Will be null for inline views.\n * @type {?}\n */\n TView.prototype.template;\n /**\n * A function containing query-related instructions.\n * @type {?}\n */\n TView.prototype.viewQuery;\n /**\n * Pointer to the host `TNode` (not part of this TView).\n *\n * If this is a `TViewNode` for an `LViewNode`, this is an embedded view of a container.\n * We need this pointer to be able to efficiently find this node when inserting the view\n * into an anchor.\n *\n * If this is a `TElementNode`, this is the view of a root component. It has exactly one\n * root TNode.\n *\n * If this is null, this is the view of a component that is not at root. We do not store\n * the host TNodes for child component views because they can potentially have several\n * different host TNodes, depending on where the component is being used. These host\n * TNodes cannot be shared (due to different indices, etc).\n * @type {?}\n */\n TView.prototype.node;\n /**\n * Whether or not this template has been processed.\n * @type {?}\n */\n TView.prototype.firstTemplatePass;\n /**\n * Static data equivalent of LView.data[]. Contains TNodes, PipeDefInternal or TI18n.\n * @type {?}\n */\n TView.prototype.data;\n /**\n * The binding start index is the index at which the data array\n * starts to store bindings only. Saving this value ensures that we\n * will begin reading bindings at the correct point in the array when\n * we are in update mode.\n * @type {?}\n */\n TView.prototype.bindingStartIndex;\n /**\n * The index where the \"expando\" section of `LView` begins. The expando\n * section contains injectors, directive instances, and host binding values.\n * Unlike the \"consts\" and \"vars\" sections of `LView`, the length of this\n * section cannot be calculated at compile-time because directives are matched\n * at runtime to preserve locality.\n *\n * We store this start index so we know where to start checking host bindings\n * in `setHostBindings`.\n * @type {?}\n */\n TView.prototype.expandoStartIndex;\n /**\n * Whether or not there are any static view queries tracked on this view.\n *\n * We store this so we know whether or not we should do a view query\n * refresh after creation mode to collect static query results.\n * @type {?}\n */\n TView.prototype.staticViewQueries;\n /**\n * Whether or not there are any static content queries tracked on this view.\n *\n * We store this so we know whether or not we should do a content query\n * refresh after creation mode to collect static query results.\n * @type {?}\n */\n TView.prototype.staticContentQueries;\n /**\n * A reference to the first child node located in the view.\n * @type {?}\n */\n TView.prototype.firstChild;\n /**\n * Set of instructions used to process host bindings efficiently.\n *\n * See VIEW_DATA.md for more information.\n * @type {?}\n */\n TView.prototype.expandoInstructions;\n /**\n * Full registry of directives and components that may be found in this view.\n *\n * It's necessary to keep a copy of the full def list on the TView so it's possible\n * to render template functions without a host component.\n * @type {?}\n */\n TView.prototype.directiveRegistry;\n /**\n * Full registry of pipes that may be found in this view.\n *\n * The property is either an array of `PipeDefs`s or a function which returns the array of\n * `PipeDefs`s. The function is necessary to be able to support forward declarations.\n *\n * It's necessary to keep a copy of the full def list on the TView so it's possible\n * to render template functions without a host component.\n * @type {?}\n */\n TView.prototype.pipeRegistry;\n /**\n * Array of ngOnInit, ngOnChanges and ngDoCheck hooks that should be executed for this view in\n * creation mode.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.preOrderHooks;\n /**\n * Array of ngOnChanges and ngDoCheck hooks that should be executed for this view in update mode.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.preOrderCheckHooks;\n /**\n * Array of ngAfterContentInit and ngAfterContentChecked hooks that should be executed\n * for this view in creation mode.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.contentHooks;\n /**\n * Array of ngAfterContentChecked hooks that should be executed for this view in update\n * mode.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.contentCheckHooks;\n /**\n * Array of ngAfterViewInit and ngAfterViewChecked hooks that should be executed for\n * this view in creation mode.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.viewHooks;\n /**\n * Array of ngAfterViewChecked hooks that should be executed for this view in\n * update mode.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.viewCheckHooks;\n /**\n * Array of ngOnDestroy hooks that should be executed when this view is destroyed.\n *\n * Even indices: Directive index\n * Odd indices: Hook function\n * @type {?}\n */\n TView.prototype.destroyHooks;\n /**\n * When a view is destroyed, listeners need to be released and outputs need to be\n * unsubscribed. This cleanup array stores both listener data (in chunks of 4)\n * and output data (in chunks of 2) for a particular view. Combining the arrays\n * saves on memory (70 bytes per array) and on a few bytes of code size (for two\n * separate for loops).\n *\n * If it's a native DOM listener or output subscription being stored:\n * 1st index is: event name `name = tView.cleanup[i+0]`\n * 2nd index is: index of native element or a function that retrieves global target (window,\n * document or body) reference based on the native element:\n * `typeof idxOrTargetGetter === 'function'`: global target getter function\n * `typeof idxOrTargetGetter === 'number'`: index of native element\n *\n * 3rd index is: index of listener function `listener = lView[CLEANUP][tView.cleanup[i+2]]`\n * 4th index is: `useCaptureOrIndx = tView.cleanup[i+3]`\n * `typeof useCaptureOrIndx == 'boolean' : useCapture boolean\n * `typeof useCaptureOrIndx == 'number':\n * `useCaptureOrIndx >= 0` `removeListener = LView[CLEANUP][useCaptureOrIndx]`\n * `useCaptureOrIndx < 0` `subscription = LView[CLEANUP][-useCaptureOrIndx]`\n *\n * If it's an output subscription or query list destroy hook:\n * 1st index is: output unsubscribe function / query list destroy function\n * 2nd index is: index of function context in LView.cleanupInstances[]\n * `tView.cleanup[i+0].call(lView[CLEANUP][tView.cleanup[i+1]])`\n * @type {?}\n */\n TView.prototype.cleanup;\n /**\n * A list of element indices for child components that will need to be\n * refreshed when the current view has finished its check. These indices have\n * already been adjusted for the HEADER_OFFSET.\n *\n * @type {?}\n */\n TView.prototype.components;\n /**\n * A collection of queries tracked in a given view.\n * @type {?}\n */\n TView.prototype.queries;\n /**\n * An array of indices pointing to directives with content queries alongside with the\n * corresponding\n * query index. Each entry in this array is a tuple of:\n * - index of the first content query index declared by a given directive;\n * - index of a directive.\n *\n * We are storing those indexes so we can refresh content queries as part of a view refresh\n * process.\n * @type {?}\n */\n TView.prototype.contentQueries;\n /**\n * Set of schemas that declare elements to be allowed inside the view.\n * @type {?}\n */\n TView.prototype.schemas;\n}\n/** @enum {number} */\nconst RootContextFlags = {\n Empty: 0, DetectChanges: 1, FlushPlayers: 2,\n};\n/**\n * RootContext contains information which is shared for all components which\n * were bootstrapped with {\\@link renderComponent}.\n * @record\n */\nfunction RootContext() { }\nif (false) {\n /**\n * A function used for scheduling change detection in the future. Usually\n * this is `requestAnimationFrame`.\n * @type {?}\n */\n RootContext.prototype.scheduler;\n /**\n * A promise which is resolved when all components are considered clean (not dirty).\n *\n * This promise is overwritten every time a first call to {\\@link markDirty} is invoked.\n * @type {?}\n */\n RootContext.prototype.clean;\n /**\n * RootComponents - The components that were instantiated by the call to\n * {\\@link renderComponent}.\n * @type {?}\n */\n RootContext.prototype.components;\n /**\n * The player flushing handler to kick off all animations\n * @type {?}\n */\n RootContext.prototype.playerHandler;\n /**\n * What render-related operations to run once a scheduler has been set\n * @type {?}\n */\n RootContext.prototype.flags;\n}\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n/** @type {?} */\nconst unusedValueExportToPlacateAjd = 1;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Special location which allows easy identification of type. If we have an array which was\n * retrieved from the `LView` and that array has `true` at `TYPE` location, we know it is\n * `LContainer`.\n * @type {?}\n */\nconst TYPE = 1;\n/**\n * Below are constants for LContainer indices to help us look up LContainer members\n * without having to remember the specific indices.\n * Uglify will inline these when minifying so there shouldn't be a cost.\n * @type {?}\n */\nconst ACTIVE_INDEX = 2;\n// PARENT and NEXT are indices 3 and 4\n// As we already have these constants in LView, we don't need to re-create them.\n/** @type {?} */\nconst MOVED_VIEWS = 5;\n// T_HOST is index 6\n// We already have this constants in LView, we don't need to re-create it.\n/** @type {?} */\nconst NATIVE = 7;\n/** @type {?} */\nconst VIEW_REFS = 8;\n/**\n * Size of LContainer's header. Represents the index after which all views in the\n * container will be inserted. We need to keep a record of current views so we know\n * which views are already in the DOM (and don't need to be re-added) and so we can\n * remove views from the DOM when they are no longer required.\n * @type {?}\n */\nconst CONTAINER_HEADER_OFFSET = 9;\n/**\n * The state associated with a container.\n *\n * This is an array so that its structure is closer to LView. This helps\n * when traversing the view tree (which is a mix of containers and component\n * views), so we can jump to viewOrContainer[NEXT] in the same way regardless\n * of type.\n * @record\n */\nfunction LContainer() { }\nif (false) {\n /* Skipping unnamed member:\n readonly[HOST]: RElement|RComment|LView;*/\n /* Skipping unnamed member:\n [TYPE]: true;*/\n /* Skipping unnamed member:\n [ACTIVE_INDEX]: number;*/\n /* Skipping unnamed member:\n [PARENT]: LView;*/\n /* Skipping unnamed member:\n [NEXT]: LView|LContainer|null;*/\n /* Skipping unnamed member:\n [MOVED_VIEWS]: LView[]|null;*/\n /* Skipping unnamed member:\n [T_HOST]: TNode;*/\n /* Skipping unnamed member:\n readonly[NATIVE]:\n RComment;*/\n /* Skipping unnamed member:\n [VIEW_REFS]: ViewRef[]|null;*/\n}\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n/** @type {?} */\nconst unusedValueExportToPlacateAjd$1 = 1;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * True if `value` is `LView`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`\n * @return {?}\n */\nfunction isLView(value) {\n return Array.isArray(value) && typeof value[TYPE] === 'object';\n}\n/**\n * True if `value` is `LContainer`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`\n * @return {?}\n */\nfunction isLContainer(value) {\n return Array.isArray(value) && value[TYPE] === true;\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction isContentQueryHost(tNode) {\n return (tNode.flags & 4 /* hasContentQuery */) !== 0;\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction isComponent(tNode) {\n return (tNode.flags & 1 /* isComponent */) === 1 /* isComponent */;\n}\n/**\n * @template T\n * @param {?} def\n * @return {?}\n */\nfunction isComponentDef(def) {\n return ((/** @type {?} */ (def))).template !== null;\n}\n/**\n * @param {?} target\n * @return {?}\n */\nfunction isRootView(target) {\n return (target[FLAGS] & 512 /* IsRoot */) !== 0;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @param {?} tNode\n * @param {?} lView\n * @return {?}\n */\nfunction assertTNodeForLView(tNode, lView) {\n tNode.hasOwnProperty('tView_') && assertEqual(((/** @type {?} */ ((/** @type {?} */ (tNode))))).tView_, lView[TVIEW], 'This TNode does not belong to this LView.');\n}\n/**\n * @param {?} actual\n * @param {?=} msg\n * @return {?}\n */\nfunction assertComponentType(actual, msg = 'Type passed in is not ComponentType, it does not have \\'ngComponentDef\\' property.') {\n if (!getComponentDef(actual)) {\n throwError(msg);\n }\n}\n/**\n * @param {?} actual\n * @param {?=} msg\n * @return {?}\n */\nfunction assertNgModuleType(actual, msg = 'Type passed in is not NgModuleType, it does not have \\'ngModuleDef\\' property.') {\n if (!getNgModuleDef(actual)) {\n throwError(msg);\n }\n}\n/**\n * @param {?} isParent\n * @return {?}\n */\nfunction assertPreviousIsParent(isParent) {\n assertEqual(isParent, true, 'previousOrParentTNode should be a parent');\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction assertHasParent(tNode) {\n assertDefined(tNode, 'previousOrParentTNode should exist!');\n assertDefined((/** @type {?} */ (tNode)).parent, 'previousOrParentTNode should have a parent');\n}\n/**\n * @param {?} lView\n * @param {?} index\n * @param {?=} arr\n * @return {?}\n */\nfunction assertDataNext(lView, index, arr) {\n if (arr == null)\n arr = lView;\n assertEqual(arr.length, index, `index ${index} expected to be at the end of arr (length ${arr.length})`);\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLContainerOrUndefined(value) {\n value && assertEqual(isLContainer(value), true, 'Expecting LContainer or undefined or null');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLContainer(value) {\n assertDefined(value, 'LContainer must be defined');\n assertEqual(isLContainer(value), true, 'Expecting LContainer');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLViewOrUndefined(value) {\n value && assertEqual(isLView(value), true, 'Expecting LView or undefined or null');\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction assertLView(value) {\n assertDefined(value, 'LView must be defined');\n assertEqual(isLView(value), true, 'Expecting LView');\n}\n/**\n * @param {?} tView\n * @param {?} errMessage\n * @return {?}\n */\nfunction assertFirstTemplatePass(tView, errMessage) {\n assertEqual(tView.firstTemplatePass, true, errMessage);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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/** @type {?} */\nconst TNODE = 8;\n/** @type {?} */\nconst PARENT_INJECTOR = 8;\n/** @type {?} */\nconst INJECTOR_BLOOM_PARENT_SIZE = 9;\n/**\n * Represents a relative location of parent injector.\n *\n * The interfaces encodes number of parents `LView`s to traverse and index in the `LView`\n * pointing to the parent injector.\n * @record\n */\nfunction RelativeInjectorLocation() { }\nif (false) {\n /** @type {?} */\n RelativeInjectorLocation.prototype.__brand__;\n}\n/** @enum {number} */\nconst RelativeInjectorLocationFlags = {\n InjectorIndexMask: 32767,\n ViewOffsetShift: 16,\n NO_PARENT: -1,\n};\n/** @type {?} */\nconst NO_PARENT_INJECTOR = (/** @type {?} */ (-1));\n/**\n * Each injector is saved in 9 contiguous slots in `LView` and 9 contiguous slots in\n * `TView.data`. This allows us to store information about the current node's tokens (which\n * can be shared in `TView`) as well as the tokens of its ancestor nodes (which cannot be\n * shared, so they live in `LView`).\n *\n * Each of these slots (aside from the last slot) contains a bloom filter. This bloom filter\n * determines whether a directive is available on the associated node or not. This prevents us\n * from searching the directives array at this level unless it's probable the directive is in it.\n *\n * See: https://en.wikipedia.org/wiki/Bloom_filter for more about bloom filters.\n *\n * Because all injectors have been flattened into `LView` and `TViewData`, they cannot typed\n * using interfaces as they were previously. The start index of each `LInjector` and `TInjector`\n * will differ based on where it is flattened into the main array, so it's not possible to know\n * the indices ahead of time and save their types here. The interfaces are still included here\n * for documentation purposes.\n *\n * export interface LInjector extends Array {\n *\n * // Cumulative bloom for directive IDs 0-31 (IDs are % BLOOM_SIZE)\n * [0]: number;\n *\n * // Cumulative bloom for directive IDs 32-63\n * [1]: number;\n *\n * // Cumulative bloom for directive IDs 64-95\n * [2]: number;\n *\n * // Cumulative bloom for directive IDs 96-127\n * [3]: number;\n *\n * // Cumulative bloom for directive IDs 128-159\n * [4]: number;\n *\n * // Cumulative bloom for directive IDs 160 - 191\n * [5]: number;\n *\n * // Cumulative bloom for directive IDs 192 - 223\n * [6]: number;\n *\n * // Cumulative bloom for directive IDs 224 - 255\n * [7]: number;\n *\n * // We need to store a reference to the injector's parent so DI can keep looking up\n * // the injector tree until it finds the dependency it's looking for.\n * [PARENT_INJECTOR]: number;\n * }\n *\n * export interface TInjector extends Array {\n *\n * // Shared node bloom for directive IDs 0-31 (IDs are % BLOOM_SIZE)\n * [0]: number;\n *\n * // Shared node bloom for directive IDs 32-63\n * [1]: number;\n *\n * // Shared node bloom for directive IDs 64-95\n * [2]: number;\n *\n * // Shared node bloom for directive IDs 96-127\n * [3]: number;\n *\n * // Shared node bloom for directive IDs 128-159\n * [4]: number;\n *\n * // Shared node bloom for directive IDs 160 - 191\n * [5]: number;\n *\n * // Shared node bloom for directive IDs 192 - 223\n * [6]: number;\n *\n * // Shared node bloom for directive IDs 224 - 255\n * [7]: number;\n *\n * // Necessary to find directive indices for a particular node.\n * [TNODE]: TElementNode|TElementContainerNode|TContainerNode;\n * }\n */\n/**\n * Factory for creating instances of injectors in the NodeInjector.\n *\n * This factory is complicated by the fact that it can resolve `multi` factories as well.\n *\n * NOTE: Some of the fields are optional which means that this class has two hidden classes.\n * - One without `multi` support (most common)\n * - One with `multi` values, (rare).\n *\n * Since VMs can cache up to 4 inline hidden classes this is OK.\n *\n * - Single factory: Only `resolving` and `factory` is defined.\n * - `providers` factory: `componentProviders` is a number and `index = -1`.\n * - `viewProviders` factory: `componentProviders` is a number and `index` points to `providers`.\n */\nclass NodeInjectorFactory {\n /**\n * @param {?} factory\n * @param {?} isViewProvider\n * @param {?} injectImplementation\n */\n constructor(factory, \n /**\n * Set to `true` if the token is declared in `viewProviders` (or if it is component).\n */\n isViewProvider, injectImplementation) {\n this.factory = factory;\n /**\n * Marker set to true during factory invocation to see if we get into recursive loop.\n * Recursive loop causes an error to be displayed.\n */\n this.resolving = false;\n this.canSeeViewProviders = isViewProvider;\n this.injectImpl = injectImplementation;\n }\n}\nif (false) {\n /**\n * The inject implementation to be activated when using the factory.\n * @type {?}\n */\n NodeInjectorFactory.prototype.injectImpl;\n /**\n * Marker set to true during factory invocation to see if we get into recursive loop.\n * Recursive loop causes an error to be displayed.\n * @type {?}\n */\n NodeInjectorFactory.prototype.resolving;\n /**\n * Marks that the token can see other Tokens declared in `viewProviders` on the same node.\n * @type {?}\n */\n NodeInjectorFactory.prototype.canSeeViewProviders;\n /**\n * An array of factories to use in case of `multi` provider.\n * @type {?}\n */\n NodeInjectorFactory.prototype.multi;\n /**\n * Number of `multi`-providers which belong to the component.\n *\n * This is needed because when multiple components and directives declare the `multi` provider\n * they have to be concatenated in the correct order.\n *\n * Example:\n *\n * If we have a component and directive active an a single element as declared here\n * ```\n * component:\n * provides: [ {provide: String, useValue: 'component', multi: true} ],\n * viewProvides: [ {provide: String, useValue: 'componentView', multi: true} ],\n *\n * directive:\n * provides: [ {provide: String, useValue: 'directive', multi: true} ],\n * ```\n *\n * Then the expected results are:\n *\n * ```\n * providers: ['component', 'directive']\n * viewProviders: ['component', 'componentView', 'directive']\n * ```\n *\n * The way to think about it is that the `viewProviders` have been inserted after the component\n * but before the directives, which is why we need to know how many `multi`s have been declared by\n * the component.\n * @type {?}\n */\n NodeInjectorFactory.prototype.componentProviders;\n /**\n * Current index of the Factory in the `data`. Needed for `viewProviders` and `providers` merging.\n * See `providerFactory`.\n * @type {?}\n */\n NodeInjectorFactory.prototype.index;\n /**\n * Because the same `multi` provider can be declared in `provides` and `viewProvides` it is\n * possible for `viewProvides` to shadow the `provides`. For this reason we store the\n * `provideFactory` of the `providers` so that `providers` can be extended with `viewProviders`.\n *\n * Example:\n *\n * Given:\n * ```\n * provides: [ {provide: String, useValue: 'all', multi: true} ],\n * viewProvides: [ {provide: String, useValue: 'viewOnly', multi: true} ],\n * ```\n *\n * We have to return `['all']` in case of content injection, but `['all', 'viewOnly']` in case\n * of view injection. We further have to make sure that the shared instances (in our case\n * `all`) are the exact same instance in both the content as well as the view injection. (We\n * have to make sure that we don't double instantiate.) For this reason the `viewProvides`\n * `Factory` has a pointer to the shadowed `provides` factory so that it can instantiate the\n * `providers` (`['all']`) and then extend it with `viewProviders` (`['all'] + ['viewOnly'] =\n * ['all', 'viewOnly']`).\n * @type {?}\n */\n NodeInjectorFactory.prototype.providerFactory;\n /**\n * Factory to invoke in order to create a new instance.\n * @type {?}\n */\n NodeInjectorFactory.prototype.factory;\n}\n/**\n * @param {?} obj\n * @return {?}\n */\nfunction isFactory(obj) {\n // See: https://jsperf.com/instanceof-vs-getprototypeof\n return obj !== null && typeof obj == 'object' &&\n Object.getPrototypeOf(obj) == NodeInjectorFactory.prototype;\n}\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n/** @type {?} */\nconst unusedValueExportToPlacateAjd$2 = 1;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @param {?} tNode\n * @param {?} type\n * @return {?}\n */\nfunction assertNodeType(tNode, type) {\n assertDefined(tNode, 'should be called with a TNode');\n assertEqual(tNode.type, type, `should be a ${typeName(type)}`);\n}\n/**\n * @param {?} tNode\n * @param {...?} types\n * @return {?}\n */\nfunction assertNodeOfPossibleTypes(tNode, ...types) {\n assertDefined(tNode, 'should be called with a TNode');\n /** @type {?} */\n const found = types.some((/**\n * @param {?} type\n * @return {?}\n */\n type => tNode.type === type));\n assertEqual(found, true, `Should be one of ${types.map(typeName).join(', ')} but got ${typeName(tNode.type)}`);\n}\n/**\n * @param {?} type\n * @return {?}\n */\nfunction typeName(type) {\n if (type == 1 /* Projection */)\n return 'Projection';\n if (type == 0 /* Container */)\n return 'Container';\n if (type == 2 /* View */)\n return 'View';\n if (type == 3 /* Element */)\n return 'Element';\n if (type == 4 /* ElementContainer */)\n return 'ElementContainer';\n return '';\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Adds all directive lifecycle hooks from the given `DirectiveDef` to the given `TView`.\n *\n * Must be run *only* on the first template pass.\n *\n * Sets up the pre-order hooks on the provided `tView`,\n * see {\\@link HookData} for details about the data structure.\n *\n * @param {?} directiveIndex The index of the directive in LView\n * @param {?} directiveDef The definition containing the hooks to setup in tView\n * @param {?} tView The current TView\n * @param {?} nodeIndex The index of the node to which the directive is attached\n * @param {?} initialPreOrderHooksLength the number of pre-order hooks already registered before the\n * current process, used to know if the node index has to be added to the array. If it is -1,\n * the node index is never added.\n * @param {?} initialPreOrderCheckHooksLength same as previous for pre-order check hooks\n * @return {?}\n */\nfunction registerPreOrderHooks(directiveIndex, directiveDef, tView, nodeIndex, initialPreOrderHooksLength, initialPreOrderCheckHooksLength) {\n ngDevMode &&\n assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');\n const { onChanges, onInit, doCheck } = directiveDef;\n if (initialPreOrderHooksLength >= 0 &&\n (!tView.preOrderHooks || initialPreOrderHooksLength === tView.preOrderHooks.length) &&\n (onChanges || onInit || doCheck)) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(nodeIndex);\n }\n if (initialPreOrderCheckHooksLength >= 0 &&\n (!tView.preOrderCheckHooks ||\n initialPreOrderCheckHooksLength === tView.preOrderCheckHooks.length) &&\n (onChanges || doCheck)) {\n (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(nodeIndex);\n }\n if (onChanges) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, onChanges);\n (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, onChanges);\n }\n if (onInit) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(-directiveIndex, onInit);\n }\n if (doCheck) {\n (tView.preOrderHooks || (tView.preOrderHooks = [])).push(directiveIndex, doCheck);\n (tView.preOrderCheckHooks || (tView.preOrderCheckHooks = [])).push(directiveIndex, doCheck);\n }\n}\n/**\n *\n * Loops through the directives on the provided `tNode` and queues hooks to be\n * run that are not initialization hooks.\n *\n * Should be executed during `elementEnd()` and similar to\n * preserve hook execution order. Content, view, and destroy hooks for projected\n * components and directives must be called *before* their hosts.\n *\n * Sets up the content, view, and destroy hooks on the provided `tView`,\n * see {\\@link HookData} for details about the data structure.\n *\n * NOTE: This does not set up `onChanges`, `onInit` or `doCheck`, those are set up\n * separately at `elementStart`.\n *\n * @param {?} tView The current TView\n * @param {?} tNode The TNode whose directives are to be searched for hooks to queue\n * @return {?}\n */\nfunction registerPostOrderHooks(tView, tNode) {\n if (tView.firstTemplatePass) {\n // It's necessary to loop through the directives at elementEnd() (rather than processing in\n // directiveCreate) so we can preserve the current hook order. Content, view, and destroy\n // hooks for projected components and directives must be called *before* their hosts.\n for (let i = tNode.directiveStart, end = tNode.directiveEnd; i < end; i++) {\n /** @type {?} */\n const directiveDef = (/** @type {?} */ (tView.data[i]));\n if (directiveDef.afterContentInit) {\n (tView.contentHooks || (tView.contentHooks = [])).push(-i, directiveDef.afterContentInit);\n }\n if (directiveDef.afterContentChecked) {\n (tView.contentHooks || (tView.contentHooks = [])).push(i, directiveDef.afterContentChecked);\n (tView.contentCheckHooks || (tView.contentCheckHooks = [])).push(i, directiveDef.afterContentChecked);\n }\n if (directiveDef.afterViewInit) {\n (tView.viewHooks || (tView.viewHooks = [])).push(-i, directiveDef.afterViewInit);\n }\n if (directiveDef.afterViewChecked) {\n (tView.viewHooks || (tView.viewHooks = [])).push(i, directiveDef.afterViewChecked);\n (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, directiveDef.afterViewChecked);\n }\n if (directiveDef.onDestroy != null) {\n (tView.destroyHooks || (tView.destroyHooks = [])).push(i, directiveDef.onDestroy);\n }\n }\n }\n}\n/**\n * Executing hooks requires complex logic as we need to deal with 2 constraints.\n *\n * 1. Init hooks (ngOnInit, ngAfterContentInit, ngAfterViewInit) must all be executed once and only\n * once, across many change detection cycles. This must be true even if some hooks throw, or if\n * some recursively trigger a change detection cycle.\n * To solve that, it is required to track the state of the execution of these init hooks.\n * This is done by storing and maintaining flags in the view: the {@link InitPhaseState},\n * and the index within that phase. They can be seen as a cursor in the following structure:\n * [[onInit1, onInit2], [afterContentInit1], [afterViewInit1, afterViewInit2, afterViewInit3]]\n * They are are stored as flags in LView[FLAGS].\n *\n * 2. Pre-order hooks can be executed in batches, because of the select instruction.\n * To be able to pause and resume their execution, we also need some state about the hook's array\n * that is being processed:\n * - the index of the next hook to be executed\n * - the number of init hooks already found in the processed part of the array\n * They are are stored as flags in LView[PREORDER_HOOK_FLAGS].\n */\n/**\n * Executes necessary hooks at the start of executing a template.\n *\n * Executes hooks that are to be run during the initialization of a directive such\n * as `onChanges`, `onInit`, and `doCheck`.\n *\n * @param {?} currentView\n * @param {?} tView Static data for the view containing the hooks to be executed\n * @param {?} checkNoChangesMode Whether or not we're in checkNoChanges mode.\n * @param {?} currentNodeIndex\n * @return {?}\n */\nfunction executePreOrderHooks(currentView, tView, checkNoChangesMode, currentNodeIndex) {\n if (!checkNoChangesMode) {\n executeHooks(currentView, tView.preOrderHooks, tView.preOrderCheckHooks, checkNoChangesMode, 0 /* OnInitHooksToBeRun */, currentNodeIndex !== undefined ? currentNodeIndex : null);\n }\n}\n/**\n * Executes hooks against the given `LView` based off of whether or not\n * This is the first pass.\n *\n * @param {?} currentView The view instance data to run the hooks against\n * @param {?} firstPassHooks An array of hooks to run if we're in the first view pass\n * @param {?} checkHooks An Array of hooks to run if we're not in the first view pass.\n * @param {?} checkNoChangesMode Whether or not we're in no changes mode.\n * @param {?} initPhaseState the current state of the init phase\n * @param {?} currentNodeIndex 3 cases depending the the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n * @return {?}\n */\nfunction executeHooks(currentView, firstPassHooks, checkHooks, checkNoChangesMode, initPhaseState, currentNodeIndex) {\n if (checkNoChangesMode)\n return;\n /** @type {?} */\n const hooksToCall = (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhaseState ?\n firstPassHooks :\n checkHooks;\n if (hooksToCall) {\n callHooks(currentView, hooksToCall, initPhaseState, currentNodeIndex);\n }\n // The init phase state must be always checked here as it may have been recursively updated\n if (currentNodeIndex == null &&\n (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhaseState &&\n initPhaseState !== 3 /* InitPhaseCompleted */) {\n currentView[FLAGS] &= 1023 /* IndexWithinInitPhaseReset */;\n currentView[FLAGS] += 1 /* InitPhaseStateIncrementer */;\n }\n}\n/**\n * Calls lifecycle hooks with their contexts, skipping init hooks if it's not\n * the first LView pass\n *\n * @param {?} currentView The current view\n * @param {?} arr The array in which the hooks are found\n * @param {?} initPhase\n * @param {?} currentNodeIndex 3 cases depending the the value:\n * - undefined: all hooks from the array should be executed (post-order case)\n * - null: execute hooks only from the saved index until the end of the array (pre-order case, when\n * flushing the remaining hooks)\n * - number: execute hooks only from the saved index until that node index exclusive (pre-order\n * case, when executing select(number))\n * @return {?}\n */\nfunction callHooks(currentView, arr, initPhase, currentNodeIndex) {\n /** @type {?} */\n const startIndex = currentNodeIndex !== undefined ?\n (currentView[PREORDER_HOOK_FLAGS] & 65535 /* IndexOfTheNextPreOrderHookMaskMask */) :\n 0;\n /** @type {?} */\n const nodeIndexLimit = currentNodeIndex != null ? currentNodeIndex : -1;\n /** @type {?} */\n let lastNodeIndexFound = 0;\n for (let i = startIndex; i < arr.length; i++) {\n /** @type {?} */\n const hook = (/** @type {?} */ (arr[i + 1]));\n if (typeof hook === 'number') {\n lastNodeIndexFound = (/** @type {?} */ (arr[i]));\n if (currentNodeIndex != null && lastNodeIndexFound >= currentNodeIndex) {\n break;\n }\n }\n else {\n /** @type {?} */\n const isInitHook = arr[i] < 0;\n if (isInitHook)\n currentView[PREORDER_HOOK_FLAGS] += 65536 /* NumberOfInitHooksCalledIncrementer */;\n if (lastNodeIndexFound < nodeIndexLimit || nodeIndexLimit == -1) {\n callHook(currentView, initPhase, arr, i);\n currentView[PREORDER_HOOK_FLAGS] =\n (currentView[PREORDER_HOOK_FLAGS] & 4294901760 /* NumberOfInitHooksCalledMask */) + i +\n 2;\n }\n i++;\n }\n }\n}\n/**\n * Execute one hook against the current `LView`.\n *\n * @param {?} currentView The current view\n * @param {?} initPhase\n * @param {?} arr The array in which the hooks are found\n * @param {?} i The current index within the hook data array\n * @return {?}\n */\nfunction callHook(currentView, initPhase, arr, i) {\n /** @type {?} */\n const isInitHook = arr[i] < 0;\n /** @type {?} */\n const hook = (/** @type {?} */ (arr[i + 1]));\n /** @type {?} */\n const directiveIndex = isInitHook ? -arr[i] : (/** @type {?} */ (arr[i]));\n /** @type {?} */\n const directive = currentView[directiveIndex];\n if (isInitHook) {\n /** @type {?} */\n const indexWithintInitPhase = currentView[FLAGS] >> 10 /* IndexWithinInitPhaseShift */;\n // The init phase state must be always checked here as it may have been recursively\n // updated\n if (indexWithintInitPhase <\n (currentView[PREORDER_HOOK_FLAGS] >> 16 /* NumberOfInitHooksCalledShift */) &&\n (currentView[FLAGS] & 3 /* InitPhaseStateMask */) === initPhase) {\n currentView[FLAGS] += 1024 /* IndexWithinInitPhaseIncrementer */;\n hook.call(directive);\n }\n }\n else {\n hook.call(directive);\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * --------\n *\n * // TODO(matsko): add updateMask info\n *\n * This file contains all state-based logic for styling in Angular.\n *\n * Styling in Angular is evaluated with a series of styling-specific\n * template instructions which are called one after another each time\n * change detection occurs in Angular.\n *\n * Styling makes use of various temporary, state-based variables between\n * instructions so that it can better cache and optimize its values.\n * These values are usually populated and cleared when an element is\n * exited in change detection (once all the instructions are run for\n * that element).\n *\n * There are, however, situations where the state-based values\n * need to be stored and used at a later point. This ONLY occurs when\n * there are template-level as well as host-binding-level styling\n * instructions on the same element. The example below shows exactly\n * what could be:\n *\n * ```html\n * \n * \n * ```\n *\n * If and when this situation occurs, the current styling state is\n * stored in a storage map value and then later accessed once the\n * host bindings are evaluated. Once styling for the current element\n * is over then the map entry will be cleared.\n *\n * To learn more about the algorithm see `TStylingContext`.\n *\n * --------\n */\n/** @type {?} */\nlet _stylingState = null;\n/** @type {?} */\nconst _stateStorage = new Map();\n// this value is not used outside this file and is only here\n// as a caching check for when the element changes.\n/** @type {?} */\nlet _stylingElement = null;\n/**\n * Used as a state reference for update values between style/class binding instructions.\n * @record\n */\nfunction StylingState() { }\nif (false) {\n /** @type {?} */\n StylingState.prototype.classesBitMask;\n /** @type {?} */\n StylingState.prototype.classesIndex;\n /** @type {?} */\n StylingState.prototype.stylesBitMask;\n /** @type {?} */\n StylingState.prototype.stylesIndex;\n}\n/** @type {?} */\nconst STYLING_INDEX_START_VALUE = 1;\n/** @type {?} */\nconst BIT_MASK_START_VALUE = 0;\n/**\n * @param {?} element\n * @param {?=} readFromMap\n * @return {?}\n */\nfunction getStylingState(element, readFromMap) {\n if (!_stylingElement || element !== _stylingElement) {\n _stylingElement = element;\n if (readFromMap) {\n _stylingState = _stateStorage.get(element) || null;\n ngDevMode && ngDevMode.stylingReadPersistedState++;\n }\n _stylingState = _stylingState || {\n classesBitMask: BIT_MASK_START_VALUE,\n classesIndex: STYLING_INDEX_START_VALUE,\n stylesBitMask: BIT_MASK_START_VALUE,\n stylesIndex: STYLING_INDEX_START_VALUE,\n };\n }\n return (/** @type {?} */ (_stylingState));\n}\n/**\n * @return {?}\n */\nfunction resetStylingState() {\n _stylingState = null;\n _stylingElement = null;\n}\n/**\n * @param {?} element\n * @param {?} state\n * @return {?}\n */\nfunction storeStylingState(element, state) {\n ngDevMode && ngDevMode.stylingWritePersistedState++;\n _stateStorage.set(element, state);\n}\n/**\n * @param {?} element\n * @return {?}\n */\nfunction deleteStylingStateFromStorage(element) {\n _stateStorage.delete(element);\n}\n/**\n * @return {?}\n */\nfunction resetAllStylingState() {\n resetStylingState();\n _stateStorage.clear();\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * This property will be monkey-patched on elements, components and directives\n * @type {?}\n */\nconst MONKEY_PATCH_KEY_NAME = '__ngContext__';\n/**\n * The internal view context which is specific to a given DOM element, directive or\n * component instance. Each value in here (besides the LView and element node details)\n * can be present, null or undefined. If undefined then it implies the value has not been\n * looked up yet, otherwise, if null, then a lookup was executed and nothing was found.\n *\n * Each value will get filled when the respective value is examined within the getContext\n * function. The component, element and each directive instance will share the same instance\n * of the context.\n * @record\n */\nfunction LContext() { }\nif (false) {\n /**\n * The component's parent view data.\n * @type {?}\n */\n LContext.prototype.lView;\n /**\n * The index instance of the node.\n * @type {?}\n */\n LContext.prototype.nodeIndex;\n /**\n * The instance of the DOM node that is attached to the lNode.\n * @type {?}\n */\n LContext.prototype.native;\n /**\n * The instance of the Component node.\n * @type {?}\n */\n LContext.prototype.component;\n /**\n * The list of active directives that exist on this element.\n * @type {?}\n */\n LContext.prototype.directives;\n /**\n * The map of local references (local reference name => element or directive instance) that exist\n * on this element.\n * @type {?}\n */\n LContext.prototype.localRefs;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * For efficiency reasons we often put several different data types (`RNode`, `LView`, `LContainer`)\n * in same location in `LView`. This is because we don't want to pre-allocate space for it\n * because the storage is sparse. This file contains utilities for dealing with such data types.\n *\n * How do we know what is stored at a given location in `LView`.\n * - `Array.isArray(value) === false` => `RNode` (The normal storage value)\n * - `Array.isArray(value) === true` => then the `value[0]` represents the wrapped value.\n * - `typeof value[TYPE] === 'object'` => `LView`\n * - This happens when we have a component at a given location\n * - `typeof value[TYPE] === true` => `LContainer`\n * - This happens when we have `LContainer` binding at a given location.\n *\n *\n * NOTE: it is assumed that `Array.isArray` and `typeof` operations are very efficient.\n */\n/**\n * Returns `RNode`.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`\n * @return {?}\n */\nfunction unwrapRNode(value) {\n while (Array.isArray(value)) {\n value = (/** @type {?} */ (value[HOST]));\n }\n return (/** @type {?} */ (value));\n}\n/**\n * Returns `LView` or `null` if not found.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`\n * @return {?}\n */\nfunction unwrapLView(value) {\n while (Array.isArray(value)) {\n // This check is same as `isLView()` but we don't call at as we don't want to call\n // `Array.isArray()` twice and give JITer more work for inlining.\n if (typeof value[TYPE] === 'object')\n return (/** @type {?} */ (value));\n value = (/** @type {?} */ (value[HOST]));\n }\n return null;\n}\n/**\n * Returns `LContainer` or `null` if not found.\n * @param {?} value wrapped value of `RNode`, `LView`, `LContainer`\n * @return {?}\n */\nfunction unwrapLContainer(value) {\n while (Array.isArray(value)) {\n // This check is same as `isLContainer()` but we don't call at as we don't want to call\n // `Array.isArray()` twice and give JITer more work for inlining.\n if (value[TYPE] === true)\n return (/** @type {?} */ (value));\n value = (/** @type {?} */ (value[HOST]));\n }\n return null;\n}\n/**\n * Retrieves an element value from the provided `viewData`, by unwrapping\n * from any containers, component views, or style contexts.\n * @param {?} index\n * @param {?} lView\n * @return {?}\n */\nfunction getNativeByIndex(index, lView) {\n return unwrapRNode(lView[index + HEADER_OFFSET]);\n}\n/**\n * Retrieve an `RNode` for a given `TNode` and `LView`.\n *\n * This function guarantees in dev mode to retrieve a non-null `RNode`.\n *\n * @param {?} tNode\n * @param {?} lView\n * @return {?}\n */\nfunction getNativeByTNode(tNode, lView) {\n ngDevMode && assertTNodeForLView(tNode, lView);\n ngDevMode && assertDataInRange(lView, tNode.index);\n /** @type {?} */\n const node = unwrapRNode(lView[tNode.index]);\n ngDevMode && assertDomNode(node);\n return node;\n}\n/**\n * Retrieve an `RNode` or `null` for a given `TNode` and `LView`.\n *\n * Some `TNode`s don't have associated `RNode`s. For example `Projection`\n *\n * @param {?} tNode\n * @param {?} lView\n * @return {?}\n */\nfunction getNativeByTNodeOrNull(tNode, lView) {\n ngDevMode && assertTNodeForLView(tNode, lView);\n /** @type {?} */\n const index = tNode.index;\n /** @type {?} */\n const node = index == -1 ? null : unwrapRNode(lView[index]);\n ngDevMode && node !== null && assertDomNode(node);\n return node;\n}\n/**\n * A helper function that returns `true` if a given `TNode` has any matching directives.\n * @param {?} tNode\n * @return {?}\n */\nfunction hasDirectives(tNode) {\n return tNode.directiveEnd > tNode.directiveStart;\n}\n/**\n * @param {?} index\n * @param {?} view\n * @return {?}\n */\nfunction getTNode(index, view) {\n ngDevMode && assertGreaterThan(index, -1, 'wrong index for TNode');\n ngDevMode && assertLessThan(index, view[TVIEW].data.length, 'wrong index for TNode');\n return (/** @type {?} */ (view[TVIEW].data[index + HEADER_OFFSET]));\n}\n/**\n * Retrieves a value from any `LView` or `TData`.\n * @template T\n * @param {?} view\n * @param {?} index\n * @return {?}\n */\nfunction loadInternal(view, index) {\n ngDevMode && assertDataInRange(view, index + HEADER_OFFSET);\n return view[index + HEADER_OFFSET];\n}\n/**\n * @param {?} nodeIndex\n * @param {?} hostView\n * @return {?}\n */\nfunction getComponentViewByIndex(nodeIndex, hostView) {\n // Could be an LView or an LContainer. If LContainer, unwrap to find LView.\n /** @type {?} */\n const slotValue = hostView[nodeIndex];\n /** @type {?} */\n const lView = isLView(slotValue) ? slotValue : slotValue[HOST];\n return lView;\n}\n/**\n * Returns the monkey-patch value data present on the target (which could be\n * a component, directive or a DOM node).\n * @param {?} target\n * @return {?}\n */\nfunction readPatchedData(target) {\n ngDevMode && assertDefined(target, 'Target expected');\n return target[MONKEY_PATCH_KEY_NAME];\n}\n/**\n * @param {?} target\n * @return {?}\n */\nfunction readPatchedLView(target) {\n /** @type {?} */\n const value = readPatchedData(target);\n if (value) {\n return Array.isArray(value) ? value : ((/** @type {?} */ (value))).lView;\n }\n return null;\n}\n/**\n * Returns a boolean for whether the view is attached to the change detection tree.\n *\n * Note: This determines whether a view should be checked, not whether it's inserted\n * into a container. For that, you'll want `viewAttachedToContainer` below.\n * @param {?} view\n * @return {?}\n */\nfunction viewAttachedToChangeDetector(view) {\n return (view[FLAGS] & 128 /* Attached */) === 128 /* Attached */;\n}\n/**\n * Returns a boolean for whether the view is attached to a container.\n * @param {?} view\n * @return {?}\n */\nfunction viewAttachedToContainer(view) {\n return isLContainer(view[PARENT]);\n}\n/**\n * Resets the pre-order hook flags of the view.\n * @param {?} lView the LView on which the flags are reset\n * @return {?}\n */\nfunction resetPreOrderHookFlags(lView) {\n lView[PREORDER_HOOK_FLAGS] = 0;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Store the element depth count. This is used to identify the root elements of the template\n * so that we can than attach `LView` to only those elements.\n * @type {?}\n */\nlet elementDepthCount;\n/**\n * @return {?}\n */\nfunction getElementDepthCount() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return elementDepthCount;\n}\n/**\n * @return {?}\n */\nfunction increaseElementDepthCount() {\n elementDepthCount++;\n}\n/**\n * @return {?}\n */\nfunction decreaseElementDepthCount() {\n elementDepthCount--;\n}\n/** @type {?} */\nlet currentDirectiveDef = null;\n/**\n * @return {?}\n */\nfunction getCurrentDirectiveDef() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return currentDirectiveDef;\n}\n/**\n * @param {?} def\n * @return {?}\n */\nfunction setCurrentDirectiveDef(def) {\n currentDirectiveDef = def;\n}\n/**\n * Stores whether directives should be matched to elements.\n *\n * When template contains `ngNonBindable` than we need to prevent the runtime form matching\n * directives on children of that element.\n *\n * Example:\n * ```\n * \n * Should match component / directive.\n * \n *
\n * \n * Should not match component / directive because we are in ngNonBindable.\n * \n *
\n * ```\n * @type {?}\n */\nlet bindingsEnabled;\n/**\n * @return {?}\n */\nfunction getBindingsEnabled() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return bindingsEnabled;\n}\n/**\n * Enables directive matching on elements.\n *\n * * Example:\n * ```\n * \n * Should match component / directive.\n * \n *
\n * \n * \n * Should not match component / directive because we are in ngNonBindable.\n * \n * \n *
\n * \n * \n * Should not match component / directive because we are in ngNonBindable.\n * \n * \n *
\n * ```\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵdisableBindings() {\n bindingsEnabled = false;\n}\n/**\n * @return {?}\n */\nfunction getLView() {\n return lView;\n}\n/**\n * Used as the starting directive id value.\n *\n * All subsequent directives are incremented from this value onwards.\n * The reason why this value is `1` instead of `0` is because the `0`\n * value is reserved for the template.\n * @type {?}\n */\nconst MIN_DIRECTIVE_ID = 1;\n/** @type {?} */\nlet activeDirectiveId = MIN_DIRECTIVE_ID;\n/**\n * Position depth (with respect from leaf to root) in a directive sub-class inheritance chain.\n * @type {?}\n */\nlet activeDirectiveSuperClassDepthPosition = 0;\n/**\n * Total count of how many directives are a part of an inheritance chain.\n *\n * When directives are sub-classed (extended) from one to another, Angular\n * needs to keep track of exactly how many were encountered so it can accurately\n * generate the next directive id (once the next directive id is visited).\n * Normally the next directive id just a single incremented value from the\n * previous one, however, if the previous directive is a part of an inheritance\n * chain (a series of sub-classed directives) then the incremented value must\n * also take into account the total amount of sub-classed values.\n *\n * Note that this value resets back to zero once the next directive is\n * visited (when `incrementActiveDirectiveId` or `setActiveHostElement`\n * is called).\n * @type {?}\n */\nlet activeDirectiveSuperClassHeight = 0;\n/**\n * Sets the active directive host element and resets the directive id value\n * (when the provided elementIndex value has changed).\n *\n * @param {?=} elementIndex the element index value for the host element where\n * the directive/component instance lives\n * @return {?}\n */\nfunction setActiveHostElement(elementIndex = null) {\n if (_selectedIndex !== elementIndex) {\n setSelectedIndex(elementIndex == null ? -1 : elementIndex);\n activeDirectiveId = elementIndex == null ? 0 : MIN_DIRECTIVE_ID;\n activeDirectiveSuperClassDepthPosition = 0;\n activeDirectiveSuperClassHeight = 0;\n }\n}\n/**\n * Returns the current id value of the current directive.\n *\n * For example we have an element that has two directives on it:\n * \n *\n * dirOne->hostBindings() (id == 1)\n * dirTwo->hostBindings() (id == 2)\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n *\n * Note that directive id values are specific to an element (this means that\n * the same id value could be present on another element with a completely\n * different set of directives).\n * @return {?}\n */\nfunction getActiveDirectiveId() {\n return activeDirectiveId;\n}\n/**\n * Increments the current directive id value.\n *\n * For example we have an element that has two directives on it:\n * \n *\n * dirOne->hostBindings() (index = 1)\n * // increment\n * dirTwo->hostBindings() (index = 2)\n *\n * Depending on whether or not a previous directive had any inherited\n * directives present, that value will be incremented in addition\n * to the id jumping up by one.\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n *\n * Note that directive id values are specific to an element (this means that\n * the same id value could be present on another element with a completely\n * different set of directives).\n * @return {?}\n */\nfunction incrementActiveDirectiveId() {\n activeDirectiveId += 1 + activeDirectiveSuperClassHeight;\n // because we are dealing with a new directive this\n // means we have exited out of the inheritance chain\n activeDirectiveSuperClassDepthPosition = 0;\n activeDirectiveSuperClassHeight = 0;\n}\n/**\n * Set the current super class (reverse inheritance) position depth for a directive.\n *\n * For example we have two directives: Child and Other (but Child is a sub-class of Parent)\n * \n *\n * // increment\n * parentInstance->hostBindings() (depth = 1)\n * // decrement\n * childInstance->hostBindings() (depth = 0)\n * otherInstance->hostBindings() (depth = 0 b/c it's a different directive)\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n * @param {?} delta\n * @return {?}\n */\nfunction adjustActiveDirectiveSuperClassDepthPosition(delta) {\n activeDirectiveSuperClassDepthPosition += delta;\n // we keep track of the height value so that when the next directive is visited\n // then Angular knows to generate a new directive id value which has taken into\n // account how many sub-class directives were a part of the previous directive.\n activeDirectiveSuperClassHeight =\n Math.max(activeDirectiveSuperClassHeight, activeDirectiveSuperClassDepthPosition);\n}\n/**\n * Returns he current depth of the super/sub class inheritance chain.\n *\n * This will return how many inherited directive/component classes\n * exist in the current chain.\n *\n * ```typescript\n * \\@Directive({ selector: '[super-dir]' })\n * class SuperDir {}\n * / selector: '[sub-dir]' })\n * class SubDir extends SuperDir {}\n *\n * // if `
` is used then the super class height is `1`\n * // if `
` is used then the super class height is `0`\n * ```\n * @return {?}\n */\nfunction getActiveDirectiveSuperClassHeight() {\n return activeDirectiveSuperClassHeight;\n}\n/**\n * Returns the current super class (reverse inheritance) depth for a directive.\n *\n * This is designed to help instruction code distinguish different hostBindings\n * calls from each other when a directive has extended from another directive.\n * Normally using the directive id value is enough, but with the case\n * of parent/sub-class directive inheritance more information is required.\n *\n * Note that this is only active when `hostBinding` functions are being processed.\n * @return {?}\n */\nfunction getActiveDirectiveSuperClassDepth() {\n return activeDirectiveSuperClassDepthPosition;\n}\n/**\n * Restores `contextViewData` to the given OpaqueViewState instance.\n *\n * Used in conjunction with the getCurrentView() instruction to save a snapshot\n * of the current view and restore it when listeners are invoked. This allows\n * walking the declaration view tree in listeners to get vars from parent views.\n *\n * \\@codeGenApi\n * @param {?} viewToRestore The OpaqueViewState instance to restore.\n *\n * @return {?}\n */\nfunction ɵɵrestoreView(viewToRestore) {\n contextLView = (/** @type {?} */ ((/** @type {?} */ (viewToRestore))));\n}\n/**\n * Used to set the parent property when nodes are created and track query results.\n * @type {?}\n */\nlet previousOrParentTNode;\n/**\n * @return {?}\n */\nfunction getPreviousOrParentTNode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return previousOrParentTNode;\n}\n/**\n * @param {?} tNode\n * @param {?} _isParent\n * @return {?}\n */\nfunction setPreviousOrParentTNode(tNode, _isParent) {\n previousOrParentTNode = tNode;\n isParent = _isParent;\n}\n/**\n * @param {?} tNode\n * @param {?} view\n * @return {?}\n */\nfunction setTNodeAndViewData(tNode, view) {\n ngDevMode && assertLViewOrUndefined(view);\n previousOrParentTNode = tNode;\n lView = view;\n}\n/**\n * If `isParent` is:\n * - `true`: then `previousOrParentTNode` points to a parent node.\n * - `false`: then `previousOrParentTNode` points to previous node (sibling).\n * @type {?}\n */\nlet isParent;\n/**\n * @return {?}\n */\nfunction getIsParent() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return isParent;\n}\n/**\n * @return {?}\n */\nfunction setIsNotParent() {\n isParent = false;\n}\n/**\n * @return {?}\n */\nfunction setIsParent() {\n isParent = true;\n}\n/**\n * Checks whether a given view is in creation mode\n * @param {?=} view\n * @return {?}\n */\nfunction isCreationMode(view = lView) {\n return (view[FLAGS] & 4 /* CreationMode */) === 4 /* CreationMode */;\n}\n/**\n * State of the current view being processed.\n *\n * An array of nodes (text, element, container, etc), pipes, their bindings, and\n * any local variables that need to be stored between invocations.\n * @type {?}\n */\nlet lView;\n/**\n * The last viewData retrieved by nextContext().\n * Allows building nextContext() and reference() calls.\n *\n * e.g. const inner = x().$implicit; const outer = x().$implicit;\n * @type {?}\n */\nlet contextLView = (/** @type {?} */ (null));\n/**\n * @return {?}\n */\nfunction getContextLView() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return contextLView;\n}\n/**\n * In this mode, any changes in bindings will throw an ExpressionChangedAfterChecked error.\n *\n * Necessary to support ChangeDetectorRef.checkNoChanges().\n * @type {?}\n */\nlet checkNoChangesMode = false;\n/**\n * @return {?}\n */\nfunction getCheckNoChangesMode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return checkNoChangesMode;\n}\n/**\n * @param {?} mode\n * @return {?}\n */\nfunction setCheckNoChangesMode(mode) {\n checkNoChangesMode = mode;\n}\n/**\n * The root index from which pure function instructions should calculate their binding\n * indices. In component views, this is TView.bindingStartIndex. In a host binding\n * context, this is the TView.expandoStartIndex + any dirs/hostVars before the given dir.\n * @type {?}\n */\nlet bindingRootIndex = -1;\n// top level variables should not be exported for performance reasons (PERF_NOTES.md)\n/**\n * @return {?}\n */\nfunction getBindingRoot() {\n return bindingRootIndex;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction setBindingRoot(value) {\n bindingRootIndex = value;\n}\n/**\n * Current index of a View or Content Query which needs to be processed next.\n * We iterate over the list of Queries and increment current query index at every step.\n * @type {?}\n */\nlet currentQueryIndex = 0;\n/**\n * @return {?}\n */\nfunction getCurrentQueryIndex() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return currentQueryIndex;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction setCurrentQueryIndex(value) {\n currentQueryIndex = value;\n}\n/**\n * Swap the current state with a new state.\n *\n * For performance reasons we store the state in the top level of the module.\n * This way we minimize the number of properties to read. Whenever a new view\n * is entered we have to store the state for later, and when the view is\n * exited the state has to be restored\n *\n * @param {?} newView New state to become active\n * @param {?} hostTNode\n * @return {?} the previous state;\n */\nfunction enterView(newView, hostTNode) {\n ngDevMode && assertLViewOrUndefined(newView);\n /** @type {?} */\n const oldView = lView;\n if (newView) {\n /** @type {?} */\n const tView = newView[TVIEW];\n bindingRootIndex = tView.bindingStartIndex;\n }\n previousOrParentTNode = (/** @type {?} */ (hostTNode));\n isParent = true;\n lView = contextLView = newView;\n return oldView;\n}\n/**\n * @template T\n * @param {?=} level\n * @return {?}\n */\nfunction nextContextImpl(level = 1) {\n contextLView = walkUpViews(level, (/** @type {?} */ (contextLView)));\n return (/** @type {?} */ (contextLView[CONTEXT]));\n}\n/**\n * @param {?} nestingLevel\n * @param {?} currentView\n * @return {?}\n */\nfunction walkUpViews(nestingLevel, currentView) {\n while (nestingLevel > 0) {\n ngDevMode && assertDefined(currentView[DECLARATION_VIEW], 'Declaration view should be defined if nesting level is greater than 0.');\n currentView = (/** @type {?} */ (currentView[DECLARATION_VIEW]));\n nestingLevel--;\n }\n return currentView;\n}\n/**\n * Resets the application state.\n * @return {?}\n */\nfunction resetComponentState() {\n isParent = false;\n previousOrParentTNode = (/** @type {?} */ (null));\n elementDepthCount = 0;\n bindingsEnabled = true;\n setCurrentStyleSanitizer(null);\n resetAllStylingState();\n}\n/**\n * Used in lieu of enterView to make it clear when we are exiting a child view. This makes\n * the direction of traversal (up or down the view tree) a bit clearer.\n *\n * @param {?} newView New state to become active\n * @param {?} safeToRunHooks Whether the runtime is in a state where running lifecycle hooks is valid.\n * This is not always the case (for example, the application may have crashed and `leaveView` is\n * being executed while unwinding the call stack).\n * @return {?}\n */\nfunction leaveView(newView, safeToRunHooks) {\n /** @type {?} */\n const tView = lView[TVIEW];\n if (isCreationMode(lView)) {\n lView[FLAGS] &= ~4 /* CreationMode */;\n }\n else {\n try {\n resetPreOrderHookFlags(lView);\n safeToRunHooks && executeHooks(lView, tView.viewHooks, tView.viewCheckHooks, checkNoChangesMode, 2 /* AfterViewInitHooksToBeRun */, undefined);\n }\n finally {\n // Views are clean and in update mode after being checked, so these bits are cleared\n lView[FLAGS] &= ~(64 /* Dirty */ | 8 /* FirstLViewPass */);\n lView[BINDING_INDEX] = tView.bindingStartIndex;\n }\n }\n enterView(newView, null);\n}\n/** @type {?} */\nlet _selectedIndex = -1;\n/**\n * Gets the most recent index passed to {\\@link select}\n *\n * Used with {\\@link property} instruction (and more in the future) to identify the index in the\n * current `LView` to act on.\n * @return {?}\n */\nfunction getSelectedIndex() {\n return _selectedIndex;\n}\n/**\n * Sets the most recent index passed to {\\@link select}\n *\n * Used with {\\@link property} instruction (and more in the future) to identify the index in the\n * current `LView` to act on.\n * @param {?} index\n * @return {?}\n */\nfunction setSelectedIndex(index) {\n _selectedIndex = index;\n // we have now jumped to another element\n // therefore the state is stale\n resetStylingState();\n}\n/** @type {?} */\nlet _currentNamespace = null;\n/**\n * Sets the namespace used to create elements to `'http://www.w3.org/2000/svg'` in global state.\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵnamespaceSVG() {\n _currentNamespace = 'http://www.w3.org/2000/svg';\n}\n/**\n * Sets the namespace used to create elements to `'http://www.w3.org/1998/MathML/'` in global state.\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵnamespaceMathML() {\n _currentNamespace = 'http://www.w3.org/1998/MathML/';\n}\n/**\n * Sets the namespace used to create elements to `null`, which forces element creation to use\n * `createElement` rather than `createElementNS`.\n *\n * \\@codeGenApi\n * @return {?}\n */\nfunction ɵɵnamespaceHTML() {\n namespaceHTMLInternal();\n}\n/**\n * Sets the namespace used to create elements to `null`, which forces element creation to use\n * `createElement` rather than `createElementNS`.\n * @return {?}\n */\nfunction namespaceHTMLInternal() {\n _currentNamespace = null;\n}\n/**\n * @return {?}\n */\nfunction getNamespace() {\n return _currentNamespace;\n}\n/** @type {?} */\nlet _currentSanitizer;\n/**\n * @param {?} sanitizer\n * @return {?}\n */\nfunction setCurrentStyleSanitizer(sanitizer) {\n _currentSanitizer = sanitizer;\n}\n/**\n * @return {?}\n */\nfunction getCurrentStyleSanitizer() {\n return _currentSanitizer;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Returns whether the values are different from a change detection stand point.\n *\n * Constraints are relaxed in checkNoChanges mode. See `devModeEqual` for details.\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction isDifferent(a, b) {\n // NaN is the only value that is not equal to itself so the first\n // test checks if both a and b are not NaN\n return !(a !== a && b !== b) && a !== b;\n}\n/**\n * Used for stringify render output in Ivy.\n * Important! This function is very performance-sensitive and we should\n * be extra careful not to introduce megamorphic reads in it.\n * @param {?} value\n * @return {?}\n */\nfunction renderStringify(value) {\n if (typeof value === 'string')\n return value;\n if (value == null)\n return '';\n return '' + value;\n}\n/**\n * Used to stringify a value so that it can be displayed in an error message.\n * Important! This function contains a megamorphic read and should only be\n * used for error messages.\n * @param {?} value\n * @return {?}\n */\nfunction stringifyForError(value) {\n if (typeof value === 'function')\n return value.name || value.toString();\n if (typeof value === 'object' && value != null && typeof value.type === 'function') {\n return value.type.name || value.type.toString();\n }\n return renderStringify(value);\n}\nconst ɵ0$2 = /**\n * @return {?}\n */\n() => (typeof requestAnimationFrame !== 'undefined' && requestAnimationFrame || // browser only\n setTimeout // everything else\n).bind(_global);\n/** @type {?} */\nconst defaultScheduler = ((ɵ0$2))();\n/**\n *\n * \\@codeGenApi\n * @param {?} element\n * @return {?}\n */\nfunction ɵɵresolveWindow(element) {\n return { name: 'window', target: element.ownerDocument.defaultView };\n}\n/**\n *\n * \\@codeGenApi\n * @param {?} element\n * @return {?}\n */\nfunction ɵɵresolveDocument(element) {\n return { name: 'document', target: element.ownerDocument };\n}\n/**\n *\n * \\@codeGenApi\n * @param {?} element\n * @return {?}\n */\nfunction ɵɵresolveBody(element) {\n return { name: 'body', target: element.ownerDocument.body };\n}\n/**\n * The special delimiter we use to separate property names, prefixes, and suffixes\n * in property binding metadata. See storeBindingMetadata().\n *\n * We intentionally use the Unicode \"REPLACEMENT CHARACTER\" (U+FFFD) as a delimiter\n * because it is a very uncommon character that is unlikely to be part of a user's\n * property names or interpolation strings. If it is in fact used in a property\n * binding, DebugElement.properties will not return the correct value for that\n * binding. However, there should be no runtime effect for real applications.\n *\n * This character is typically rendered as a question mark inside of a diamond.\n * See https://en.wikipedia.org/wiki/Specials_(Unicode_block)\n *\n * @type {?}\n */\nconst INTERPOLATION_DELIMITER = `�`;\n/**\n * Determines whether or not the given string is a property metadata string.\n * See storeBindingMetadata().\n * @param {?} str\n * @return {?}\n */\nfunction isPropMetadataString(str) {\n return str.indexOf(INTERPOLATION_DELIMITER) >= 0;\n}\n/**\n * Unwrap a value which might be behind a closure (for forward declaration reasons).\n * @template T\n * @param {?} value\n * @return {?}\n */\nfunction maybeUnwrapFn(value) {\n if (value instanceof Function) {\n return value();\n }\n else {\n return value;\n }\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/** @type {?} */\nconst MAP_BASED_ENTRY_PROP_NAME = '--MAP--';\n/** @type {?} */\nconst TEMPLATE_DIRECTIVE_INDEX = 0;\n/**\n * Creates a new instance of the `TStylingContext`.\n *\n * The `TStylingContext` is used as a manifest of all style or all class bindings on\n * an element. Because it is a T-level data-structure, it is only created once per\n * tNode for styles and for classes. This function allocates a new instance of a\n * `TStylingContext` with the initial values (see `interfaces.ts` for more info).\n * @param {?=} initialStyling\n * @return {?}\n */\nfunction allocTStylingContext(initialStyling) {\n // because map-based bindings deal with a dynamic set of values, there\n // is no way to know ahead of time whether or not sanitization is required.\n // For this reason the configuration will always mark sanitization as active\n // (this means that when map-based values are applied then sanitization will\n // be checked against each property).\n /** @type {?} */\n const mapBasedConfig = 1 /* SanitizationRequired */;\n return [\n initialStyling || [''],\n 0 /* Initial */,\n TEMPLATE_DIRECTIVE_INDEX,\n mapBasedConfig,\n 0,\n MAP_BASED_ENTRY_PROP_NAME,\n ];\n}\n/**\n * Sets the provided directive as the last directive index in the provided `TStylingContext`.\n *\n * Styling in Angular can be applied from the template as well as multiple sources of\n * host bindings. This means that each binding function (the template function or the\n * hostBindings functions) will generate styling instructions as well as a styling\n * apply function (i.e. `stylingApply()`). Because host bindings functions and the\n * template function are independent from one another this means that the styling apply\n * function will be called multiple times. By tracking the last directive index (which\n * is what happens in this function) the styling algorithm knows exactly when to flush\n * styling (which is when the last styling apply function is executed).\n * @param {?} context\n * @param {?} lastDirectiveIndex\n * @return {?}\n */\nfunction updateLastDirectiveIndex(context, lastDirectiveIndex) {\n if (lastDirectiveIndex === TEMPLATE_DIRECTIVE_INDEX) {\n /** @type {?} */\n const currentValue = context[2 /* LastDirectiveIndexPosition */];\n if (currentValue > TEMPLATE_DIRECTIVE_INDEX) {\n // This means that a directive or two contained a host bindings function, but\n // now the template function also contains styling. When this combination of sources\n // comes up then we need to tell the context to store the state between updates\n // (because host bindings evaluation happens after template binding evaluation).\n markContextToPersistState(context);\n }\n }\n else {\n context[2 /* LastDirectiveIndexPosition */] = lastDirectiveIndex;\n }\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction getConfig(context) {\n return context[1 /* ConfigPosition */];\n}\n/**\n * @param {?} context\n * @param {?} value\n * @return {?}\n */\nfunction setConfig(context, value) {\n context[1 /* ConfigPosition */] = value;\n}\n/**\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction getProp(context, index) {\n return (/** @type {?} */ (context[index + 2 /* PropOffset */]));\n}\n/**\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction getPropConfig(context, index) {\n return ((/** @type {?} */ (context[index + 0 /* ConfigAndGuardOffset */]))) &\n 1 /* Mask */;\n}\n/**\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction isSanitizationRequired(context, index) {\n return (getPropConfig(context, index) & 1 /* SanitizationRequired */) > 0;\n}\n/**\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction getGuardMask(context, index) {\n /** @type {?} */\n const configGuardValue = (/** @type {?} */ (context[index + 0 /* ConfigAndGuardOffset */]));\n return configGuardValue >> 1 /* TotalBits */;\n}\n/**\n * @param {?} context\n * @param {?} index\n * @param {?} maskValue\n * @return {?}\n */\nfunction setGuardMask(context, index, maskValue) {\n /** @type {?} */\n const config = getPropConfig(context, index);\n /** @type {?} */\n const guardMask = maskValue << 1 /* TotalBits */;\n context[index + 0 /* ConfigAndGuardOffset */] = config | guardMask;\n}\n/**\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction getValuesCount(context, index) {\n return (/** @type {?} */ (context[index + 1 /* ValuesCountOffset */]));\n}\n/**\n * @param {?} context\n * @param {?} index\n * @param {?} offset\n * @return {?}\n */\nfunction getBindingValue(context, index, offset) {\n return (/** @type {?} */ (context[index + 3 /* BindingsStartOffset */ + offset]));\n}\n/**\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction getDefaultValue(context, index) {\n /** @type {?} */\n const valuesCount = getValuesCount(context, index);\n return (/** @type {?} */ (context[index + 3 /* BindingsStartOffset */ + valuesCount - 1]));\n}\n/**\n * Temporary function which determines whether or not a context is\n * allowed to be flushed based on the provided directive index.\n * @param {?} context\n * @param {?} index\n * @return {?}\n */\nfunction allowStylingFlush(context, index) {\n return (context && index === context[2 /* LastDirectiveIndexPosition */]) ? true :\n false;\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction lockContext(context) {\n setConfig(context, getConfig(context) | 1 /* Locked */);\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction isContextLocked(context) {\n return (getConfig(context) & 1 /* Locked */) > 0;\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction stateIsPersisted(context) {\n return (getConfig(context) & 2 /* PersistStateValues */) > 0;\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction markContextToPersistState(context) {\n setConfig(context, getConfig(context) | 2 /* PersistStateValues */);\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction getPropValuesStartPosition(context) {\n return 6 /* MapBindingsBindingsStartPosition */ +\n context[4 /* MapBindingsValuesCountPosition */];\n}\n/**\n * @param {?} prop\n * @return {?}\n */\nfunction isMapBased(prop) {\n return prop === MAP_BASED_ENTRY_PROP_NAME;\n}\n/**\n * @param {?} a\n * @param {?} b\n * @return {?}\n */\nfunction hasValueChanged(a, b) {\n /** @type {?} */\n let compareValueA = Array.isArray(a) ? a[0 /* RawValuePosition */] : a;\n /** @type {?} */\n let compareValueB = Array.isArray(b) ? b[0 /* RawValuePosition */] : b;\n // these are special cases for String based values (which are created as artifacts\n // when sanitization is bypassed on a particular value)\n if (compareValueA instanceof String) {\n compareValueA = compareValueA.toString();\n }\n if (compareValueB instanceof String) {\n compareValueB = compareValueB.toString();\n }\n return isDifferent(compareValueA, compareValueB);\n}\n/**\n * Determines whether the provided styling value is truthy or falsy.\n * @param {?} value\n * @return {?}\n */\nfunction isStylingValueDefined(value) {\n // the reason why null is compared against is because\n // a CSS class value that is set to `false` must be\n // respected (otherwise it would be treated as falsy).\n // Empty string values are because developers usually\n // set a value to an empty string to remove it.\n return value != null && value !== '';\n}\n/**\n * @param {?} a\n * @param {?} b\n * @param {?=} separator\n * @return {?}\n */\nfunction concatString(a, b, separator = ' ') {\n return a + ((b.length && a.length) ? separator : '') + b;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction hyphenate(value) {\n return value.replace(/[a-z][A-Z]/g, (/**\n * @param {?} v\n * @return {?}\n */\n v => v.charAt(0) + '-' + v.charAt(1))).toLowerCase();\n}\n/**\n * Returns an instance of `StylingMapArray`.\n *\n * This function is designed to find an instance of `StylingMapArray` in case it is stored\n * inside of an instance of `TStylingContext`. When a styling context is created it\n * will copy over an initial styling values from the tNode (which are stored as a\n * `StylingMapArray` on the `tNode.classes` or `tNode.styles` values).\n * @param {?} value\n * @return {?}\n */\nfunction getStylingMapArray(value) {\n return isStylingContext(value) ?\n ((/** @type {?} */ (value)))[0 /* InitialStylingValuePosition */] :\n value;\n}\n/**\n * @param {?} value\n * @return {?}\n */\nfunction isStylingContext(value) {\n // the StylingMapArray is in the format of [initial, prop, string, prop, string]\n // and this is the defining value to distinguish between arrays\n return Array.isArray(value) &&\n value.length >= 6 /* MapBindingsBindingsStartPosition */ &&\n typeof value[1] !== 'string';\n}\n/**\n * @param {?} context\n * @return {?}\n */\nfunction getInitialStylingValue(context) {\n /** @type {?} */\n const map = getStylingMapArray(context);\n return map && ((/** @type {?} */ (map[0 /* RawValuePosition */]))) || '';\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction hasClassInput(tNode) {\n return (tNode.flags & 8 /* hasClassInput */) !== 0;\n}\n/**\n * @param {?} tNode\n * @return {?}\n */\nfunction hasStyleInput(tNode) {\n return (tNode.flags & 16 /* hasStyleInput */) !== 0;\n}\n/**\n * @param {?} map\n * @param {?} index\n * @return {?}\n */\nfunction getMapProp(map, index) {\n return (/** @type {?} */ (map[index + 0 /* PropOffset */]));\n}\n/**\n * @param {?} map\n * @param {?} index\n * @param {?} value\n * @return {?}\n */\nfunction setMapValue(map, index, value) {\n map[index + 1 /* ValueOffset */] = value;\n}\n/**\n * @param {?} map\n * @param {?} index\n * @return {?}\n */\nfunction getMapValue(map, index) {\n return (/** @type {?} */ (map[index + 1 /* ValueOffset */]));\n}\n/**\n * @param {?} classes\n * @return {?}\n */\nfunction forceClassesAsString(classes) {\n if (classes && typeof classes !== 'string') {\n classes = Object.keys(classes).join(' ');\n }\n return ((/** @type {?} */ (classes))) || '';\n}\n/**\n * @param {?} styles\n * @return {?}\n */\nfunction forceStylesAsString(styles) {\n /** @type {?} */\n let str = '';\n if (styles) {\n /** @type {?} */\n const props = Object.keys(styles);\n for (let i = 0; i < props.length; i++) {\n /** @type {?} */\n const prop = props[i];\n str = concatString(str, `${prop}:${styles[prop]}`, ';');\n }\n }\n return str;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 goal here is to make sure that the browser DOM API is the Renderer.\n * We do this by defining a subset of DOM API to be the renderer and than\n * use that time for rendering.\n *\n * At runtime we can then use the DOM api directly, in server or web-worker\n * it will be easy to implement such API.\n */\n/** @enum {number} */\nconst RendererStyleFlags3 = {\n Important: 1,\n DashCase: 2,\n};\nRendererStyleFlags3[RendererStyleFlags3.Important] = 'Important';\nRendererStyleFlags3[RendererStyleFlags3.DashCase] = 'DashCase';\n/**\n * Object Oriented style of API needed to create elements and text nodes.\n *\n * This is the native browser API style, e.g. operations are methods on individual objects\n * like HTMLElement. With this style, no additional code is needed as a facade\n * (reducing payload size).\n *\n * @record\n */\nfunction ObjectOrientedRenderer3() { }\nif (false) {\n /**\n * @param {?} data\n * @return {?}\n */\n ObjectOrientedRenderer3.prototype.createComment = function (data) { };\n /**\n * @param {?} tagName\n * @return {?}\n */\n ObjectOrientedRenderer3.prototype.createElement = function (tagName) { };\n /**\n * @param {?} namespace\n * @param {?} tagName\n * @return {?}\n */\n ObjectOrientedRenderer3.prototype.createElementNS = function (namespace, tagName) { };\n /**\n * @param {?} data\n * @return {?}\n */\n ObjectOrientedRenderer3.prototype.createTextNode = function (data) { };\n /**\n * @param {?} selectors\n * @return {?}\n */\n ObjectOrientedRenderer3.prototype.querySelector = function (selectors) { };\n}\n/**\n * Returns whether the `renderer` is a `ProceduralRenderer3`\n * @param {?} renderer\n * @return {?}\n */\nfunction isProceduralRenderer(renderer) {\n return !!(((/** @type {?} */ (renderer))).listen);\n}\n/**\n * Procedural style of API needed to create elements and text nodes.\n *\n * In non-native browser environments (e.g. platforms such as web-workers), this is the\n * facade that enables element manipulation. This also facilitates backwards compatibility\n * with Renderer2.\n * @record\n */\nfunction ProceduralRenderer3() { }\nif (false) {\n /**\n * This property is allowed to be null / undefined,\n * in which case the view engine won't call it.\n * This is used as a performance optimization for production mode.\n * @type {?|undefined}\n */\n ProceduralRenderer3.prototype.destroyNode;\n /**\n * @return {?}\n */\n ProceduralRenderer3.prototype.destroy = function () { };\n /**\n * @param {?} value\n * @return {?}\n */\n ProceduralRenderer3.prototype.createComment = function (value) { };\n /**\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\n ProceduralRenderer3.prototype.createElement = function (name, namespace) { };\n /**\n * @param {?} value\n * @return {?}\n */\n ProceduralRenderer3.prototype.createText = function (value) { };\n /**\n * @param {?} parent\n * @param {?} newChild\n * @return {?}\n */\n ProceduralRenderer3.prototype.appendChild = function (parent, newChild) { };\n /**\n * @param {?} parent\n * @param {?} newChild\n * @param {?} refChild\n * @return {?}\n */\n ProceduralRenderer3.prototype.insertBefore = function (parent, newChild, refChild) { };\n /**\n * @param {?} parent\n * @param {?} oldChild\n * @param {?=} isHostElement\n * @return {?}\n */\n ProceduralRenderer3.prototype.removeChild = function (parent, oldChild, isHostElement) { };\n /**\n * @param {?} selectorOrNode\n * @return {?}\n */\n ProceduralRenderer3.prototype.selectRootElement = function (selectorOrNode) { };\n /**\n * @param {?} node\n * @return {?}\n */\n ProceduralRenderer3.prototype.parentNode = function (node) { };\n /**\n * @param {?} node\n * @return {?}\n */\n ProceduralRenderer3.prototype.nextSibling = function (node) { };\n /**\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @param {?=} namespace\n * @return {?}\n */\n ProceduralRenderer3.prototype.setAttribute = function (el, name, value, namespace) { };\n /**\n * @param {?} el\n * @param {?} name\n * @param {?=} namespace\n * @return {?}\n */\n ProceduralRenderer3.prototype.removeAttribute = function (el, name, namespace) { };\n /**\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\n ProceduralRenderer3.prototype.addClass = function (el, name) { };\n /**\n * @param {?} el\n * @param {?} name\n * @return {?}\n */\n ProceduralRenderer3.prototype.removeClass = function (el, name) { };\n /**\n * @param {?} el\n * @param {?} style\n * @param {?} value\n * @param {?=} flags\n * @return {?}\n */\n ProceduralRenderer3.prototype.setStyle = function (el, style, value, flags) { };\n /**\n * @param {?} el\n * @param {?} style\n * @param {?=} flags\n * @return {?}\n */\n ProceduralRenderer3.prototype.removeStyle = function (el, style, flags) { };\n /**\n * @param {?} el\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\n ProceduralRenderer3.prototype.setProperty = function (el, name, value) { };\n /**\n * @param {?} node\n * @param {?} value\n * @return {?}\n */\n ProceduralRenderer3.prototype.setValue = function (node, value) { };\n /**\n * @param {?} target\n * @param {?} eventName\n * @param {?} callback\n * @return {?}\n */\n ProceduralRenderer3.prototype.listen = function (target, eventName, callback) { };\n}\n/**\n * @record\n */\nfunction RendererFactory3() { }\nif (false) {\n /**\n * @param {?} hostElement\n * @param {?} rendererType\n * @return {?}\n */\n RendererFactory3.prototype.createRenderer = function (hostElement, rendererType) { };\n /**\n * @return {?}\n */\n RendererFactory3.prototype.begin = function () { };\n /**\n * @return {?}\n */\n RendererFactory3.prototype.end = function () { };\n}\nconst ɵ0$3 = /**\n * @param {?} hostElement\n * @param {?} rendererType\n * @return {?}\n */\n(hostElement, rendererType) => { return document; };\n/** @type {?} */\nconst domRendererFactory3 = {\n createRenderer: (ɵ0$3)\n};\n/**\n * Subset of API needed for appending elements and text nodes.\n * @record\n */\nfunction RNode() { }\nif (false) {\n /**\n * Returns the parent Element, Document, or DocumentFragment\n * @type {?}\n */\n RNode.prototype.parentNode;\n /**\n * Returns the parent Element if there is one\n * @type {?}\n */\n RNode.prototype.parentElement;\n /**\n * Gets the Node immediately following this one in the parent's childNodes\n * @type {?}\n */\n RNode.prototype.nextSibling;\n /**\n * Removes a child from the current node and returns the removed node\n * @param {?} oldChild the child node to remove\n * @return {?}\n */\n RNode.prototype.removeChild = function (oldChild) { };\n /**\n * Insert a child node.\n *\n * Used exclusively for adding View root nodes into ViewAnchor location.\n * @param {?} newChild\n * @param {?} refChild\n * @param {?} isViewRoot\n * @return {?}\n */\n RNode.prototype.insertBefore = function (newChild, refChild, isViewRoot) { };\n /**\n * Append a child node.\n *\n * Used exclusively for building up DOM which are static (ie not View roots)\n * @param {?} newChild\n * @return {?}\n */\n RNode.prototype.appendChild = function (newChild) { };\n}\n/**\n * Subset of API needed for writing attributes, properties, and setting up\n * listeners on Element.\n * @record\n */\nfunction RElement() { }\nif (false) {\n /** @type {?} */\n RElement.prototype.style;\n /** @type {?} */\n RElement.prototype.classList;\n /** @type {?} */\n RElement.prototype.className;\n /**\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\n RElement.prototype.setAttribute = function (name, value) { };\n /**\n * @param {?} name\n * @return {?}\n */\n RElement.prototype.removeAttribute = function (name) { };\n /**\n * @param {?} namespaceURI\n * @param {?} qualifiedName\n * @param {?} value\n * @return {?}\n */\n RElement.prototype.setAttributeNS = function (namespaceURI, qualifiedName, value) { };\n /**\n * @param {?} type\n * @param {?} listener\n * @param {?=} useCapture\n * @return {?}\n */\n RElement.prototype.addEventListener = function (type, listener, useCapture) { };\n /**\n * @param {?} type\n * @param {?=} listener\n * @param {?=} options\n * @return {?}\n */\n RElement.prototype.removeEventListener = function (type, listener, options) { };\n /**\n * @param {?} name\n * @param {?} value\n * @return {?}\n */\n RElement.prototype.setProperty = function (name, value) { };\n}\n/**\n * @record\n */\nfunction RCssStyleDeclaration() { }\nif (false) {\n /**\n * @param {?} propertyName\n * @return {?}\n */\n RCssStyleDeclaration.prototype.removeProperty = function (propertyName) { };\n /**\n * @param {?} propertyName\n * @param {?} value\n * @param {?=} priority\n * @return {?}\n */\n RCssStyleDeclaration.prototype.setProperty = function (propertyName, value, priority) { };\n}\n/**\n * @record\n */\nfunction RDomTokenList() { }\nif (false) {\n /**\n * @param {?} token\n * @return {?}\n */\n RDomTokenList.prototype.add = function (token) { };\n /**\n * @param {?} token\n * @return {?}\n */\n RDomTokenList.prototype.remove = function (token) { };\n}\n/**\n * @record\n */\nfunction RText() { }\nif (false) {\n /** @type {?} */\n RText.prototype.textContent;\n}\n/**\n * @record\n */\nfunction RComment() { }\nif (false) {\n /** @type {?} */\n RComment.prototype.textContent;\n}\n// Note: This hack is necessary so we don't erroneously get a circular dependency\n// failure based on types.\n/** @type {?} */\nconst unusedValueExportToPlacateAjd$3 = 1;\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Assigns all attribute values to the provided element via the inferred renderer.\n *\n * This function accepts two forms of attribute entries:\n *\n * default: (key, value):\n * attrs = [key1, value1, key2, value2]\n *\n * namespaced: (NAMESPACE_MARKER, uri, name, value)\n * attrs = [NAMESPACE_MARKER, uri, name, value, NAMESPACE_MARKER, uri, name, value]\n *\n * The `attrs` array can contain a mix of both the default and namespaced entries.\n * The \"default\" values are set without a marker, but if the function comes across\n * a marker value then it will attempt to set a namespaced value. If the marker is\n * not of a namespaced value then the function will quit and return the index value\n * where it stopped during the iteration of the attrs array.\n *\n * See [AttributeMarker] to understand what the namespace marker value is.\n *\n * Note that this instruction does not support assigning style and class values to\n * an element. See `elementStart` and `elementHostAttrs` to learn how styling values\n * are applied to an element.\n *\n * @param {?} native The element that the attributes will be assigned to\n * @param {?} attrs The attribute array of values that will be assigned to the element\n * @return {?} the index value that was last accessed in the attributes array\n */\nfunction setUpAttributes(native, attrs) {\n /** @type {?} */\n const renderer = getLView()[RENDERER];\n /** @type {?} */\n const isProc = isProceduralRenderer(renderer);\n /** @type {?} */\n let i = 0;\n while (i < attrs.length) {\n /** @type {?} */\n const value = attrs[i];\n if (typeof value === 'number') {\n // only namespaces are supported. Other value types (such as style/class\n // entries) are not supported in this function.\n if (value !== 0 /* NamespaceURI */) {\n break;\n }\n // we just landed on the marker value ... therefore\n // we should skip to the next entry\n i++;\n /** @type {?} */\n const namespaceURI = (/** @type {?} */ (attrs[i++]));\n /** @type {?} */\n const attrName = (/** @type {?} */ (attrs[i++]));\n /** @type {?} */\n const attrVal = (/** @type {?} */ (attrs[i++]));\n ngDevMode && ngDevMode.rendererSetAttribute++;\n isProc ?\n ((/** @type {?} */ (renderer))).setAttribute(native, attrName, attrVal, namespaceURI) :\n native.setAttributeNS(namespaceURI, attrName, attrVal);\n }\n else {\n // attrName is string;\n /** @type {?} */\n const attrName = (/** @type {?} */ (value));\n /** @type {?} */\n const attrVal = attrs[++i];\n // Standard attributes\n ngDevMode && ngDevMode.rendererSetAttribute++;\n if (isAnimationProp(attrName)) {\n if (isProc) {\n ((/** @type {?} */ (renderer))).setProperty(native, attrName, attrVal);\n }\n }\n else {\n isProc ?\n ((/** @type {?} */ (renderer)))\n .setAttribute(native, (/** @type {?} */ (attrName)), (/** @type {?} */ (attrVal))) :\n native.setAttribute((/** @type {?} */ (attrName)), (/** @type {?} */ (attrVal)));\n }\n i++;\n }\n }\n // another piece of code may iterate over the same attributes array. Therefore\n // it may be helpful to return the exact spot where the attributes array exited\n // whether by running into an unsupported marker or if all the static values were\n // iterated over.\n return i;\n}\n/**\n * @param {?} attrs\n * @param {?} startIndex\n * @return {?}\n */\nfunction attrsStylingIndexOf(attrs, startIndex) {\n for (let i = startIndex; i < attrs.length; i++) {\n /** @type {?} */\n const val = attrs[i];\n if (val === 1 /* Classes */ || val === 2 /* Styles */) {\n return i;\n }\n }\n return -1;\n}\n/**\n * Test whether the given value is a marker that indicates that the following\n * attribute values in a `TAttributes` array are only the names of attributes,\n * and not name-value pairs.\n * @param {?} marker The attribute marker to test.\n * @return {?} true if the marker is a \"name-only\" marker (e.g. `Bindings`, `Template` or `I18n`).\n */\nfunction isNameOnlyAttributeMarker(marker) {\n return marker === 3 /* Bindings */ || marker === 4 /* Template */ ||\n marker === 6 /* I18n */;\n}\n/** @type {?} */\nconst ANIMATION_PROP_PREFIX = '@';\n/**\n * @param {?} name\n * @return {?}\n */\nfunction isAnimationProp(name) {\n return name[0] === ANIMATION_PROP_PREFIX;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/// Parent Injector Utils ///////////////////////////////////////////////////////////////\n/**\n * @param {?} parentLocation\n * @return {?}\n */\nfunction hasParentInjector(parentLocation) {\n return parentLocation !== NO_PARENT_INJECTOR;\n}\n/**\n * @param {?} parentLocation\n * @return {?}\n */\nfunction getParentInjectorIndex(parentLocation) {\n return ((/** @type {?} */ ((/** @type {?} */ (parentLocation))))) & 32767 /* InjectorIndexMask */;\n}\n/**\n * @param {?} parentLocation\n * @return {?}\n */\nfunction getParentInjectorViewOffset(parentLocation) {\n return ((/** @type {?} */ ((/** @type {?} */ (parentLocation))))) >> 16 /* ViewOffsetShift */;\n}\n/**\n * Unwraps a parent injector location number to find the view offset from the current injector,\n * then walks up the declaration view tree until the view is found that contains the parent\n * injector.\n *\n * @param {?} location The location of the parent injector, which contains the view offset\n * @param {?} startView The LView instance from which to start walking up the view tree\n * @return {?} The LView instance that contains the parent injector\n */\nfunction getParentInjectorView(location, startView) {\n /** @type {?} */\n let viewOffset = getParentInjectorViewOffset(location);\n /** @type {?} */\n let parentView = startView;\n // For most cases, the parent injector can be found on the host node (e.g. for component\n // or container), but we must keep the loop here to support the rarer case of deeply nested\n // tags or inline views, where the parent injector might live many views\n // above the child injector.\n while (viewOffset > 0) {\n parentView = (/** @type {?} */ (parentView[DECLARATION_VIEW]));\n viewOffset--;\n }\n return parentView;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Gets the parent LView of the passed LView, if the PARENT is an LContainer, will get the parent of\n * that LContainer, which is an LView\n * @param {?} lView the lView whose parent to get\n * @return {?}\n */\nfunction getLViewParent(lView) {\n ngDevMode && assertLView(lView);\n /** @type {?} */\n const parent = lView[PARENT];\n return isLContainer(parent) ? (/** @type {?} */ (parent[PARENT])) : parent;\n}\n/**\n * Retrieve the root view from any component or `LView` by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param {?} componentOrLView any component or `LView`\n * @return {?}\n */\nfunction getRootView(componentOrLView) {\n ngDevMode && assertDefined(componentOrLView, 'component');\n /** @type {?} */\n let lView = isLView(componentOrLView) ? componentOrLView : (/** @type {?} */ (readPatchedLView(componentOrLView)));\n while (lView && !(lView[FLAGS] & 512 /* IsRoot */)) {\n lView = (/** @type {?} */ (getLViewParent(lView)));\n }\n ngDevMode && assertLView(lView);\n return lView;\n}\n/**\n * Given an `LView`, find the closest declaration view which is not an embedded view.\n *\n * This method searches for the `LView` associated with the component which declared the `LView`.\n *\n * This function may return itself if the `LView` passed in is not an embedded `LView`. Otherwise\n * it walks the declaration parents until it finds a component view (non-embedded-view.)\n *\n * @param {?} lView LView for which we want a host element node\n * @return {?} The host node\n */\nfunction findComponentView(lView) {\n /** @type {?} */\n let rootTNode = lView[T_HOST];\n while (rootTNode !== null && rootTNode.type === 2 /* View */) {\n ngDevMode && assertDefined(lView[DECLARATION_VIEW], 'lView[DECLARATION_VIEW]');\n lView = (/** @type {?} */ (lView[DECLARATION_VIEW]));\n rootTNode = lView[T_HOST];\n }\n ngDevMode && assertLView(lView);\n return lView;\n}\n/**\n * Returns the `RootContext` instance that is associated with\n * the application where the target is situated. It does this by walking the parent views until it\n * gets to the root view, then getting the context off of that.\n *\n * @param {?} viewOrComponent the `LView` or component to get the root context for.\n * @return {?}\n */\nfunction getRootContext(viewOrComponent) {\n /** @type {?} */\n const rootView = getRootView(viewOrComponent);\n ngDevMode &&\n assertDefined(rootView[CONTEXT], 'RootView has no context. Perhaps it is disconnected?');\n return (/** @type {?} */ (rootView[CONTEXT]));\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Defines if the call to `inject` should include `viewProviders` in its resolution.\n *\n * This is set to true when we try to instantiate a component. This value is reset in\n * `getNodeInjectable` to a value which matches the declaration location of the token about to be\n * instantiated. This is done so that if we are injecting a token which was declared outside of\n * `viewProviders` we don't accidentally pull `viewProviders` in.\n *\n * Example:\n *\n * ```\n * \\@Injectable()\n * class MyService {\n * constructor(public value: String) {}\n * }\n *\n * \\@Component({\n * providers: [\n * MyService,\n * {provide: String, value: 'providers' }\n * ]\n * viewProviders: [\n * {provide: String, value: 'viewProviders'}\n * ]\n * })\n * class MyComponent {\n * constructor(myService: MyService, value: String) {\n * // We expect that Component can see into `viewProviders`.\n * expect(value).toEqual('viewProviders');\n * // `MyService` was not declared in `viewProviders` hence it can't see it.\n * expect(myService.value).toEqual('providers');\n * }\n * }\n *\n * ```\n * @type {?}\n */\nlet includeViewProviders = true;\n/**\n * @param {?} v\n * @return {?}\n */\nfunction setIncludeViewProviders(v) {\n /** @type {?} */\n const oldValue = includeViewProviders;\n includeViewProviders = v;\n return oldValue;\n}\n/**\n * The number of slots in each bloom filter (used by DI). The larger this number, the fewer\n * directives that will share slots, and thus, the fewer false positives when checking for\n * the existence of a directive.\n * @type {?}\n */\nconst BLOOM_SIZE = 256;\n/** @type {?} */\nconst BLOOM_MASK = BLOOM_SIZE - 1;\n/**\n * Counter used to generate unique IDs for directives.\n * @type {?}\n */\nlet nextNgElementId = 0;\n/**\n * Registers this directive as present in its node's injector by flipping the directive's\n * corresponding bit in the injector's bloom filter.\n *\n * @param {?} injectorIndex The index of the node injector where this token should be registered\n * @param {?} tView The TView for the injector's bloom filters\n * @param {?} type The directive token to register\n * @return {?}\n */\nfunction bloomAdd(injectorIndex, tView, type) {\n ngDevMode && assertEqual(tView.firstTemplatePass, true, 'expected firstTemplatePass to be true');\n /** @type {?} */\n let id = typeof type !== 'string' ? ((/** @type {?} */ (type)))[NG_ELEMENT_ID] : type.charCodeAt(0) || 0;\n // Set a unique ID on the directive type, so if something tries to inject the directive,\n // we can easily retrieve the ID and hash it into the bloom bit that should be checked.\n if (id == null) {\n id = ((/** @type {?} */ (type)))[NG_ELEMENT_ID] = nextNgElementId++;\n }\n // We only have BLOOM_SIZE (256) slots in our bloom filter (8 buckets * 32 bits each),\n // so all unique IDs must be modulo-ed into a number from 0 - 255 to fit into the filter.\n /** @type {?} */\n const bloomBit = id & BLOOM_MASK;\n // Create a mask that targets the specific bit associated with the directive.\n // JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding\n // to bit positions 0 - 31 in a 32 bit integer.\n /** @type {?} */\n const mask = 1 << bloomBit;\n // Use the raw bloomBit number to determine which bloom filter bucket we should check\n // e.g: bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc\n /** @type {?} */\n const b7 = bloomBit & 0x80;\n /** @type {?} */\n const b6 = bloomBit & 0x40;\n /** @type {?} */\n const b5 = bloomBit & 0x20;\n /** @type {?} */\n const tData = (/** @type {?} */ (tView.data));\n if (b7) {\n b6 ? (b5 ? (tData[injectorIndex + 7] |= mask) : (tData[injectorIndex + 6] |= mask)) :\n (b5 ? (tData[injectorIndex + 5] |= mask) : (tData[injectorIndex + 4] |= mask));\n }\n else {\n b6 ? (b5 ? (tData[injectorIndex + 3] |= mask) : (tData[injectorIndex + 2] |= mask)) :\n (b5 ? (tData[injectorIndex + 1] |= mask) : (tData[injectorIndex] |= mask));\n }\n}\n/**\n * Creates (or gets an existing) injector for a given element or container.\n *\n * @param {?} tNode for which an injector should be retrieved / created.\n * @param {?} hostView View where the node is stored\n * @return {?} Node injector\n */\nfunction getOrCreateNodeInjectorForNode(tNode, hostView) {\n /** @type {?} */\n const existingInjectorIndex = getInjectorIndex(tNode, hostView);\n if (existingInjectorIndex !== -1) {\n return existingInjectorIndex;\n }\n /** @type {?} */\n const tView = hostView[TVIEW];\n if (tView.firstTemplatePass) {\n tNode.injectorIndex = hostView.length;\n insertBloom(tView.data, tNode); // foundation for node bloom\n insertBloom(hostView, null); // foundation for cumulative bloom\n insertBloom(tView.blueprint, null);\n ngDevMode && assertEqual(tNode.flags === 0 || tNode.flags === 1 /* isComponent */, true, 'expected tNode.flags to not be initialized');\n }\n /** @type {?} */\n const parentLoc = getParentInjectorLocation(tNode, hostView);\n /** @type {?} */\n const parentIndex = getParentInjectorIndex(parentLoc);\n /** @type {?} */\n const parentLView = getParentInjectorView(parentLoc, hostView);\n /** @type {?} */\n const injectorIndex = tNode.injectorIndex;\n // If a parent injector can't be found, its location is set to -1.\n // In that case, we don't need to set up a cumulative bloom\n if (hasParentInjector(parentLoc)) {\n /** @type {?} */\n const parentData = (/** @type {?} */ (parentLView[TVIEW].data));\n // Creates a cumulative bloom filter that merges the parent's bloom filter\n // and its own cumulative bloom (which contains tokens for all ancestors)\n for (let i = 0; i < 8; i++) {\n hostView[injectorIndex + i] = parentLView[parentIndex + i] | parentData[parentIndex + i];\n }\n }\n hostView[injectorIndex + PARENT_INJECTOR] = parentLoc;\n return injectorIndex;\n}\n/**\n * @param {?} arr\n * @param {?} footer\n * @return {?}\n */\nfunction insertBloom(arr, footer) {\n arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);\n}\n/**\n * @param {?} tNode\n * @param {?} hostView\n * @return {?}\n */\nfunction getInjectorIndex(tNode, hostView) {\n if (tNode.injectorIndex === -1 ||\n // If the injector index is the same as its parent's injector index, then the index has been\n // copied down from the parent node. No injector has been created yet on this node.\n (tNode.parent && tNode.parent.injectorIndex === tNode.injectorIndex) ||\n // After the first template pass, the injector index might exist but the parent values\n // might not have been calculated yet for this instance\n hostView[tNode.injectorIndex + PARENT_INJECTOR] == null) {\n return -1;\n }\n else {\n return tNode.injectorIndex;\n }\n}\n/**\n * Finds the index of the parent injector, with a view offset if applicable. Used to set the\n * parent injector initially.\n *\n * Returns a combination of number of `ViewData` we have to go up and index in that `Viewdata`\n * @param {?} tNode\n * @param {?} view\n * @return {?}\n */\nfunction getParentInjectorLocation(tNode, view) {\n if (tNode.parent && tNode.parent.injectorIndex !== -1) {\n return (/** @type {?} */ (tNode.parent.injectorIndex)); // ViewOffset is 0\n }\n // For most cases, the parent injector index can be found on the host node (e.g. for component\n // or container), so this loop will be skipped, but we must keep the loop here to support\n // the rarer case of deeply nested tags or inline views.\n /** @type {?} */\n let hostTNode = view[T_HOST];\n /** @type {?} */\n let viewOffset = 1;\n while (hostTNode && hostTNode.injectorIndex === -1) {\n view = (/** @type {?} */ (view[DECLARATION_VIEW]));\n hostTNode = view ? view[T_HOST] : null;\n viewOffset++;\n }\n return hostTNode ?\n hostTNode.injectorIndex | (viewOffset << 16 /* ViewOffsetShift */) :\n (/** @type {?} */ (-1));\n}\n/**\n * Makes a type or an injection token public to the DI system by adding it to an\n * injector's bloom filter.\n *\n * @param {?} injectorIndex\n * @param {?} tView\n * @param {?} token The type or the injection token to be made public\n * @return {?}\n */\nfunction diPublicInInjector(injectorIndex, tView, token) {\n bloomAdd(injectorIndex, tView, token);\n}\n/**\n * Inject static attribute value into directive constructor.\n *\n * This method is used with `factory` functions which are generated as part of\n * `defineDirective` or `defineComponent`. The method retrieves the static value\n * of an attribute. (Dynamic attributes are not supported since they are not resolved\n * at the time of injection and can change over time.)\n *\n * # Example\n * Given:\n * ```\n * \\@Component(...)\n * class MyComponent {\n * constructor(\\@Attribute('title') title: string) { ... }\n * }\n * ```\n * When instantiated with\n * ```\n * \n * ```\n *\n * Then factory method generated is:\n * ```\n * MyComponent.ngComponentDef = defineComponent({\n * factory: () => new MyComponent(injectAttribute('title'))\n * ...\n * })\n * ```\n *\n * \\@publicApi\n * @param {?} tNode\n * @param {?} attrNameToInject\n * @return {?}\n */\nfunction injectAttributeImpl(tNode, attrNameToInject) {\n ngDevMode && assertNodeOfPossibleTypes(tNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */);\n ngDevMode && assertDefined(tNode, 'expecting tNode');\n if (attrNameToInject === 'class') {\n return getInitialStylingValue(tNode.classes);\n }\n if (attrNameToInject === 'style') {\n return getInitialStylingValue(tNode.styles);\n }\n /** @type {?} */\n const attrs = tNode.attrs;\n if (attrs) {\n /** @type {?} */\n const attrsLength = attrs.length;\n /** @type {?} */\n let i = 0;\n while (i < attrsLength) {\n /** @type {?} */\n const value = attrs[i];\n // If we hit a `Bindings` or `Template` marker then we are done.\n if (isNameOnlyAttributeMarker(value))\n break;\n // Skip namespaced attributes\n if (value === 0 /* NamespaceURI */) {\n // we skip the next two values\n // as namespaced attributes looks like\n // [..., AttributeMarker.NamespaceURI, 'http://someuri.com/test', 'test:exist',\n // 'existValue', ...]\n i = i + 2;\n }\n else if (typeof value === 'number') {\n // Skip to the first value of the marked attribute.\n i++;\n while (i < attrsLength && typeof attrs[i] === 'string') {\n i++;\n }\n }\n else if (value === attrNameToInject) {\n return (/** @type {?} */ (attrs[i + 1]));\n }\n else {\n i = i + 2;\n }\n }\n }\n return null;\n}\n/**\n * Returns the value associated to the given token from the NodeInjectors => ModuleInjector.\n *\n * Look for the injector providing the token by walking up the node injector tree and then\n * the module injector tree.\n *\n * This function patches `token` with `__NG_ELEMENT_ID__` which contains the id for the bloom\n * filter. Negative values are reserved for special objects.\n * - `-1` is reserved for injecting `Injector` (implemented by `NodeInjector`)\n *\n * @template T\n * @param {?} tNode The Node where the search for the injector should start\n * @param {?} lView The `LView` that contains the `tNode`\n * @param {?} token The token to look for\n * @param {?=} flags Injection flags\n * @param {?=} notFoundValue The value to return when the injection flags is `InjectFlags.Optional`\n * @return {?} the value from the injector, `null` when not found, or `notFoundValue` if provided\n */\nfunction getOrCreateInjectable(tNode, lView, token, flags = InjectFlags.Default, notFoundValue) {\n if (tNode) {\n /** @type {?} */\n const bloomHash = bloomHashBitOrFactory(token);\n // If the ID stored here is a function, this is a special object like ElementRef or TemplateRef\n // so just call the factory function to create it.\n if (typeof bloomHash === 'function') {\n /** @type {?} */\n const savePreviousOrParentTNode = getPreviousOrParentTNode();\n /** @type {?} */\n const saveLView = getLView();\n setTNodeAndViewData(tNode, lView);\n try {\n /** @type {?} */\n const value = bloomHash();\n if (value == null && !(flags & InjectFlags.Optional)) {\n throw new Error(`No provider for ${stringifyForError(token)}!`);\n }\n else {\n return value;\n }\n }\n finally {\n setTNodeAndViewData(savePreviousOrParentTNode, saveLView);\n }\n }\n else if (typeof bloomHash == 'number') {\n if (bloomHash === -1) {\n // `-1` is a special value used to identify `Injector` types.\n return (/** @type {?} */ (new NodeInjector(tNode, lView)));\n }\n // If the token has a bloom hash, then it is a token which could be in NodeInjector.\n // A reference to the previous injector TView that was found while climbing the element\n // injector tree. This is used to know if viewProviders can be accessed on the current\n // injector.\n /** @type {?} */\n let previousTView = null;\n /** @type {?} */\n let injectorIndex = getInjectorIndex(tNode, lView);\n /** @type {?} */\n let parentLocation = NO_PARENT_INJECTOR;\n /** @type {?} */\n let hostTElementNode = flags & InjectFlags.Host ? findComponentView(lView)[T_HOST] : null;\n // If we should skip this injector, or if there is no injector on this node, start by\n // searching\n // the parent injector.\n if (injectorIndex === -1 || flags & InjectFlags.SkipSelf) {\n parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lView) :\n lView[injectorIndex + PARENT_INJECTOR];\n if (!shouldSearchParent(flags, false)) {\n injectorIndex = -1;\n }\n else {\n previousTView = lView[TVIEW];\n injectorIndex = getParentInjectorIndex(parentLocation);\n lView = getParentInjectorView(parentLocation, lView);\n }\n }\n // Traverse up the injector tree until we find a potential match or until we know there\n // *isn't* a match.\n while (injectorIndex !== -1) {\n parentLocation = lView[injectorIndex + PARENT_INJECTOR];\n // Check the current injector. If it matches, see if it contains token.\n /** @type {?} */\n const tView = lView[TVIEW];\n if (bloomHasToken(bloomHash, injectorIndex, tView.data)) {\n // At this point, we have an injector which *may* contain the token, so we step through\n // the providers and directives associated with the injector's corresponding node to get\n // the instance.\n /** @type {?} */\n const instance = searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode);\n if (instance !== NOT_FOUND) {\n return instance;\n }\n }\n if (shouldSearchParent(flags, lView[TVIEW].data[injectorIndex + TNODE] === hostTElementNode) &&\n bloomHasToken(bloomHash, injectorIndex, lView)) {\n // The def wasn't found anywhere on this node, so it was a false positive.\n // Traverse up the tree and continue searching.\n previousTView = tView;\n injectorIndex = getParentInjectorIndex(parentLocation);\n lView = getParentInjectorView(parentLocation, lView);\n }\n else {\n // If we should not search parent OR If the ancestor bloom filter value does not have the\n // bit corresponding to the directive we can give up on traversing up to find the specific\n // injector.\n injectorIndex = -1;\n }\n }\n }\n }\n if (flags & InjectFlags.Optional && notFoundValue === undefined) {\n // This must be set or the NullInjector will throw for optional deps\n notFoundValue = null;\n }\n if ((flags & (InjectFlags.Self | InjectFlags.Host)) === 0) {\n /** @type {?} */\n const moduleInjector = lView[INJECTOR$1];\n // switch to `injectInjectorOnly` implementation for module injector, since module injector\n // should not have access to Component/Directive DI scope (that may happen through\n // `directiveInject` implementation)\n /** @type {?} */\n const previousInjectImplementation = setInjectImplementation(undefined);\n try {\n if (moduleInjector) {\n return moduleInjector.get(token, notFoundValue, flags & InjectFlags.Optional);\n }\n else {\n return injectRootLimpMode(token, notFoundValue, flags & InjectFlags.Optional);\n }\n }\n finally {\n setInjectImplementation(previousInjectImplementation);\n }\n }\n if (flags & InjectFlags.Optional) {\n return notFoundValue;\n }\n else {\n throw new Error(`NodeInjector: NOT_FOUND [${stringifyForError(token)}]`);\n }\n}\n/** @type {?} */\nconst NOT_FOUND = {};\n/**\n * @template T\n * @param {?} injectorIndex\n * @param {?} lView\n * @param {?} token\n * @param {?} previousTView\n * @param {?} flags\n * @param {?} hostTElementNode\n * @return {?}\n */\nfunction searchTokensOnInjector(injectorIndex, lView, token, previousTView, flags, hostTElementNode) {\n /** @type {?} */\n const currentTView = lView[TVIEW];\n /** @type {?} */\n const tNode = (/** @type {?} */ (currentTView.data[injectorIndex + TNODE]));\n // First, we need to determine if view providers can be accessed by the starting element.\n // There are two possibities\n /** @type {?} */\n const canAccessViewProviders = previousTView == null ?\n // 1) This is the first invocation `previousTView == null` which means that we are at the\n // `TNode` of where injector is starting to look. In such a case the only time we are allowed\n // to look into the ViewProviders is if:\n // - we are on a component\n // - AND the injector set `includeViewProviders` to true (implying that the token can see\n // ViewProviders because it is the Component or a Service which itself was declared in\n // ViewProviders)\n (isComponent(tNode) && includeViewProviders) :\n // 2) `previousTView != null` which means that we are now walking across the parent nodes.\n // In such a case we are only allowed to look into the ViewProviders if:\n // - We just crossed from child View to Parent View `previousTView != currentTView`\n // - AND the parent TNode is an Element.\n // This means that we just came from the Component's View and therefore are allowed to see\n // into the ViewProviders.\n (previousTView != currentTView && (tNode.type === 3 /* Element */));\n // This special case happens when there is a @host on the inject and when we are searching\n // on the host element node.\n /** @type {?} */\n const isHostSpecialCase = (flags & InjectFlags.Host) && hostTElementNode === tNode;\n /** @type {?} */\n const injectableIdx = locateDirectiveOrProvider(tNode, currentTView, token, canAccessViewProviders, isHostSpecialCase);\n if (injectableIdx !== null) {\n return getNodeInjectable(currentTView.data, lView, injectableIdx, (/** @type {?} */ (tNode)));\n }\n else {\n return NOT_FOUND;\n }\n}\n/**\n * Searches for the given token among the node's directives and providers.\n *\n * @template T\n * @param {?} tNode TNode on which directives are present.\n * @param {?} tView The tView we are currently processing\n * @param {?} token Provider token or type of a directive to look for.\n * @param {?} canAccessViewProviders Whether view providers should be considered.\n * @param {?} isHostSpecialCase Whether the host special case applies.\n * @return {?} Index of a found directive or provider, or null when none found.\n */\nfunction locateDirectiveOrProvider(tNode, tView, token, canAccessViewProviders, isHostSpecialCase) {\n /** @type {?} */\n const nodeProviderIndexes = tNode.providerIndexes;\n /** @type {?} */\n const tInjectables = tView.data;\n /** @type {?} */\n const injectablesStart = nodeProviderIndexes & 65535 /* ProvidersStartIndexMask */;\n /** @type {?} */\n const directivesStart = tNode.directiveStart;\n /** @type {?} */\n const directiveEnd = tNode.directiveEnd;\n /** @type {?} */\n const cptViewProvidersCount = nodeProviderIndexes >> 16 /* CptViewProvidersCountShift */;\n /** @type {?} */\n const startingIndex = canAccessViewProviders ? injectablesStart : injectablesStart + cptViewProvidersCount;\n // When the host special case applies, only the viewProviders and the component are visible\n /** @type {?} */\n const endIndex = isHostSpecialCase ? injectablesStart + cptViewProvidersCount : directiveEnd;\n for (let i = startingIndex; i < endIndex; i++) {\n /** @type {?} */\n const providerTokenOrDef = (/** @type {?} */ (tInjectables[i]));\n if (i < directivesStart && token === providerTokenOrDef ||\n i >= directivesStart && ((/** @type {?} */ (providerTokenOrDef))).type === token) {\n return i;\n }\n }\n if (isHostSpecialCase) {\n /** @type {?} */\n const dirDef = (/** @type {?} */ (tInjectables[directivesStart]));\n if (dirDef && isComponentDef(dirDef) && dirDef.type === token) {\n return directivesStart;\n }\n }\n return null;\n}\n/**\n * Retrieve or instantiate the injectable from the `lData` at particular `index`.\n *\n * This function checks to see if the value has already been instantiated and if so returns the\n * cached `injectable`. Otherwise if it detects that the value is still a factory it\n * instantiates the `injectable` and caches the value.\n * @param {?} tData\n * @param {?} lData\n * @param {?} index\n * @param {?} tNode\n * @return {?}\n */\nfunction getNodeInjectable(tData, lData, index, tNode) {\n /** @type {?} */\n let value = lData[index];\n if (isFactory(value)) {\n /** @type {?} */\n const factory = value;\n if (factory.resolving) {\n throw new Error(`Circular dep for ${stringifyForError(tData[index])}`);\n }\n /** @type {?} */\n const previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);\n factory.resolving = true;\n /** @type {?} */\n let previousInjectImplementation;\n if (factory.injectImpl) {\n previousInjectImplementation = setInjectImplementation(factory.injectImpl);\n }\n /** @type {?} */\n const savePreviousOrParentTNode = getPreviousOrParentTNode();\n /** @type {?} */\n const saveLView = getLView();\n setTNodeAndViewData(tNode, lData);\n try {\n value = lData[index] = factory.factory(undefined, tData, lData, tNode);\n }\n finally {\n if (factory.injectImpl)\n setInjectImplementation(previousInjectImplementation);\n setIncludeViewProviders(previousIncludeViewProviders);\n factory.resolving = false;\n setTNodeAndViewData(savePreviousOrParentTNode, saveLView);\n }\n }\n return value;\n}\n/**\n * Returns the bit in an injector's bloom filter that should be used to determine whether or not\n * the directive might be provided by the injector.\n *\n * When a directive is public, it is added to the bloom filter and given a unique ID that can be\n * retrieved on the Type. When the directive isn't public or the token is not a directive `null`\n * is returned as the node injector can not possibly provide that token.\n *\n * @param {?} token the injection token\n * @return {?} the matching bit to check in the bloom filter or `null` if the token is not known.\n * When the returned value is negative then it represents special values such as `Injector`.\n */\nfunction bloomHashBitOrFactory(token) {\n ngDevMode && assertDefined(token, 'token must be defined');\n if (typeof token === 'string') {\n return token.charCodeAt(0) || 0;\n }\n /** @type {?} */\n const tokenId = ((/** @type {?} */ (token)))[NG_ELEMENT_ID];\n // Negative token IDs are used for special objects such as `Injector`\n return (typeof tokenId === 'number' && tokenId > 0) ? tokenId & BLOOM_MASK : tokenId;\n}\n/**\n * @param {?} bloomHash\n * @param {?} injectorIndex\n * @param {?} injectorView\n * @return {?}\n */\nfunction bloomHasToken(bloomHash, injectorIndex, injectorView) {\n // Create a mask that targets the specific bit associated with the directive we're looking for.\n // JS bit operations are 32 bits, so this will be a number between 2^0 and 2^31, corresponding\n // to bit positions 0 - 31 in a 32 bit integer.\n /** @type {?} */\n const mask = 1 << bloomHash;\n /** @type {?} */\n const b7 = bloomHash & 0x80;\n /** @type {?} */\n const b6 = bloomHash & 0x40;\n /** @type {?} */\n const b5 = bloomHash & 0x20;\n // Our bloom filter size is 256 bits, which is eight 32-bit bloom filter buckets:\n // bf0 = [0 - 31], bf1 = [32 - 63], bf2 = [64 - 95], bf3 = [96 - 127], etc.\n // Get the bloom filter value from the appropriate bucket based on the directive's bloomBit.\n /** @type {?} */\n let value;\n if (b7) {\n value = b6 ? (b5 ? injectorView[injectorIndex + 7] : injectorView[injectorIndex + 6]) :\n (b5 ? injectorView[injectorIndex + 5] : injectorView[injectorIndex + 4]);\n }\n else {\n value = b6 ? (b5 ? injectorView[injectorIndex + 3] : injectorView[injectorIndex + 2]) :\n (b5 ? injectorView[injectorIndex + 1] : injectorView[injectorIndex]);\n }\n // If the bloom filter value has the bit corresponding to the directive's bloomBit flipped on,\n // this injector is a potential match.\n return !!(value & mask);\n}\n/**\n * Returns true if flags prevent parent injector from being searched for tokens\n * @param {?} flags\n * @param {?} isFirstHostTNode\n * @return {?}\n */\nfunction shouldSearchParent(flags, isFirstHostTNode) {\n return !(flags & InjectFlags.Self) && !(flags & InjectFlags.Host && isFirstHostTNode);\n}\nclass NodeInjector {\n /**\n * @param {?} _tNode\n * @param {?} _lView\n */\n constructor(_tNode, _lView) {\n this._tNode = _tNode;\n this._lView = _lView;\n }\n /**\n * @param {?} token\n * @param {?=} notFoundValue\n * @return {?}\n */\n get(token, notFoundValue) {\n return getOrCreateInjectable(this._tNode, this._lView, token, undefined, notFoundValue);\n }\n}\nif (false) {\n /**\n * @type {?}\n * @private\n */\n NodeInjector.prototype._tNode;\n /**\n * @type {?}\n * @private\n */\n NodeInjector.prototype._lView;\n}\n/**\n * \\@codeGenApi\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction ɵɵgetFactoryOf(type) {\n /** @type {?} */\n const typeAny = (/** @type {?} */ (type));\n /** @type {?} */\n const def = getComponentDef(typeAny) || getDirectiveDef(typeAny) ||\n getPipeDef(typeAny) || getInjectableDef(typeAny) || getInjectorDef(typeAny);\n if (!def || def.factory === undefined) {\n return null;\n }\n return def.factory;\n}\n/**\n * \\@codeGenApi\n * @template T\n * @param {?} type\n * @return {?}\n */\nfunction ɵɵgetInheritedFactory(type) {\n /** @type {?} */\n const proto = (/** @type {?} */ (Object.getPrototypeOf(type.prototype).constructor));\n /** @type {?} */\n const factory = ɵɵgetFactoryOf(proto);\n if (factory !== null) {\n return factory;\n }\n else {\n // There is no factory defined. Either this was improper usage of inheritance\n // (no Angular decorator on the superclass) or there is no constructor at all\n // in the inheritance chain. Since the two cases cannot be distinguished, the\n // latter has to be assumed.\n return (/**\n * @param {?} t\n * @return {?}\n */\n (t) => new t());\n }\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 */\nconst ERROR_TYPE = 'ngType';\nconst ERROR_DEBUG_CONTEXT = 'ngDebugContext';\nconst ERROR_ORIGINAL_ERROR = 'ngOriginalError';\nconst ERROR_LOGGER = 'ngErrorLogger';\nfunction wrappedError(message, originalError) {\n const msg = `${message} caused by: ${originalError instanceof Error ? originalError.message : originalError}`;\n const error = Error(msg);\n error[ERROR_ORIGINAL_ERROR] = originalError;\n return error;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * @param {?} error\n * @return {?}\n */\nfunction getType(error) {\n return ((/** @type {?} */ (error)))[ERROR_TYPE];\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction getDebugContext(error) {\n return ((/** @type {?} */ (error)))[ERROR_DEBUG_CONTEXT];\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction getOriginalError(error) {\n return ((/** @type {?} */ (error)))[ERROR_ORIGINAL_ERROR];\n}\n/**\n * @param {?} error\n * @return {?}\n */\nfunction getErrorLogger(error) {\n return ((/** @type {?} */ (error)))[ERROR_LOGGER] || defaultErrorLogger;\n}\n/**\n * @param {?} console\n * @param {...?} values\n * @return {?}\n */\nfunction defaultErrorLogger(console, ...values) {\n ((/** @type {?} */ (console.error)))(...values);\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\n */\n/**\n * Provides a hook for centralized exception handling.\n *\n * The default implementation of `ErrorHandler` prints error messages to the `console`. To\n * intercept error handling, write a custom exception handler that replaces this default as\n * appropriate for your app.\n *\n * \\@usageNotes\n * ### Example\n *\n * ```\n * class MyErrorHandler implements ErrorHandler {\n * handleError(error) {\n * // do something with the exception\n * }\n * }\n *\n * \\@NgModule({\n * providers: [{provide: ErrorHandler, useClass: MyErrorHandler}]\n * })\n * class MyModule {}\n * ```\n *\n * \\@publicApi\n */\nclass ErrorHandler {\n constructor() {\n /**\n * \\@internal\n */\n this._console = console;\n }\n /**\n * @param {?} error\n * @return {?}\n */\n handleError(error) {\n /** @type {?} */\n const originalError = this._findOriginalError(error);\n /** @type {?} */\n const context = this._findContext(error);\n // Note: Browser consoles show the place from where console.error was called.\n // We can use this to give users additional information about the error.\n /** @type {?} */\n const errorLogger = getErrorLogger(error);\n errorLogger(this._console, `ERROR`, error);\n if (originalError) {\n errorLogger(this._console, `ORIGINAL ERROR`, originalError);\n }\n if (context) {\n errorLogger(this._console, 'ERROR CONTEXT', context);\n }\n }\n /**\n * \\@internal\n * @param {?} error\n * @return {?}\n */\n _findContext(error) {\n if (error) {\n return getDebugContext(error) ? getDebugContext(error) :\n this._findContext(getOriginalError(error));\n }\n return null;\n }\n /**\n * \\@internal\n * @param {?} error\n * @return {?}\n */\n _findOriginalError(error) {\n /** @type {?} */\n let e = getOriginalError(error);\n while (e && getOriginalError(e)) {\n e = getOriginalError(e);\n }\n return e;\n }\n}\nif (false) {\n /**\n * \\@internal\n * @type {?}\n */\n ErrorHandler.prototype._console;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * A schema definition associated with an NgModule.\n *\n * @see `\\@NgModule`, `CUSTOM_ELEMENTS_SCHEMA`, `NO_ERRORS_SCHEMA`\n *\n * @param name The name of a defined schema.\n *\n * \\@publicApi\n * @record\n */\nfunction SchemaMetadata() { }\nif (false) {\n /** @type {?} */\n SchemaMetadata.prototype.name;\n}\n/**\n * Defines a schema that allows an NgModule to contain the following:\n * - Non-Angular elements named with dash case (`-`).\n * - Element properties named with dash case (`-`).\n * Dash case is the naming convention for custom elements.\n *\n * \\@publicApi\n * @type {?}\n */\nconst CUSTOM_ELEMENTS_SCHEMA = {\n name: 'custom-elements'\n};\n/**\n * Defines a schema that allows any property on any element.\n *\n * \\@publicApi\n * @type {?}\n */\nconst NO_ERRORS_SCHEMA = {\n name: 'no-errors-schema'\n};\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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/** @type {?} */\nconst BRAND = '__SANITIZER_TRUSTED_BRAND__';\n/** @enum {string} */\nconst BypassType = {\n Url: 'Url',\n Html: 'Html',\n ResourceUrl: 'ResourceUrl',\n Script: 'Script',\n Style: 'Style',\n};\n/**\n * A branded trusted string used with sanitization.\n *\n * See: {\\@link TrustedHtmlString}, {\\@link TrustedResourceUrlString}, {\\@link TrustedScriptString},\n * {\\@link TrustedStyleString}, {\\@link TrustedUrlString}\n * @record\n */\nfunction TrustedString() { }\nif (false) {\n /* Skipping unnamed member:\n [BRAND]: BypassType;*/\n}\n/**\n * A branded trusted string used with sanitization of `html` strings.\n *\n * See: {\\@link bypassSanitizationTrustHtml} and {\\@link htmlSanitizer}.\n * @record\n */\nfunction TrustedHtmlString() { }\nif (false) {\n /* Skipping unnamed member:\n [BRAND]: BypassType.Html;*/\n}\n/**\n * A branded trusted string used with sanitization of `style` strings.\n *\n * See: {\\@link bypassSanitizationTrustStyle} and {\\@link styleSanitizer}.\n * @record\n */\nfunction TrustedStyleString() { }\nif (false) {\n /* Skipping unnamed member:\n [BRAND]: BypassType.Style;*/\n}\n/**\n * A branded trusted string used with sanitization of `url` strings.\n *\n * See: {\\@link bypassSanitizationTrustScript} and {\\@link scriptSanitizer}.\n * @record\n */\nfunction TrustedScriptString() { }\nif (false) {\n /* Skipping unnamed member:\n [BRAND]: BypassType.Script;*/\n}\n/**\n * A branded trusted string used with sanitization of `url` strings.\n *\n * See: {\\@link bypassSanitizationTrustUrl} and {\\@link urlSanitizer}.\n * @record\n */\nfunction TrustedUrlString() { }\nif (false) {\n /* Skipping unnamed member:\n [BRAND]: BypassType.Url;*/\n}\n/**\n * A branded trusted string used with sanitization of `resourceUrl` strings.\n *\n * See: {\\@link bypassSanitizationTrustResourceUrl} and {\\@link resourceUrlSanitizer}.\n * @record\n */\nfunction TrustedResourceUrlString() { }\nif (false) {\n /* Skipping unnamed member:\n [BRAND]: BypassType.ResourceUrl;*/\n}\n/**\n * @param {?} value\n * @param {?} type\n * @return {?}\n */\nfunction allowSanitizationBypass(value, type) {\n return (value instanceof String && ((/** @type {?} */ (value)))[BRAND] === type);\n}\n/**\n * Mark `html` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link htmlSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedHtml `html` string which needs to be implicitly trusted.\n * @return {?} a `html` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustHtml(trustedHtml) {\n return bypassSanitizationTrustString(trustedHtml, \"Html\" /* Html */);\n}\n/**\n * Mark `style` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link styleSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedStyle `style` string which needs to be implicitly trusted.\n * @return {?} a `style` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustStyle(trustedStyle) {\n return bypassSanitizationTrustString(trustedStyle, \"Style\" /* Style */);\n}\n/**\n * Mark `script` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link scriptSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedScript `script` string which needs to be implicitly trusted.\n * @return {?} a `script` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustScript(trustedScript) {\n return bypassSanitizationTrustString(trustedScript, \"Script\" /* Script */);\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link urlSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedUrl `url` string which needs to be implicitly trusted.\n * @return {?} a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustUrl(trustedUrl) {\n return bypassSanitizationTrustString(trustedUrl, \"Url\" /* Url */);\n}\n/**\n * Mark `url` string as trusted.\n *\n * This function wraps the trusted string in `String` and brands it in a way which makes it\n * recognizable to {\\@link resourceUrlSanitizer} to be trusted implicitly.\n *\n * @param {?} trustedResourceUrl `url` string which needs to be implicitly trusted.\n * @return {?} a `url` `String` which has been branded to be implicitly trusted.\n */\nfunction bypassSanitizationTrustResourceUrl(trustedResourceUrl) {\n return bypassSanitizationTrustString(trustedResourceUrl, \"ResourceUrl\" /* ResourceUrl */);\n}\n/**\n * @param {?} trustedString\n * @param {?} mode\n * @return {?}\n */\nfunction bypassSanitizationTrustString(trustedString, mode) {\n // tslint:disable-next-line\n /** @type {?} */\n const trusted = (/** @type {?} */ (new String(trustedString)));\n trusted[BRAND] = mode;\n return trusted;\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/**\n * This file is used to control if the default rendering pipeline should be `ViewEngine` or `Ivy`.\n *\n * For more information on how to run and debug tests with either Ivy or View Engine (legacy),\n * please see [BAZEL.md](./docs/BAZEL.md).\n */\nlet _devMode = true;\nlet _runModeLocked = false;\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 * @publicApi\n */\nfunction isDevMode() {\n _runModeLocked = true;\n return _devMode;\n}\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 * @publicApi\n */\nfunction enableProdMode() {\n if (_runModeLocked) {\n throw new Error('Cannot enable prod mode after platform setup.');\n }\n _devMode = false;\n}\n\n/**\n * @fileoverview added by tsickle\n * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc\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 * This helper class is used to get hold of an inert tree of DOM elements containing dirty HTML\n * that needs sanitizing.\n * Depending upon browser support we must use one of three strategies for doing this.\n * Support: Safari 10.x -> XHR strategy\n * Support: Firefox -> DomParser strategy\n * Default: InertDocument strategy\n */\nclass InertBodyHelper {\n /**\n * @param {?} defaultDoc\n */\n constructor(defaultDoc) {\n this.defaultDoc = defaultDoc;\n this.inertDocument = this.defaultDoc.implementation.createHTMLDocument('sanitization-inert');\n this.inertBodyElement = this.inertDocument.body;\n if (this.inertBodyElement == null) {\n // usually there should be only one body element in the document, but IE doesn't have any, so\n // we need to create one.\n /** @type {?} */\n const inertHtml = this.inertDocument.createElement('html');\n this.inertDocument.appendChild(inertHtml);\n this.inertBodyElement = this.inertDocument.createElement('body');\n inertHtml.appendChild(this.inertBodyElement);\n }\n this.inertBodyElement.innerHTML = '';\n if (this.inertBodyElement.querySelector && !this.inertBodyElement.querySelector('svg')) {\n // We just hit the Safari 10.1 bug - which allows JS to run inside the SVG G element\n // so use the XHR strategy.\n this.getInertBodyElement = this.getInertBodyElement_XHR;\n return;\n }\n this.inertBodyElement.innerHTML =\n '