\n \n ","/** PURE_IMPORTS_START tslib,_Scheduler PURE_IMPORTS_END */\nimport * as tslib_1 from \"tslib\";\nimport { Scheduler } from '../Scheduler';\nvar AsyncScheduler = /*@__PURE__*/ (function (_super) {\n tslib_1.__extends(AsyncScheduler, _super);\n function AsyncScheduler(SchedulerAction, now) {\n if (now === void 0) {\n now = Scheduler.now;\n }\n var _this = _super.call(this, SchedulerAction, function () {\n if (AsyncScheduler.delegate && AsyncScheduler.delegate !== _this) {\n return AsyncScheduler.delegate.now();\n }\n else {\n return now();\n }\n }) || this;\n _this.actions = [];\n _this.active = false;\n _this.scheduled = undefined;\n return _this;\n }\n AsyncScheduler.prototype.schedule = function (work, delay, state) {\n if (delay === void 0) {\n delay = 0;\n }\n if (AsyncScheduler.delegate && AsyncScheduler.delegate !== this) {\n return AsyncScheduler.delegate.schedule(work, delay, state);\n }\n else {\n return _super.prototype.schedule.call(this, work, delay, state);\n }\n };\n AsyncScheduler.prototype.flush = function (action) {\n var actions = this.actions;\n if (this.active) {\n actions.push(action);\n return;\n }\n var error;\n this.active = true;\n do {\n if (error = action.execute(action.state, action.delay)) {\n break;\n }\n } while (action = actions.shift());\n this.active = false;\n if (error) {\n while (action = actions.shift()) {\n action.unsubscribe();\n }\n throw error;\n }\n };\n return AsyncScheduler;\n}(Scheduler));\nexport { AsyncScheduler };\n//# sourceMappingURL=AsyncScheduler.js.map\n","/** PURE_IMPORTS_START _multicast,_refCount,_Subject PURE_IMPORTS_END */\nimport { multicast } from './multicast';\nimport { refCount } from './refCount';\nimport { Subject } from '../Subject';\nfunction shareSubjectFactory() {\n return new Subject();\n}\nexport function share() {\n return function (source) { return refCount()(multicast(shareSubjectFactory)(source)); };\n}\n//# sourceMappingURL=share.js.map\n","/**\n * @license Angular v7.1.4\n * (c) 2010-2018 Google, Inc. https://angular.io/\n * License: MIT\n */\n\nimport { __decorate, __metadata, __spread, __extends, __param, __read, __assign, __values } from 'tslib';\nimport { Subject, Subscription, Observable, merge } 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 */\nfunction getClosureSafeProperty(objWithPropertyToExtract) {\n for (var 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 (var 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 */\nvar NG_COMPONENT_DEF = getClosureSafeProperty({ ngComponentDef: getClosureSafeProperty });\nvar NG_DIRECTIVE_DEF = getClosureSafeProperty({ ngDirectiveDef: getClosureSafeProperty });\nvar NG_INJECTABLE_DEF = getClosureSafeProperty({ ngInjectableDef: getClosureSafeProperty });\nvar NG_INJECTOR_DEF = getClosureSafeProperty({ ngInjectorDef: getClosureSafeProperty });\nvar NG_PIPE_DEF = getClosureSafeProperty({ ngPipeDef: getClosureSafeProperty });\nvar NG_MODULE_DEF = getClosureSafeProperty({ ngModuleDef: getClosureSafeProperty });\nvar NG_BASE_DEF = getClosureSafeProperty({ ngBaseDef: getClosureSafeProperty });\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 */\nvar NG_ELEMENT_ID = getClosureSafeProperty({ __NG_ELEMENT_ID__: 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 */\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 * @publicApi\n */\nfunction defineInjectable(opts) {\n return {\n providedIn: opts.providedIn || null, factory: opts.factory, value: undefined,\n };\n}\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` type in a way which is immune to accidentally reading inherited value.\n *\n * @param type type which may have `ngInjectableDef`\n */\nfunction getInjectableDef(type) {\n return type.hasOwnProperty(NG_INJECTABLE_DEF) ? type[NG_INJECTABLE_DEF] : null;\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.hasOwnProperty(NG_INJECTOR_DEF) ? type[NG_INJECTOR_DEF] : null;\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 * 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 * parametrized 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 */\nvar InjectionToken = /** @class */ (function () {\n function InjectionToken(_desc, options) {\n this._desc = _desc;\n /** @internal */\n this.ngMetadataName = 'InjectionToken';\n if (options !== undefined) {\n this.ngInjectableDef = defineInjectable({\n providedIn: options.providedIn || 'root',\n factory: options.factory,\n });\n }\n else {\n this.ngInjectableDef = undefined;\n }\n }\n InjectionToken.prototype.toString = function () { return \"InjectionToken \" + this._desc; };\n return InjectionToken;\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 */\nvar ANNOTATIONS = '__annotations__';\nvar PARAMETERS = '__parameters__';\nvar PROP_METADATA = '__prop__metadata__';\n/**\n * @suppress {globalThis}\n */\nfunction makeDecorator(name, props, parentClass, additionalProcessing, typeFn) {\n var metaCtor = makeMetadataCtor(props);\n function DecoratorFactory() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n var _a;\n if (this instanceof DecoratorFactory) {\n metaCtor.call.apply(metaCtor, __spread([this], args));\n return this;\n }\n var annotationInstance = new ((_a = DecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n return function TypeDecorator(cls) {\n if (typeFn)\n typeFn.apply(void 0, __spread([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 var 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() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n if (props) {\n var values = props.apply(void 0, __spread(args));\n for (var propName in values) {\n this[propName] = values[propName];\n }\n }\n };\n}\nfunction makeParamDecorator(name, props, parentClass) {\n var metaCtor = makeMetadataCtor(props);\n function ParamDecoratorFactory() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n var _a;\n if (this instanceof ParamDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n var annotationInstance = new ((_a = ParamDecoratorFactory).bind.apply(_a, __spread([void 0], 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 var 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 var metaCtor = makeMetadataCtor(props);\n function PropDecoratorFactory() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n var _a;\n if (this instanceof PropDecoratorFactory) {\n metaCtor.apply(this, args);\n return this;\n }\n var decoratorInstance = new ((_a = PropDecoratorFactory).bind.apply(_a, __spread([void 0], args)))();\n function PropDecorator(target, name) {\n var 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 var 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.apply(void 0, __spread([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 * @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 token can be used to create a virtual provider that will populate the\n * `entryComponents` fields of components and ng modules based on its `useValue`.\n * All components that are referenced in the `useValue` value (either directly\n * or in a nested array or map) will be added to the `entryComponents` property.\n *\n * @usageNotes\n * ### Example\n * The following example shows how the router can populate the `entryComponents`\n * field of an NgModule based on the router configuration which refers\n * to components.\n *\n * ```typescript\n * // helper function inside the router\n * function provideRoutes(routes) {\n * return [\n * {provide: ROUTES, useValue: routes},\n * {provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: routes, multi: true}\n * ];\n * }\n *\n * // user code\n * let routes = [\n * {path: '/root', component: RootComp},\n * {path: '/teams', component: TeamsComp}\n * ];\n *\n * @NgModule({\n * providers: [provideRoutes(routes)]\n * })\n * class ModuleWithRoutes {}\n * ```\n *\n * @publicApi\n */\nvar ANALYZE_FOR_ENTRY_COMPONENTS = new InjectionToken('AnalyzeForEntryComponents');\n/**\n * Attribute decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar Attribute = makeParamDecorator('Attribute', function (attributeName) { return ({ attributeName: attributeName }); });\n/**\n * Base class for query metadata.\n *\n * @see `ContentChildren`.\n * @see `ContentChild`.\n * @see `ViewChildren`.\n * @see `ViewChild`.\n *\n * @publicApi\n */\nvar Query = /** @class */ (function () {\n function Query() {\n }\n return Query;\n}());\n/**\n * ContentChildren decorator and metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nvar ContentChildren = makePropDecorator('ContentChildren', function (selector, data) {\n if (data === void 0) { data = {}; }\n return (__assign({ selector: selector, first: false, isViewQuery: false, descendants: false }, data));\n}, Query);\n/**\n * ContentChild decorator and metadata.\n *\n *\n * @Annotation\n * @publicApi\n */\nvar ContentChild = makePropDecorator('ContentChild', function (selector, data) {\n if (data === void 0) { data = {}; }\n return (__assign({ selector: selector, first: true, isViewQuery: false, descendants: true }, data));\n}, Query);\n/**\n * ViewChildren decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar ViewChildren = makePropDecorator('ViewChildren', function (selector, data) {\n if (data === void 0) { data = {}; }\n return (__assign({ selector: selector, first: false, isViewQuery: true, descendants: true }, data));\n}, Query);\n/**\n * ViewChild decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar ViewChild = makePropDecorator('ViewChild', function (selector, data) {\n return (__assign({ selector: selector, first: true, isViewQuery: true, descendants: true }, data));\n}, Query);\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 strategy that the default change detector uses to detect changes.\n * When set, takes effect the next time change detection is triggered.\n *\n * @publicApi\n */\nvar ChangeDetectionStrategy;\n(function (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 explictly invoked.\n */\n ChangeDetectionStrategy[ChangeDetectionStrategy[\"OnPush\"] = 0] = \"OnPush\";\n /**\n * Use the default `CheckAlways` strategy, in which change detection is automatic until\n * explicitly deactivated.\n */\n ChangeDetectionStrategy[ChangeDetectionStrategy[\"Default\"] = 1] = \"Default\";\n})(ChangeDetectionStrategy || (ChangeDetectionStrategy = {}));\n/**\n * Defines the possible states of the default change detector.\n * @see `ChangeDetectorRef`\n */\nvar ChangeDetectorStatus;\n(function (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 ChangeDetectorStatus[ChangeDetectorStatus[\"CheckOnce\"] = 0] = \"CheckOnce\";\n /**\n * A state in which change detection is skipped until the change detector mode\n * becomes `CheckOnce`.\n */\n ChangeDetectorStatus[ChangeDetectorStatus[\"Checked\"] = 1] = \"Checked\";\n /**\n * A state in which change detection continues automatically until explictly\n * deactivated.\n */\n ChangeDetectorStatus[ChangeDetectorStatus[\"CheckAlways\"] = 2] = \"CheckAlways\";\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 ChangeDetectorStatus[ChangeDetectorStatus[\"Detached\"] = 3] = \"Detached\";\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 ChangeDetectorStatus[ChangeDetectorStatus[\"Errored\"] = 4] = \"Errored\";\n /**\n * Indicates that the change detector has been destroyed.\n */\n ChangeDetectorStatus[ChangeDetectorStatus[\"Destroyed\"] = 5] = \"Destroyed\";\n})(ChangeDetectorStatus || (ChangeDetectorStatus = {}));\n/**\n * Reports whether a given strategy is currently the default for change detection.\n * @param changeDetectionStrategy The strategy to check.\n * @returns True if the given strategy is the current default, false otherwise.\n * @see `ChangeDetectorStatus`\n * @see `ChangeDetectorRef`\n */\nfunction isDefaultChangeDetectionStrategy(changeDetectionStrategy) {\n return changeDetectionStrategy == null ||\n changeDetectionStrategy === ChangeDetectionStrategy.Default;\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 * Used to resolve resource URLs on `@Component` when used with JIT compilation.\n *\n * Example:\n * ```\n * @Component({\n * selector: 'my-comp',\n * templateUrl: 'my-comp.html', // This requires asynchronous resolution\n * })\n * class MyComponnent{\n * }\n *\n * // Calling `renderComponent` will fail because `MyComponent`'s `@Compenent.templateUrl`\n * // needs to be resolved because `renderComponent` is synchronous process.\n * // renderComponent(MyComponent);\n *\n * // Calling `resolveComponentResources` will resolve `@Compenent.templateUrl` into\n * // `@Compenent.template`, which would allow `renderComponent` to proceed in synchronous manner.\n * // Use browser's `fetch` function as the default resource resolution strategy.\n * resolveComponentResources(fetch).then(() => {\n * // After resolution all URLs have been converted into strings.\n * renderComponent(MyComponent);\n * });\n *\n * ```\n *\n * NOTE: In AOT the resolution happens during compilation, and so there should be no need\n * to call this method outside JIT mode.\n *\n * @param resourceResolver a function which is responsible to returning a `Promise` of the resolved\n * URL. Browser's `fetch` method is a good default implementation.\n */\nfunction resolveComponentResources(resourceResolver) {\n // Store all promises which are fetching the resources.\n var urlFetches = [];\n // Cache so that we don't fetch the same resource more than once.\n var urlMap = new Map();\n function cachedResourceResolve(url) {\n var promise = urlMap.get(url);\n if (!promise) {\n var resp = resourceResolver(url);\n urlMap.set(url, promise = resp.then(unwrapResponse));\n urlFetches.push(promise);\n }\n return promise;\n }\n componentResourceResolutionQueue.forEach(function (component) {\n if (component.templateUrl) {\n cachedResourceResolve(component.templateUrl).then(function (template) {\n component.template = template;\n component.templateUrl = undefined;\n });\n }\n var styleUrls = component.styleUrls;\n var styles = component.styles || (component.styles = []);\n var styleOffset = component.styles.length;\n styleUrls && styleUrls.forEach(function (styleUrl, index) {\n styles.push(''); // pre-allocate array.\n cachedResourceResolve(styleUrl).then(function (style) {\n styles[styleOffset + index] = style;\n styleUrls.splice(styleUrls.indexOf(styleUrl), 1);\n if (styleUrls.length == 0) {\n component.styleUrls = undefined;\n }\n });\n });\n });\n componentResourceResolutionQueue.clear();\n return Promise.all(urlFetches).then(function () { return null; });\n}\nvar componentResourceResolutionQueue = new Set();\nfunction maybeQueueResolutionOfComponentResources(metadata) {\n if (componentNeedsResolution(metadata)) {\n componentResourceResolutionQueue.add(metadata);\n }\n}\nfunction componentNeedsResolution(component) {\n return component.templateUrl || component.styleUrls && component.styleUrls.length;\n}\nfunction unwrapResponse(response) {\n return typeof response == 'string' ? response : response.text();\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 * Defines template and style encapsulation options available for Component's {@link Component}.\n *\n * See {@link Component#encapsulation encapsulation}.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/ts/metadata/encapsulation.ts region='longform'}\n *\n * @publicApi\n */\nvar ViewEncapsulation;\n(function (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 ViewEncapsulation[ViewEncapsulation[\"Emulated\"] = 0] = \"Emulated\";\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 ViewEncapsulation[ViewEncapsulation[\"Native\"] = 1] = \"Native\";\n /**\n * Don't provide any template or style encapsulation.\n */\n ViewEncapsulation[ViewEncapsulation[\"None\"] = 2] = \"None\";\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 ViewEncapsulation[ViewEncapsulation[\"ShadowDom\"] = 3] = \"ShadowDom\";\n})(ViewEncapsulation || (ViewEncapsulation = {}));\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 __window = typeof window !== 'undefined' && window;\nvar __self = typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined' &&\n self instanceof WorkerGlobalScope && self;\nvar __global = typeof global !== 'undefined' && global;\n// Check __global first, because in Node tests both __global and __window may be defined and _global\n// should be __global in that case.\nvar _global = __global || __window || __self;\nvar promise = Promise.resolve(0);\nvar _symbolIterator = null;\nfunction getSymbolIterator() {\n if (!_symbolIterator) {\n var Symbol_1 = _global['Symbol'];\n if (Symbol_1 && Symbol_1.iterator) {\n _symbolIterator = Symbol_1.iterator;\n }\n else {\n // es6-shim specific logic\n var keys = Object.getOwnPropertyNames(Map.prototype);\n for (var i = 0; i < keys.length; ++i) {\n var key = keys[i];\n if (key !== 'entries' && key !== 'size' &&\n Map.prototype[key] === Map.prototype['entries']) {\n _symbolIterator = key;\n }\n }\n }\n }\n return _symbolIterator;\n}\nfunction scheduleMicroTask(fn) {\n if (typeof Zone === 'undefined') {\n // use promise to schedule microTask instead of use Zone\n promise.then(function () { fn && fn.apply(null, null); });\n }\n else {\n Zone.current.scheduleMicroTask('scheduleMicrotask', fn);\n }\n}\n// JS has NaN !== NaN\nfunction looseIdentical(a, b) {\n return a === b || typeof a === 'number' && typeof b === 'number' && isNaN(a) && isNaN(b);\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 var res = token.toString();\n if (res == null) {\n return '' + res;\n }\n var newLineIndex = res.indexOf('\\n');\n return newLineIndex === -1 ? res : res.substring(0, newLineIndex);\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 * @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 var newCounters = {\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 rendererCreateComment: 0,\n };\n // NOTE: Under Ivy we may have both window & global defined in the Node\n // environment since ensureDocument() in render3.ts sets global.window.\n if (typeof window != 'undefined') {\n // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.\n window['ngDevMode'] = newCounters;\n }\n if (typeof global != 'undefined') {\n // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.\n global['ngDevMode'] = newCounters;\n }\n if (typeof self != 'undefined') {\n // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.\n self['ngDevMode'] = newCounters;\n }\n return newCounters;\n}\n/**\n * This checks to see if the `ngDevMode` has been set. If yes,\n * than 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 */\nif (typeof ngDevMode === 'undefined' || ngDevMode) {\n ngDevModeResetPerfCounters();\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 */\nvar EMPTY = {};\nvar EMPTY_ARRAY = [];\nif (typeof ngDevMode !== 'undefined' && ngDevMode) {\n Object.freeze(EMPTY);\n Object.freeze(EMPTY_ARRAY);\n}\nvar _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 */\nfunction defineComponent(componentDefinition) {\n var type = componentDefinition.type;\n var typePrototype = type.prototype;\n var declaredInputs = {};\n var def = {\n type: type,\n providersResolver: null,\n consts: componentDefinition.consts,\n vars: componentDefinition.vars,\n hostVars: componentDefinition.hostVars || 0,\n factory: componentDefinition.factory,\n template: componentDefinition.template || null,\n hostBindings: componentDefinition.hostBindings || null,\n contentQueries: componentDefinition.contentQueries || null,\n contentQueriesRefresh: componentDefinition.contentQueriesRefresh || null,\n attributes: componentDefinition.attributes || null,\n declaredInputs: declaredInputs,\n inputs: null,\n outputs: null,\n exportAs: componentDefinition.exportAs || 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: null,\n pipeDefs: null,\n selectors: componentDefinition.selectors,\n viewQuery: componentDefinition.viewQuery || null,\n features: 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 _: null,\n };\n def._ = noSideEffects(function () {\n var directiveTypes = componentDefinition.directives;\n var feature = componentDefinition.features;\n var pipeTypes = componentDefinition.pipes;\n def.id += _renderCompCount++;\n def.inputs = invertObject(componentDefinition.inputs, declaredInputs),\n def.outputs = invertObject(componentDefinition.outputs),\n feature && feature.forEach(function (fn) { return fn(def); });\n def.directiveDefs = directiveTypes ?\n function () { return (typeof directiveTypes === 'function' ? directiveTypes() : directiveTypes)\n .map(extractDirectiveDef); } :\n null;\n def.pipeDefs = pipeTypes ?\n function () { return (typeof pipeTypes === 'function' ? pipeTypes() : pipeTypes).map(extractPipeDef); } :\n null;\n });\n return def;\n}\nfunction extractDirectiveDef(type) {\n var def = getComponentDef(type) || getDirectiveDef(type);\n if (ngDevMode && !def) {\n throw new Error(\"'\" + type.name + \"' is neither 'ComponentType' or 'DirectiveType'.\");\n }\n return def;\n}\nfunction extractPipeDef(type) {\n var def = getPipeDef(type);\n if (ngDevMode && !def) {\n throw new Error(\"'\" + type.name + \"' is not a 'PipeType'.\");\n }\n return def;\n}\nfunction defineNgModule(def) {\n var 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 };\n return res;\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('publicName')\n * propName2: number;\n * }\n * ```\n *\n * will be serialized as\n *\n * ```\n * {\n * a0: 'propName1',\n * b1: ['publicName', 'propName2'],\n * }\n * ```\n *\n * becomes\n *\n * ```\n * {\n * 'propName1': 'a0',\n * 'publicName': 'b1'\n * }\n * ```\n *\n * Optionally the function can take `secondary` which will result in:\n *\n * ```\n * {\n * 'propName1': 'a0',\n * 'propName2': 'b1'\n * }\n * ```\n *\n\n */\nfunction invertObject(obj, secondary) {\n if (obj == null)\n return EMPTY;\n var newLookup = {};\n for (var minifiedKey in obj) {\n if (obj.hasOwnProperty(minifiedKey)) {\n var publicName = obj[minifiedKey];\n var 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[declaredName] = minifiedKey);\n }\n }\n }\n return newLookup;\n}\n/**\n * Create a base definition\n *\n * # Example\n * ```\n * class ShouldBeInherited {\n * static ngBaseDef = defineBase({\n * ...\n * })\n * }\n * @param baseDefinition The base definition parameters\n */\nfunction defineBase(baseDefinition) {\n var declaredInputs = {};\n return {\n inputs: invertObject(baseDefinition.inputs, declaredInputs),\n declaredInputs: declaredInputs,\n outputs: invertObject(baseDefinition.outputs),\n };\n}\n/**\n * Create a directive definition object.\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 ngDirectiveDef = defineDirective({\n * ...\n * });\n * }\n * ```\n */\nvar defineDirective = 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 * @param pipeDef Pipe definition generated by the compiler\n */\nfunction definePipe(pipeDef) {\n return {\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 */\nfunction getComponentDef(type) {\n return type[NG_COMPONENT_DEF] || null;\n}\nfunction getDirectiveDef(type) {\n return type[NG_DIRECTIVE_DEF] || null;\n}\nfunction getPipeDef(type) {\n return type[NG_PIPE_DEF] || null;\n}\nfunction getNgModuleDef(type) {\n return type[NG_MODULE_DEF] || null;\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 */\nvar R3ResolvedDependencyType;\n(function (R3ResolvedDependencyType) {\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"Token\"] = 0] = \"Token\";\n R3ResolvedDependencyType[R3ResolvedDependencyType[\"Attribute\"] = 1] = \"Attribute\";\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 var 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 * @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 * Inject decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar Inject = makeParamDecorator('Inject', function (token) { return ({ token: token }); });\n/**\n * Optional decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar Optional = makeParamDecorator('Optional');\n/**\n * Self decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar Self = makeParamDecorator('Self');\n/**\n * SkipSelf decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar SkipSelf = makeParamDecorator('SkipSelf');\n/**\n * Host decorator and metadata.\n *\n * @Annotation\n * @publicApi\n */\nvar Host = makeParamDecorator('Host');\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 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 descend into 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 * 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 */\nvar _currentInjector = undefined;\nfunction setCurrentInjector(injector) {\n var 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 */\nvar _injectImplementation;\n/**\n * Sets the current inject implementation.\n */\nfunction setInjectImplementation(impl) {\n var previous = _injectImplementation;\n _injectImplementation = impl;\n return previous;\n}\nfunction injectInjectorOnly(token, flags) {\n if (flags === void 0) { 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}\nfunction inject(token, flags) {\n if (flags === void 0) { flags = InjectFlags.Default; }\n return (_injectImplementation || injectInjectorOnly)(token, flags);\n}\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 */\nfunction injectRootLimpMode(token, notFoundValue, flags) {\n var 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}\nfunction injectArgs(types) {\n var args = [];\n for (var i = 0; i < types.length; i++) {\n var arg = types[i];\n if (Array.isArray(arg)) {\n if (arg.length === 0) {\n throw new Error('Arguments array must have arguments.');\n }\n var type = undefined;\n var flags = InjectFlags.Default;\n for (var j = 0; j < arg.length; j++) {\n var meta = arg[j];\n if (meta instanceof Optional || meta.ngMetadataName === 'Optional') {\n flags |= InjectFlags.Optional;\n }\n else if (meta instanceof SkipSelf || meta.ngMetadataName === 'SkipSelf') {\n flags |= InjectFlags.SkipSelf;\n }\n else if (meta instanceof Self || meta.ngMetadataName === 'Self') {\n flags |= InjectFlags.Self;\n }\n else if (meta instanceof Inject) {\n type = meta.token;\n }\n else {\n type = meta;\n }\n }\n args.push(inject(type, flags));\n }\n else {\n args.push(inject(arg));\n }\n }\n return args;\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 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 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 assertDefined(actual, msg) {\n if (actual == null) {\n throwError(msg);\n }\n}\nfunction assertComponentType(actual, msg) {\n if (msg === void 0) { msg = 'Type passed in is not ComponentType, it does not have \\'ngComponentDef\\' property.'; }\n if (!getComponentDef(actual)) {\n throwError(msg);\n }\n}\nfunction assertNgModuleType(actual, msg) {\n if (msg === void 0) { msg = 'Type passed in is not NgModuleType, it does not have \\'ngModuleDef\\' property.'; }\n if (!getNgModuleDef(actual)) {\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}\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 TNODE = 8;\nvar PARENT_INJECTOR = 8;\nvar INJECTOR_SIZE = 9;\nvar NO_PARENT_INJECTOR = -1;\n/**\n * Each injector is saved in 9 contiguous slots in `LViewData` 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 `LViewData`).\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 `LViewData` 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*/\nvar NodeInjectorFactory = /** @class */ (function () {\n function NodeInjectorFactory(\n /**\n * Factory to invoke in order to create a new instance.\n */\n 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 return NodeInjectorFactory;\n}());\nvar FactoryPrototype = NodeInjectorFactory.prototype;\nfunction isFactory(obj) {\n // See: https://jsperf.com/instanceof-vs-getprototypeof\n return obj != null && typeof obj == 'object' && Object.getPrototypeOf(obj) == FactoryPrototype;\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/** Size of LViewData's header. Necessary to adjust for it when setting slots. */\nvar HEADER_OFFSET = 17;\n// Below are constants for LViewData indices to help us look up LViewData members\n// without having to remember the specific indices.\n// Uglify will inline these when minifying so there shouldn't be a cost.\nvar TVIEW = 0;\nvar FLAGS = 1;\nvar PARENT = 2;\nvar NEXT = 3;\nvar QUERIES = 4;\nvar HOST = 5;\nvar HOST_NODE = 6;\nvar BINDING_INDEX = 7;\nvar CLEANUP = 8;\nvar CONTEXT = 9;\nvar INJECTOR = 10;\nvar RENDERER = 11;\nvar SANITIZER = 12;\nvar TAIL = 13;\nvar CONTAINER_INDEX = 14;\nvar CONTENT_QUERIES = 15;\nvar DECLARATION_VIEW = 16;\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 assertNodeType(tNode, type) {\n assertDefined(tNode, 'should be called with a TNode');\n assertEqual(tNode.type, type, \"should be a \" + typeName(type));\n}\nfunction assertNodeOfPossibleTypes(tNode) {\n var types = [];\n for (var _i = 1; _i < arguments.length; _i++) {\n types[_i - 1] = arguments[_i];\n }\n assertDefined(tNode, 'should be called with a TNode');\n var found = types.some(function (type) { return tNode.type === type; });\n assertEqual(found, true, \"Should be one of \" + types.map(typeName).join(', ') + \" but got \" + typeName(tNode.type));\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 * @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 * If this is the first template pass, any ngOnInit or ngDoCheck hooks will be queued into\n * TView.initHooks during directiveCreate.\n *\n * The directive index and hook type are encoded into one number (1st bit: type, remaining bits:\n * directive index), then saved in the even indices of the initHooks array. The odd indices\n * hold the hook functions themselves.\n *\n * @param index The index of the directive in LViewData\n * @param hooks The static hooks map on the directive def\n * @param tView The current TView\n */\nfunction queueInitHooks(index, onInit, doCheck, tView) {\n ngDevMode &&\n assertEqual(tView.firstTemplatePass, true, 'Should only be called on first template pass');\n if (onInit) {\n (tView.initHooks || (tView.initHooks = [])).push(index, onInit);\n }\n if (doCheck) {\n (tView.initHooks || (tView.initHooks = [])).push(index, doCheck);\n (tView.checkHooks || (tView.checkHooks = [])).push(index, doCheck);\n }\n}\n/**\n * Loops through the directives on a node and queues all their hooks except ngOnInit\n * and ngDoCheck, which are queued separately in directiveCreate.\n */\nfunction queueLifecycleHooks(flags, tView) {\n if (tView.firstTemplatePass) {\n var start = flags >> 16 /* DirectiveStartingIndexShift */;\n var count = flags & 4095 /* DirectiveCountMask */;\n var end = start + count;\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 (var i = start; i < end; i++) {\n var def = tView.data[i];\n queueContentHooks(def, tView, i);\n queueViewHooks(def, tView, i);\n queueDestroyHooks(def, tView, i);\n }\n }\n}\n/** Queues afterContentInit and afterContentChecked hooks on TView */\nfunction queueContentHooks(def, tView, i) {\n if (def.afterContentInit) {\n (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentInit);\n }\n if (def.afterContentChecked) {\n (tView.contentHooks || (tView.contentHooks = [])).push(i, def.afterContentChecked);\n (tView.contentCheckHooks || (tView.contentCheckHooks = [])).push(i, def.afterContentChecked);\n }\n}\n/** Queues afterViewInit and afterViewChecked hooks on TView */\nfunction queueViewHooks(def, tView, i) {\n if (def.afterViewInit) {\n (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewInit);\n }\n if (def.afterViewChecked) {\n (tView.viewHooks || (tView.viewHooks = [])).push(i, def.afterViewChecked);\n (tView.viewCheckHooks || (tView.viewCheckHooks = [])).push(i, def.afterViewChecked);\n }\n}\n/** Queues onDestroy hooks on TView */\nfunction queueDestroyHooks(def, tView, i) {\n if (def.onDestroy != null) {\n (tView.destroyHooks || (tView.destroyHooks = [])).push(i, def.onDestroy);\n }\n}\n/**\n * Calls onInit and doCheck calls if they haven't already been called.\n *\n * @param currentView The current view\n */\nfunction executeInitHooks(currentView, tView, creationMode) {\n if (currentView[FLAGS] & 16 /* RunInit */) {\n executeHooks(currentView, tView.initHooks, tView.checkHooks, creationMode);\n currentView[FLAGS] &= ~16 /* RunInit */;\n }\n}\n/**\n * Iterates over afterViewInit and afterViewChecked functions and calls them.\n *\n * @param currentView The current view\n */\nfunction executeHooks(data, allHooks, checkHooks, creationMode) {\n var hooksToCall = creationMode ? allHooks : checkHooks;\n if (hooksToCall) {\n callHooks(data, hooksToCall);\n }\n}\n/**\n * Calls lifecycle hooks with their contexts, skipping init hooks if it's not\n * creation mode.\n *\n * @param currentView The current view\n * @param arr The array in which the hooks are found\n */\nfunction callHooks(currentView, arr) {\n for (var i = 0; i < arr.length; i += 2) {\n arr[i + 1].call(currentView[arr[i]]);\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 devModeEqual(a, b) {\n var isListLikeIterableA = isListLikeIterable(a);\n var isListLikeIterableB = isListLikeIterable(b);\n if (isListLikeIterableA && isListLikeIterableB) {\n return areIterablesEqual(a, b, devModeEqual);\n }\n else {\n var isAObject = a && (typeof a === 'object' || typeof a === 'function');\n var isBObject = b && (typeof b === 'object' || typeof b === 'function');\n if (!isListLikeIterableA && isAObject && !isListLikeIterableB && isBObject) {\n return true;\n }\n else {\n return looseIdentical(a, b);\n }\n }\n}\n/**\n * Indicates that the result of a {@link Pipe} transformation has changed even though the\n * reference has not changed.\n *\n * Wrapped values are unwrapped automatically during the change detection, and the unwrapped value\n * is stored.\n *\n * Example:\n *\n * ```\n * if (this._latestValue === this._latestReturnedValue) {\n * return this._latestReturnedValue;\n * } else {\n * this._latestReturnedValue = this._latestValue;\n * return WrappedValue.wrap(this._latestValue); // this will force update\n * }\n * ```\n *\n * @publicApi\n */\nvar WrappedValue = /** @class */ (function () {\n function WrappedValue(value) {\n this.wrapped = value;\n }\n /** Creates a wrapped value. */\n WrappedValue.wrap = function (value) { return new WrappedValue(value); };\n /**\n * Returns the underlying value of a wrapped value.\n * Returns the given `value` when it is not wrapped.\n **/\n WrappedValue.unwrap = function (value) { return WrappedValue.isWrapped(value) ? value.wrapped : value; };\n /** Returns true if `value` is a wrapped value. */\n WrappedValue.isWrapped = function (value) { return value instanceof WrappedValue; };\n return WrappedValue;\n}());\n/**\n * Represents a basic change from a previous to a new value.\n *\n * @publicApi\n */\nvar SimpleChange = /** @class */ (function () {\n function SimpleChange(previousValue, currentValue, firstChange) {\n this.previousValue = previousValue;\n this.currentValue = currentValue;\n this.firstChange = firstChange;\n }\n /**\n * Check whether the new value is the first value assigned.\n */\n SimpleChange.prototype.isFirstChange = function () { return this.firstChange; };\n return SimpleChange;\n}());\nfunction isListLikeIterable(obj) {\n if (!isJsObject(obj))\n return false;\n return Array.isArray(obj) ||\n (!(obj instanceof Map) && // JS Map are iterables but return entries as [k, v]\n getSymbolIterator() in obj); // JS Iterable have a Symbol.iterator prop\n}\nfunction areIterablesEqual(a, b, comparator) {\n var iterator1 = a[getSymbolIterator()]();\n var iterator2 = b[getSymbolIterator()]();\n while (true) {\n var item1 = iterator1.next();\n var item2 = iterator2.next();\n if (item1.done && item2.done)\n return true;\n if (item1.done || item2.done)\n return false;\n if (!comparator(item1.value, item2.value))\n return false;\n }\n}\nfunction iterateListLike(obj, fn) {\n if (Array.isArray(obj)) {\n for (var i = 0; i < obj.length; i++) {\n fn(obj[i]);\n }\n }\n else {\n var iterator = obj[getSymbolIterator()]();\n var item = void 0;\n while (!((item = iterator.next()).done)) {\n fn(item.value);\n }\n }\n}\nfunction isJsObject(o) {\n return o !== null && (typeof o === 'function' || typeof o === 'object');\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 * 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 */\nvar ACTIVE_INDEX = 0;\nvar VIEWS = 1;\n// PARENT, NEXT, QUERIES, and HOST are indices 2, 3, 4, and 5.\n// As we already have these constants in LViewData, we don't need to re-create them.\nvar NATIVE = 6;\nvar RENDER_PARENT = 7;\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 */\nvar MONKEY_PATCH_KEY_NAME = '__ngContext__';\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 * 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 */\nfunction isDifferent(a, b, checkNoChangesMode) {\n if (ngDevMode && checkNoChangesMode) {\n return !devModeEqual(a, b);\n }\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}\nfunction stringify$1(value) {\n if (typeof value == 'function')\n return value.name || value;\n if (typeof value == 'string')\n return value;\n if (value == null)\n return '';\n return '' + value;\n}\n/**\n * Flattens an array in non-recursive way. Input arrays are not modified.\n */\nfunction flatten(list) {\n var result = [];\n var i = 0;\n while (i < list.length) {\n var item = list[i];\n if (Array.isArray(item)) {\n if (item.length > 0) {\n list = item.concat(list.slice(i + 1));\n i = 0;\n }\n else {\n i++;\n }\n }\n else {\n result.push(item);\n i++;\n }\n }\n return result;\n}\n/** Retrieves a value from any `LViewData` or `TData`. */\nfunction loadInternal(index, arr) {\n ngDevMode && assertDataInRangeInternal(index + HEADER_OFFSET, arr);\n return arr[index + HEADER_OFFSET];\n}\nfunction assertDataInRangeInternal(index, arr) {\n assertLessThan(index, arr ? arr.length : 0, 'index expected to be a valid data index');\n}\n/**\n * Takes the value of a slot in `LViewData` and returns the element node.\n *\n * Normally, element nodes are stored flat, but if the node has styles/classes on it,\n * it might be wrapped in a styling context. Or if that node has a directive that injects\n * ViewContainerRef, it may be wrapped in an LContainer. Or if that node is a component,\n * it will be wrapped in LViewData. It could even have all three, so we keep looping\n * until we find something that isn't an array.\n *\n * @param value The initial value in `LViewData`\n */\nfunction readElementValue(value) {\n while (Array.isArray(value)) {\n value = value[HOST];\n }\n return value;\n}\n/**\n * Retrieves an element value from the provided `viewData`, by unwrapping\n * from any containers, component views, or style contexts.\n */\nfunction getNativeByIndex(index, arr) {\n return readElementValue(arr[index + HEADER_OFFSET]);\n}\nfunction getNativeByTNode(tNode, hostView) {\n return readElementValue(hostView[tNode.index]);\n}\nfunction getTNode(index, view) {\n return view[TVIEW].data[index + HEADER_OFFSET];\n}\nfunction getComponentViewByIndex(nodeIndex, hostView) {\n // Could be an LViewData or an LContainer. If LContainer, unwrap to find LViewData.\n var slotValue = hostView[nodeIndex];\n return slotValue.length >= HEADER_OFFSET ? slotValue : slotValue[HOST];\n}\nfunction isContentQueryHost(tNode) {\n return (tNode.flags & 16384 /* hasContentQuery */) !== 0;\n}\nfunction isComponent(tNode) {\n return (tNode.flags & 4096 /* isComponent */) === 4096 /* isComponent */;\n}\nfunction isComponentDef(def) {\n return def.template !== null;\n}\nfunction isLContainer(value) {\n // Styling contexts are also arrays, but their first index contains an element node\n return Array.isArray(value) && typeof value[ACTIVE_INDEX] === 'number';\n}\nfunction isRootView(target) {\n return (target[FLAGS] & 64 /* IsRoot */) !== 0;\n}\n/**\n * Retrieve the root view from any component by walking the parent `LViewData` until\n * reaching the root `LViewData`.\n *\n * @param component any component\n */\nfunction getRootView(target) {\n ngDevMode && assertDefined(target, 'component');\n var lViewData = Array.isArray(target) ? target : readPatchedLViewData(target);\n while (lViewData && !(lViewData[FLAGS] & 64 /* IsRoot */)) {\n lViewData = lViewData[PARENT];\n }\n return lViewData;\n}\nfunction getRootContext(viewOrComponent) {\n var rootView = getRootView(viewOrComponent);\n ngDevMode &&\n assertDefined(rootView[CONTEXT], 'RootView has no context. Perhaps it is disconnected?');\n return rootView[CONTEXT];\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 */\nfunction readPatchedData(target) {\n return target[MONKEY_PATCH_KEY_NAME];\n}\nfunction readPatchedLViewData(target) {\n var value = readPatchedData(target);\n if (value) {\n return Array.isArray(value) ? value : value.lViewData;\n }\n return null;\n}\nfunction hasParentInjector(parentLocation) {\n return parentLocation !== NO_PARENT_INJECTOR;\n}\nfunction getParentInjectorIndex(parentLocation) {\n return parentLocation & 32767 /* InjectorIndexMask */;\n}\nfunction getParentInjectorViewOffset(parentLocation) {\n return 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 LViewData instance from which to start walking up the view tree\n * @returns The LViewData instance that contains the parent injector\n */\nfunction getParentInjectorView(location, startView) {\n var viewOffset = getParentInjectorViewOffset(location);\n var 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 = parentView[DECLARATION_VIEW];\n viewOffset--;\n }\n return parentView;\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 TNode of the parent injector is found.\n *\n * @param location The location of the parent injector, which contains the view offset\n * @param startView The LViewData instance from which to start walking up the view tree\n * @param startTNode The TNode instance of the starting element\n * @returns The TNode of the parent injector\n */\nfunction getParentInjectorTNode(location, startView, startTNode) {\n if (startTNode.parent && startTNode.parent.injectorIndex !== -1) {\n // view offset is 0\n var injectorIndex = startTNode.parent.injectorIndex;\n var parentTNode_1 = startTNode.parent;\n while (parentTNode_1.parent != null && injectorIndex == parentTNode_1.injectorIndex) {\n parentTNode_1 = parentTNode_1.parent;\n }\n return parentTNode_1;\n }\n var viewOffset = getParentInjectorViewOffset(location);\n // view offset is 1\n var parentView = startView;\n var parentTNode = startView[HOST_NODE];\n // view offset is superior to 1\n while (viewOffset > 1) {\n parentView = parentView[DECLARATION_VIEW];\n parentTNode = parentView[HOST_NODE];\n viewOffset--;\n }\n return parentTNode;\n}\nvar defaultScheduler = (typeof requestAnimationFrame !== 'undefined' && requestAnimationFrame || // browser only\n setTimeout // everything else\n).bind(_global);\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 (var i = 0; i < items.length; i++) {\n arr.push(items[i]);\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 * This property gets set before entering a template.\n *\n * This renderer can be one of two varieties of Renderer3:\n *\n * - ObjectedOrientedRenderer3\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 (reducing payload\n * size).\n *\n * - ProceduralRenderer3\n *\n * In non-native browser environments (e.g. platforms such as web-workers), this is the facade\n * that enables element manipulation. This also facilitates backwards compatibility with\n * Renderer2.\n */\nvar renderer;\nfunction getRenderer() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return renderer;\n}\nvar rendererFactory;\nfunction getRendererFactory() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return rendererFactory;\n}\nfunction setRendererFactory(factory) {\n rendererFactory = factory;\n}\nfunction getCurrentSanitizer() {\n return viewData && viewData[SANITIZER];\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 `LViewData` to only those elements.\n */\nvar elementDepthCount;\nfunction getElementDepthCount() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return elementDepthCount;\n}\nfunction increaseElementDepthCount() {\n elementDepthCount++;\n}\nfunction decreaseElementDepthCount() {\n elementDepthCount--;\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 */\nvar bindingsEnabled;\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 */\nfunction disableBindings() {\n bindingsEnabled = false;\n}\n/**\n * Returns the current OpaqueViewState instance.\n *\n * Used in conjunction with the restoreView() 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 */\nfunction getCurrentView() {\n return viewData;\n}\nfunction _getViewData() {\n return viewData;\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 * @param viewToRestore The OpaqueViewState instance to restore.\n */\nfunction restoreView(viewToRestore) {\n contextViewData = viewToRestore;\n}\n/** Used to set the parent property when nodes are created and track query results. */\nvar previousOrParentTNode;\nfunction getPreviousOrParentTNode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return previousOrParentTNode;\n}\nfunction setPreviousOrParentTNode(tNode) {\n previousOrParentTNode = tNode;\n}\nfunction setTNodeAndViewData(tNode, view) {\n previousOrParentTNode = tNode;\n viewData = 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 */\nvar isParent;\nfunction getIsParent() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return isParent;\n}\nfunction setIsParent(value) {\n isParent = value;\n}\nvar tView;\nfunction getTView() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return tView;\n}\nvar currentQueries;\nfunction getCurrentQueries() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return currentQueries;\n}\nfunction setCurrentQueries(queries) {\n currentQueries = queries;\n}\n/**\n * Query instructions can ask for \"current queries\" in 2 different cases:\n * - when creating view queries (at the root of a component view, before any node is created - in\n * this case currentQueries points to view queries)\n * - when creating content queries (i.e. this previousOrParentTNode points to a node on which we\n * create content queries).\n */\nfunction getOrCreateCurrentQueries(QueryType) {\n // if this is the first content query on a node, any existing LQueries needs to be cloned\n // in subsequent template passes, the cloning occurs before directive instantiation.\n if (previousOrParentTNode && previousOrParentTNode !== viewData[HOST_NODE] &&\n !isContentQueryHost(previousOrParentTNode)) {\n currentQueries && (currentQueries = currentQueries.clone());\n previousOrParentTNode.flags |= 16384 /* hasContentQuery */;\n }\n return currentQueries || (currentQueries = new QueryType(null, null, null));\n}\n/**\n * This property gets set before entering a template.\n */\nvar creationMode;\nfunction getCreationMode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return 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 */\nvar viewData;\n/**\n * Internal function that returns the current LViewData instance.\n *\n * The getCurrentView() instruction should be used for anything public.\n */\nfunction getViewData() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return viewData;\n}\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 */\nvar contextViewData = null;\nfunction getContextViewData() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return contextViewData;\n}\nfunction getCleanup(view) {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return view[CLEANUP] || (view[CLEANUP] = []);\n}\nfunction getTViewCleanup(view) {\n return view[TVIEW].cleanup || (view[TVIEW].cleanup = []);\n}\n/**\n * In this mode, any changes in bindings will throw an ExpressionChangedAfterChecked error.\n *\n * Necessary to support ChangeDetectorRef.checkNoChanges().\n */\nvar checkNoChangesMode = false;\nfunction getCheckNoChangesMode() {\n // top level variables should not be exported for performance reasons (PERF_NOTES.md)\n return checkNoChangesMode;\n}\nfunction setCheckNoChangesMode(mode) {\n checkNoChangesMode = mode;\n}\n/** Whether or not this is the first time the current view has been processed. */\nvar firstTemplatePass = true;\nfunction getFirstTemplatePass() {\n return firstTemplatePass;\n}\nfunction setFirstTemplatePass(value) {\n firstTemplatePass = value;\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 */\nvar bindingRootIndex = -1;\n// top level variables should not be exported for performance reasons (PERF_NOTES.md)\nfunction getBindingRoot() {\n return bindingRootIndex;\n}\nfunction setBindingRoot(value) {\n bindingRootIndex = 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 host Element to which the View is a child of\n * @returns the previous state;\n */\nfunction enterView(newView, hostTNode) {\n var oldView = viewData;\n tView = newView && newView[TVIEW];\n creationMode = newView && (newView[FLAGS] & 1 /* CreationMode */) === 1 /* CreationMode */;\n firstTemplatePass = newView && tView.firstTemplatePass;\n bindingRootIndex = newView && tView.bindingStartIndex;\n renderer = newView && newView[RENDERER];\n previousOrParentTNode = hostTNode;\n isParent = true;\n viewData = contextViewData = newView;\n oldView && (oldView[QUERIES] = currentQueries);\n currentQueries = newView && newView[QUERIES];\n return oldView;\n}\nfunction nextContextImpl(level) {\n if (level === void 0) { level = 1; }\n contextViewData = walkUpViews(level, contextViewData);\n return contextViewData[CONTEXT];\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 = currentView[DECLARATION_VIEW];\n nestingLevel--;\n }\n return currentView;\n}\n/**\n * Resets the application state.\n */\nfunction resetComponentState() {\n isParent = false;\n previousOrParentTNode = null;\n elementDepthCount = 0;\n bindingsEnabled = true;\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 creationOnly An optional boolean to indicate that the view was processed in creation mode\n * only, i.e. the first update will be done later. Only possible for dynamically created views.\n */\nfunction leaveView(newView, creationOnly) {\n if (!creationOnly) {\n if (!checkNoChangesMode) {\n executeHooks(viewData, tView.viewHooks, tView.viewCheckHooks, creationMode);\n }\n // Views are clean and in update mode after being checked, so these bits are cleared\n viewData[FLAGS] &= ~(1 /* CreationMode */ | 4 /* Dirty */);\n }\n viewData[FLAGS] |= 16 /* RunInit */;\n viewData[BINDING_INDEX] = tView.bindingStartIndex;\n enterView(newView, null);\n}\nfunction assertPreviousIsParent() {\n assertEqual(isParent, true, 'previousOrParentTNode should be a parent');\n}\nfunction assertHasParent() {\n assertDefined(previousOrParentTNode.parent, 'previousOrParentTNode should have a parent');\n}\nfunction assertDataInRange(index, arr) {\n if (arr == null)\n arr = viewData;\n assertDataInRangeInternal(index, arr || viewData);\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 * 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 */\nvar includeViewProviders = false;\nfunction setIncludeViewProviders(v) {\n var 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 */\nvar BLOOM_SIZE = 256;\nvar BLOOM_MASK = BLOOM_SIZE - 1;\n/** Counter used to generate unique IDs for directives. */\nvar 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 */\nfunction bloomAdd(injectorIndex, tView, type) {\n ngDevMode && assertEqual(tView.firstTemplatePass, true, 'expected firstTemplatePass to be true');\n var id = type[NG_ELEMENT_ID];\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[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 var 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 var 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 var b7 = bloomBit & 0x80;\n var b6 = bloomBit & 0x40;\n var b5 = bloomBit & 0x20;\n var tData = 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 * @returns Node injector\n */\nfunction getOrCreateNodeInjectorForNode(tNode, hostView) {\n var existingInjectorIndex = getInjectorIndex(tNode, hostView);\n if (existingInjectorIndex !== -1) {\n return existingInjectorIndex;\n }\n var 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 === 4096 /* isComponent */, true, 'expected tNode.flags to not be initialized');\n }\n var parentLoc = getParentInjectorLocation(tNode, hostView);\n var parentIndex = getParentInjectorIndex(parentLoc);\n var parentView = getParentInjectorView(parentLoc, hostView);\n var 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 var parentData = parentView[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 (var i = 0; i < 8; i++) {\n hostView[injectorIndex + i] = parentView[parentIndex + i] | parentData[parentIndex + i];\n }\n }\n hostView[injectorIndex + PARENT_INJECTOR] = parentLoc;\n return injectorIndex;\n}\nfunction insertBloom(arr, footer) {\n arr.push(0, 0, 0, 0, 0, 0, 0, 0, footer);\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 */\nfunction getParentInjectorLocation(tNode, view) {\n if (tNode.parent && tNode.parent.injectorIndex !== -1) {\n return tNode.parent.injectorIndex; // ViewOffset is 0, AcrossHostBoundary 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 var hostTNode = view[HOST_NODE];\n var viewOffset = 1;\n while (hostTNode && hostTNode.injectorIndex === -1) {\n view = view[DECLARATION_VIEW];\n hostTNode = view[HOST_NODE];\n viewOffset++;\n }\n var acrossHostBoundary = hostTNode && hostTNode.type === 3 /* Element */ ?\n 32768 /* AcrossHostBoundary */ :\n 0;\n return hostTNode ?\n hostTNode.injectorIndex | (viewOffset << 16 /* ViewOffsetShift */) |\n acrossHostBoundary :\n -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 di The node injector in which a directive will be added\n * @param token The type or the injection token to be made public\n */\nfunction diPublicInInjector(injectorIndex, view, token) {\n bloomAdd(injectorIndex, view[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 */\nfunction injectAttributeImpl(tNode, attrNameToInject) {\n ngDevMode && assertNodeOfPossibleTypes(tNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */);\n ngDevMode && assertDefined(tNode, 'expecting tNode');\n var attrs = tNode.attrs;\n if (attrs) {\n for (var i = 0; i < attrs.length; i = i + 2) {\n var attrName = attrs[i];\n if (attrName === 1 /* SelectOnly */)\n break;\n if (attrName == attrNameToInject) {\n return attrs[i + 1];\n }\n }\n }\n return undefined;\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 * @param nodeInjector Node injector where the search should start\n * @param token The token to look for\n * @param flags Injection flags\n * @returns the value from the injector or `null` when not found\n */\nfunction getOrCreateInjectable(tNode, lViewData, token, flags, notFoundValue) {\n if (flags === void 0) { flags = InjectFlags.Default; }\n var 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 var savePreviousOrParentTNode = getPreviousOrParentTNode();\n var saveViewData = getViewData();\n setTNodeAndViewData(tNode, lViewData);\n try {\n var value = bloomHash();\n if (value == null && !(flags & InjectFlags.Optional)) {\n throw new Error(\"No provider for \" + stringify$1(token));\n }\n else {\n return value;\n }\n }\n finally {\n setTNodeAndViewData(savePreviousOrParentTNode, saveViewData);\n }\n }\n else if (typeof bloomHash == 'number') {\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 injector\n // tree. This is used to know if viewProviders can be accessed on the current injector.\n var previousTView = null;\n var injectorIndex = getInjectorIndex(tNode, lViewData);\n var parentLocation = NO_PARENT_INJECTOR;\n // If we should skip this injector, or if there is no injector on this node, start by searching\n // the parent injector.\n if (injectorIndex === -1 || flags & InjectFlags.SkipSelf) {\n parentLocation = injectorIndex === -1 ? getParentInjectorLocation(tNode, lViewData) :\n lViewData[injectorIndex + PARENT_INJECTOR];\n if (!shouldSearchParent(flags, parentLocation)) {\n injectorIndex = -1;\n }\n else {\n previousTView = lViewData[TVIEW];\n injectorIndex = getParentInjectorIndex(parentLocation);\n lViewData = getParentInjectorView(parentLocation, lViewData);\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 = lViewData[injectorIndex + PARENT_INJECTOR];\n // Check the current injector. If it matches, see if it contains token.\n var tView = lViewData[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 var instance = searchTokensOnInjector(injectorIndex, lViewData, token, previousTView);\n if (instance !== NOT_FOUND) {\n return instance;\n }\n }\n if (shouldSearchParent(flags, parentLocation) &&\n bloomHasToken(bloomHash, injectorIndex, lViewData)) {\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 lViewData = getParentInjectorView(parentLocation, lViewData);\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 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 var moduleInjector = lViewData[INJECTOR];\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 if (flags & InjectFlags.Optional) {\n return notFoundValue;\n }\n else {\n throw new Error(\"NodeInjector: NOT_FOUND [\" + stringify$1(token) + \"]\");\n }\n}\nvar NOT_FOUND = {};\nfunction searchTokensOnInjector(injectorIndex, injectorView, token, previousTView) {\n var currentTView = injectorView[TVIEW];\n var tNode = currentTView.data[injectorIndex + TNODE];\n var nodeFlags = tNode.flags;\n var nodeProviderIndexes = tNode.providerIndexes;\n var tInjectables = currentTView.data;\n // First, we step through providers\n var canAccessViewProviders = false;\n // We need to determine if view providers can be accessed by the starting element.\n // It happens in 2 cases:\n // 1) On the initial element injector , if we are instantiating a token which can see the\n // viewProviders of the component of that element. Such token are:\n // - the component itself (but not other directives)\n // - viewProviders tokens of the component (but not providers tokens)\n // 2) Upper in the element injector tree, if the starting element is actually in the view of\n // the current element. To determine this, we track the transition of view during the climb,\n // and check the host node of the current view to identify component views.\n if (previousTView == null && isComponent(tNode) && includeViewProviders ||\n previousTView != null && previousTView != currentTView &&\n (currentTView.node == null || currentTView.node.type === 3 /* Element */)) {\n canAccessViewProviders = true;\n }\n var startInjectables = nodeProviderIndexes & 65535 /* ProvidersStartIndexMask */;\n var startDirectives = nodeFlags >> 16 /* DirectiveStartingIndexShift */;\n var cptViewProvidersCount = nodeProviderIndexes >> 16 /* CptViewProvidersCountShift */;\n var startingIndex = canAccessViewProviders ? startInjectables : startInjectables + cptViewProvidersCount;\n var directiveCount = nodeFlags & 4095 /* DirectiveCountMask */;\n for (var i = startingIndex; i < startDirectives + directiveCount; i++) {\n var providerTokenOrDef = tInjectables[i];\n if (i < startDirectives && token === providerTokenOrDef ||\n i >= startDirectives && providerTokenOrDef.type === token) {\n return getNodeInjectable(tInjectables, injectorView, i, tNode);\n }\n }\n return NOT_FOUND;\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*/\nfunction getNodeInjectable(tData, lData, index, tNode) {\n var value = lData[index];\n if (isFactory(value)) {\n var factory = value;\n if (factory.resolving) {\n throw new Error(\"Circular dep for \" + stringify$1(tData[index]));\n }\n var previousIncludeViewProviders = setIncludeViewProviders(factory.canSeeViewProviders);\n factory.resolving = true;\n var previousInjectImplementation = void 0;\n if (factory.injectImpl) {\n previousInjectImplementation = setInjectImplementation(factory.injectImpl);\n }\n var savePreviousOrParentTNode = getPreviousOrParentTNode();\n var saveViewData = getViewData();\n setTNodeAndViewData(tNode, lData);\n try {\n value = lData[index] = factory.factory(null, tData, lData, tNode);\n }\n finally {\n if (factory.injectImpl)\n setInjectImplementation(previousInjectImplementation);\n setIncludeViewProviders(previousIncludeViewProviders);\n factory.resolving = false;\n setTNodeAndViewData(savePreviousOrParentTNode, saveViewData);\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 * @returns the matching bit to check in the bloom filter or `null` if the token is not known.\n */\nfunction bloomHashBitOrFactory(token) {\n ngDevMode && assertDefined(token, 'token must be defined');\n var tokenId = token[NG_ELEMENT_ID];\n return typeof tokenId === 'number' ? tokenId & BLOOM_MASK : tokenId;\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 var mask = 1 << bloomHash;\n var b7 = bloomHash & 0x80;\n var b6 = bloomHash & 0x40;\n var 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 var 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/** Returns true if flags prevent parent injector from being searched for tokens */\nfunction shouldSearchParent(flags, parentLocation) {\n return !(flags & InjectFlags.Self ||\n (flags & InjectFlags.Host &&\n (parentLocation & 32768 /* AcrossHostBoundary */)));\n}\nfunction injectInjector() {\n var tNode = getPreviousOrParentTNode();\n return new NodeInjector(tNode, getViewData());\n}\nvar NodeInjector = /** @class */ (function () {\n function NodeInjector(_tNode, _hostView) {\n this._tNode = _tNode;\n this._hostView = _hostView;\n this._injectorIndex = getOrCreateNodeInjectorForNode(_tNode, _hostView);\n }\n NodeInjector.prototype.get = function (token) {\n setTNodeAndViewData(this._tNode, this._hostView);\n return getOrCreateInjectable(this._tNode, this._hostView, token);\n };\n return NodeInjector;\n}());\nfunction getFactoryOf(type) {\n var typeAny = type;\n var 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}\nfunction getInheritedFactory(type) {\n var proto = Object.getPrototypeOf(type.prototype).constructor;\n var 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 function (t) { return 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 */\n/** Returns the matching `LContext` data for a given DOM node, directive or component instance.\n *\n * This function will examine the provided DOM element, component, or directive instance\\'s\n * monkey-patched property to derive the `LContext` data. Once called then the monkey-patched\n * value will be that of the newly created `LContext`.\n *\n * If the monkey-patched value is the `LViewData` instance then the context value for that\n * target will be created and the monkey-patch reference will be updated. Therefore when this\n * function is called it may mutate the provided element\\'s, component\\'s or any of the associated\n * directive\\'s monkey-patch values.\n *\n * If the monkey-patch value is not detected then the code will walk up the DOM until an element\n * is found which contains a monkey-patch reference. When that occurs then the provided element\n * will be updated with a new context (which is then returned). If the monkey-patch value is not\n * detected for a component/directive instance then it will throw an error (all components and\n * directives should be automatically monkey-patched by ivy).\n *\n * @param target Component, Directive or DOM Node.\n */\nfunction getContext(target) {\n var mpValue = readPatchedData(target);\n if (mpValue) {\n // only when it's an array is it considered an LViewData instance\n // ... otherwise it's an already constructed LContext instance\n if (Array.isArray(mpValue)) {\n var lViewData = mpValue;\n var nodeIndex = void 0;\n var component = undefined;\n var directives = undefined;\n if (isComponentInstance(target)) {\n nodeIndex = findViaComponent(lViewData, target);\n if (nodeIndex == -1) {\n throw new Error('The provided component was not found in the application');\n }\n component = target;\n }\n else if (isDirectiveInstance(target)) {\n nodeIndex = findViaDirective(lViewData, target);\n if (nodeIndex == -1) {\n throw new Error('The provided directive was not found in the application');\n }\n directives = getDirectivesAtNodeIndex(nodeIndex, lViewData, false);\n }\n else {\n nodeIndex = findViaNativeElement(lViewData, target);\n if (nodeIndex == -1) {\n return null;\n }\n }\n // the goal is not to fill the entire context full of data because the lookups\n // are expensive. Instead, only the target data (the element, compontent or\n // directive details) are filled into the context. If called multiple times\n // with different target values then the missing target data will be filled in.\n var native = readElementValue(lViewData[nodeIndex]);\n var existingCtx = readPatchedData(native);\n var context = (existingCtx && !Array.isArray(existingCtx)) ?\n existingCtx :\n createLContext(lViewData, nodeIndex, native);\n // only when the component has been discovered then update the monkey-patch\n if (component && context.component === undefined) {\n context.component = component;\n attachPatchData(context.component, context);\n }\n // only when the directives have been discovered then update the monkey-patch\n if (directives && context.directives === undefined) {\n context.directives = directives;\n for (var i = 0; i < directives.length; i++) {\n attachPatchData(directives[i], context);\n }\n }\n attachPatchData(context.native, context);\n mpValue = context;\n }\n }\n else {\n var rElement = target;\n ngDevMode && assertDomElement(rElement);\n // if the context is not found then we need to traverse upwards up the DOM\n // to find the nearest element that has already been monkey patched with data\n var parent_1 = rElement;\n while (parent_1 = parent_1.parentNode) {\n var parentContext = readPatchedData(parent_1);\n if (parentContext) {\n var lViewData = void 0;\n if (Array.isArray(parentContext)) {\n lViewData = parentContext;\n }\n else {\n lViewData = parentContext.lViewData;\n }\n // the edge of the app was also reached here through another means\n // (maybe because the DOM was changed manually).\n if (!lViewData) {\n return null;\n }\n var index = findViaNativeElement(lViewData, rElement);\n if (index >= 0) {\n var native = readElementValue(lViewData[index]);\n var context = createLContext(lViewData, index, native);\n attachPatchData(native, context);\n mpValue = context;\n break;\n }\n }\n }\n }\n return mpValue || null;\n}\n/**\n * Creates an empty instance of a `LContext` context\n */\nfunction createLContext(lViewData, nodeIndex, native) {\n return {\n lViewData: lViewData,\n nodeIndex: nodeIndex,\n native: native,\n component: undefined,\n directives: undefined,\n localRefs: undefined,\n };\n}\n/**\n * Takes a component instance and returns the view for that component.\n *\n * @param componentInstance\n * @returns The component's view\n */\nfunction getComponentViewByInstance(componentInstance) {\n var lViewData = readPatchedData(componentInstance);\n var view;\n if (Array.isArray(lViewData)) {\n var nodeIndex = findViaComponent(lViewData, componentInstance);\n view = getComponentViewByIndex(nodeIndex, lViewData);\n var context = createLContext(lViewData, nodeIndex, view[HOST]);\n context.component = componentInstance;\n attachPatchData(componentInstance, context);\n attachPatchData(context.native, context);\n }\n else {\n var context = lViewData;\n view = getComponentViewByIndex(context.nodeIndex, context.lViewData);\n }\n return view;\n}\n/**\n * Assigns the given data to the given target (which could be a component,\n * directive or DOM node instance) using monkey-patching.\n */\nfunction attachPatchData(target, data) {\n target[MONKEY_PATCH_KEY_NAME] = data;\n}\nfunction isComponentInstance(instance) {\n return instance && instance.constructor && instance.constructor.ngComponentDef;\n}\nfunction isDirectiveInstance(instance) {\n return instance && instance.constructor && instance.constructor.ngDirectiveDef;\n}\n/**\n * Locates the element within the given LViewData and returns the matching index\n */\nfunction findViaNativeElement(lViewData, target) {\n var tNode = lViewData[TVIEW].firstChild;\n while (tNode) {\n var native = getNativeByTNode(tNode, lViewData);\n if (native === target) {\n return tNode.index;\n }\n tNode = traverseNextElement(tNode);\n }\n return -1;\n}\n/**\n * Locates the next tNode (child, sibling or parent).\n */\nfunction traverseNextElement(tNode) {\n if (tNode.child) {\n return tNode.child;\n }\n else if (tNode.next) {\n return tNode.next;\n }\n else if (tNode.parent) {\n return tNode.parent.next || null;\n }\n return null;\n}\n/**\n * Locates the component within the given LViewData and returns the matching index\n */\nfunction findViaComponent(lViewData, componentInstance) {\n var componentIndices = lViewData[TVIEW].components;\n if (componentIndices) {\n for (var i = 0; i < componentIndices.length; i++) {\n var elementComponentIndex = componentIndices[i];\n var componentView = getComponentViewByIndex(elementComponentIndex, lViewData);\n if (componentView[CONTEXT] === componentInstance) {\n return elementComponentIndex;\n }\n }\n }\n else {\n var rootComponentView = getComponentViewByIndex(HEADER_OFFSET, lViewData);\n var rootComponent = rootComponentView[CONTEXT];\n if (rootComponent === componentInstance) {\n // we are dealing with the root element here therefore we know that the\n // element is the very first element after the HEADER data in the lView\n return HEADER_OFFSET;\n }\n }\n return -1;\n}\n/**\n * Locates the directive within the given LViewData and returns the matching index\n */\nfunction findViaDirective(lViewData, directiveInstance) {\n // if a directive is monkey patched then it will (by default)\n // have a reference to the LViewData of the current view. The\n // element bound to the directive being search lives somewhere\n // in the view data. We loop through the nodes and check their\n // list of directives for the instance.\n var tNode = lViewData[TVIEW].firstChild;\n while (tNode) {\n var directiveIndexStart = getDirectiveStartIndex(tNode);\n var directiveIndexEnd = getDirectiveEndIndex(tNode, directiveIndexStart);\n for (var i = directiveIndexStart; i < directiveIndexEnd; i++) {\n if (lViewData[i] === directiveInstance) {\n return tNode.index;\n }\n }\n tNode = traverseNextElement(tNode);\n }\n return -1;\n}\nfunction assertDomElement(element) {\n assertEqual(element && (element.nodeType == Node.ELEMENT_NODE || element.nodeType == Node.TEXT_NODE), true, 'The provided value must be an instance of an HTMLElement');\n}\n/**\n * Returns a list of directives extracted from the given view based on the\n * provided list of directive index values.\n *\n * @param nodeIndex The node index\n * @param lViewData The target view data\n * @param includeComponents Whether or not to include components in returned directives\n */\nfunction getDirectivesAtNodeIndex(nodeIndex, lViewData, includeComponents) {\n var tNode = lViewData[TVIEW].data[nodeIndex];\n var directiveStartIndex = getDirectiveStartIndex(tNode);\n if (directiveStartIndex == 0)\n return EMPTY_ARRAY;\n var directiveEndIndex = getDirectiveEndIndex(tNode, directiveStartIndex);\n if (!includeComponents && tNode.flags & 4096 /* isComponent */)\n directiveStartIndex++;\n return lViewData.slice(directiveStartIndex, directiveEndIndex);\n}\nfunction getComponentAtNodeIndex(nodeIndex, lViewData) {\n var tNode = lViewData[TVIEW].data[nodeIndex];\n var directiveStartIndex = getDirectiveStartIndex(tNode);\n return tNode.flags & 4096 /* isComponent */ ? lViewData[directiveStartIndex] : null;\n}\n/**\n * Returns a map of local references (local reference name => element or directive instance) that\n * exist on a given element.\n */\nfunction discoverLocalRefs(lViewData, nodeIndex) {\n var tNode = lViewData[TVIEW].data[nodeIndex];\n if (tNode && tNode.localNames) {\n var result = {};\n for (var i = 0; i < tNode.localNames.length; i += 2) {\n var localRefName = tNode.localNames[i];\n var directiveIndex = tNode.localNames[i + 1];\n result[localRefName] =\n directiveIndex === -1 ? getNativeByTNode(tNode, lViewData) : lViewData[directiveIndex];\n }\n return result;\n }\n return null;\n}\nfunction getDirectiveStartIndex(tNode) {\n // the tNode instances store a flag value which then has a\n // pointer which tells the starting index of where all the\n // active directives are in the master directive array\n return tNode.flags >> 16 /* DirectiveStartingIndexShift */;\n}\nfunction getDirectiveEndIndex(tNode, startIndex) {\n // The end value is also a part of the same flag\n // (see `TNodeFlags` to see how the flag bit shifting\n // values are used).\n var count = tNode.flags & 4095 /* DirectiveCountMask */;\n return count ? (startIndex + count) : -1;\n}\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\nfunction noop() {\n var args = [];\n for (var _i = 0; _i < arguments.length; _i++) {\n args[_i] = arguments[_i];\n }\n // Do nothing.\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 */\nvar __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 */\nfunction forwardRef(forwardRefFn) {\n forwardRefFn.__forward_ref__ = forwardRef;\n forwardRefFn.toString = function () { return stringify(this()); };\n return 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 */\nfunction resolveForwardRef(type) {\n var 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 */\nvar SOURCE = '__source';\nvar _THROW_IF_NOT_FOUND = new Object();\nvar THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\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 */\nvar INJECTOR$1 = new InjectionToken('INJECTOR');\nvar NullInjector = /** @class */ (function () {\n function NullInjector() {\n }\n NullInjector.prototype.get = function (token, notFoundValue) {\n if (notFoundValue === void 0) { 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 throw new Error(\"NullInjectorError: No provider for \" + stringify(token) + \"!\");\n }\n return notFoundValue;\n };\n return NullInjector;\n}());\n/**\n * Concrete injectors implement this interface.\n *\n * For more details, see the [\"Dependency Injection Guide\"](guide/dependency-injection).\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/di/ts/injector_spec.ts region='Injector'}\n *\n * `Injector` returns itself when given `Injector` as a token:\n *\n * {@example core/di/ts/injector_spec.ts region='injectInjector'}\n *\n * @publicApi\n */\nvar Injector = /** @class */ (function () {\n function Injector() {\n }\n /**\n * Create a new Injector which is configure using `StaticProvider`s.\n *\n * @usageNotes\n * ### Example\n *\n * {@example core/di/ts/provider_spec.ts region='ConstructorProvider'}\n */\n Injector.create = function (options, parent) {\n if (Array.isArray(options)) {\n return new StaticInjector(options, parent);\n }\n else {\n return new StaticInjector(options.providers, options.parent, options.name || null);\n }\n };\n Injector.THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;\n Injector.NULL = new NullInjector();\n /** @nocollapse */\n Injector.ngInjectableDef = defineInjectable({\n providedIn: 'any',\n factory: function () { return inject(INJECTOR$1); },\n });\n /** @internal */\n Injector.__NG_ELEMENT_ID__ = function () { return SWITCH_INJECTOR_FACTORY(); };\n return Injector;\n}());\nvar SWITCH_INJECTOR_FACTORY__POST_R3__ = function () {\n return injectInjector();\n};\nvar SWITCH_INJECTOR_FACTORY__PRE_R3__ = noop;\nvar SWITCH_INJECTOR_FACTORY = SWITCH_INJECTOR_FACTORY__PRE_R3__;\nvar IDENT = function (value) {\n return value;\n};\nvar EMPTY$1 = [];\nvar CIRCULAR = IDENT;\nvar MULTI_PROVIDER_FN = function () {\n return Array.prototype.slice.call(arguments);\n};\nvar USE_VALUE = getClosureSafeProperty({ provide: String, useValue: getClosureSafeProperty });\nvar NG_TOKEN_PATH = 'ngTokenPath';\nvar NG_TEMP_TOKEN_PATH = 'ngTempTokenPath';\nvar NULL_INJECTOR = Injector.NULL;\nvar NEW_LINE = /\\n/gm;\nvar NO_NEW_LINE = 'ɵ';\nvar StaticInjector = /** @class */ (function () {\n function StaticInjector(providers, parent, source) {\n if (parent === void 0) { parent = NULL_INJECTOR; }\n if (source === void 0) { source = null; }\n this.parent = parent;\n this.source = source;\n var records = this._records = new Map();\n records.set(Injector, { token: Injector, fn: IDENT, deps: EMPTY$1, value: this, useNew: false });\n records.set(INJECTOR$1, { token: INJECTOR$1, fn: IDENT, deps: EMPTY$1, value: this, useNew: false });\n recursivelyProcessProviders(records, providers);\n }\n StaticInjector.prototype.get = function (token, notFoundValue, flags) {\n if (flags === void 0) { flags = InjectFlags.Default; }\n var record = this._records.get(token);\n try {\n return tryResolveToken(token, record, this._records, this.parent, notFoundValue, flags);\n }\n catch (e) {\n var tokenPath = e[NG_TEMP_TOKEN_PATH];\n if (token[SOURCE]) {\n tokenPath.unshift(token[SOURCE]);\n }\n e.message = formatError('\\n' + e.message, tokenPath, this.source);\n e[NG_TOKEN_PATH] = tokenPath;\n e[NG_TEMP_TOKEN_PATH] = null;\n throw e;\n }\n };\n StaticInjector.prototype.toString = function () {\n var tokens = [], records = this._records;\n records.forEach(function (v, token) { return tokens.push(stringify(token)); });\n return \"StaticInjector[\" + tokens.join(', ') + \"]\";\n };\n return StaticInjector;\n}());\nfunction resolveProvider(provider) {\n var deps = computeDeps(provider);\n var fn = IDENT;\n var value = EMPTY$1;\n var useNew = false;\n var provide = resolveForwardRef(provider.provide);\n if (USE_VALUE in provider) {\n // We need to use USE_VALUE in provider since provider.useValue could be defined as undefined.\n value = provider.useValue;\n }\n else if (provider.useFactory) {\n fn = provider.useFactory;\n }\n else if (provider.useExisting) ;\n else if (provider.useClass) {\n useNew = true;\n fn = resolveForwardRef(provider.useClass);\n }\n else if (typeof provide == 'function') {\n useNew = true;\n fn = provide;\n }\n else {\n throw staticError('StaticProvider does not have [useValue|useFactory|useExisting|useClass] or [provide] is not newable', provider);\n }\n return { deps: deps, fn: fn, useNew: useNew, value: value };\n}\nfunction multiProviderMixError(token) {\n return staticError('Cannot mix multi providers and regular providers', token);\n}\nfunction recursivelyProcessProviders(records, provider) {\n if (provider) {\n provider = resolveForwardRef(provider);\n if (provider instanceof Array) {\n // if we have an array recurse into the array\n for (var i = 0; i < provider.length; i++) {\n recursivelyProcessProviders(records, provider[i]);\n }\n }\n else if (typeof provider === 'function') {\n // Functions were supported in ReflectiveInjector, but are not here. For safety give useful\n // error messages\n throw staticError('Function/Class not supported', provider);\n }\n else if (provider && typeof provider === 'object' && provider.provide) {\n // At this point we have what looks like a provider: {provide: ?, ....}\n var token = resolveForwardRef(provider.provide);\n var resolvedProvider = resolveProvider(provider);\n if (provider.multi === true) {\n // This is a multi provider.\n var multiProvider = records.get(token);\n if (multiProvider) {\n if (multiProvider.fn !== MULTI_PROVIDER_FN) {\n throw multiProviderMixError(token);\n }\n }\n else {\n // Create a placeholder factory which will look up the constituents of the multi provider.\n records.set(token, multiProvider = {\n token: provider.provide,\n deps: [],\n useNew: false,\n fn: MULTI_PROVIDER_FN,\n value: EMPTY$1\n });\n }\n // Treat the provider as the token.\n token = provider;\n multiProvider.deps.push({ token: token, options: 6 /* Default */ });\n }\n var record = records.get(token);\n if (record && record.fn == MULTI_PROVIDER_FN) {\n throw multiProviderMixError(token);\n }\n records.set(token, resolvedProvider);\n }\n else {\n throw staticError('Unexpected provider', provider);\n }\n }\n}\nfunction tryResolveToken(token, record, records, parent, notFoundValue, flags) {\n try {\n return resolveToken(token, record, records, parent, notFoundValue, flags);\n }\n catch (e) {\n // ensure that 'e' is of type Error.\n if (!(e instanceof Error)) {\n e = new Error(e);\n }\n var path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];\n path.unshift(token);\n if (record && record.value == CIRCULAR) {\n // Reset the Circular flag.\n record.value = EMPTY$1;\n }\n throw e;\n }\n}\nfunction resolveToken(token, record, records, parent, notFoundValue, flags) {\n var _a;\n var value;\n if (record && !(flags & InjectFlags.SkipSelf)) {\n // If we don't have a record, this implies that we don't own the provider hence don't know how\n // to resolve it.\n value = record.value;\n if (value == CIRCULAR) {\n throw Error(NO_NEW_LINE + 'Circular dependency');\n }\n else if (value === EMPTY$1) {\n record.value = CIRCULAR;\n var obj = undefined;\n var useNew = record.useNew;\n var fn = record.fn;\n var depRecords = record.deps;\n var deps = EMPTY$1;\n if (depRecords.length) {\n deps = [];\n for (var i = 0; i < depRecords.length; i++) {\n var depRecord = depRecords[i];\n var options = depRecord.options;\n var childRecord = options & 2 /* CheckSelf */ ? records.get(depRecord.token) : undefined;\n deps.push(tryResolveToken(\n // Current Token to resolve\n depRecord.token, \n // A record which describes how to resolve the token.\n // If undefined, this means we don't have such a record\n childRecord, \n // Other records we know about.\n records, \n // If we don't know how to resolve dependency and we should not check parent for it,\n // than pass in Null injector.\n !childRecord && !(options & 4 /* CheckParent */) ? NULL_INJECTOR : parent, options & 1 /* Optional */ ? null : Injector.THROW_IF_NOT_FOUND, InjectFlags.Default));\n }\n }\n record.value = value = useNew ? new ((_a = fn).bind.apply(_a, __spread([void 0], deps)))() : fn.apply(obj, deps);\n }\n }\n else if (!(flags & InjectFlags.Self)) {\n value = parent.get(token, notFoundValue, InjectFlags.Default);\n }\n return value;\n}\nfunction computeDeps(provider) {\n var deps = EMPTY$1;\n var providerDeps = provider.deps;\n if (providerDeps && providerDeps.length) {\n deps = [];\n for (var i = 0; i < providerDeps.length; i++) {\n var options = 6 /* Default */;\n var token = resolveForwardRef(providerDeps[i]);\n if (token instanceof Array) {\n for (var j = 0, annotations = token; j < annotations.length; j++) {\n var annotation = annotations[j];\n if (annotation instanceof Optional || annotation == Optional) {\n options = options | 1 /* Optional */;\n }\n else if (annotation instanceof SkipSelf || annotation == SkipSelf) {\n options = options & ~2 /* CheckSelf */;\n }\n else if (annotation instanceof Self || annotation == Self) {\n options = options & ~4 /* CheckParent */;\n }\n else if (annotation instanceof Inject) {\n token = annotation.token;\n }\n else {\n token = resolveForwardRef(annotation);\n }\n }\n }\n deps.push({ token: token, options: options });\n }\n }\n else if (provider.useExisting) {\n var token = resolveForwardRef(provider.useExisting);\n deps = [{ token: token, options: 6 /* Default */ }];\n }\n else if (!providerDeps && !(USE_VALUE in provider)) {\n // useValue & useExisting are the only ones which are exempt from deps all others need it.\n throw staticError('\\'deps\\' required', provider);\n }\n return deps;\n}\nfunction formatError(text, obj, source) {\n if (source === void 0) { source = null; }\n text = text && text.charAt(0) === '\\n' && text.charAt(1) == NO_NEW_LINE ? text.substr(2) : text;\n var context = stringify(obj);\n if (obj instanceof Array) {\n context = obj.map(stringify).join(' -> ');\n }\n else if (typeof obj === 'object') {\n var parts = [];\n for (var key in obj) {\n if (obj.hasOwnProperty(key)) {\n var value = obj[key];\n parts.push(key + ':' + (typeof value === 'string' ? JSON.stringify(value) : stringify(value)));\n }\n }\n context = \"{\" + parts.join(', ') + \"}\";\n }\n return \"StaticInjectorError\" + (source ? '(' + source + ')' : '') + \"[\" + context + \"]: \" + text.replace(NEW_LINE, '\\n ');\n}\nfunction staticError(text, obj) {\n return new Error(formatError(text, obj));\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 * 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 */\nvar NgModuleRef = /** @class */ (function () {\n function NgModuleRef() {\n }\n return NgModuleRef;\n}());\n/**\n * @publicApi\n */\nvar NgModuleFactory = /** @class */ (function () {\n function NgModuleFactory() {\n }\n return NgModuleFactory;\n}());\n\n/** Called when directives inject each other (creating a circular dependency) */\n/** Called when there are multiple component selectors that match a given node */\nfunction throwMultipleComponentError(tNode) {\n throw new Error(\"Multiple components match node with tagname \" + tNode.tagName);\n}\n/** Throws an ExpressionChangedAfterChecked error if checkNoChanges mode is on. */\nfunction throwErrorIfNoChangesMode(creationMode, checkNoChangesMode, oldValue, currValue) {\n if (checkNoChangesMode) {\n var msg = \"ExpressionChangedAfterItHasBeenCheckedError: Expression has changed after it was checked. Previous value: '\" + oldValue + \"'. Current value: '\" + currValue + \"'.\";\n if (creationMode) {\n msg +=\n \" It seems like the view has been created after its parent and its children have been dirty checked.\" +\n \" Has it been created in a change detection hook ?\";\n }\n // TODO: include debug context\n throw new Error(msg);\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 */\nvar NG_PROJECT_AS_ATTR_NAME = 'ngProjectAs';\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// TODO: cleanup once the code is merged in angular/angular\nvar RendererStyleFlags3;\n(function (RendererStyleFlags3) {\n RendererStyleFlags3[RendererStyleFlags3[\"Important\"] = 1] = \"Important\";\n RendererStyleFlags3[RendererStyleFlags3[\"DashCase\"] = 2] = \"DashCase\";\n})(RendererStyleFlags3 || (RendererStyleFlags3 = {}));\n/** Returns whether the `renderer` is a `ProceduralRenderer3` */\nfunction isProceduralRenderer(renderer) {\n return !!(renderer.listen);\n}\nvar domRendererFactory3 = {\n createRenderer: function (hostElement, rendererType) { return document; }\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/**\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/** Retrieves the parent element of a given node. */\nfunction getParentNative(tNode, currentView) {\n if (tNode.parent == null) {\n return getHostNative(currentView);\n }\n else {\n var parentTNode = getFirstParentNative(tNode);\n return getNativeByTNode(parentTNode, currentView);\n }\n}\n/**\n * Get the first parent of a node that isn't an IcuContainer TNode\n */\nfunction getFirstParentNative(tNode) {\n var parent = tNode.parent;\n while (parent && parent.type === 5 /* IcuContainer */) {\n parent = parent.parent;\n }\n return parent;\n}\n/**\n * Gets the host element given a view. Will return null if the current view is an embedded view,\n * which does not have a host element.\n */\nfunction getHostNative(currentView) {\n var hostTNode = currentView[HOST_NODE];\n return hostTNode && hostTNode.type !== 2 /* View */ ?\n getNativeByTNode(hostTNode, currentView[PARENT]) :\n null;\n}\nfunction getLContainer(tNode, embeddedView) {\n if (tNode.index === -1) {\n // This is a dynamically created view inside a dynamic container.\n // If the host index is -1, the view has not yet been inserted, so it has no parent.\n var containerHostIndex = embeddedView[CONTAINER_INDEX];\n return containerHostIndex > -1 ? embeddedView[PARENT][containerHostIndex] : null;\n }\n else {\n // This is a inline view node (e.g. embeddedViewStart)\n return embeddedView[PARENT][tNode.parent.index];\n }\n}\n/**\n * Retrieves render parent for a given view.\n * Might be null if a view is not yet attached to any container.\n */\nfunction getContainerRenderParent(tViewNode, view) {\n var container = getLContainer(tViewNode, view);\n return container ? container[RENDER_PARENT] : null;\n}\n/**\n * Stack used to keep track of projection nodes in walkTNodeTree.\n *\n * This is deliberately created outside of walkTNodeTree to avoid allocating\n * a new array each time the function is called. Instead the array will be\n * re-used by each invocation. This works because the function is not reentrant.\n */\nvar projectionNodeStack = [];\n/**\n * Walks a tree of TNodes, applying a transformation on the element nodes, either only on the first\n * one found, or on all of them.\n *\n * @param viewToWalk the view to walk\n * @param action identifies the action to be performed on the elements\n * @param renderer the current renderer.\n * @param renderParent Optional the render parent node to be set in all LContainers found,\n * required for action modes Insert and Destroy.\n * @param beforeNode Optional the node before which elements should be added, required for action\n * Insert.\n */\nfunction walkTNodeTree(viewToWalk, action, renderer, renderParent, beforeNode) {\n var rootTNode = viewToWalk[TVIEW].node;\n var projectionNodeIndex = -1;\n var currentView = viewToWalk;\n var tNode = rootTNode.child;\n while (tNode) {\n var nextTNode = null;\n if (tNode.type === 3 /* Element */) {\n executeNodeAction(action, renderer, renderParent, getNativeByTNode(tNode, currentView), beforeNode);\n var nodeOrContainer = currentView[tNode.index];\n if (isLContainer(nodeOrContainer)) {\n // This element has an LContainer, and its comment needs to be handled\n executeNodeAction(action, renderer, renderParent, nodeOrContainer[NATIVE], beforeNode);\n }\n }\n else if (tNode.type === 0 /* Container */) {\n var lContainer = currentView[tNode.index];\n executeNodeAction(action, renderer, renderParent, lContainer[NATIVE], beforeNode);\n if (renderParent)\n lContainer[RENDER_PARENT] = renderParent;\n if (lContainer[VIEWS].length) {\n currentView = lContainer[VIEWS][0];\n nextTNode = currentView[TVIEW].node;\n // When the walker enters a container, then the beforeNode has to become the local native\n // comment node.\n beforeNode = lContainer[NATIVE];\n }\n }\n else if (tNode.type === 1 /* Projection */) {\n var componentView = findComponentView(currentView);\n var componentHost = componentView[HOST_NODE];\n var head = componentHost.projection[tNode.projection];\n // Must store both the TNode and the view because this projection node could be nested\n // deeply inside embedded views, and we need to get back down to this particular nested view.\n projectionNodeStack[++projectionNodeIndex] = tNode;\n projectionNodeStack[++projectionNodeIndex] = currentView;\n if (head) {\n currentView = componentView[PARENT];\n nextTNode = currentView[TVIEW].data[head.index];\n }\n }\n else {\n // Otherwise, this is a View or an ElementContainer\n nextTNode = tNode.child;\n }\n if (nextTNode === null) {\n // this last node was projected, we need to get back down to its projection node\n if (tNode.next === null && (tNode.flags & 8192 /* isProjected */)) {\n currentView = projectionNodeStack[projectionNodeIndex--];\n tNode = projectionNodeStack[projectionNodeIndex--];\n }\n nextTNode = tNode.next;\n /**\n * Find the next node in the TNode tree, taking into account the place where a node is\n * projected (in the shadow DOM) rather than where it comes from (in the light DOM).\n *\n * If there is no sibling node, then it goes to the next sibling of the parent node...\n * until it reaches rootNode (at which point null is returned).\n */\n while (!nextTNode) {\n // If parent is null, we're crossing the view boundary, so we should get the host TNode.\n tNode = tNode.parent || currentView[TVIEW].node;\n if (tNode === null || tNode === rootTNode)\n return null;\n // When exiting a container, the beforeNode must be restored to the previous value\n if (tNode.type === 0 /* Container */) {\n currentView = currentView[PARENT];\n beforeNode = currentView[tNode.index][NATIVE];\n }\n if (tNode.type === 2 /* View */ && currentView[NEXT]) {\n currentView = currentView[NEXT];\n nextTNode = currentView[TVIEW].node;\n }\n else {\n nextTNode = tNode.next;\n }\n }\n }\n tNode = nextTNode;\n }\n}\n/**\n * Given a current view, finds the nearest component's host (LElement).\n *\n * @param lViewData LViewData for which we want a host element node\n * @returns The host node\n */\nfunction findComponentView(lViewData) {\n var rootTNode = lViewData[HOST_NODE];\n while (rootTNode && rootTNode.type === 2 /* View */) {\n ngDevMode && assertDefined(lViewData[PARENT], 'viewData.parent');\n lViewData = lViewData[PARENT];\n rootTNode = lViewData[HOST_NODE];\n }\n return lViewData;\n}\n/**\n * NOTE: for performance reasons, the possible actions are inlined within the function instead of\n * being passed as an argument.\n */\nfunction executeNodeAction(action, renderer, parent, node, beforeNode) {\n if (action === 0 /* Insert */) {\n isProceduralRenderer(renderer) ?\n renderer.insertBefore(parent, node, beforeNode) :\n parent.insertBefore(node, beforeNode, true);\n }\n else if (action === 1 /* Detach */) {\n isProceduralRenderer(renderer) ?\n renderer.removeChild(parent, node) :\n parent.removeChild(node);\n }\n else if (action === 2 /* Destroy */) {\n ngDevMode && ngDevMode.rendererDestroyNode++;\n renderer.destroyNode(node);\n }\n}\nfunction createTextNode(value, renderer) {\n return isProceduralRenderer(renderer) ? renderer.createText(stringify$1(value)) :\n renderer.createTextNode(stringify$1(value));\n}\nfunction addRemoveViewFromContainer(viewToWalk, insertMode, beforeNode) {\n var renderParent = getContainerRenderParent(viewToWalk[TVIEW].node, viewToWalk);\n ngDevMode && assertNodeType(viewToWalk[TVIEW].node, 2 /* View */);\n if (renderParent) {\n var renderer = viewToWalk[RENDERER];\n walkTNodeTree(viewToWalk, insertMode ? 0 /* Insert */ : 1 /* Detach */, renderer, renderParent, beforeNode);\n }\n}\n/**\n * Traverses down and up the tree of views and containers to remove listeners and\n * call onDestroy callbacks.\n *\n * Notes:\n * - Because it's used for onDestroy calls, it needs to be bottom-up.\n * - Must process containers instead of their views to avoid splicing\n * when views are destroyed and re-added.\n * - Using a while loop because it's faster than recursion\n * - Destroy only called on movement to sibling or movement to parent (laterally or up)\n *\n * @param rootView The view to destroy\n */\nfunction destroyViewTree(rootView) {\n // If the view has no children, we can clean it up and return early.\n if (rootView[TVIEW].childIndex === -1) {\n return cleanUpView(rootView);\n }\n var viewOrContainer = getLViewChild(rootView);\n while (viewOrContainer) {\n var next = null;\n if (viewOrContainer.length >= HEADER_OFFSET) {\n // If LViewData, traverse down to child.\n var view = viewOrContainer;\n if (view[TVIEW].childIndex > -1)\n next = getLViewChild(view);\n }\n else {\n // If container, traverse down to its first LViewData.\n var container = viewOrContainer;\n if (container[VIEWS].length)\n next = container[VIEWS][0];\n }\n if (next == null) {\n // Only clean up view when moving to the side or up, as destroy hooks\n // should be called in order from the bottom up.\n while (viewOrContainer && !viewOrContainer[NEXT] && viewOrContainer !== rootView) {\n cleanUpView(viewOrContainer);\n viewOrContainer = getParentState(viewOrContainer, rootView);\n }\n cleanUpView(viewOrContainer || rootView);\n next = viewOrContainer && viewOrContainer[NEXT];\n }\n viewOrContainer = next;\n }\n}\n/**\n * Inserts a view into a container.\n *\n * This adds the view to the container's array of active views in the correct\n * position. It also adds the view's elements to the DOM if the container isn't a\n * root node of another view (in that case, the view's elements will be added when\n * the container's parent view is added later).\n *\n * @param lView The view to insert\n * @param lContainer The container into which the view should be inserted\n * @param parentView The new parent of the inserted view\n * @param index The index at which to insert the view\n * @param containerIndex The index of the container node, if dynamic\n */\nfunction insertView(lView, lContainer, parentView, index, containerIndex) {\n var views = lContainer[VIEWS];\n if (index > 0) {\n // This is a new view, we need to add it to the children.\n views[index - 1][NEXT] = lView;\n }\n if (index < views.length) {\n lView[NEXT] = views[index];\n views.splice(index, 0, lView);\n }\n else {\n views.push(lView);\n lView[NEXT] = null;\n }\n // Dynamically inserted views need a reference to their parent container's host so it's\n // possible to jump from a view to its container's next when walking the node tree.\n if (containerIndex > -1) {\n lView[CONTAINER_INDEX] = containerIndex;\n lView[PARENT] = parentView;\n }\n // Notify query that a new view has been added\n if (lView[QUERIES]) {\n lView[QUERIES].insertView(index);\n }\n // Sets the attached flag\n lView[FLAGS] |= 8 /* Attached */;\n}\n/**\n * Detaches a view from a container.\n *\n * This method splices the view from the container's array of active views. It also\n * removes the view's elements from the DOM.\n *\n * @param lContainer The container from which to detach a view\n * @param removeIndex The index of the view to detach\n * @param detached Whether or not this view is already detached.\n */\nfunction detachView(lContainer, removeIndex, detached) {\n var views = lContainer[VIEWS];\n var viewToDetach = views[removeIndex];\n if (removeIndex > 0) {\n views[removeIndex - 1][NEXT] = viewToDetach[NEXT];\n }\n views.splice(removeIndex, 1);\n if (!detached) {\n addRemoveViewFromContainer(viewToDetach, false);\n }\n if (viewToDetach[QUERIES]) {\n viewToDetach[QUERIES].removeView();\n }\n viewToDetach[CONTAINER_INDEX] = -1;\n viewToDetach[PARENT] = null;\n // Unsets the attached flag\n viewToDetach[FLAGS] &= ~8 /* Attached */;\n}\n/**\n * Removes a view from a container, i.e. detaches it and then destroys the underlying LView.\n *\n * @param lContainer The container from which to remove a view\n * @param tContainer The TContainer node associated with the LContainer\n * @param removeIndex The index of the view to remove\n */\nfunction removeView(lContainer, containerHost, removeIndex) {\n var view = lContainer[VIEWS][removeIndex];\n detachView(lContainer, removeIndex, !!containerHost.detached);\n destroyLView(view);\n}\n/** Gets the child of the given LViewData */\nfunction getLViewChild(viewData) {\n var childIndex = viewData[TVIEW].childIndex;\n return childIndex === -1 ? null : viewData[childIndex];\n}\n/**\n * A standalone function which destroys an LView,\n * conducting cleanup (e.g. removing listeners, calling onDestroys).\n *\n * @param view The view to be destroyed.\n */\nfunction destroyLView(view) {\n var renderer = view[RENDERER];\n if (isProceduralRenderer(renderer) && renderer.destroyNode) {\n walkTNodeTree(view, 2 /* Destroy */, renderer, null);\n }\n destroyViewTree(view);\n // Sets the destroyed flag\n view[FLAGS] |= 32 /* Destroyed */;\n}\n/**\n * Determines which LViewOrLContainer to jump to when traversing back up the\n * tree in destroyViewTree.\n *\n * Normally, the view's parent LView should be checked, but in the case of\n * embedded views, the container (which is the view node's parent, but not the\n * LView's parent) needs to be checked for a possible next property.\n *\n * @param state The LViewOrLContainer for which we need a parent state\n * @param rootView The rootView, so we don't propagate too far up the view tree\n * @returns The correct parent LViewOrLContainer\n */\nfunction getParentState(state, rootView) {\n var tNode;\n if (state.length >= HEADER_OFFSET && (tNode = state[HOST_NODE]) &&\n tNode.type === 2 /* View */) {\n // if it's an embedded view, the state needs to go up to the container, in case the\n // container has a next\n return getLContainer(tNode, state);\n }\n else {\n // otherwise, use parent view for containers or component views\n return state[PARENT] === rootView ? null : state[PARENT];\n }\n}\n/**\n * Removes all listeners and call all onDestroys in a given view.\n *\n * @param view The LViewData to clean up\n */\nfunction cleanUpView(viewOrContainer) {\n if (viewOrContainer.length >= HEADER_OFFSET) {\n var view = viewOrContainer;\n removeListeners(view);\n executeOnDestroys(view);\n executePipeOnDestroys(view);\n // For component views only, the local renderer is destroyed as clean up time.\n if (view[TVIEW].id === -1 && isProceduralRenderer(view[RENDERER])) {\n ngDevMode && ngDevMode.rendererDestroy++;\n view[RENDERER].destroy();\n }\n }\n}\n/** Removes listeners and unsubscribes from output subscriptions */\nfunction removeListeners(viewData) {\n var cleanup = viewData[TVIEW].cleanup;\n if (cleanup != null) {\n for (var i = 0; i < cleanup.length - 1; i += 2) {\n if (typeof cleanup[i] === 'string') {\n // This is a listener with the native renderer\n var native = readElementValue(viewData[cleanup[i + 1]]);\n var listener = viewData[CLEANUP][cleanup[i + 2]];\n native.removeEventListener(cleanup[i], listener, cleanup[i + 3]);\n i += 2;\n }\n else if (typeof cleanup[i] === 'number') {\n // This is a listener with renderer2 (cleanup fn can be found by index)\n var cleanupFn = viewData[CLEANUP][cleanup[i]];\n cleanupFn();\n }\n else {\n // This is a cleanup function that is grouped with the index of its context\n var context = viewData[CLEANUP][cleanup[i + 1]];\n cleanup[i].call(context);\n }\n }\n viewData[CLEANUP] = null;\n }\n}\n/** Calls onDestroy hooks for this view */\nfunction executeOnDestroys(view) {\n var tView = view[TVIEW];\n var destroyHooks;\n if (tView != null && (destroyHooks = tView.destroyHooks) != null) {\n callHooks(view, destroyHooks);\n }\n}\n/** Calls pipe destroy hooks for this view */\nfunction executePipeOnDestroys(viewData) {\n var pipeDestroyHooks = viewData[TVIEW] && viewData[TVIEW].pipeDestroyHooks;\n if (pipeDestroyHooks) {\n callHooks(viewData, pipeDestroyHooks);\n }\n}\nfunction getRenderParent(tNode, currentView) {\n if (canInsertNativeNode(tNode, currentView)) {\n // If we are asked for a render parent of the root component we need to do low-level DOM\n // operation as LTree doesn't exist above the topmost host node. We might need to find a render\n // parent of the topmost host node if the root component injects ViewContainerRef.\n if (isRootView(currentView)) {\n return nativeParentNode(currentView[RENDERER], getNativeByTNode(tNode, currentView));\n }\n var hostTNode = currentView[HOST_NODE];\n var tNodeParent = tNode.parent;\n if (tNodeParent != null && tNodeParent.type === 4 /* ElementContainer */) {\n tNode = getHighestElementContainer(tNodeParent);\n }\n return tNode.parent == null && hostTNode.type === 2 /* View */ ?\n getContainerRenderParent(hostTNode, currentView) :\n getParentNative(tNode, currentView);\n }\n return null;\n}\nfunction canInsertNativeChildOfElement(tNode) {\n // If the parent is null, then we are inserting across views. This happens when we\n // insert a root element of the component view into the component host element and it\n // should always be eager.\n if (tNode.parent == null ||\n // We should also eagerly insert if the parent is a regular, non-component element\n // since we know that this relationship will never be broken.\n tNode.parent.type === 3 /* Element */ && !(tNode.parent.flags & 4096 /* isComponent */)) {\n return true;\n }\n // Parent is a Component. Component's content nodes are not inserted immediately\n // because they will be projected, and so doing insert at this point would be wasteful.\n // Since the projection would than move it to its final destination.\n return false;\n}\n/**\n * We might delay insertion of children for a given view if it is disconnected.\n * This might happen for 2 main reasons:\n * - view is not inserted into any container (view was created but not inserted yet)\n * - view is inserted into a container but the container itself is not inserted into the DOM\n * (container might be part of projection or child of a view that is not inserted yet).\n *\n * In other words we can insert children of a given view if this view was inserted into a container\n * and\n * the container itself has its render parent determined.\n */\nfunction canInsertNativeChildOfView(viewTNode, view) {\n // Because we are inserting into a `View` the `View` may be disconnected.\n var container = getLContainer(viewTNode, view);\n if (container == null || container[RENDER_PARENT] == null) {\n // The `View` is not inserted into a `Container` or the parent `Container`\n // itself is disconnected. So we have to delay.\n return false;\n }\n // The parent `Container` is in inserted state, so we can eagerly insert into\n // this location.\n return true;\n}\n/**\n * Returns whether a native element can be inserted into the given parent.\n *\n * There are two reasons why we may not be able to insert a element immediately.\n * - Projection: When creating a child content element of a component, we have to skip the\n * insertion because the content of a component will be projected.\n * `delayed due to projection`\n * - Parent container is disconnected: This can happen when we are inserting a view into\n * parent container, which itself is disconnected. For example the parent container is part\n * of a View which has not be inserted or is mare for projection but has not been inserted\n * into destination.\n *\n\n *\n * @param tNode The tNode of the node that we want to insert.\n * @param currentView Current LView being processed.\n * @return boolean Whether the node should be inserted now (or delayed until later).\n */\nfunction canInsertNativeNode(tNode, currentView) {\n var currentNode = tNode;\n var parent = tNode.parent;\n if (tNode.parent) {\n if (tNode.parent.type === 4 /* ElementContainer */) {\n currentNode = getHighestElementContainer(tNode);\n parent = currentNode.parent;\n }\n else if (tNode.parent.type === 5 /* IcuContainer */) {\n currentNode = getFirstParentNative(currentNode);\n parent = currentNode.parent;\n }\n }\n if (parent === null)\n parent = currentView[HOST_NODE];\n if (parent && parent.type === 2 /* View */) {\n return canInsertNativeChildOfView(parent, currentView);\n }\n else {\n // Parent is a regular element or a component\n return canInsertNativeChildOfElement(currentNode);\n }\n}\n/**\n * Inserts a native node before another native node for a given parent using {@link Renderer3}.\n * This is a utility function that can be used when native nodes were determined - it abstracts an\n * actual renderer being used.\n */\nfunction nativeInsertBefore(renderer, parent, child, beforeNode) {\n if (isProceduralRenderer(renderer)) {\n renderer.insertBefore(parent, child, beforeNode);\n }\n else {\n parent.insertBefore(child, beforeNode, true);\n }\n}\n/**\n * Returns a native parent of a given native node.\n */\nfunction nativeParentNode(renderer, node) {\n return (isProceduralRenderer(renderer) ? renderer.parentNode(node) : node.parentNode);\n}\n/**\n * Returns a native sibling of a given native node.\n */\nfunction nativeNextSibling(renderer, node) {\n return isProceduralRenderer(renderer) ? renderer.nextSibling(node) : node.nextSibling;\n}\n/**\n * Appends the `child` element to the `parent`.\n *\n * The element insertion might be delayed {@link canInsertNativeNode}.\n *\n * @param childEl The child that should be appended\n * @param childTNode The TNode of the child element\n * @param currentView The current LView\n * @returns Whether or not the child was appended\n */\nfunction appendChild(childEl, childTNode, currentView) {\n if (childEl === void 0) { childEl = null; }\n if (childEl !== null && canInsertNativeNode(childTNode, currentView)) {\n var renderer = currentView[RENDERER];\n var parentEl = getParentNative(childTNode, currentView);\n var parentTNode = childTNode.parent || currentView[HOST_NODE];\n if (parentTNode.type === 2 /* View */) {\n var lContainer = getLContainer(parentTNode, currentView);\n var views = lContainer[VIEWS];\n var index = views.indexOf(currentView);\n nativeInsertBefore(renderer, lContainer[RENDER_PARENT], childEl, getBeforeNodeForView(index, views, lContainer[NATIVE]));\n }\n else if (parentTNode.type === 4 /* ElementContainer */) {\n var renderParent = getRenderParent(childTNode, currentView);\n nativeInsertBefore(renderer, renderParent, childEl, parentEl);\n }\n else if (parentTNode.type === 5 /* IcuContainer */) {\n var icuAnchorNode = getNativeByTNode(childTNode.parent, currentView);\n nativeInsertBefore(renderer, parentEl, childEl, icuAnchorNode);\n }\n else {\n isProceduralRenderer(renderer) ? renderer.appendChild(parentEl, childEl) :\n parentEl.appendChild(childEl);\n }\n return true;\n }\n return false;\n}\n/**\n * Gets the top-level ng-container if ng-containers are nested.\n *\n * @param ngContainer The TNode of the starting ng-container\n * @returns tNode The TNode of the highest level ng-container\n */\nfunction getHighestElementContainer(ngContainer) {\n while (ngContainer.parent != null && ngContainer.parent.type === 4 /* ElementContainer */) {\n ngContainer = ngContainer.parent;\n }\n return ngContainer;\n}\nfunction getBeforeNodeForView(index, views, containerNative) {\n if (index + 1 < views.length) {\n var view = views[index + 1];\n var viewTNode = view[HOST_NODE];\n return viewTNode.child ? getNativeByTNode(viewTNode.child, view) : containerNative;\n }\n else {\n return containerNative;\n }\n}\n/**\n * Removes the `child` element from the DOM if not in view and not projected.\n *\n * @param childTNode The TNode of the child to remove\n * @param childEl The child that should be removed\n * @param currentView The current LView\n * @returns Whether or not the child was removed\n */\nfunction removeChild(childTNode, childEl, currentView) {\n // We only remove the element if not in View or not projected.\n if (childEl !== null && canInsertNativeNode(childTNode, currentView)) {\n var parentNative = getParentNative(childTNode, currentView);\n var renderer = currentView[RENDERER];\n isProceduralRenderer(renderer) ? renderer.removeChild(parentNative, childEl) :\n parentNative.removeChild(childEl);\n return true;\n }\n return false;\n}\n/**\n * Appends a projected node to the DOM, or in the case of a projected container,\n * appends the nodes from all of the container's active views to the DOM.\n *\n * @param projectedTNode The TNode to be projected\n * @param tProjectionNode The projection (ng-content) TNode\n * @param currentView Current LView\n * @param projectionView Projection view (view above current)\n */\nfunction appendProjectedNode(projectedTNode, tProjectionNode, currentView, projectionView) {\n var native = getNativeByTNode(projectedTNode, projectionView);\n appendChild(native, tProjectionNode, currentView);\n // the projected contents are processed while in the shadow view (which is the currentView)\n // therefore we need to extract the view where the host element lives since it's the\n // logical container of the content projected views\n attachPatchData(native, projectionView);\n var renderParent = getRenderParent(tProjectionNode, currentView);\n var nodeOrContainer = projectionView[projectedTNode.index];\n if (projectedTNode.type === 0 /* Container */) {\n // The node we are adding is a container and we are adding it to an element which\n // is not a component (no more re-projection).\n // Alternatively a container is projected at the root of a component's template\n // and can't be re-projected (as not content of any component).\n // Assign the final projection location in those cases.\n nodeOrContainer[RENDER_PARENT] = renderParent;\n var views = nodeOrContainer[VIEWS];\n for (var i = 0; i < views.length; i++) {\n addRemoveViewFromContainer(views[i], true, nodeOrContainer[NATIVE]);\n }\n }\n else {\n if (projectedTNode.type === 4 /* ElementContainer */) {\n var ngContainerChildTNode = projectedTNode.child;\n while (ngContainerChildTNode) {\n appendProjectedNode(ngContainerChildTNode, tProjectionNode, currentView, projectionView);\n ngContainerChildTNode = ngContainerChildTNode.next;\n }\n }\n if (isLContainer(nodeOrContainer)) {\n nodeOrContainer[RENDER_PARENT] = renderParent;\n appendChild(nodeOrContainer[NATIVE], tProjectionNode, currentView);\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 */\nfunction isCssClassMatching(nodeClassAttrVal, cssClassToMatch) {\n var nodeClassesLen = nodeClassAttrVal.length;\n var matchIndex = nodeClassAttrVal.indexOf(cssClassToMatch);\n var matchEndIdx = matchIndex + cssClassToMatch.length;\n if (matchIndex === -1 // no match\n || (matchIndex > 0 && nodeClassAttrVal[matchIndex - 1] !== ' ') // no space before\n ||\n (matchEndIdx < nodeClassesLen && nodeClassAttrVal[matchEndIdx] !== ' ')) // no space after\n {\n return false;\n }\n return true;\n}\n/**\n * A utility function to match an Ivy node static data against a simple CSS selector\n *\n * @param node static data to match\n * @param selector\n * @returns true if node matches the selector.\n */\nfunction isNodeMatchingSelector(tNode, selector) {\n ngDevMode && assertDefined(selector[0], 'Selector should have a tag name');\n var mode = 4 /* ELEMENT */;\n var nodeAttrs = tNode.attrs;\n var selectOnlyMarkerIdx = nodeAttrs ? nodeAttrs.indexOf(1 /* SelectOnly */) : -1;\n // When processing \":not\" selectors, we skip to the next \":not\" if the\n // current one doesn't match\n var skipToNextSelector = false;\n for (var i = 0; i < selector.length; i++) {\n var current = selector[i];\n if (typeof current === 'number') {\n // If we finish processing a :not selector and it hasn't failed, return false\n if (!skipToNextSelector && !isPositive(mode) && !isPositive(current)) {\n return false;\n }\n // If we are skipping to the next :not() and this mode flag is positive,\n // it's a part of the current :not() selector, and we should keep skipping\n if (skipToNextSelector && isPositive(current))\n continue;\n skipToNextSelector = false;\n mode = current | (mode & 1 /* NOT */);\n continue;\n }\n if (skipToNextSelector)\n continue;\n if (mode & 4 /* ELEMENT */) {\n mode = 2 /* ATTRIBUTE */ | mode & 1 /* NOT */;\n if (current !== '' && current !== tNode.tagName) {\n if (isPositive(mode))\n return false;\n skipToNextSelector = true;\n }\n }\n else {\n var attrName = mode & 8 /* CLASS */ ? 'class' : current;\n var attrIndexInNode = findAttrIndexInNode(attrName, nodeAttrs);\n if (attrIndexInNode === -1) {\n if (isPositive(mode))\n return false;\n skipToNextSelector = true;\n continue;\n }\n var selectorAttrValue = mode & 8 /* CLASS */ ? current : selector[++i];\n if (selectorAttrValue !== '') {\n var nodeAttrValue = void 0;\n var maybeAttrName = nodeAttrs[attrIndexInNode];\n if (selectOnlyMarkerIdx > -1 && attrIndexInNode > selectOnlyMarkerIdx) {\n nodeAttrValue = '';\n }\n else {\n ngDevMode && assertNotEqual(maybeAttrName, 0 /* NamespaceURI */, 'We do not match directives on namespaced attributes');\n nodeAttrValue = nodeAttrs[attrIndexInNode + 1];\n }\n if (mode & 8 /* CLASS */ &&\n !isCssClassMatching(nodeAttrValue, selectorAttrValue) ||\n mode & 2 /* ATTRIBUTE */ && selectorAttrValue !== nodeAttrValue) {\n if (isPositive(mode))\n return false;\n skipToNextSelector = true;\n }\n }\n }\n }\n return isPositive(mode) || skipToNextSelector;\n}\nfunction isPositive(mode) {\n return (mode & 1 /* NOT */) === 0;\n}\n/**\n * Examines an attributes definition array from a node to find the index of the\n * attribute with the specified name.\n *\n * NOTE: Will not find namespaced attributes.\n *\n * @param name the name of the attribute to find\n * @param attrs the attribute array to examine\n */\nfunction findAttrIndexInNode(name, attrs) {\n if (attrs === null)\n return -1;\n var selectOnlyMode = false;\n var i = 0;\n while (i < attrs.length) {\n var maybeAttrName = attrs[i];\n if (maybeAttrName === name) {\n return i;\n }\n else if (maybeAttrName === 0 /* NamespaceURI */) {\n // NOTE(benlesh): will not find namespaced attributes. This is by design.\n i += 4;\n }\n else {\n if (maybeAttrName === 1 /* SelectOnly */) {\n selectOnlyMode = true;\n }\n i += selectOnlyMode ? 1 : 2;\n }\n }\n return -1;\n}\nfunction isNodeMatchingSelectorList(tNode, selector) {\n for (var i = 0; i < selector.length; i++) {\n if (isNodeMatchingSelector(tNode, selector[i])) {\n return true;\n }\n }\n return false;\n}\nfunction getProjectAsAttrValue(tNode) {\n var nodeAttrs = tNode.attrs;\n if (nodeAttrs != null) {\n var ngProjectAsAttrIdx = nodeAttrs.indexOf(NG_PROJECT_AS_ATTR_NAME);\n // only check for ngProjectAs in attribute names, don't accidentally match attribute's value\n // (attribute names are stored at even indexes)\n if ((ngProjectAsAttrIdx & 1) === 0) {\n return nodeAttrs[ngProjectAsAttrIdx + 1];\n }\n }\n return null;\n}\n/**\n * Checks a given node against matching selectors and returns\n * selector index (or 0 if none matched).\n *\n * This function takes into account the ngProjectAs attribute: if present its value will be compared\n * to the raw (un-parsed) CSS selector instead of using standard selector matching logic.\n */\nfunction matchingSelectorIndex(tNode, selectors, textSelectors) {\n var ngProjectAsAttrVal = getProjectAsAttrValue(tNode);\n for (var i = 0; i < selectors.length; i++) {\n // if a node has the ngProjectAs attribute match it against unparsed selector\n // match a node against a parsed selector only if ngProjectAs attribute is not present\n if (ngProjectAsAttrVal === textSelectors[i] ||\n ngProjectAsAttrVal === null && isNodeMatchingSelectorList(tNode, selectors[i])) {\n return i + 1; // first matching selector \"captures\" a given node\n }\n }\n return 0;\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/** A special value which designates that a value has not changed. */\nvar NO_CHANGE = {};\n\n/**\n * Combines the binding value and a factory for an animation player.\n *\n * Used to bind a player to an element template binding (currently only\n * `[style]`, `[style.prop]`, `[class]` and `[class.name]` bindings\n * supported). The provided `factoryFn` function will be run once all\n * the associated bindings have been evaluated on the element and is\n * designed to return a player which will then be placed on the element.\n *\n * @param factoryFn The function that is used to create a player\n * once all the rendering-related (styling values) have been\n * processed for the element binding.\n * @param value The raw value that will be exposed to the binding\n * so that the binding can update its internal values when\n * any changes are evaluated.\n */\nfunction bindPlayerFactory(factoryFn, value) {\n return new BoundPlayerFactory(factoryFn, value);\n}\nvar BoundPlayerFactory = /** @class */ (function () {\n function BoundPlayerFactory(fn, value) {\n this.fn = fn;\n this.value = value;\n }\n return BoundPlayerFactory;\n}());\n\nvar CorePlayerHandler = /** @class */ (function () {\n function CorePlayerHandler() {\n this._players = [];\n }\n CorePlayerHandler.prototype.flushPlayers = function () {\n for (var i = 0; i < this._players.length; i++) {\n var player = this._players[i];\n if (!player.parent && player.state === 0 /* Pending */) {\n player.play();\n }\n }\n this._players.length = 0;\n };\n CorePlayerHandler.prototype.queuePlayer = function (player) { this._players.push(player); };\n return CorePlayerHandler;\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 createEmptyStylingContext(element, sanitizer, initialStylingValues) {\n return [\n null,\n sanitizer || null,\n initialStylingValues || [null],\n 0,\n 0,\n element || null,\n null,\n null // PreviousMultiStyleValue\n ];\n}\n/**\n * Used clone a copy of a pre-computed template of a styling context.\n *\n * A pre-computed template is designed to be computed once for a given element\n * (instructions.ts has logic for caching this).\n */\nfunction allocStylingContext(element, templateStyleContext) {\n // each instance gets a copy\n var context = templateStyleContext.slice();\n context[5 /* ElementPosition */] = element;\n return context;\n}\n/**\n * Retrieve the `StylingContext` at a given index.\n *\n * This method lazily creates the `StylingContext`. This is because in most cases\n * we have styling without any bindings. Creating `StylingContext` eagerly would mean that\n * every style declaration such as `
` would result `StyleContext`\n * which would create unnecessary memory pressure.\n *\n * @param index Index of the style allocation. See: `elementStyling`.\n * @param viewData The view to search for the styling context\n */\nfunction getStylingContext(index, viewData) {\n var storageIndex = index + HEADER_OFFSET;\n var slotValue = viewData[storageIndex];\n var wrapper = viewData;\n while (Array.isArray(slotValue)) {\n wrapper = slotValue;\n slotValue = slotValue[HOST];\n }\n if (isStylingContext(wrapper)) {\n return wrapper;\n }\n else {\n // This is an LViewData or an LContainer\n var stylingTemplate = getTNode(index, viewData).stylingTemplate;\n if (wrapper !== viewData) {\n storageIndex = HOST;\n }\n return wrapper[storageIndex] = stylingTemplate ?\n allocStylingContext(slotValue, stylingTemplate) :\n createEmptyStylingContext(slotValue);\n }\n}\nfunction isStylingContext(value) {\n // Not an LViewData or an LContainer\n return typeof value[FLAGS] !== 'number' && typeof value[ACTIVE_INDEX] !== 'number';\n}\nfunction addPlayerInternal(playerContext, rootContext, element, player, playerContextIndex, ref) {\n ref = ref || element;\n if (playerContextIndex) {\n playerContext[playerContextIndex] = player;\n }\n else {\n playerContext.push(player);\n }\n if (player) {\n player.addEventListener(200 /* Destroyed */, function () {\n var index = playerContext.indexOf(player);\n var nonFactoryPlayerIndex = playerContext[0 /* NonBuilderPlayersStart */];\n // if the player is being removed from the factory side of the context\n // (which is where the [style] and [class] bindings do their thing) then\n // that side of the array cannot be resized since the respective bindings\n // have pointer index values that point to the associated factory instance\n if (index) {\n if (index < nonFactoryPlayerIndex) {\n playerContext[index] = null;\n }\n else {\n playerContext.splice(index, 1);\n }\n }\n player.destroy();\n });\n var playerHandler = rootContext.playerHandler || (rootContext.playerHandler = new CorePlayerHandler());\n playerHandler.queuePlayer(player, ref);\n return true;\n }\n return false;\n}\nfunction getPlayersInternal(playerContext) {\n var players = [];\n var nonFactoryPlayersStart = playerContext[0 /* NonBuilderPlayersStart */];\n // add all factory-based players (which are apart of [style] and [class] bindings)\n for (var i = 1 /* PlayerBuildersStartPosition */ + 1 /* PlayerOffsetPosition */; i < nonFactoryPlayersStart; i += 2 /* PlayerAndPlayerBuildersTupleSize */) {\n var player = playerContext[i];\n if (player) {\n players.push(player);\n }\n }\n // add all custom players (not apart of [style] and [class] bindings)\n for (var i = nonFactoryPlayersStart; i < playerContext.length; i++) {\n players.push(playerContext[i]);\n }\n return players;\n}\nfunction getOrCreatePlayerContext(target, context) {\n context = context || getContext(target);\n if (!context) {\n ngDevMode && throwInvalidRefError();\n return null;\n }\n var lViewData = context.lViewData, nodeIndex = context.nodeIndex;\n var stylingContext = getStylingContext(nodeIndex - HEADER_OFFSET, lViewData);\n return getPlayerContext(stylingContext) || allocPlayerContext(stylingContext);\n}\nfunction getPlayerContext(stylingContext) {\n return stylingContext[0 /* PlayerContext */];\n}\nfunction allocPlayerContext(data) {\n return data[0 /* PlayerContext */] =\n [5 /* SinglePlayerBuildersStartPosition */, null, null, null, null];\n}\nfunction throwInvalidRefError() {\n throw new Error('Only elements that exist in an Angular application can be used for animations');\n}\n\nvar EMPTY_ARR = [];\nvar EMPTY_OBJ = {};\n/**\n * Creates a styling context template where styling information is stored.\n * Any styles that are later referenced using `updateStyleProp` must be\n * passed in within this function. Initial values for those styles are to\n * be declared after all initial style properties are declared (this change in\n * mode between declarations and initial styles is made possible using a special\n * enum value found in `definition.ts`).\n *\n * @param initialStyleDeclarations a list of style declarations and initial style values\n * that are used later within the styling context.\n *\n * -> ['width', 'height', SPECIAL_ENUM_VAL, 'width', '100px']\n * This implies that `width` and `height` will be later styled and that the `width`\n * property has an initial value of `100px`.\n *\n * @param initialClassDeclarations a list of class declarations and initial class values\n * that are used later within the styling context.\n *\n * -> ['foo', 'bar', SPECIAL_ENUM_VAL, 'foo', true]\n * This implies that `foo` and `bar` will be later styled and that the `foo`\n * class will be applied to the element as an initial class since it's true\n */\nfunction createStylingContextTemplate(initialClassDeclarations, initialStyleDeclarations, styleSanitizer, onlyProcessSingleClasses) {\n var initialStylingValues = [null];\n var context = createEmptyStylingContext(null, styleSanitizer, initialStylingValues);\n // we use two maps since a class name might collide with a CSS style prop\n var stylesLookup = {};\n var classesLookup = {};\n var totalStyleDeclarations = 0;\n if (initialStyleDeclarations) {\n var hasPassedDeclarations = false;\n for (var i = 0; i < initialStyleDeclarations.length; i++) {\n var v = initialStyleDeclarations[i];\n // this flag value marks where the declarations end the initial values begin\n if (v === 1 /* VALUES_MODE */) {\n hasPassedDeclarations = true;\n }\n else {\n var prop = v;\n if (hasPassedDeclarations) {\n var value = initialStyleDeclarations[++i];\n initialStylingValues.push(value);\n stylesLookup[prop] = initialStylingValues.length - 1;\n }\n else {\n totalStyleDeclarations++;\n stylesLookup[prop] = 0;\n }\n }\n }\n }\n // make where the class offsets begin\n context[4 /* ClassOffsetPosition */] = totalStyleDeclarations;\n var initialStaticClasses = onlyProcessSingleClasses ? [] : null;\n if (initialClassDeclarations) {\n var hasPassedDeclarations = false;\n for (var i = 0; i < initialClassDeclarations.length; i++) {\n var v = initialClassDeclarations[i];\n // this flag value marks where the declarations end the initial values begin\n if (v === 1 /* VALUES_MODE */) {\n hasPassedDeclarations = true;\n }\n else {\n var className = v;\n if (hasPassedDeclarations) {\n var value = initialClassDeclarations[++i];\n initialStylingValues.push(value);\n classesLookup[className] = initialStylingValues.length - 1;\n initialStaticClasses && initialStaticClasses.push(className);\n }\n else {\n classesLookup[className] = 0;\n }\n }\n }\n }\n var styleProps = Object.keys(stylesLookup);\n var classNames = Object.keys(classesLookup);\n var classNamesIndexStart = styleProps.length;\n var totalProps = styleProps.length + classNames.length;\n // *2 because we are filling for both single and multi style spaces\n var maxLength = totalProps * 4 /* Size */ * 2 + 8 /* SingleStylesStartPosition */;\n // we need to fill the array from the start so that we can access\n // both the multi and the single array positions in the same loop block\n for (var i = 8 /* SingleStylesStartPosition */; i < maxLength; i++) {\n context.push(null);\n }\n var singleStart = 8 /* SingleStylesStartPosition */;\n var multiStart = totalProps * 4 /* Size */ + 8 /* SingleStylesStartPosition */;\n // fill single and multi-level styles\n for (var i = 0; i < totalProps; i++) {\n var isClassBased_1 = i >= classNamesIndexStart;\n var prop = isClassBased_1 ? classNames[i - classNamesIndexStart] : styleProps[i];\n var indexForInitial = isClassBased_1 ? classesLookup[prop] : stylesLookup[prop];\n var initialValue = initialStylingValues[indexForInitial];\n var indexForMulti = i * 4 /* Size */ + multiStart;\n var indexForSingle = i * 4 /* Size */ + singleStart;\n var initialFlag = prepareInitialFlag(prop, isClassBased_1, styleSanitizer || null);\n setFlag(context, indexForSingle, pointers(initialFlag, indexForInitial, indexForMulti));\n setProp(context, indexForSingle, prop);\n setValue(context, indexForSingle, null);\n setPlayerBuilderIndex(context, indexForSingle, 0);\n var flagForMulti = initialFlag | (initialValue !== null ? 1 /* Dirty */ : 0 /* None */);\n setFlag(context, indexForMulti, pointers(flagForMulti, indexForInitial, indexForSingle));\n setProp(context, indexForMulti, prop);\n setValue(context, indexForMulti, null);\n setPlayerBuilderIndex(context, indexForMulti, 0);\n }\n // there is no initial value flag for the master index since it doesn't\n // reference an initial style value\n var masterFlag = pointers(0, 0, multiStart) |\n (onlyProcessSingleClasses ? 16 /* OnlyProcessSingleClasses */ : 0);\n setFlag(context, 3 /* MasterFlagPosition */, masterFlag);\n setContextDirty(context, initialStylingValues.length > 1);\n if (initialStaticClasses) {\n context[6 /* PreviousOrCachedMultiClassValue */] = initialStaticClasses.join(' ');\n }\n return context;\n}\n/**\n * Sets and resolves all `multi` styling on an `StylingContext` so that they can be\n * applied to the element once `renderStyleAndClassBindings` is called.\n *\n * All missing styles/class (any values that are not provided in the new `styles`\n * or `classes` params) will resolve to `null` within their respective positions\n * in the context.\n *\n * @param context The styling context that will be updated with the\n * newly provided style values.\n * @param classesInput The key/value map of CSS class names that will be used for the update.\n * @param stylesInput The key/value map of CSS styles that will be used for the update.\n */\nfunction updateStylingMap(context, classesInput, stylesInput) {\n stylesInput = stylesInput || null;\n var element = context[5 /* ElementPosition */];\n var classesPlayerBuilder = classesInput instanceof BoundPlayerFactory ?\n new ClassAndStylePlayerBuilder(classesInput, element, 1 /* Class */) :\n null;\n var stylesPlayerBuilder = stylesInput instanceof BoundPlayerFactory ?\n new ClassAndStylePlayerBuilder(stylesInput, element, 2 /* Style */) :\n null;\n var classesValue = classesPlayerBuilder ?\n classesInput.value :\n classesInput;\n var stylesValue = stylesPlayerBuilder ? stylesInput.value : stylesInput;\n // early exit (this is what's done to avoid using ctx.bind() to cache the value)\n var ignoreAllClassUpdates = limitToSingleClasses(context) || classesValue === NO_CHANGE ||\n classesValue === context[6 /* PreviousOrCachedMultiClassValue */];\n var ignoreAllStyleUpdates = stylesValue === NO_CHANGE || stylesValue === context[7 /* PreviousMultiStyleValue */];\n if (ignoreAllClassUpdates && ignoreAllStyleUpdates)\n return;\n context[6 /* PreviousOrCachedMultiClassValue */] = classesValue;\n context[7 /* PreviousMultiStyleValue */] = stylesValue;\n var classNames = EMPTY_ARR;\n var applyAllClasses = false;\n var playerBuildersAreDirty = false;\n var classesPlayerBuilderIndex = classesPlayerBuilder ? 1 /* ClassMapPlayerBuilderPosition */ : 0;\n if (hasPlayerBuilderChanged(context, classesPlayerBuilder, 1 /* ClassMapPlayerBuilderPosition */)) {\n setPlayerBuilder(context, classesPlayerBuilder, 1 /* ClassMapPlayerBuilderPosition */);\n playerBuildersAreDirty = true;\n }\n var stylesPlayerBuilderIndex = stylesPlayerBuilder ? 3 /* StyleMapPlayerBuilderPosition */ : 0;\n if (hasPlayerBuilderChanged(context, stylesPlayerBuilder, 3 /* StyleMapPlayerBuilderPosition */)) {\n setPlayerBuilder(context, stylesPlayerBuilder, 3 /* StyleMapPlayerBuilderPosition */);\n playerBuildersAreDirty = true;\n }\n // each time a string-based value pops up then it shouldn't require a deep\n // check of what's changed.\n if (!ignoreAllClassUpdates) {\n if (typeof classesValue == 'string') {\n classNames = classesValue.split(/\\s+/);\n // this boolean is used to avoid having to create a key/value map of `true` values\n // since a classname string implies that all those classes are added\n applyAllClasses = true;\n }\n else {\n classNames = classesValue ? Object.keys(classesValue) : EMPTY_ARR;\n }\n }\n var classes = (classesValue || EMPTY_OBJ);\n var styleProps = stylesValue ? Object.keys(stylesValue) : EMPTY_ARR;\n var styles = stylesValue || EMPTY_OBJ;\n var classesStartIndex = styleProps.length;\n var multiStartIndex = getMultiStartIndex(context);\n var dirty = false;\n var ctxIndex = multiStartIndex;\n var propIndex = 0;\n var propLimit = styleProps.length + classNames.length;\n // the main loop here will try and figure out how the shape of the provided\n // styles differ with respect to the context. Later if the context/styles/classes\n // are off-balance then they will be dealt in another loop after this one\n while (ctxIndex < context.length && propIndex < propLimit) {\n var isClassBased_2 = propIndex >= classesStartIndex;\n var processValue = (!isClassBased_2 && !ignoreAllStyleUpdates) || (isClassBased_2 && !ignoreAllClassUpdates);\n // when there is a cache-hit for a string-based class then we should\n // avoid doing any work diffing any of the changes\n if (processValue) {\n var adjustedPropIndex = isClassBased_2 ? propIndex - classesStartIndex : propIndex;\n var newProp = isClassBased_2 ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];\n var newValue = isClassBased_2 ? (applyAllClasses ? true : classes[newProp]) : styles[newProp];\n var playerBuilderIndex = isClassBased_2 ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n var prop = getProp(context, ctxIndex);\n if (prop === newProp) {\n var value = getValue(context, ctxIndex);\n var flag = getPointers(context, ctxIndex);\n setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);\n if (hasValueChanged(flag, value, newValue)) {\n setValue(context, ctxIndex, newValue);\n playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n var initialValue = getInitialValue(context, flag);\n // there is no point in setting this to dirty if the previously\n // rendered value was being referenced by the initial style (or null)\n if (hasValueChanged(flag, initialValue, newValue)) {\n setDirty(context, ctxIndex, true);\n dirty = true;\n }\n }\n }\n else {\n var indexOfEntry = findEntryPositionByProp(context, newProp, ctxIndex);\n if (indexOfEntry > 0) {\n // it was found at a later point ... just swap the values\n var valueToCompare = getValue(context, indexOfEntry);\n var flagToCompare = getPointers(context, indexOfEntry);\n swapMultiContextEntries(context, ctxIndex, indexOfEntry);\n if (hasValueChanged(flagToCompare, valueToCompare, newValue)) {\n var initialValue = getInitialValue(context, flagToCompare);\n setValue(context, ctxIndex, newValue);\n if (hasValueChanged(flagToCompare, initialValue, newValue)) {\n setDirty(context, ctxIndex, true);\n playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n dirty = true;\n }\n }\n }\n else {\n // we only care to do this if the insertion is in the middle\n var newFlag = prepareInitialFlag(newProp, isClassBased_2, getStyleSanitizer(context));\n playerBuildersAreDirty = playerBuildersAreDirty || !!playerBuilderIndex;\n insertNewMultiProperty(context, ctxIndex, isClassBased_2, newProp, newFlag, newValue, playerBuilderIndex);\n dirty = true;\n }\n }\n }\n ctxIndex += 4 /* Size */;\n propIndex++;\n }\n // this means that there are left-over values in the context that\n // were not included in the provided styles/classes and in this\n // case the goal is to \"remove\" them from the context (by nullifying)\n while (ctxIndex < context.length) {\n var flag = getPointers(context, ctxIndex);\n var isClassBased_3 = (flag & 2 /* Class */) === 2 /* Class */;\n var processValue = (!isClassBased_3 && !ignoreAllStyleUpdates) || (isClassBased_3 && !ignoreAllClassUpdates);\n if (processValue) {\n var value = getValue(context, ctxIndex);\n var doRemoveValue = valueExists(value, isClassBased_3);\n if (doRemoveValue) {\n setDirty(context, ctxIndex, true);\n setValue(context, ctxIndex, null);\n // we keep the player factory the same so that the `nulled` value can\n // be instructed into the player because removing a style and/or a class\n // is a valid animation player instruction.\n var playerBuilderIndex = isClassBased_3 ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n setPlayerBuilderIndex(context, ctxIndex, playerBuilderIndex);\n dirty = true;\n }\n }\n ctxIndex += 4 /* Size */;\n }\n // this means that there are left-over properties in the context that\n // were not detected in the context during the loop above. In that\n // case we want to add the new entries into the list\n var sanitizer = getStyleSanitizer(context);\n while (propIndex < propLimit) {\n var isClassBased_4 = propIndex >= classesStartIndex;\n var processValue = (!isClassBased_4 && !ignoreAllStyleUpdates) || (isClassBased_4 && !ignoreAllClassUpdates);\n if (processValue) {\n var adjustedPropIndex = isClassBased_4 ? propIndex - classesStartIndex : propIndex;\n var prop = isClassBased_4 ? classNames[adjustedPropIndex] : styleProps[adjustedPropIndex];\n var value = isClassBased_4 ? (applyAllClasses ? true : classes[prop]) : styles[prop];\n var flag = prepareInitialFlag(prop, isClassBased_4, sanitizer) | 1 /* Dirty */;\n var playerBuilderIndex = isClassBased_4 ? classesPlayerBuilderIndex : stylesPlayerBuilderIndex;\n context.push(flag, prop, value, playerBuilderIndex);\n dirty = true;\n }\n propIndex++;\n }\n if (dirty) {\n setContextDirty(context, true);\n }\n if (playerBuildersAreDirty) {\n setContextPlayersDirty(context, true);\n }\n}\n/**\n * Sets and resolves a single styling property/value on the provided `StylingContext` so\n * that they can be applied to the element once `renderStyleAndClassBindings` is called.\n *\n * Note that prop-level styling values are considered higher priority than any styling that\n * has been applied using `updateStylingMap`, therefore, when styling values are rendered\n * then any styles/classes that have been applied using this function will be considered first\n * (then multi values second and then initial values as a backup).\n *\n * @param context The styling context that will be updated with the\n * newly provided style value.\n * @param index The index of the property which is being updated.\n * @param value The CSS style value that will be assigned\n */\nfunction updateStyleProp(context, index, input) {\n var singleIndex = 8 /* SingleStylesStartPosition */ + index * 4 /* Size */;\n var currValue = getValue(context, singleIndex);\n var currFlag = getPointers(context, singleIndex);\n var value = (input instanceof BoundPlayerFactory) ? input.value : input;\n // didn't change ... nothing to make a note of\n if (hasValueChanged(currFlag, currValue, value)) {\n var isClassBased_5 = (currFlag & 2 /* Class */) === 2 /* Class */;\n var element = context[5 /* ElementPosition */];\n var playerBuilder = input instanceof BoundPlayerFactory ?\n new ClassAndStylePlayerBuilder(input, element, isClassBased_5 ? 1 /* Class */ : 2 /* Style */) :\n null;\n var value_1 = (playerBuilder ? input.value : input);\n var currPlayerIndex = getPlayerBuilderIndex(context, singleIndex);\n var playerBuildersAreDirty = false;\n var playerBuilderIndex = playerBuilder ? currPlayerIndex : 0;\n if (hasPlayerBuilderChanged(context, playerBuilder, currPlayerIndex)) {\n var newIndex = setPlayerBuilder(context, playerBuilder, currPlayerIndex);\n playerBuilderIndex = playerBuilder ? newIndex : 0;\n setPlayerBuilderIndex(context, singleIndex, playerBuilderIndex);\n playerBuildersAreDirty = true;\n }\n // the value will always get updated (even if the dirty flag is skipped)\n setValue(context, singleIndex, value_1);\n var indexForMulti = getMultiOrSingleIndex(currFlag);\n // if the value is the same in the multi-area then there's no point in re-assembling\n var valueForMulti = getValue(context, indexForMulti);\n if (!valueForMulti || hasValueChanged(currFlag, valueForMulti, value_1)) {\n var multiDirty = false;\n var singleDirty = true;\n // only when the value is set to `null` should the multi-value get flagged\n if (!valueExists(value_1, isClassBased_5) && valueExists(valueForMulti, isClassBased_5)) {\n multiDirty = true;\n singleDirty = false;\n }\n setDirty(context, indexForMulti, multiDirty);\n setDirty(context, singleIndex, singleDirty);\n setContextDirty(context, true);\n }\n if (playerBuildersAreDirty) {\n setContextPlayersDirty(context, true);\n }\n }\n}\n/**\n * This method will toggle the referenced CSS class (by the provided index)\n * within the given context.\n *\n * @param context The styling context that will be updated with the\n * newly provided class value.\n * @param index The index of the CSS class which is being updated.\n * @param addOrRemove Whether or not to add or remove the CSS class\n */\nfunction updateClassProp(context, index, addOrRemove) {\n var adjustedIndex = index + context[4 /* ClassOffsetPosition */];\n updateStyleProp(context, adjustedIndex, addOrRemove);\n}\n/**\n * Renders all queued styling using a renderer onto the given element.\n *\n * This function works by rendering any styles (that have been applied\n * using `updateStylingMap`) and any classes (that have been applied using\n * `updateStyleProp`) onto the provided element using the provided renderer.\n * Just before the styles/classes are rendered a final key/value style map\n * will be assembled (if `styleStore` or `classStore` are provided).\n *\n * @param lElement the element that the styles will be rendered on\n * @param context The styling context that will be used to determine\n * what styles will be rendered\n * @param renderer the renderer that will be used to apply the styling\n * @param classesStore if provided, the updated class values will be applied\n * to this key/value map instead of being renderered via the renderer.\n * @param stylesStore if provided, the updated style values will be applied\n * to this key/value map instead of being renderered via the renderer.\n * @returns number the total amount of players that got queued for animation (if any)\n */\nfunction renderStyleAndClassBindings(context, renderer, rootOrView, isFirstRender, classesStore, stylesStore) {\n var totalPlayersQueued = 0;\n if (isContextDirty(context)) {\n var flushPlayerBuilders = context[3 /* MasterFlagPosition */] & 8 /* PlayerBuildersDirty */;\n var native = context[5 /* ElementPosition */];\n var multiStartIndex = getMultiStartIndex(context);\n var styleSanitizer = getStyleSanitizer(context);\n var onlySingleClasses = limitToSingleClasses(context);\n for (var i = 8 /* SingleStylesStartPosition */; i < context.length; i += 4 /* Size */) {\n // there is no point in rendering styles that have not changed on screen\n if (isDirty(context, i)) {\n var prop = getProp(context, i);\n var value = getValue(context, i);\n var flag = getPointers(context, i);\n var playerBuilder = getPlayerBuilder(context, i);\n var isClassBased_6 = flag & 2 /* Class */ ? true : false;\n var isInSingleRegion = i < multiStartIndex;\n var readInitialValue = !isClassBased_6 || !onlySingleClasses;\n var valueToApply = value;\n // VALUE DEFER CASE 1: Use a multi value instead of a null single value\n // this check implies that a single value was removed and we\n // should now defer to a multi value and use that (if set).\n if (isInSingleRegion && !valueExists(valueToApply, isClassBased_6)) {\n // single values ALWAYS have a reference to a multi index\n var multiIndex = getMultiOrSingleIndex(flag);\n valueToApply = getValue(context, multiIndex);\n }\n // VALUE DEFER CASE 2: Use the initial value if all else fails (is falsy)\n // the initial value will always be a string or null,\n // therefore we can safely adopt it incase there's nothing else\n // note that this should always be a falsy check since `false` is used\n // for both class and style comparisons (styles can't be false and false\n // classes are turned off and should therefore defer to their initial values)\n if (!valueExists(valueToApply, isClassBased_6) && readInitialValue) {\n valueToApply = getInitialValue(context, flag);\n }\n // if the first render is true then we do not want to start applying falsy\n // values to the DOM element's styling. Otherwise then we know there has\n // been a change and even if it's falsy then it's removing something that\n // was truthy before.\n var doApplyValue = isFirstRender ? valueToApply : true;\n if (doApplyValue) {\n if (isClassBased_6) {\n setClass(native, prop, valueToApply ? true : false, renderer, classesStore, playerBuilder);\n }\n else {\n var sanitizer = (flag & 4 /* Sanitize */) ? styleSanitizer : null;\n setStyle(native, prop, valueToApply, renderer, sanitizer, stylesStore, playerBuilder);\n }\n }\n setDirty(context, i, false);\n }\n }\n if (flushPlayerBuilders) {\n var rootContext = Array.isArray(rootOrView) ? getRootContext(rootOrView) : rootOrView;\n var playerContext = getPlayerContext(context);\n var playersStartIndex = playerContext[0 /* NonBuilderPlayersStart */];\n for (var i = 1 /* PlayerBuildersStartPosition */; i < playersStartIndex; i += 2 /* PlayerAndPlayerBuildersTupleSize */) {\n var builder = playerContext[i];\n var playerInsertionIndex = i + 1 /* PlayerOffsetPosition */;\n var oldPlayer = playerContext[playerInsertionIndex];\n if (builder) {\n var player = builder.buildPlayer(oldPlayer, isFirstRender);\n if (player !== undefined) {\n if (player != null) {\n var wasQueued = addPlayerInternal(playerContext, rootContext, native, player, playerInsertionIndex);\n wasQueued && totalPlayersQueued++;\n }\n if (oldPlayer) {\n oldPlayer.destroy();\n }\n }\n }\n else if (oldPlayer) {\n // the player builder has been removed ... therefore we should delete the associated\n // player\n oldPlayer.destroy();\n }\n }\n setContextPlayersDirty(context, false);\n }\n setContextDirty(context, false);\n }\n return totalPlayersQueued;\n}\n/**\n * This function renders a given CSS prop/value entry using the\n * provided renderer. If a `store` value is provided then\n * that will be used a render context instead of the provided\n * renderer.\n *\n * @param native the DOM Element\n * @param prop the CSS style property that will be rendered\n * @param value the CSS style value that will be rendered\n * @param renderer\n * @param store an optional key/value map that will be used as a context to render styles on\n */\nfunction setStyle(native, prop, value, renderer, sanitizer, store, playerBuilder) {\n value = sanitizer && value ? sanitizer(prop, value) : value;\n if (store || playerBuilder) {\n if (store) {\n store.setValue(prop, value);\n }\n if (playerBuilder) {\n playerBuilder.setValue(prop, value);\n }\n }\n else if (value) {\n ngDevMode && ngDevMode.rendererSetStyle++;\n isProceduralRenderer(renderer) ?\n renderer.setStyle(native, prop, value, RendererStyleFlags3.DashCase) :\n native['style'].setProperty(prop, value);\n }\n else {\n ngDevMode && ngDevMode.rendererRemoveStyle++;\n isProceduralRenderer(renderer) ?\n renderer.removeStyle(native, prop, RendererStyleFlags3.DashCase) :\n native['style'].removeProperty(prop);\n }\n}\n/**\n * This function renders a given CSS class value using the provided\n * renderer (by adding or removing it from the provided element).\n * If a `store` value is provided then that will be used a render\n * context instead of the provided renderer.\n *\n * @param native the DOM Element\n * @param prop the CSS style property that will be rendered\n * @param value the CSS style value that will be rendered\n * @param renderer\n * @param store an optional key/value map that will be used as a context to render styles on\n */\nfunction setClass(native, className, add, renderer, store, playerBuilder) {\n if (store || playerBuilder) {\n if (store) {\n store.setValue(className, add);\n }\n if (playerBuilder) {\n playerBuilder.setValue(className, add);\n }\n }\n else if (add) {\n ngDevMode && ngDevMode.rendererAddClass++;\n isProceduralRenderer(renderer) ? renderer.addClass(native, className) :\n native['classList'].add(className);\n }\n else {\n ngDevMode && ngDevMode.rendererRemoveClass++;\n isProceduralRenderer(renderer) ? renderer.removeClass(native, className) :\n native['classList'].remove(className);\n }\n}\nfunction setDirty(context, index, isDirtyYes) {\n var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;\n if (isDirtyYes) {\n context[adjustedIndex] |= 1 /* Dirty */;\n }\n else {\n context[adjustedIndex] &= ~1 /* Dirty */;\n }\n}\nfunction isDirty(context, index) {\n var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;\n return (context[adjustedIndex] & 1 /* Dirty */) == 1 /* Dirty */;\n}\nfunction isClassBased(context, index) {\n var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;\n return (context[adjustedIndex] & 2 /* Class */) == 2 /* Class */;\n}\nfunction isSanitizable(context, index) {\n var adjustedIndex = index >= 8 /* SingleStylesStartPosition */ ? (index + 0 /* FlagsOffset */) : index;\n return (context[adjustedIndex] & 4 /* Sanitize */) == 4 /* Sanitize */;\n}\nfunction pointers(configFlag, staticIndex, dynamicIndex) {\n return (configFlag & 31 /* BitMask */) | (staticIndex << 5 /* BitCountSize */) |\n (dynamicIndex << (14 /* BitCountSize */ + 5 /* BitCountSize */));\n}\nfunction getInitialValue(context, flag) {\n var index = getInitialIndex(flag);\n return context[2 /* InitialStylesPosition */][index];\n}\nfunction getInitialIndex(flag) {\n return (flag >> 5 /* BitCountSize */) & 16383 /* BitMask */;\n}\nfunction getMultiOrSingleIndex(flag) {\n var index = (flag >> (14 /* BitCountSize */ + 5 /* BitCountSize */)) & 16383 /* BitMask */;\n return index >= 8 /* SingleStylesStartPosition */ ? index : -1;\n}\nfunction getMultiStartIndex(context) {\n return getMultiOrSingleIndex(context[3 /* MasterFlagPosition */]);\n}\nfunction getStyleSanitizer(context) {\n return context[1 /* StyleSanitizerPosition */];\n}\nfunction setProp(context, index, prop) {\n context[index + 1 /* PropertyOffset */] = prop;\n}\nfunction setValue(context, index, value) {\n context[index + 2 /* ValueOffset */] = value;\n}\nfunction hasPlayerBuilderChanged(context, builder, index) {\n var playerContext = context[0 /* PlayerContext */];\n if (builder) {\n if (!playerContext || index === 0) {\n return true;\n }\n }\n else if (!playerContext) {\n return false;\n }\n return playerContext[index] !== builder;\n}\nfunction setPlayerBuilder(context, builder, insertionIndex) {\n var playerContext = context[0 /* PlayerContext */] || allocPlayerContext(context);\n if (insertionIndex > 0) {\n playerContext[insertionIndex] = builder;\n }\n else {\n insertionIndex = playerContext[0 /* NonBuilderPlayersStart */];\n playerContext.splice(insertionIndex, 0, builder, null);\n playerContext[0 /* NonBuilderPlayersStart */] +=\n 2 /* PlayerAndPlayerBuildersTupleSize */;\n }\n return insertionIndex;\n}\nfunction setPlayerBuilderIndex(context, index, playerBuilderIndex) {\n context[index + 3 /* PlayerBuilderIndexOffset */] = playerBuilderIndex;\n}\nfunction getPlayerBuilderIndex(context, index) {\n return context[index + 3 /* PlayerBuilderIndexOffset */] || 0;\n}\nfunction getPlayerBuilder(context, index) {\n var playerBuilderIndex = getPlayerBuilderIndex(context, index);\n if (playerBuilderIndex) {\n var playerContext = context[0 /* PlayerContext */];\n if (playerContext) {\n return playerContext[playerBuilderIndex];\n }\n }\n return null;\n}\nfunction setFlag(context, index, flag) {\n var adjustedIndex = index === 3 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);\n context[adjustedIndex] = flag;\n}\nfunction getPointers(context, index) {\n var adjustedIndex = index === 3 /* MasterFlagPosition */ ? index : (index + 0 /* FlagsOffset */);\n return context[adjustedIndex];\n}\nfunction getValue(context, index) {\n return context[index + 2 /* ValueOffset */];\n}\nfunction getProp(context, index) {\n return context[index + 1 /* PropertyOffset */];\n}\nfunction isContextDirty(context) {\n return isDirty(context, 3 /* MasterFlagPosition */);\n}\nfunction limitToSingleClasses(context) {\n return context[3 /* MasterFlagPosition */] & 16 /* OnlyProcessSingleClasses */;\n}\nfunction setContextDirty(context, isDirtyYes) {\n setDirty(context, 3 /* MasterFlagPosition */, isDirtyYes);\n}\nfunction setContextPlayersDirty(context, isDirtyYes) {\n if (isDirtyYes) {\n context[3 /* MasterFlagPosition */] |= 8 /* PlayerBuildersDirty */;\n }\n else {\n context[3 /* MasterFlagPosition */] &= ~8 /* PlayerBuildersDirty */;\n }\n}\nfunction findEntryPositionByProp(context, prop, startIndex) {\n for (var i = (startIndex || 0) + 1 /* PropertyOffset */; i < context.length; i += 4 /* Size */) {\n var thisProp = context[i];\n if (thisProp == prop) {\n return i - 1 /* PropertyOffset */;\n }\n }\n return -1;\n}\nfunction swapMultiContextEntries(context, indexA, indexB) {\n var tmpValue = getValue(context, indexA);\n var tmpProp = getProp(context, indexA);\n var tmpFlag = getPointers(context, indexA);\n var tmpPlayerBuilderIndex = getPlayerBuilderIndex(context, indexA);\n var flagA = tmpFlag;\n var flagB = getPointers(context, indexB);\n var singleIndexA = getMultiOrSingleIndex(flagA);\n if (singleIndexA >= 0) {\n var _flag = getPointers(context, singleIndexA);\n var _initial = getInitialIndex(_flag);\n setFlag(context, singleIndexA, pointers(_flag, _initial, indexB));\n }\n var singleIndexB = getMultiOrSingleIndex(flagB);\n if (singleIndexB >= 0) {\n var _flag = getPointers(context, singleIndexB);\n var _initial = getInitialIndex(_flag);\n setFlag(context, singleIndexB, pointers(_flag, _initial, indexA));\n }\n setValue(context, indexA, getValue(context, indexB));\n setProp(context, indexA, getProp(context, indexB));\n setFlag(context, indexA, getPointers(context, indexB));\n setPlayerBuilderIndex(context, indexA, getPlayerBuilderIndex(context, indexB));\n setValue(context, indexB, tmpValue);\n setProp(context, indexB, tmpProp);\n setFlag(context, indexB, tmpFlag);\n setPlayerBuilderIndex(context, indexB, tmpPlayerBuilderIndex);\n}\nfunction updateSinglePointerValues(context, indexStartPosition) {\n for (var i = indexStartPosition; i < context.length; i += 4 /* Size */) {\n var multiFlag = getPointers(context, i);\n var singleIndex = getMultiOrSingleIndex(multiFlag);\n if (singleIndex > 0) {\n var singleFlag = getPointers(context, singleIndex);\n var initialIndexForSingle = getInitialIndex(singleFlag);\n var flagValue = (isDirty(context, singleIndex) ? 1 /* Dirty */ : 0 /* None */) |\n (isClassBased(context, singleIndex) ? 2 /* Class */ : 0 /* None */) |\n (isSanitizable(context, singleIndex) ? 4 /* Sanitize */ : 0 /* None */);\n var updatedFlag = pointers(flagValue, initialIndexForSingle, i);\n setFlag(context, singleIndex, updatedFlag);\n }\n }\n}\nfunction insertNewMultiProperty(context, index, classBased, name, flag, value, playerIndex) {\n var doShift = index < context.length;\n // prop does not exist in the list, add it in\n context.splice(index, 0, flag | 1 /* Dirty */ | (classBased ? 2 /* Class */ : 0 /* None */), name, value, playerIndex);\n if (doShift) {\n // because the value was inserted midway into the array then we\n // need to update all the shifted multi values' single value\n // pointers to point to the newly shifted location\n updateSinglePointerValues(context, index + 4 /* Size */);\n }\n}\nfunction valueExists(value, isClassBased) {\n if (isClassBased) {\n return value ? true : false;\n }\n return value !== null;\n}\nfunction prepareInitialFlag(name, isClassBased, sanitizer) {\n if (isClassBased) {\n return 2 /* Class */;\n }\n else if (sanitizer && sanitizer(name)) {\n return 4 /* Sanitize */;\n }\n return 0 /* None */;\n}\nfunction hasValueChanged(flag, a, b) {\n var isClassBased = flag & 2 /* Class */;\n var hasValues = a && b;\n var usesSanitizer = flag & 4 /* Sanitize */;\n // the toString() comparison ensures that a value is checked\n // ... otherwise (during sanitization bypassing) the === comparsion\n // would fail since a new String() instance is created\n if (!isClassBased && hasValues && usesSanitizer) {\n // we know for sure we're dealing with strings at this point\n return a.toString() !== b.toString();\n }\n // everything else is safe to check with a normal equality check\n return a !== b;\n}\nvar ClassAndStylePlayerBuilder = /** @class */ (function () {\n function ClassAndStylePlayerBuilder(factory, _element, _type) {\n this._element = _element;\n this._type = _type;\n this._values = {};\n this._dirty = false;\n this._factory = factory;\n }\n ClassAndStylePlayerBuilder.prototype.setValue = function (prop, value) {\n if (this._values[prop] !== value) {\n this._values[prop] = value;\n this._dirty = true;\n }\n };\n ClassAndStylePlayerBuilder.prototype.buildPlayer = function (currentPlayer, isFirstRender) {\n // if no values have been set here then this means the binding didn't\n // change and therefore the binding values were not updated through\n // `setValue` which means no new player will be provided.\n if (this._dirty) {\n var player = this._factory.fn(this._element, this._type, this._values, isFirstRender, currentPlayer || null);\n this._values = {};\n this._dirty = false;\n return player;\n }\n return undefined;\n };\n return ClassAndStylePlayerBuilder;\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 * A permanent marker promise which signifies that the current CD tree is\n * clean.\n */\nvar _CLEAN_PROMISE = Promise.resolve(null);\n/**\n * Refreshes the view, executing the following steps in that order:\n * triggers init hooks, refreshes dynamic embedded views, triggers content hooks, sets host\n * bindings, refreshes child components.\n * Note: view hooks are triggered later when leaving the view.\n */\nfunction refreshDescendantViews(viewData, rf) {\n var tView = getTView();\n var parentFirstTemplatePass = getFirstTemplatePass();\n // This needs to be set before children are processed to support recursive components\n tView.firstTemplatePass = false;\n setFirstTemplatePass(false);\n // Dynamically created views must run first only in creation mode. If this is a\n // creation-only pass, we should not call lifecycle hooks or evaluate bindings.\n // This will be done in the update-only pass.\n if (rf !== 1 /* Create */) {\n var creationMode = getCreationMode();\n var checkNoChangesMode = getCheckNoChangesMode();\n if (!checkNoChangesMode) {\n executeInitHooks(viewData, tView, creationMode);\n }\n refreshDynamicEmbeddedViews(viewData);\n // Content query results must be refreshed before content hooks are called.\n refreshContentQueries(tView);\n if (!checkNoChangesMode) {\n executeHooks(viewData, tView.contentHooks, tView.contentCheckHooks, creationMode);\n }\n setHostBindings(tView, viewData);\n }\n refreshChildComponents(tView.components, parentFirstTemplatePass, rf);\n}\n/** Sets the host bindings for the current view. */\nfunction setHostBindings(tView, viewData) {\n if (tView.expandoInstructions) {\n var bindingRootIndex = viewData[BINDING_INDEX] = tView.expandoStartIndex;\n setBindingRoot(bindingRootIndex);\n var currentDirectiveIndex = -1;\n var currentElementIndex = -1;\n for (var i = 0; i < tView.expandoInstructions.length; i++) {\n var instruction = tView.expandoInstructions[i];\n if (typeof instruction === 'number') {\n if (instruction <= 0) {\n // Negative numbers mean that we are starting new EXPANDO block and need to update\n // the current element and directive index.\n currentElementIndex = -instruction;\n // Injector block and providers are taken into account.\n var providerCount = tView.expandoInstructions[++i];\n bindingRootIndex += INJECTOR_SIZE + providerCount;\n currentDirectiveIndex = bindingRootIndex;\n }\n else {\n // This is either the injector size (so the binding root can skip over directives\n // and get to the first set of host bindings on this node) or the host var count\n // (to get to the next set of host bindings on this node).\n bindingRootIndex += instruction;\n }\n setBindingRoot(bindingRootIndex);\n }\n else {\n // If it's not a number, it's a host binding function that needs to be executed.\n viewData[BINDING_INDEX] = bindingRootIndex;\n // We must subtract the header offset because the load() instruction\n // expects a raw, unadjusted index.\n // : set the `previousOrParentTNode` so that hostBindings functions can\n // correctly retrieve it. This should be removed once we call the hostBindings function\n // inline as part of the `RenderFlags.Create` because in that case the value will already be\n // correctly set.\n setPreviousOrParentTNode(getTView().data[currentElementIndex + HEADER_OFFSET]);\n // \n instruction(currentDirectiveIndex - HEADER_OFFSET, currentElementIndex);\n currentDirectiveIndex++;\n }\n }\n }\n}\n/** Refreshes content queries for all directives in the given view. */\nfunction refreshContentQueries(tView) {\n if (tView.contentQueries != null) {\n for (var i = 0; i < tView.contentQueries.length; i += 2) {\n var directiveDefIdx = tView.contentQueries[i];\n var directiveDef = tView.data[directiveDefIdx];\n directiveDef.contentQueriesRefresh(directiveDefIdx - HEADER_OFFSET, tView.contentQueries[i + 1]);\n }\n }\n}\n/** Refreshes child components in the current view. */\nfunction refreshChildComponents(components, parentFirstTemplatePass, rf) {\n if (components != null) {\n for (var i = 0; i < components.length; i++) {\n componentRefresh(components[i], parentFirstTemplatePass, rf);\n }\n }\n}\nfunction createLViewData(parentViewData, renderer, tView, context, flags, sanitizer, injector) {\n var instance = tView.blueprint.slice();\n instance[FLAGS] = flags | 1 /* CreationMode */ | 8 /* Attached */ | 16 /* RunInit */;\n instance[PARENT] = instance[DECLARATION_VIEW] = parentViewData;\n instance[CONTEXT] = context;\n instance[INJECTOR] =\n injector === undefined ? (parentViewData ? parentViewData[INJECTOR] : null) : injector;\n instance[RENDERER] = renderer;\n instance[SANITIZER] = sanitizer || null;\n return instance;\n}\nfunction createNodeAtIndex(index, type, native, name, attrs) {\n var viewData = getViewData();\n var tView = getTView();\n var adjustedIndex = index + HEADER_OFFSET;\n ngDevMode &&\n assertLessThan(adjustedIndex, viewData.length, \"Slot should have been initialized with null\");\n viewData[adjustedIndex] = native;\n var tNode = tView.data[adjustedIndex];\n if (tNode == null) {\n var previousOrParentTNode = getPreviousOrParentTNode();\n var isParent = getIsParent();\n tNode = tView.data[adjustedIndex] =\n createTNode(viewData, type, adjustedIndex, name, attrs, null);\n // Now link ourselves into the tree.\n if (previousOrParentTNode) {\n if (isParent && previousOrParentTNode.child == null &&\n (tNode.parent !== null || previousOrParentTNode.type === 2 /* View */)) {\n // We are in the same view, which means we are adding content node to the parent view.\n previousOrParentTNode.child = tNode;\n }\n else if (!isParent) {\n previousOrParentTNode.next = tNode;\n }\n }\n }\n if (tView.firstChild == null && type === 3 /* Element */) {\n tView.firstChild = tNode;\n }\n setPreviousOrParentTNode(tNode);\n setIsParent(true);\n return tNode;\n}\nfunction createViewNode(index, view) {\n // View nodes are not stored in data because they can be added / removed at runtime (which\n // would cause indices to change). Their TNodes are instead stored in tView.node.\n if (view[TVIEW].node == null) {\n view[TVIEW].node = createTNode(view, 2 /* View */, index, null, null, null);\n }\n setIsParent(true);\n var tNode = view[TVIEW].node;\n setPreviousOrParentTNode(tNode);\n return view[HOST_NODE] = tNode;\n}\n/**\n * When elements are created dynamically after a view blueprint is created (e.g. through\n * i18nApply() or ComponentFactory.create), we need to adjust the blueprint for future\n * template passes.\n */\nfunction allocExpando(view) {\n var tView = view[TVIEW];\n if (tView.firstTemplatePass) {\n tView.expandoStartIndex++;\n tView.blueprint.push(null);\n tView.data.push(null);\n view.push(null);\n }\n}\n/**\n * Used for creating the LViewNode of a dynamic embedded view,\n * either through ViewContainerRef.createEmbeddedView() or TemplateRef.createEmbeddedView().\n * Such lViewNode will then be renderer with renderEmbeddedTemplate() (see below).\n */\nfunction createEmbeddedViewAndNode(tView, context, declarationView, renderer, queries, injectorIndex) {\n var _isParent = getIsParent();\n var _previousOrParentTNode = getPreviousOrParentTNode();\n setIsParent(true);\n setPreviousOrParentTNode(null);\n var lView = createLViewData(declarationView, renderer, tView, context, 2 /* CheckAlways */, getCurrentSanitizer());\n lView[DECLARATION_VIEW] = declarationView;\n if (queries) {\n lView[QUERIES] = queries.createView();\n }\n createViewNode(-1, lView);\n if (tView.firstTemplatePass) {\n tView.node.injectorIndex = injectorIndex;\n }\n setIsParent(_isParent);\n setPreviousOrParentTNode(_previousOrParentTNode);\n return lView;\n}\n/**\n * Used for rendering embedded views (e.g. dynamically created views)\n *\n * Dynamically created views must store/retrieve their TViews differently from component views\n * because their template functions are nested in the template functions of their hosts, creating\n * closures. If their host template happens to be an embedded template in a loop (e.g. ngFor inside\n * an ngFor), the nesting would mean we'd have multiple instances of the template function, so we\n * can't store TViews in the template function itself (as we do for comps). Instead, we store the\n * TView for dynamically created views on their host TNode, which only has one instance.\n */\nfunction renderEmbeddedTemplate(viewToRender, tView, context, rf) {\n var _isParent = getIsParent();\n var _previousOrParentTNode = getPreviousOrParentTNode();\n setIsParent(true);\n setPreviousOrParentTNode(null);\n var oldView;\n if (viewToRender[FLAGS] & 64 /* IsRoot */) {\n // This is a root view inside the view tree\n tickRootContext(getRootContext(viewToRender));\n }\n else {\n try {\n setIsParent(true);\n setPreviousOrParentTNode(null);\n oldView = enterView(viewToRender, viewToRender[HOST_NODE]);\n namespaceHTML();\n tView.template(rf, context);\n if (rf & 2 /* Update */) {\n refreshDescendantViews(viewToRender, null);\n }\n else {\n // This must be set to false immediately after the first creation run because in an\n // ngFor loop, all the views will be created together before update mode runs and turns\n // off firstTemplatePass. If we don't set it here, instances will perform directive\n // matching, etc again and again.\n viewToRender[TVIEW].firstTemplatePass = false;\n setFirstTemplatePass(false);\n }\n }\n finally {\n // renderEmbeddedTemplate() is called twice, once for creation only and then once for\n // update. When for creation only, leaveView() must not trigger view hooks, nor clean flags.\n var isCreationOnly = (rf & 1 /* Create */) === 1 /* Create */;\n leaveView(oldView, isCreationOnly);\n setIsParent(_isParent);\n setPreviousOrParentTNode(_previousOrParentTNode);\n }\n }\n}\n/**\n * Retrieves a context at the level specified and saves it as the global, contextViewData.\n * Will get the next level up if level is not specified.\n *\n * This is used to save contexts of parent views so they can be bound in embedded views, or\n * in conjunction with reference() to bind a ref from a parent view.\n *\n * @param level The relative level of the view from which to grab context compared to contextVewData\n * @returns context\n */\nfunction nextContext(level) {\n if (level === void 0) { level = 1; }\n return nextContextImpl(level);\n}\nfunction renderComponentOrTemplate(hostView, componentOrContext, rf, templateFn) {\n var rendererFactory = getRendererFactory();\n var oldView = enterView(hostView, hostView[HOST_NODE]);\n try {\n if (rendererFactory.begin) {\n rendererFactory.begin();\n }\n if (templateFn) {\n namespaceHTML();\n templateFn(rf || getRenderFlags(hostView), componentOrContext);\n }\n refreshDescendantViews(hostView, rf);\n }\n finally {\n if (rendererFactory.end) {\n rendererFactory.end();\n }\n leaveView(oldView);\n }\n}\n/**\n * This function returns the default configuration of rendering flags depending on when the\n * template is in creation mode or update mode. By default, the update block is run with the\n * creation block when the view is in creation mode. Otherwise, the update block is run\n * alone.\n *\n * Dynamically created views do NOT use this configuration (update block and create block are\n * always run separately).\n */\nfunction getRenderFlags(view) {\n return view[FLAGS] & 1 /* CreationMode */ ? 1 /* Create */ | 2 /* Update */ :\n 2 /* Update */;\n}\n//////////////////////////\n//// Namespace\n//////////////////////////\nvar _currentNamespace = null;\nfunction namespaceSVG() {\n _currentNamespace = 'http://www.w3.org/2000/svg/';\n}\nfunction namespaceMathML() {\n _currentNamespace = 'http://www.w3.org/1998/MathML/';\n}\nfunction namespaceHTML() {\n _currentNamespace = null;\n}\n//////////////////////////\n//// Element\n//////////////////////////\n/**\n * Creates an empty element using {@link elementStart} and {@link elementEnd}\n *\n * @param index Index of the element in the data array\n * @param name Name of the DOM Node\n * @param attrs Statically bound set of attributes to be written into the DOM element on creation.\n * @param localRefs A set of local reference bindings on the element.\n */\nfunction element(index, name, attrs, localRefs) {\n elementStart(index, name, attrs, localRefs);\n elementEnd();\n}\n/**\n * Creates a logical container for other nodes () backed by a comment node in the DOM.\n * The instruction must later be followed by `elementContainerEnd()` call.\n *\n * @param index Index of the element in the LViewData array\n * @param attrs Set of attributes to be used when matching directives.\n * @param localRefs A set of local reference bindings on the element.\n *\n * Even if this instruction accepts a set of attributes no actual attribute values are propagated to\n * the DOM (as a comment node can't have attributes). Attributes are here only for directive\n * matching purposes and setting initial inputs of directives.\n */\nfunction elementContainerStart(index, attrs, localRefs) {\n var viewData = getViewData();\n var tView = getTView();\n var renderer = getRenderer();\n ngDevMode && assertEqual(viewData[BINDING_INDEX], tView.bindingStartIndex, 'element containers should be created before any bindings');\n ngDevMode && ngDevMode.rendererCreateComment++;\n var native = renderer.createComment(ngDevMode ? 'ng-container' : '');\n ngDevMode && assertDataInRange(index - 1);\n var tNode = createNodeAtIndex(index, 4 /* ElementContainer */, native, null, attrs || null);\n appendChild(native, tNode, viewData);\n createDirectivesAndLocals(tView, viewData, localRefs);\n}\n/** Mark the end of the . */\nfunction elementContainerEnd() {\n var previousOrParentTNode = getPreviousOrParentTNode();\n var tView = getTView();\n if (getIsParent()) {\n setIsParent(false);\n }\n else {\n ngDevMode && assertHasParent();\n previousOrParentTNode = previousOrParentTNode.parent;\n setPreviousOrParentTNode(previousOrParentTNode);\n }\n ngDevMode && assertNodeType(previousOrParentTNode, 4 /* ElementContainer */);\n var currentQueries = getCurrentQueries();\n if (currentQueries) {\n setCurrentQueries(currentQueries.addNode(previousOrParentTNode));\n }\n queueLifecycleHooks(previousOrParentTNode.flags, tView);\n}\n/**\n * Create DOM element. The instruction must later be followed by `elementEnd()` call.\n *\n * @param index Index of the element in the LViewData array\n * @param name Name of the DOM Node\n * @param attrs Statically bound set of attributes to be written into the DOM element on creation.\n * @param localRefs A set of local reference bindings on the element.\n *\n * Attributes and localRefs are passed as an array of strings where elements with an even index\n * hold an attribute name and elements with an odd index hold an attribute value, ex.:\n * ['id', 'warning5', 'class', 'alert']\n */\nfunction elementStart(index, name, attrs, localRefs) {\n var viewData = getViewData();\n var tView = getTView();\n ngDevMode && assertEqual(viewData[BINDING_INDEX], tView.bindingStartIndex, 'elements should be created before any bindings ');\n ngDevMode && ngDevMode.rendererCreateElement++;\n var native = elementCreate(name);\n ngDevMode && assertDataInRange(index - 1);\n var tNode = createNodeAtIndex(index, 3 /* Element */, native, name, attrs || null);\n if (attrs) {\n setUpAttributes(native, attrs);\n }\n appendChild(native, tNode, viewData);\n createDirectivesAndLocals(tView, viewData, localRefs);\n // any immediate children of a component or template container must be pre-emptively\n // monkey-patched with the component view data so that the element can be inspected\n // later on using any element discovery utility methods (see `element_discovery.ts`)\n if (getElementDepthCount() === 0) {\n attachPatchData(native, viewData);\n }\n increaseElementDepthCount();\n}\n/**\n * Creates a native element from a tag name, using a renderer.\n * @param name the tag name\n * @param overriddenRenderer Optional A renderer to override the default one\n * @returns the element created\n */\nfunction elementCreate(name, overriddenRenderer) {\n var native;\n var rendererToUse = overriddenRenderer || getRenderer();\n if (isProceduralRenderer(rendererToUse)) {\n native = rendererToUse.createElement(name, _currentNamespace);\n }\n else {\n if (_currentNamespace === null) {\n native = rendererToUse.createElement(name);\n }\n else {\n native = rendererToUse.createElementNS(_currentNamespace, name);\n }\n }\n return native;\n}\n/**\n * Creates directive instances and populates local refs.\n *\n * @param localRefs Local refs of the node in question\n * @param localRefExtractor mapping function that extracts local ref value from TNode\n */\nfunction createDirectivesAndLocals(tView, viewData, localRefs, localRefExtractor) {\n if (localRefExtractor === void 0) { localRefExtractor = getNativeByTNode; }\n if (!getBindingsEnabled())\n return;\n var previousOrParentTNode = getPreviousOrParentTNode();\n if (getFirstTemplatePass()) {\n ngDevMode && ngDevMode.firstTemplatePass++;\n resolveDirectives(tView, viewData, findDirectiveMatches(tView, viewData, previousOrParentTNode), previousOrParentTNode, localRefs || null);\n }\n instantiateAllDirectives(tView, viewData, previousOrParentTNode);\n saveResolvedLocalsInData(viewData, previousOrParentTNode, localRefExtractor);\n}\n/**\n * Takes a list of local names and indices and pushes the resolved local variable values\n * to LViewData in the same order as they are loaded in the template with load().\n */\nfunction saveResolvedLocalsInData(viewData, tNode, localRefExtractor) {\n var localNames = tNode.localNames;\n if (localNames) {\n var localIndex = tNode.index + 1;\n for (var i = 0; i < localNames.length; i += 2) {\n var index = localNames[i + 1];\n var value = index === -1 ?\n localRefExtractor(tNode, viewData) :\n viewData[index];\n viewData[localIndex++] = value;\n }\n }\n}\n/**\n * Gets TView from a template function or creates a new TView\n * if it doesn't already exist.\n *\n * @param templateFn The template from which to get static data\n * @param consts The number of nodes, local refs, and pipes in this view\n * @param vars The number of bindings and pure function bindings in this view\n * @param directives Directive defs that should be saved on TView\n * @param pipes Pipe defs that should be saved on TView\n * @returns TView\n */\nfunction getOrCreateTView(templateFn, consts, vars, directives, pipes, viewQuery) {\n // TODO(misko): reading `ngPrivateData` here is problematic for two reasons\n // 1. It is a megamorphic call on each invocation.\n // 2. For nested embedded views (ngFor inside ngFor) the template instance is per\n // outer template invocation, which means that no such property will exist\n // Correct solution is to only put `ngPrivateData` on the Component template\n // and not on embedded templates.\n return templateFn.ngPrivateData ||\n (templateFn.ngPrivateData =\n createTView(-1, templateFn, consts, vars, directives, pipes, viewQuery));\n}\n/**\n * Creates a TView instance\n *\n * @param viewIndex The viewBlockId for inline views, or -1 if it's a component/dynamic\n * @param templateFn Template function\n * @param consts The number of nodes, local refs, and pipes in this template\n * @param directives Registry of directives for this view\n * @param pipes Registry of pipes for this view\n */\nfunction createTView(viewIndex, templateFn, consts, vars, directives, pipes, viewQuery) {\n ngDevMode && ngDevMode.tView++;\n var bindingStartIndex = HEADER_OFFSET + consts;\n // This length does not yet contain host bindings from child directives because at this point,\n // we don't know which directives are active on this template. As soon as a directive is matched\n // that has a host binding, we will update the blueprint with that def's hostVars count.\n var initialViewLength = bindingStartIndex + vars;\n var blueprint = createViewBlueprint(bindingStartIndex, initialViewLength);\n return blueprint[TVIEW] = {\n id: viewIndex,\n blueprint: blueprint,\n template: templateFn,\n viewQuery: viewQuery,\n node: null,\n data: blueprint.slice(),\n childIndex: -1,\n bindingStartIndex: bindingStartIndex,\n expandoStartIndex: initialViewLength,\n expandoInstructions: null,\n firstTemplatePass: true,\n initHooks: null,\n checkHooks: null,\n contentHooks: null,\n contentCheckHooks: null,\n viewHooks: null,\n viewCheckHooks: null,\n destroyHooks: null,\n pipeDestroyHooks: null,\n cleanup: null,\n contentQueries: null,\n components: null,\n directiveRegistry: typeof directives === 'function' ? directives() : directives,\n pipeRegistry: typeof pipes === 'function' ? pipes() : pipes,\n firstChild: null,\n };\n}\nfunction createViewBlueprint(bindingStartIndex, initialViewLength) {\n var blueprint = new Array(initialViewLength)\n .fill(null, 0, bindingStartIndex)\n .fill(NO_CHANGE, bindingStartIndex);\n blueprint[CONTAINER_INDEX] = -1;\n blueprint[BINDING_INDEX] = bindingStartIndex;\n return blueprint;\n}\nfunction setUpAttributes(native, attrs) {\n var renderer = getRenderer();\n var isProc = isProceduralRenderer(renderer);\n var i = 0;\n while (i < attrs.length) {\n var attrName = attrs[i];\n if (attrName === 1 /* SelectOnly */)\n break;\n if (attrName === NG_PROJECT_AS_ATTR_NAME) {\n i += 2;\n }\n else {\n ngDevMode && ngDevMode.rendererSetAttribute++;\n if (attrName === 0 /* NamespaceURI */) {\n // Namespaced attributes\n var namespaceURI = attrs[i + 1];\n var attrName_1 = attrs[i + 2];\n var attrVal = attrs[i + 3];\n isProc ?\n renderer\n .setAttribute(native, attrName_1, attrVal, namespaceURI) :\n native.setAttributeNS(namespaceURI, attrName_1, attrVal);\n i += 4;\n }\n else {\n // Standard attributes\n var attrVal = attrs[i + 1];\n isProc ?\n renderer\n .setAttribute(native, attrName, attrVal) :\n native.setAttribute(attrName, attrVal);\n i += 2;\n }\n }\n }\n}\nfunction createError(text, token) {\n return new Error(\"Renderer: \" + text + \" [\" + stringify$1(token) + \"]\");\n}\n/**\n * Locates the host native element, used for bootstrapping existing nodes into rendering pipeline.\n *\n * @param elementOrSelector Render element or CSS selector to locate the element.\n */\nfunction locateHostElement(factory, elementOrSelector) {\n ngDevMode && assertDataInRange(-1);\n setRendererFactory(factory);\n var defaultRenderer = factory.createRenderer(null, null);\n var rNode = typeof elementOrSelector === 'string' ?\n (isProceduralRenderer(defaultRenderer) ?\n defaultRenderer.selectRootElement(elementOrSelector) :\n defaultRenderer.querySelector(elementOrSelector)) :\n elementOrSelector;\n if (ngDevMode && !rNode) {\n if (typeof elementOrSelector === 'string') {\n throw createError('Host node with selector not found:', elementOrSelector);\n }\n else {\n throw createError('Host node is required:', elementOrSelector);\n }\n }\n return rNode;\n}\n/**\n * Adds an event listener to the current node.\n *\n * If an output exists on one of the node's directives, it also subscribes to the output\n * and saves the subscription for later cleanup.\n *\n * @param eventName Name of the event\n * @param listenerFn The function to be called when event emits\n * @param useCapture Whether or not to use capture in event listener.\n */\nfunction listener(eventName, listenerFn, useCapture) {\n if (useCapture === void 0) { useCapture = false; }\n var viewData = getViewData();\n var tNode = getPreviousOrParentTNode();\n ngDevMode && assertNodeOfPossibleTypes(tNode, 3 /* Element */, 0 /* Container */, 4 /* ElementContainer */);\n // add native event listener - applicable to elements only\n if (tNode.type === 3 /* Element */) {\n var native = getNativeByTNode(tNode, viewData);\n ngDevMode && ngDevMode.rendererAddEventListener++;\n var renderer = getRenderer();\n // In order to match current behavior, native DOM event listeners must be added for all\n // events (including outputs).\n if (isProceduralRenderer(renderer)) {\n var cleanupFn = renderer.listen(native, eventName, listenerFn);\n storeCleanupFn(viewData, cleanupFn);\n }\n else {\n var wrappedListener = wrapListenerWithPreventDefault(listenerFn);\n native.addEventListener(eventName, wrappedListener, useCapture);\n var cleanupInstances = getCleanup(viewData);\n cleanupInstances.push(wrappedListener);\n if (getFirstTemplatePass()) {\n getTViewCleanup(viewData).push(eventName, tNode.index, cleanupInstances.length - 1, useCapture);\n }\n }\n }\n // subscribe to directive outputs\n if (tNode.outputs === undefined) {\n // if we create TNode here, inputs must be undefined so we know they still need to be\n // checked\n tNode.outputs = generatePropertyAliases(tNode.flags, 1 /* Output */);\n }\n var outputs = tNode.outputs;\n var outputData;\n if (outputs && (outputData = outputs[eventName])) {\n createOutput(viewData, outputData, listenerFn);\n }\n}\n/**\n * Iterates through the outputs associated with a particular event name and subscribes to\n * each output.\n */\nfunction createOutput(viewData, outputs, listener) {\n for (var i = 0; i < outputs.length; i += 2) {\n ngDevMode && assertDataInRange(outputs[i], viewData);\n var subscription = viewData[outputs[i]][outputs[i + 1]].subscribe(listener);\n storeCleanupWithContext(viewData, subscription, subscription.unsubscribe);\n }\n}\n/**\n * Saves context for this cleanup function in LView.cleanupInstances.\n *\n * On the first template pass, saves in TView:\n * - Cleanup function\n * - Index of context we just saved in LView.cleanupInstances\n */\nfunction storeCleanupWithContext(view, context, cleanupFn) {\n if (!view)\n view = getViewData();\n getCleanup(view).push(context);\n if (view[TVIEW].firstTemplatePass) {\n getTViewCleanup(view).push(cleanupFn, view[CLEANUP].length - 1);\n }\n}\n/**\n * Saves the cleanup function itself in LView.cleanupInstances.\n *\n * This is necessary for functions that are wrapped with their contexts, like in renderer2\n * listeners.\n *\n * On the first template pass, the index of the cleanup function is saved in TView.\n */\nfunction storeCleanupFn(view, cleanupFn) {\n getCleanup(view).push(cleanupFn);\n if (view[TVIEW].firstTemplatePass) {\n getTViewCleanup(view).push(view[CLEANUP].length - 1, null);\n }\n}\n/** Mark the end of the element. */\nfunction elementEnd() {\n var previousOrParentTNode = getPreviousOrParentTNode();\n if (getIsParent()) {\n setIsParent(false);\n }\n else {\n ngDevMode && assertHasParent();\n previousOrParentTNode = previousOrParentTNode.parent;\n setPreviousOrParentTNode(previousOrParentTNode);\n }\n ngDevMode && assertNodeType(previousOrParentTNode, 3 /* Element */);\n var currentQueries = getCurrentQueries();\n if (currentQueries) {\n setCurrentQueries(currentQueries.addNode(previousOrParentTNode));\n }\n queueLifecycleHooks(previousOrParentTNode.flags, getTView());\n decreaseElementDepthCount();\n}\n/**\n * Updates the value of removes an attribute on an Element.\n *\n * @param number index The index of the element in the data array\n * @param name name The name of the attribute.\n * @param value value The attribute is removed when value is `null` or `undefined`.\n * Otherwise the attribute value is set to the stringified value.\n * @param sanitizer An optional function used to sanitize the value.\n */\nfunction elementAttribute(index, name, value, sanitizer) {\n if (value !== NO_CHANGE) {\n var viewData = getViewData();\n var renderer = getRenderer();\n var element_1 = getNativeByIndex(index, viewData);\n if (value == null) {\n ngDevMode && ngDevMode.rendererRemoveAttribute++;\n isProceduralRenderer(renderer) ? renderer.removeAttribute(element_1, name) :\n element_1.removeAttribute(name);\n }\n else {\n ngDevMode && ngDevMode.rendererSetAttribute++;\n var strValue = sanitizer == null ? stringify$1(value) : sanitizer(value);\n isProceduralRenderer(renderer) ? renderer.setAttribute(element_1, name, strValue) :\n element_1.setAttribute(name, strValue);\n }\n }\n}\n/**\n * Update a property on an Element.\n *\n * If the property name also exists as an input property on one of the element's directives,\n * the component property will be set instead of the element property. This check must\n * be conducted at runtime so child components that add new @Inputs don't have to be re-compiled.\n *\n * @param index The index of the element to update in the data array\n * @param propName Name of property. Because it is going to DOM, this is not subject to\n * renaming as part of minification.\n * @param value New value to write.\n * @param sanitizer An optional function used to sanitize the value.\n */\nfunction elementProperty(index, propName, value, sanitizer) {\n if (value === NO_CHANGE)\n return;\n var viewData = getViewData();\n var element = getNativeByIndex(index, viewData);\n var tNode = getTNode(index, viewData);\n var inputData = initializeTNodeInputs(tNode);\n var dataValue;\n if (inputData && (dataValue = inputData[propName])) {\n setInputsForProperty(viewData, dataValue, value);\n if (isComponent(tNode))\n markDirtyIfOnPush(viewData, index + HEADER_OFFSET);\n }\n else if (tNode.type === 3 /* Element */) {\n var renderer = getRenderer();\n // It is assumed that the sanitizer is only added when the compiler determines that the property\n // is risky, so sanitization can be done without further checks.\n value = sanitizer != null ? sanitizer(value) : value;\n ngDevMode && ngDevMode.rendererSetProperty++;\n isProceduralRenderer(renderer) ?\n renderer.setProperty(element, propName, value) :\n (element.setProperty ? element.setProperty(propName, value) :\n element[propName] = value);\n }\n}\n/**\n * Constructs a TNode object from the arguments.\n *\n * @param type The type of the node\n * @param adjustedIndex The index of the TNode in TView.data, adjusted for HEADER_OFFSET\n * @param tagName The tag name of the node\n * @param attrs The attributes defined on this node\n * @param tViews Any TViews attached to this node\n * @returns the TNode object\n */\nfunction createTNode(viewData, type, adjustedIndex, tagName, attrs, tViews) {\n var previousOrParentTNode = getPreviousOrParentTNode();\n ngDevMode && ngDevMode.tNode++;\n var parent = getIsParent() ? previousOrParentTNode : previousOrParentTNode && previousOrParentTNode.parent;\n // Parents cannot cross component boundaries because components will be used in multiple places,\n // so it's only set if the view is the same.\n var parentInSameView = parent && viewData && parent !== viewData[HOST_NODE];\n var tParent = parentInSameView ? parent : null;\n return {\n type: type,\n index: adjustedIndex,\n injectorIndex: tParent ? tParent.injectorIndex : -1,\n flags: 0,\n providerIndexes: 0,\n tagName: tagName,\n attrs: attrs,\n localNames: null,\n initialInputs: undefined,\n inputs: undefined,\n outputs: undefined,\n tViews: tViews,\n next: null,\n child: null,\n parent: tParent,\n detached: null,\n stylingTemplate: null,\n projection: null\n };\n}\n/**\n * Given a list of directive indices and minified input names, sets the\n * input properties on the corresponding directives.\n */\nfunction setInputsForProperty(viewData, inputs, value) {\n for (var i = 0; i < inputs.length; i += 2) {\n ngDevMode && assertDataInRange(inputs[i], viewData);\n viewData[inputs[i]][inputs[i + 1]] = value;\n }\n}\n/**\n * Consolidates all inputs or outputs of all directives on this logical node.\n *\n * @param number tNodeFlags node flags\n * @param Direction direction whether to consider inputs or outputs\n * @returns PropertyAliases|null aggregate of all properties if any, `null` otherwise\n */\nfunction generatePropertyAliases(tNodeFlags, direction) {\n var tView = getTView();\n var count = tNodeFlags & 4095 /* DirectiveCountMask */;\n var propStore = null;\n if (count > 0) {\n var start = tNodeFlags >> 16 /* DirectiveStartingIndexShift */;\n var end = start + count;\n var isInput = direction === 0 /* Input */;\n var defs = tView.data;\n for (var i = start; i < end; i++) {\n var directiveDef = defs[i];\n var propertyAliasMap = isInput ? directiveDef.inputs : directiveDef.outputs;\n for (var publicName in propertyAliasMap) {\n if (propertyAliasMap.hasOwnProperty(publicName)) {\n propStore = propStore || {};\n var internalName = propertyAliasMap[publicName];\n var hasProperty = propStore.hasOwnProperty(publicName);\n hasProperty ? propStore[publicName].push(i, internalName) :\n (propStore[publicName] = [i, internalName]);\n }\n }\n }\n }\n return propStore;\n}\n/**\n * Add or remove a class in a `classList` on a DOM element.\n *\n * This instruction is meant to handle the [class.foo]=\"exp\" case\n *\n * @param index The index of the element to update in the data array\n * @param classIndex Index of class to toggle. Because it is going to DOM, this is not subject to\n * renaming as part of minification.\n * @param value A value indicating if a given class should be added or removed.\n * @param directiveIndex the index for the directive that is attempting to change styling.\n */\nfunction elementClassProp(index, classIndex, value, directiveIndex) {\n if (directiveIndex != undefined) {\n return hackImplementationOfElementClassProp(index, classIndex, value, directiveIndex); // proper supported in next PR\n }\n var val = (value instanceof BoundPlayerFactory) ? value : (!!value);\n updateClassProp(getStylingContext(index, getViewData()), classIndex, val);\n}\n/**\n * Assign any inline style values to the element during creation mode.\n *\n * This instruction is meant to be called during creation mode to apply all styling\n * (e.g. `style=\"...\"`) values to the element. This is also where the provided index\n * value is allocated for the styling details for its corresponding element (the element\n * index is the previous index value from this one).\n *\n * (Note this function calls `elementStylingApply` immediately when called.)\n *\n *\n * @param index Index value which will be allocated to store styling data for the element.\n * (Note that this is not the element index, but rather an index value allocated\n * specifically for element styling--the index must be the next index after the element\n * index.)\n * @param classDeclarations A key/value array of CSS classes that will be registered on the element.\n * Each individual style will be used on the element as long as it is not overridden\n * by any classes placed on the element by multiple (`[class]`) or singular (`[class.named]`)\n * bindings. If a class binding changes its value to a falsy value then the matching initial\n * class value that are passed in here will be applied to the element (if matched).\n * @param styleDeclarations A key/value array of CSS styles that will be registered on the element.\n * Each individual style will be used on the element as long as it is not overridden\n * by any styles placed on the element by multiple (`[style]`) or singular (`[style.prop]`)\n * bindings. If a style binding changes its value to null then the initial styling\n * values that are passed in here will be applied to the element (if matched).\n * @param styleSanitizer An optional sanitizer function that will be used (if provided)\n * to sanitize the any CSS property values that are applied to the element (during rendering).\n * @param directiveIndex the index for the directive that is attempting to change styling.\n */\nfunction elementStyling(classDeclarations, styleDeclarations, styleSanitizer, directiveIndex) {\n if (directiveIndex !== undefined) {\n getCreationMode() &&\n hackImplementationOfElementStyling(classDeclarations || null, styleDeclarations || null, styleSanitizer || null, directiveIndex); // supported in next PR\n return;\n }\n var tNode = getPreviousOrParentTNode();\n var inputData = initializeTNodeInputs(tNode);\n if (!tNode.stylingTemplate) {\n var hasClassInput = inputData && inputData.hasOwnProperty('class') ? true : false;\n if (hasClassInput) {\n tNode.flags |= 32768 /* hasClassInput */;\n }\n // initialize the styling template.\n tNode.stylingTemplate = createStylingContextTemplate(classDeclarations, styleDeclarations, styleSanitizer, hasClassInput);\n }\n if (styleDeclarations && styleDeclarations.length ||\n classDeclarations && classDeclarations.length) {\n var index = tNode.index - HEADER_OFFSET;\n if (delegateToClassInput(tNode)) {\n var stylingContext = getStylingContext(index, getViewData());\n var initialClasses = stylingContext[6 /* PreviousOrCachedMultiClassValue */];\n setInputsForProperty(getViewData(), tNode.inputs['class'], initialClasses);\n }\n elementStylingApply(index);\n }\n}\n/**\n * Apply all styling values to the element which have been queued by any styling instructions.\n *\n * This instruction is meant to be run once one or more `elementStyle` and/or `elementStyleProp`\n * have been issued against the element. This function will also determine if any styles have\n * changed and will then skip the operation if there is nothing new to render.\n *\n * Once called then all queued styles will be flushed.\n *\n * @param index Index of the element's styling storage that will be rendered.\n * (Note that this is not the element index, but rather an index value allocated\n * specifically for element styling--the index must be the next index after the element\n * index.)\n * @param directiveIndex the index for the directive that is attempting to change styling.\n */\nfunction elementStylingApply(index, directiveIndex) {\n if (directiveIndex != undefined) {\n return hackImplementationOfElementStylingApply(index, directiveIndex); // supported in next PR\n }\n var viewData = getViewData();\n var isFirstRender = (viewData[FLAGS] & 1 /* CreationMode */) !== 0;\n var totalPlayersQueued = renderStyleAndClassBindings(getStylingContext(index, viewData), getRenderer(), viewData, isFirstRender);\n if (totalPlayersQueued > 0) {\n var rootContext = getRootContext(viewData);\n scheduleTick(rootContext, 2 /* FlushPlayers */);\n }\n}\n/**\n * Queue a given style to be rendered on an Element.\n *\n * If the style value is `null` then it will be removed from the element\n * (or assigned a different value depending if there are any styles placed\n * on the element with `elementStyle` or any styles that are present\n * from when the element was created (with `elementStyling`).\n *\n * (Note that the styling instruction will not be applied until `elementStylingApply` is called.)\n *\n * @param index Index of the element's styling storage to change in the data array.\n * (Note that this is not the element index, but rather an index value allocated\n * specifically for element styling--the index must be the next index after the element\n * index.)\n * @param styleIndex Index of the style property on this element. (Monotonically increasing.)\n * @param value New value to write (null to remove).\n * @param suffix Optional suffix. Used with scalar values to add unit such as `px`.\n * Note that when a suffix is provided then the underlying sanitizer will\n * be ignored.\n * @param directiveIndex the index for the directive that is attempting to change styling.\n */\nfunction elementStyleProp(index, styleIndex, value, suffix, directiveIndex) {\n if (directiveIndex != undefined)\n return hackImplementationOfElementStyleProp(index, styleIndex, value, suffix, directiveIndex); // supported in next PR\n var valueToAdd = null;\n if (value) {\n if (suffix) {\n // when a suffix is applied then it will bypass\n // sanitization entirely (b/c a new string is created)\n valueToAdd = stringify$1(value) + suffix;\n }\n else {\n // sanitization happens by dealing with a String value\n // this means that the string value will be passed through\n // into the style rendering later (which is where the value\n // will be sanitized before it is applied)\n valueToAdd = value;\n }\n }\n updateStyleProp(getStylingContext(index, getViewData()), styleIndex, valueToAdd);\n}\n/**\n * Queue a key/value map of styles to be rendered on an Element.\n *\n * This instruction is meant to handle the `[style]=\"exp\"` usage. When styles are applied to\n * the Element they will then be placed with respect to any styles set with `elementStyleProp`.\n * If any styles are set to `null` then they will be removed from the element (unless the same\n * style properties have been assigned to the element during creation using `elementStyling`).\n *\n * (Note that the styling instruction will not be applied until `elementStylingApply` is called.)\n *\n * @param index Index of the element's styling storage to change in the data array.\n * (Note that this is not the element index, but rather an index value allocated\n * specifically for element styling--the index must be the next index after the element\n * index.)\n * @param classes A key/value style map of CSS classes that will be added to the given element.\n * Any missing classes (that have already been applied to the element beforehand) will be\n * removed (unset) from the element's list of CSS classes.\n * @param styles A key/value style map of the styles that will be applied to the given element.\n * Any missing styles (that have already been applied to the element beforehand) will be\n * removed (unset) from the element's styling.\n * @param directiveIndex the index for the directive that is attempting to change styling.\n */\nfunction elementStylingMap(index, classes, styles, directiveIndex) {\n if (directiveIndex != undefined)\n return hackImplementationOfElementStylingMap(index, classes, styles, directiveIndex); // supported in next PR\n var viewData = getViewData();\n var tNode = getTNode(index, viewData);\n var stylingContext = getStylingContext(index, viewData);\n if (delegateToClassInput(tNode) && classes !== NO_CHANGE) {\n var initialClasses = stylingContext[6 /* PreviousOrCachedMultiClassValue */];\n var classInputVal = (initialClasses.length ? (initialClasses + ' ') : '') + classes;\n setInputsForProperty(getViewData(), tNode.inputs['class'], classInputVal);\n }\n updateStylingMap(stylingContext, classes, styles);\n}\nfunction hackImplementationOfElementStyling(classDeclarations, styleDeclarations, styleSanitizer, directiveIndex) {\n var node = getNativeByTNode(getPreviousOrParentTNode(), getViewData());\n ngDevMode && assertDefined(node, 'expecting parent DOM node');\n var hostStylingHackMap = (node.hostStylingHack || (node.hostStylingHack = {}));\n hostStylingHackMap[directiveIndex] = {\n classDeclarations: hackSquashDeclaration(classDeclarations),\n styleDeclarations: hackSquashDeclaration(styleDeclarations), styleSanitizer: styleSanitizer\n };\n}\nfunction hackSquashDeclaration(declarations) {\n // assume the array is correct. This should be fine for View Engine compatibility.\n return declarations || [];\n}\nfunction hackImplementationOfElementClassProp(index, classIndex, value, directiveIndex) {\n var node = getNativeByIndex(index, getViewData());\n ngDevMode && assertDefined(node, 'could not locate node');\n var hostStylingHack = node.hostStylingHack[directiveIndex];\n var className = hostStylingHack.classDeclarations[classIndex];\n var renderer = getRenderer();\n if (isProceduralRenderer(renderer)) {\n value ? renderer.addClass(node, className) : renderer.removeClass(node, className);\n }\n else {\n var classList = node.classList;\n value ? classList.add(className) : classList.remove(className);\n }\n}\nfunction hackImplementationOfElementStylingApply(index, directiveIndex) {\n // Do nothing because the hack implementation is eager.\n}\nfunction hackImplementationOfElementStyleProp(index, styleIndex, value, suffix, directiveIndex) {\n throw new Error('unimplemented. Should not be needed by ViewEngine compatibility');\n}\nfunction hackImplementationOfElementStylingMap(index, classes, styles, directiveIndex) {\n throw new Error('unimplemented. Should not be needed by ViewEngine compatibility');\n}\n/* END OF HACK BLOCK */\n//////////////////////////\n//// Text\n//////////////////////////\n/**\n * Create static text node\n *\n * @param index Index of the node in the data array\n * @param value Value to write. This value will be stringified.\n */\nfunction text(index, value) {\n var viewData = getViewData();\n ngDevMode && assertEqual(viewData[BINDING_INDEX], getTView().bindingStartIndex, 'text nodes should be created before any bindings');\n ngDevMode && ngDevMode.rendererCreateTextNode++;\n var textNative = createTextNode(value, getRenderer());\n var tNode = createNodeAtIndex(index, 3 /* Element */, textNative, null, null);\n // Text nodes are self closing.\n setIsParent(false);\n appendChild(textNative, tNode, viewData);\n}\n/**\n * Create text node with binding\n * Bindings should be handled externally with the proper interpolation(1-8) method\n *\n * @param index Index of the node in the data array.\n * @param value Stringified value to write.\n */\nfunction textBinding(index, value) {\n if (value !== NO_CHANGE) {\n ngDevMode && assertDataInRange(index + HEADER_OFFSET);\n var element_2 = getNativeByIndex(index, getViewData());\n ngDevMode && assertDefined(element_2, 'native element should exist');\n ngDevMode && ngDevMode.rendererSetText++;\n var renderer = getRenderer();\n isProceduralRenderer(renderer) ? renderer.setValue(element_2, stringify$1(value)) :\n element_2.textContent = stringify$1(value);\n }\n}\n//////////////////////////\n//// Directive\n//////////////////////////\n/**\n * Instantiate a root component.\n */\nfunction instantiateRootComponent(tView, viewData, def) {\n var rootTNode = getPreviousOrParentTNode();\n if (tView.firstTemplatePass) {\n if (def.providersResolver)\n def.providersResolver(def);\n generateExpandoInstructionBlock(tView, rootTNode, 1);\n baseResolveDirective(tView, viewData, def, def.factory);\n }\n var directive = getNodeInjectable(tView.data, viewData, viewData.length - 1, rootTNode);\n postProcessBaseDirective(viewData, rootTNode, directive, def);\n return directive;\n}\n/**\n * Resolve the matched directives on a node.\n */\nfunction resolveDirectives(tView, viewData, directives, tNode, localRefs) {\n // Please make sure to have explicit type for `exportsMap`. Inferred type triggers bug in tsickle.\n ngDevMode && assertEqual(getFirstTemplatePass(), true, 'should run on first template pass only');\n var exportsMap = localRefs ? { '': -1 } : null;\n var totalHostVars = 0;\n if (directives) {\n initNodeFlags(tNode, tView.data.length, directives.length);\n // When the same token is provided by several directives on the same node, some rules apply in\n // the viewEngine:\n // - viewProviders have priority over providers\n // - the last directive in NgModule.declarations has priority over the previous one\n // So to match these rules, the order in which providers are added in the arrays is very\n // important.\n for (var i = 0; i < directives.length; i++) {\n var def = directives[i];\n if (def.providersResolver)\n def.providersResolver(def);\n }\n generateExpandoInstructionBlock(tView, tNode, directives.length);\n for (var i = 0; i < directives.length; i++) {\n var def = directives[i];\n var directiveDefIdx = tView.data.length;\n baseResolveDirective(tView, viewData, def, def.factory);\n totalHostVars += def.hostVars;\n saveNameToExportMap(tView.data.length - 1, def, exportsMap);\n // Init hooks are queued now so ngOnInit is called in host components before\n // any projected components.\n queueInitHooks(directiveDefIdx, def.onInit, def.doCheck, tView);\n }\n }\n if (exportsMap)\n cacheMatchingLocalNames(tNode, localRefs, exportsMap);\n prefillHostVars(tView, viewData, totalHostVars);\n}\n/**\n * Instantiate all the directives that were previously resolved on the current node.\n */\nfunction instantiateAllDirectives(tView, viewData, previousOrParentTNode) {\n var start = previousOrParentTNode.flags >> 16 /* DirectiveStartingIndexShift */;\n var end = start + previousOrParentTNode.flags & 4095 /* DirectiveCountMask */;\n if (!getFirstTemplatePass() && start < end) {\n getOrCreateNodeInjectorForNode(previousOrParentTNode, viewData);\n }\n for (var i = start; i < end; i++) {\n var def = tView.data[i];\n if (isComponentDef(def)) {\n addComponentLogic(viewData, previousOrParentTNode, def);\n }\n var directive = getNodeInjectable(tView.data, viewData, i, previousOrParentTNode);\n postProcessDirective(viewData, directive, def, i);\n }\n}\n/**\n* Generates a new block in TView.expandoInstructions for this node.\n*\n* Each expando block starts with the element index (turned negative so we can distinguish\n* it from the hostVar count) and the directive count. See more in VIEW_DATA.md.\n*/\nfunction generateExpandoInstructionBlock(tView, tNode, directiveCount) {\n ngDevMode && assertEqual(tView.firstTemplatePass, true, 'Expando block should only be generated on first template pass.');\n var elementIndex = -(tNode.index - HEADER_OFFSET);\n var providerStartIndex = tNode.providerIndexes & 65535 /* ProvidersStartIndexMask */;\n var providerCount = tView.data.length - providerStartIndex;\n (tView.expandoInstructions || (tView.expandoInstructions = [])).push(elementIndex, providerCount, directiveCount);\n}\n/**\n* On the first template pass, we need to reserve space for host binding values\n* after directives are matched (so all directives are saved, then bindings).\n* Because we are updating the blueprint, we only need to do this once.\n*/\nfunction prefillHostVars(tView, viewData, totalHostVars) {\n for (var i = 0; i < totalHostVars; i++) {\n viewData.push(NO_CHANGE);\n tView.blueprint.push(NO_CHANGE);\n tView.data.push(null);\n }\n}\n/**\n * Process a directive on the current node after its creation.\n */\nfunction postProcessDirective(viewData, directive, def, directiveDefIdx) {\n var previousOrParentTNode = getPreviousOrParentTNode();\n postProcessBaseDirective(viewData, previousOrParentTNode, directive, def);\n ngDevMode && assertDefined(previousOrParentTNode, 'previousOrParentTNode');\n if (previousOrParentTNode && previousOrParentTNode.attrs) {\n setInputsFromAttrs(directiveDefIdx, directive, def.inputs, previousOrParentTNode);\n }\n if (def.contentQueries) {\n def.contentQueries(directiveDefIdx);\n }\n if (isComponentDef(def)) {\n var componentView = getComponentViewByIndex(previousOrParentTNode.index, viewData);\n componentView[CONTEXT] = directive;\n }\n}\n/**\n * A lighter version of postProcessDirective() that is used for the root component.\n */\nfunction postProcessBaseDirective(viewData, previousOrParentTNode, directive, def) {\n var native = getNativeByTNode(previousOrParentTNode, viewData);\n ngDevMode && assertEqual(viewData[BINDING_INDEX], getTView().bindingStartIndex, 'directives should be created before any bindings');\n ngDevMode && assertPreviousIsParent();\n attachPatchData(directive, viewData);\n if (native) {\n attachPatchData(native, viewData);\n }\n // TODO(misko): setUpAttributes should be a feature for better treeshakability.\n if (def.attributes != null && previousOrParentTNode.type == 3 /* Element */) {\n setUpAttributes(native, def.attributes);\n }\n}\n/**\n* Matches the current node against all available selectors.\n* If a component is matched (at most one), it is returned in first position in the array.\n*/\nfunction findDirectiveMatches(tView, viewData, tNode) {\n ngDevMode && assertEqual(getFirstTemplatePass(), true, 'should run on first template pass only');\n var registry = tView.directiveRegistry;\n var matches = null;\n if (registry) {\n for (var i = 0; i < registry.length; i++) {\n var def = registry[i];\n if (isNodeMatchingSelectorList(tNode, def.selectors)) {\n matches || (matches = []);\n diPublicInInjector(getOrCreateNodeInjectorForNode(getPreviousOrParentTNode(), viewData), viewData, def.type);\n if (isComponentDef(def)) {\n if (tNode.flags & 4096 /* isComponent */)\n throwMultipleComponentError(tNode);\n tNode.flags = 4096 /* isComponent */;\n // The component is always stored first with directives after.\n matches.unshift(def);\n }\n else {\n matches.push(def);\n }\n }\n }\n }\n return matches;\n}\n/** Stores index of component's host element so it will be queued for view refresh during CD. */\nfunction queueComponentIndexForCheck(previousOrParentTNode) {\n ngDevMode &&\n assertEqual(getFirstTemplatePass(), true, 'Should only be called in first template pass.');\n var tView = getTView();\n (tView.components || (tView.components = [])).push(previousOrParentTNode.index);\n}\n/** Stores index of directive and host element so it will be queued for binding refresh during CD.\n*/\nfunction queueHostBindingForCheck(tView, def) {\n ngDevMode &&\n assertEqual(getFirstTemplatePass(), true, 'Should only be called in first template pass.');\n tView.expandoInstructions.push(def.hostBindings || noop);\n if (def.hostVars)\n tView.expandoInstructions.push(def.hostVars);\n}\n/** Caches local names and their matching directive indices for query and template lookups. */\nfunction cacheMatchingLocalNames(tNode, localRefs, exportsMap) {\n if (localRefs) {\n var localNames = tNode.localNames = [];\n // Local names must be stored in tNode in the same order that localRefs are defined\n // in the template to ensure the data is loaded in the same slots as their refs\n // in the template (for template queries).\n for (var i = 0; i < localRefs.length; i += 2) {\n var index = exportsMap[localRefs[i + 1]];\n if (index == null)\n throw new Error(\"Export of name '\" + localRefs[i + 1] + \"' not found!\");\n localNames.push(localRefs[i], index);\n }\n }\n}\n/**\n* Builds up an export map as directives are created, so local refs can be quickly mapped\n* to their directive instances.\n*/\nfunction saveNameToExportMap(index, def, exportsMap) {\n if (exportsMap) {\n if (def.exportAs)\n exportsMap[def.exportAs] = index;\n if (def.template)\n exportsMap[''] = index;\n }\n}\n/**\n * Initializes the flags on the current node, setting all indices to the initial index,\n * the directive count to 0, and adding the isComponent flag.\n * @param index the initial index\n */\nfunction initNodeFlags(tNode, index, numberOfDirectives) {\n ngDevMode && assertEqual(getFirstTemplatePass(), true, 'expected firstTemplatePass to be true');\n var flags = tNode.flags;\n ngDevMode && assertEqual(flags === 0 || flags === 4096 /* isComponent */, true, 'expected node flags to not be initialized');\n ngDevMode && assertNotEqual(numberOfDirectives, 4095 /* DirectiveCountMask */, 'Reached the max number of directives');\n // When the first directive is created on a node, save the index\n tNode.flags = index << 16 /* DirectiveStartingIndexShift */ | flags & 4096 /* isComponent */ |\n numberOfDirectives;\n tNode.providerIndexes = index;\n}\nfunction baseResolveDirective(tView, viewData, def, directiveFactory) {\n tView.data.push(def);\n var nodeInjectorFactory = new NodeInjectorFactory(directiveFactory, isComponentDef(def), null);\n tView.blueprint.push(nodeInjectorFactory);\n viewData.push(nodeInjectorFactory);\n queueHostBindingForCheck(tView, def);\n}\nfunction addComponentLogic(viewData, previousOrParentTNode, def) {\n var native = getNativeByTNode(previousOrParentTNode, viewData);\n var tView = getOrCreateTView(def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery);\n // Only component views should be added to the view tree directly. Embedded views are\n // accessed through their containers because they may be removed / re-added later.\n var componentView = addToViewTree(viewData, previousOrParentTNode.index, createLViewData(getViewData(), getRendererFactory().createRenderer(native, def), tView, null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */, getCurrentSanitizer()));\n componentView[HOST_NODE] = previousOrParentTNode;\n // Component view will always be created before any injected LContainers,\n // so this is a regular element, wrap it with the component view\n componentView[HOST] = viewData[previousOrParentTNode.index];\n viewData[previousOrParentTNode.index] = componentView;\n if (getFirstTemplatePass()) {\n queueComponentIndexForCheck(previousOrParentTNode);\n }\n}\n/**\n * Sets initial input properties on directive instances from attribute data\n *\n * @param directiveIndex Index of the directive in directives array\n * @param instance Instance of the directive on which to set the initial inputs\n * @param inputs The list of inputs from the directive def\n * @param tNode The static data for this node\n */\nfunction setInputsFromAttrs(directiveIndex, instance, inputs, tNode) {\n var initialInputData = tNode.initialInputs;\n if (initialInputData === undefined || directiveIndex >= initialInputData.length) {\n initialInputData = generateInitialInputs(directiveIndex, inputs, tNode);\n }\n var initialInputs = initialInputData[directiveIndex];\n if (initialInputs) {\n for (var i = 0; i < initialInputs.length; i += 2) {\n instance[initialInputs[i]] = initialInputs[i + 1];\n }\n }\n}\n/**\n * Generates initialInputData for a node and stores it in the template's static storage\n * so subsequent template invocations don't have to recalculate it.\n *\n * initialInputData is an array containing values that need to be set as input properties\n * for directives on this node, but only once on creation. We need this array to support\n * the case where you set an @Input property of a directive using attribute-like syntax.\n * e.g. if you have a `name` @Input, you can set it once like this:\n *\n * \n *\n * @param directiveIndex Index to store the initial input data\n * @param inputs The list of inputs from the directive def\n * @param tNode The static data on this node\n */\nfunction generateInitialInputs(directiveIndex, inputs, tNode) {\n var initialInputData = tNode.initialInputs || (tNode.initialInputs = []);\n initialInputData[directiveIndex] = null;\n var attrs = tNode.attrs;\n var i = 0;\n while (i < attrs.length) {\n var attrName = attrs[i];\n if (attrName === 1 /* SelectOnly */)\n break;\n if (attrName === 0 /* NamespaceURI */) {\n // We do not allow inputs on namespaced attributes.\n i += 4;\n continue;\n }\n var minifiedInputName = inputs[attrName];\n var attrValue = attrs[i + 1];\n if (minifiedInputName !== undefined) {\n var inputsToStore = initialInputData[directiveIndex] || (initialInputData[directiveIndex] = []);\n inputsToStore.push(minifiedInputName, attrValue);\n }\n i += 2;\n }\n return initialInputData;\n}\n//////////////////////////\n//// ViewContainer & View\n//////////////////////////\n/**\n * Creates a LContainer, either from a container instruction, or for a ViewContainerRef.\n *\n * @param hostNative The host element for the LContainer\n * @param hostTNode The host TNode for the LContainer\n * @param currentView The parent view of the LContainer\n * @param native The native comment element\n * @param isForViewContainerRef Optional a flag indicating the ViewContainerRef case\n * @returns LContainer\n */\nfunction createLContainer(hostNative, hostTNode, currentView, native, isForViewContainerRef) {\n return [\n isForViewContainerRef ? -1 : 0,\n [],\n currentView,\n null,\n null,\n hostNative,\n native,\n getRenderParent(hostTNode, currentView) // renderParent\n ];\n}\n/**\n * Creates an LContainer for an ng-template (dynamically-inserted view), e.g.\n *\n * \n * \n * \n *\n * @param index The index of the container in the data array\n * @param templateFn Inline template\n * @param consts The number of nodes, local refs, and pipes for this template\n * @param vars The number of bindings for this template\n * @param tagName The name of the container element, if applicable\n * @param attrs The attrs attached to the container, if applicable\n * @param localRefs A set of local reference bindings on the element.\n * @param localRefExtractor A function which extracts local-refs values from the template.\n * Defaults to the current element associated with the local-ref.\n */\nfunction template(index, templateFn, consts, vars, tagName, attrs, localRefs, localRefExtractor) {\n var viewData = getViewData();\n var tView = getTView();\n // TODO: consider a separate node type for templates\n var tNode = containerInternal(index, tagName || null, attrs || null);\n if (getFirstTemplatePass()) {\n tNode.tViews = createTView(-1, templateFn, consts, vars, tView.directiveRegistry, tView.pipeRegistry, null);\n }\n createDirectivesAndLocals(tView, viewData, localRefs, localRefExtractor);\n var currentQueries = getCurrentQueries();\n var previousOrParentTNode = getPreviousOrParentTNode();\n if (currentQueries) {\n setCurrentQueries(currentQueries.addNode(previousOrParentTNode));\n }\n queueLifecycleHooks(tNode.flags, tView);\n setIsParent(false);\n}\n/**\n * Creates an LContainer for inline views, e.g.\n *\n * % if (showing) {\n * \n * % }\n *\n * @param index The index of the container in the data array\n */\nfunction container(index) {\n var tNode = containerInternal(index, null, null);\n getFirstTemplatePass() && (tNode.tViews = []);\n setIsParent(false);\n}\nfunction containerInternal(index, tagName, attrs) {\n var viewData = getViewData();\n ngDevMode && assertEqual(viewData[BINDING_INDEX], getTView().bindingStartIndex, 'container nodes should be created before any bindings');\n var adjustedIndex = index + HEADER_OFFSET;\n var comment = getRenderer().createComment(ngDevMode ? 'container' : '');\n ngDevMode && ngDevMode.rendererCreateComment++;\n var tNode = createNodeAtIndex(index, 0 /* Container */, comment, tagName, attrs);\n var lContainer = viewData[adjustedIndex] =\n createLContainer(viewData[adjustedIndex], tNode, viewData, comment);\n appendChild(comment, tNode, viewData);\n // Containers are added to the current view tree instead of their embedded views\n // because views can be removed and re-inserted.\n addToViewTree(viewData, index + HEADER_OFFSET, lContainer);\n var currentQueries = getCurrentQueries();\n if (currentQueries) {\n // prepare place for matching nodes from views inserted into a given container\n lContainer[QUERIES] = currentQueries.container();\n }\n ngDevMode && assertNodeType(getPreviousOrParentTNode(), 0 /* Container */);\n return tNode;\n}\n/**\n * Sets a container up to receive views.\n *\n * @param index The index of the container in the data array\n */\nfunction containerRefreshStart(index) {\n var viewData = getViewData();\n var tView = getTView();\n var previousOrParentTNode = loadInternal(index, tView.data);\n setPreviousOrParentTNode(previousOrParentTNode);\n ngDevMode && assertNodeType(previousOrParentTNode, 0 /* Container */);\n setIsParent(true);\n viewData[index + HEADER_OFFSET][ACTIVE_INDEX] = 0;\n if (!getCheckNoChangesMode()) {\n // We need to execute init hooks here so ngOnInit hooks are called in top level views\n // before they are called in embedded views (for backwards compatibility).\n executeInitHooks(viewData, tView, getCreationMode());\n }\n}\n/**\n * Marks the end of the LContainer.\n *\n * Marking the end of LContainer is the time when to child views get inserted or removed.\n */\nfunction containerRefreshEnd() {\n var previousOrParentTNode = getPreviousOrParentTNode();\n if (getIsParent()) {\n setIsParent(false);\n }\n else {\n ngDevMode && assertNodeType(previousOrParentTNode, 2 /* View */);\n ngDevMode && assertHasParent();\n previousOrParentTNode = previousOrParentTNode.parent;\n setPreviousOrParentTNode(previousOrParentTNode);\n }\n ngDevMode && assertNodeType(previousOrParentTNode, 0 /* Container */);\n var lContainer = getViewData()[previousOrParentTNode.index];\n var nextIndex = lContainer[ACTIVE_INDEX];\n // remove extra views at the end of the container\n while (nextIndex < lContainer[VIEWS].length) {\n removeView(lContainer, previousOrParentTNode, nextIndex);\n }\n}\n/**\n * Goes over dynamic embedded views (ones created through ViewContainerRef APIs) and refreshes them\n * by executing an associated template function.\n */\nfunction refreshDynamicEmbeddedViews(lViewData) {\n for (var current = getLViewChild(lViewData); current !== null; current = current[NEXT]) {\n // Note: current can be an LViewData or an LContainer instance, but here we are only interested\n // in LContainer. We can tell it's an LContainer because its length is less than the LViewData\n // header.\n if (current.length < HEADER_OFFSET && current[ACTIVE_INDEX] === -1) {\n var container_1 = current;\n for (var i = 0; i < container_1[VIEWS].length; i++) {\n var dynamicViewData = container_1[VIEWS][i];\n // The directives and pipes are not needed here as an existing view is only being refreshed.\n ngDevMode && assertDefined(dynamicViewData[TVIEW], 'TView must be allocated');\n renderEmbeddedTemplate(dynamicViewData, dynamicViewData[TVIEW], dynamicViewData[CONTEXT], 2 /* Update */);\n }\n }\n }\n}\n/**\n * Looks for a view with a given view block id inside a provided LContainer.\n * Removes views that need to be deleted in the process.\n *\n * @param lContainer to search for views\n * @param tContainerNode to search for views\n * @param startIdx starting index in the views array to search from\n * @param viewBlockId exact view block id to look for\n * @returns index of a found view or -1 if not found\n */\nfunction scanForView(lContainer, tContainerNode, startIdx, viewBlockId) {\n var views = lContainer[VIEWS];\n for (var i = startIdx; i < views.length; i++) {\n var viewAtPositionId = views[i][TVIEW].id;\n if (viewAtPositionId === viewBlockId) {\n return views[i];\n }\n else if (viewAtPositionId < viewBlockId) {\n // found a view that should not be at this position - remove\n removeView(lContainer, tContainerNode, i);\n }\n else {\n // found a view with id greater than the one we are searching for\n // which means that required view doesn't exist and can't be found at\n // later positions in the views array - stop the searchdef.cont here\n break;\n }\n }\n return null;\n}\n/**\n * Marks the start of an embedded view.\n *\n * @param viewBlockId The ID of this view\n * @return boolean Whether or not this view is in creation mode\n */\nfunction embeddedViewStart(viewBlockId, consts, vars) {\n var viewData = getViewData();\n var previousOrParentTNode = getPreviousOrParentTNode();\n // The previous node can be a view node if we are processing an inline for loop\n var containerTNode = previousOrParentTNode.type === 2 /* View */ ?\n previousOrParentTNode.parent :\n previousOrParentTNode;\n var lContainer = viewData[containerTNode.index];\n ngDevMode && assertNodeType(containerTNode, 0 /* Container */);\n var viewToRender = scanForView(lContainer, containerTNode, lContainer[ACTIVE_INDEX], viewBlockId);\n if (viewToRender) {\n setIsParent(true);\n enterView(viewToRender, viewToRender[TVIEW].node);\n }\n else {\n // When we create a new LView, we always reset the state of the instructions.\n viewToRender = createLViewData(getViewData(), getRenderer(), getOrCreateEmbeddedTView(viewBlockId, consts, vars, containerTNode), null, 2 /* CheckAlways */, getCurrentSanitizer());\n if (lContainer[QUERIES]) {\n viewToRender[QUERIES] = lContainer[QUERIES].createView();\n }\n createViewNode(viewBlockId, viewToRender);\n enterView(viewToRender, viewToRender[TVIEW].node);\n }\n if (lContainer) {\n if (getCreationMode()) {\n // it is a new view, insert it into collection of views for a given container\n insertView(viewToRender, lContainer, viewData, lContainer[ACTIVE_INDEX], -1);\n }\n lContainer[ACTIVE_INDEX]++;\n }\n return getRenderFlags(viewToRender);\n}\n/**\n * Initialize the TView (e.g. static data) for the active embedded view.\n *\n * Each embedded view block must create or retrieve its own TView. Otherwise, the embedded view's\n * static data for a particular node would overwrite the static data for a node in the view above\n * it with the same index (since it's in the same template).\n *\n * @param viewIndex The index of the TView in TNode.tViews\n * @param consts The number of nodes, local refs, and pipes in this template\n * @param vars The number of bindings and pure function bindings in this template\n * @param container The parent container in which to look for the view's static data\n * @returns TView\n */\nfunction getOrCreateEmbeddedTView(viewIndex, consts, vars, parent) {\n var tView = getTView();\n ngDevMode && assertNodeType(parent, 0 /* Container */);\n var containerTViews = parent.tViews;\n ngDevMode && assertDefined(containerTViews, 'TView expected');\n ngDevMode && assertEqual(Array.isArray(containerTViews), true, 'TViews should be in an array');\n if (viewIndex >= containerTViews.length || containerTViews[viewIndex] == null) {\n containerTViews[viewIndex] = createTView(viewIndex, null, consts, vars, tView.directiveRegistry, tView.pipeRegistry, null);\n }\n return containerTViews[viewIndex];\n}\n/** Marks the end of an embedded view. */\nfunction embeddedViewEnd() {\n var viewData = getViewData();\n var viewHost = viewData[HOST_NODE];\n refreshDescendantViews(viewData, null);\n leaveView(viewData[PARENT]);\n setPreviousOrParentTNode(viewHost);\n setIsParent(false);\n}\n/////////////\n/**\n * Refreshes components by entering the component view and processing its bindings, queries, etc.\n *\n * @param adjustedElementIndex Element index in LViewData[] (adjusted for HEADER_OFFSET)\n */\nfunction componentRefresh(adjustedElementIndex, parentFirstTemplatePass, rf) {\n ngDevMode && assertDataInRange(adjustedElementIndex);\n var hostView = getComponentViewByIndex(adjustedElementIndex, getViewData());\n ngDevMode && assertNodeType(getTView().data[adjustedElementIndex], 3 /* Element */);\n // Only attached CheckAlways components or attached, dirty OnPush components should be checked\n if (viewAttached(hostView) && hostView[FLAGS] & (2 /* CheckAlways */ | 4 /* Dirty */)) {\n parentFirstTemplatePass && syncViewWithBlueprint(hostView);\n detectChangesInternal(hostView, hostView[CONTEXT], rf);\n }\n}\n/**\n * Syncs an LViewData instance with its blueprint if they have gotten out of sync.\n *\n * Typically, blueprints and their view instances should always be in sync, so the loop here\n * will be skipped. However, consider this case of two components side-by-side:\n *\n * App template:\n * ```\n * \n * \n * ```\n *\n * The following will happen:\n * 1. App template begins processing.\n * 2. First is matched as a component and its LViewData is created.\n * 3. Second is matched as a component and its LViewData is created.\n * 4. App template completes processing, so it's time to check child templates.\n * 5. First template is checked. It has a directive, so its def is pushed to blueprint.\n * 6. Second template is checked. Its blueprint has been updated by the first\n * template, but its LViewData was created before this update, so it is out of sync.\n *\n * Note that embedded views inside ngFor loops will never be out of sync because these views\n * are processed as soon as they are created.\n *\n * @param componentView The view to sync\n */\nfunction syncViewWithBlueprint(componentView) {\n var componentTView = componentView[TVIEW];\n for (var i = componentView.length; i < componentTView.blueprint.length; i++) {\n componentView[i] = componentTView.blueprint[i];\n }\n}\n/** Returns a boolean for whether the view is attached */\nfunction viewAttached(view) {\n return (view[FLAGS] & 8 /* Attached */) === 8 /* Attached */;\n}\n/**\n * Instruction to distribute projectable nodes among occurrences in a given template.\n * It takes all the selectors from the entire component's template and decides where\n * each projected node belongs (it re-distributes nodes among \"buckets\" where each \"bucket\" is\n * backed by a selector).\n *\n * This function requires CSS selectors to be provided in 2 forms: parsed (by a compiler) and text,\n * un-parsed form.\n *\n * The parsed form is needed for efficient matching of a node against a given CSS selector.\n * The un-parsed, textual form is needed for support of the ngProjectAs attribute.\n *\n * Having a CSS selector in 2 different formats is not ideal, but alternatives have even more\n * drawbacks:\n * - having only a textual form would require runtime parsing of CSS selectors;\n * - we can't have only a parsed as we can't re-construct textual form from it (as entered by a\n * template author).\n *\n * @param selectors A collection of parsed CSS selectors\n * @param rawSelectors A collection of CSS selectors in the raw, un-parsed form\n */\nfunction projectionDef(selectors, textSelectors) {\n var componentNode = findComponentView(getViewData())[HOST_NODE];\n if (!componentNode.projection) {\n var noOfNodeBuckets = selectors ? selectors.length + 1 : 1;\n var pData = componentNode.projection =\n new Array(noOfNodeBuckets).fill(null);\n var tails = pData.slice();\n var componentChild = componentNode.child;\n while (componentChild !== null) {\n var bucketIndex = selectors ? matchingSelectorIndex(componentChild, selectors, textSelectors) : 0;\n var nextNode = componentChild.next;\n if (tails[bucketIndex]) {\n tails[bucketIndex].next = componentChild;\n }\n else {\n pData[bucketIndex] = componentChild;\n componentChild.next = null;\n }\n tails[bucketIndex] = componentChild;\n componentChild = nextNode;\n }\n }\n}\n/**\n * Stack used to keep track of projection nodes in projection() instruction.\n *\n * This is deliberately created outside of projection() to avoid allocating\n * a new array each time the function is called. Instead the array will be\n * re-used by each invocation. This works because the function is not reentrant.\n */\nvar projectionNodeStack$1 = [];\n/**\n * Inserts previously re-distributed projected nodes. This instruction must be preceded by a call\n * to the projectionDef instruction.\n *\n * @param nodeIndex\n * @param selectorIndex:\n * - 0 when the selector is `*` (or unspecified as this is the default value),\n * - 1 based index of the selector from the {@link projectionDef}\n */\nfunction projection(nodeIndex, selectorIndex, attrs) {\n if (selectorIndex === void 0) { selectorIndex = 0; }\n var viewData = getViewData();\n var tProjectionNode = createNodeAtIndex(nodeIndex, 1 /* Projection */, null, null, attrs || null);\n // We can't use viewData[HOST_NODE] because projection nodes can be nested in embedded views.\n if (tProjectionNode.projection === null)\n tProjectionNode.projection = selectorIndex;\n // `` has no content\n setIsParent(false);\n // re-distribution of projectable nodes is stored on a component's view level\n var componentView = findComponentView(viewData);\n var componentNode = componentView[HOST_NODE];\n var nodeToProject = componentNode.projection[selectorIndex];\n var projectedView = componentView[PARENT];\n var projectionNodeIndex = -1;\n while (nodeToProject) {\n if (nodeToProject.type === 1 /* Projection */) {\n // This node is re-projected, so we must go up the tree to get its projected nodes.\n var currentComponentView = findComponentView(projectedView);\n var currentComponentHost = currentComponentView[HOST_NODE];\n var firstProjectedNode = currentComponentHost.projection[nodeToProject.projection];\n if (firstProjectedNode) {\n projectionNodeStack$1[++projectionNodeIndex] = nodeToProject;\n projectionNodeStack$1[++projectionNodeIndex] = projectedView;\n nodeToProject = firstProjectedNode;\n projectedView = currentComponentView[PARENT];\n continue;\n }\n }\n else {\n // This flag must be set now or we won't know that this node is projected\n // if the nodes are inserted into a container later.\n nodeToProject.flags |= 8192 /* isProjected */;\n appendProjectedNode(nodeToProject, tProjectionNode, viewData, projectedView);\n }\n // If we are finished with a list of re-projected nodes, we need to get\n // back to the root projection node that was re-projected.\n if (nodeToProject.next === null && projectedView !== componentView[PARENT]) {\n projectedView = projectionNodeStack$1[projectionNodeIndex--];\n nodeToProject = projectionNodeStack$1[projectionNodeIndex--];\n }\n nodeToProject = nodeToProject.next;\n }\n}\n/**\n * Adds LViewData or LContainer to the end of the current view tree.\n *\n * This structure will be used to traverse through nested views to remove listeners\n * and call onDestroy callbacks.\n *\n * @param currentView The view where LViewData or LContainer should be added\n * @param adjustedHostIndex Index of the view's host node in LViewData[], adjusted for header\n * @param state The LViewData or LContainer to add to the view tree\n * @returns The state passed in\n */\nfunction addToViewTree(currentView, adjustedHostIndex, state) {\n var tView = getTView();\n var firstTemplatePass = getFirstTemplatePass();\n if (currentView[TAIL]) {\n currentView[TAIL][NEXT] = state;\n }\n else if (firstTemplatePass) {\n tView.childIndex = adjustedHostIndex;\n }\n currentView[TAIL] = state;\n return state;\n}\n///////////////////////////////\n//// Change detection\n///////////////////////////////\n/** If node is an OnPush component, marks its LViewData dirty. */\nfunction markDirtyIfOnPush(viewData, viewIndex) {\n var view = getComponentViewByIndex(viewIndex, viewData);\n if (!(view[FLAGS] & 2 /* CheckAlways */)) {\n view[FLAGS] |= 4 /* Dirty */;\n }\n}\n/** Wraps an event listener with preventDefault behavior. */\nfunction wrapListenerWithPreventDefault(listenerFn) {\n return function wrapListenerIn_preventDefault(e) {\n if (listenerFn(e) === false) {\n e.preventDefault();\n // Necessary for legacy browsers that don't support preventDefault (e.g. IE)\n e.returnValue = false;\n }\n };\n}\n/** Marks current view and all ancestors dirty */\nfunction markViewDirty(view) {\n var currentView = view;\n while (currentView && !(currentView[FLAGS] & 64 /* IsRoot */)) {\n currentView[FLAGS] |= 4 /* Dirty */;\n currentView = currentView[PARENT];\n }\n currentView[FLAGS] |= 4 /* Dirty */;\n ngDevMode && assertDefined(currentView[CONTEXT], 'rootContext should be defined');\n var rootContext = currentView[CONTEXT];\n scheduleTick(rootContext, 1 /* DetectChanges */);\n}\n/**\n * Used to schedule change detection on the whole application.\n *\n * Unlike `tick`, `scheduleTick` coalesces multiple calls into one change detection run.\n * It is usually called indirectly by calling `markDirty` when the view needs to be\n * re-rendered.\n *\n * Typically `scheduleTick` uses `requestAnimationFrame` to coalesce multiple\n * `scheduleTick` requests. The scheduling function can be overridden in\n * `renderComponent`'s `scheduler` option.\n */\nfunction scheduleTick(rootContext, flags) {\n var nothingScheduled = rootContext.flags === 0 /* Empty */;\n rootContext.flags |= flags;\n if (nothingScheduled && rootContext.clean == _CLEAN_PROMISE) {\n var res_1;\n rootContext.clean = new Promise(function (r) { return res_1 = r; });\n rootContext.scheduler(function () {\n if (rootContext.flags & 1 /* DetectChanges */) {\n rootContext.flags &= ~1 /* DetectChanges */;\n tickRootContext(rootContext);\n }\n if (rootContext.flags & 2 /* FlushPlayers */) {\n rootContext.flags &= ~2 /* FlushPlayers */;\n var playerHandler = rootContext.playerHandler;\n if (playerHandler) {\n playerHandler.flushPlayers();\n }\n }\n rootContext.clean = _CLEAN_PROMISE;\n res_1(null);\n });\n }\n}\nfunction tickRootContext(rootContext) {\n for (var i = 0; i < rootContext.components.length; i++) {\n var rootComponent = rootContext.components[i];\n renderComponentOrTemplate(readPatchedLViewData(rootComponent), rootComponent, 2 /* Update */);\n }\n}\n/**\n * Synchronously perform change detection on a component (and possibly its sub-components).\n *\n * This function triggers change detection in a synchronous way on a component. There should\n * be very little reason to call this function directly since a preferred way to do change\n * detection is to {@link markDirty} the component and wait for the scheduler to call this method\n * at some future point in time. This is because a single user action often results in many\n * components being invalidated and calling change detection on each component synchronously\n * would be inefficient. It is better to wait until all components are marked as dirty and\n * then perform single change detection across all of the components\n *\n * @param component The component which the change detection should be performed on.\n */\nfunction detectChanges(component) {\n detectChangesInternal(getComponentViewByInstance(component), component, null);\n}\n/**\n * Synchronously perform change detection on a root view and its components.\n *\n * @param lViewData The view which the change detection should be performed on.\n */\nfunction detectChangesInRootView(lViewData) {\n tickRootContext(lViewData[CONTEXT]);\n}\n/**\n * Checks the change detector and its children, and throws if any changes are detected.\n *\n * This is used in development mode to verify that running change detection doesn't\n * introduce other changes.\n */\nfunction checkNoChanges(component) {\n setCheckNoChangesMode(true);\n try {\n detectChanges(component);\n }\n finally {\n setCheckNoChangesMode(false);\n }\n}\n/**\n * Checks the change detector on a root view and its components, and throws if any changes are\n * detected.\n *\n * This is used in development mode to verify that running change detection doesn't\n * introduce other changes.\n *\n * @param lViewData The view which the change detection should be checked on.\n */\nfunction checkNoChangesInRootView(lViewData) {\n setCheckNoChangesMode(true);\n try {\n detectChangesInRootView(lViewData);\n }\n finally {\n setCheckNoChangesMode(false);\n }\n}\n/** Checks the view of the component provided. Does not gate on dirty checks or execute doCheck. */\nfunction detectChangesInternal(hostView, component, rf) {\n var hostTView = hostView[TVIEW];\n var oldView = enterView(hostView, hostView[HOST_NODE]);\n var templateFn = hostTView.template;\n var viewQuery = hostTView.viewQuery;\n try {\n namespaceHTML();\n createViewQuery(viewQuery, rf, hostView[FLAGS], component);\n templateFn(rf || getRenderFlags(hostView), component);\n refreshDescendantViews(hostView, rf);\n updateViewQuery(viewQuery, hostView[FLAGS], component);\n }\n finally {\n leaveView(oldView, rf === 1 /* Create */);\n }\n}\nfunction createViewQuery(viewQuery, renderFlags, viewFlags, component) {\n if (viewQuery && (renderFlags === 1 /* Create */ ||\n (renderFlags === null && (viewFlags & 1 /* CreationMode */)))) {\n viewQuery(1 /* Create */, component);\n }\n}\nfunction updateViewQuery(viewQuery, flags, component) {\n if (viewQuery && flags & 2 /* Update */) {\n viewQuery(2 /* Update */, component);\n }\n}\n/**\n * Mark the component as dirty (needing change detection).\n *\n * Marking a component dirty will schedule a change detection on this\n * component at some point in the future. Marking an already dirty\n * component as dirty is a noop. Only one outstanding change detection\n * can be scheduled per component tree. (Two components bootstrapped with\n * separate `renderComponent` will have separate schedulers)\n *\n * When the root component is bootstrapped with `renderComponent`, a scheduler\n * can be provided.\n *\n * @param component Component to mark as dirty.\n *\n * @publicApi\n */\nfunction markDirty(component) {\n ngDevMode && assertDefined(component, 'component');\n markViewDirty(getComponentViewByInstance(component));\n}\n///////////////////////////////\n//// Bindings & interpolations\n///////////////////////////////\n/**\n * Creates a single value binding.\n *\n * @param value Value to diff\n */\nfunction bind(value) {\n return bindingUpdated(getViewData()[BINDING_INDEX]++, value) ? value : NO_CHANGE;\n}\n/**\n * Create interpolation bindings with a variable number of expressions.\n *\n * If there are 1 to 8 expressions `interpolation1()` to `interpolation8()` should be used instead.\n * Those are faster because there is no need to create an array of expressions and iterate over it.\n *\n * `values`:\n * - has static text at even indexes,\n * - has evaluated expressions at odd indexes.\n *\n * Returns the concatenated string when any of the arguments changes, `NO_CHANGE` otherwise.\n */\nfunction interpolationV(values) {\n ngDevMode && assertLessThan(2, values.length, 'should have at least 3 values');\n ngDevMode && assertEqual(values.length % 2, 1, 'should have an odd number of values');\n var different = false;\n for (var i = 1; i < values.length; i += 2) {\n // Check if bindings (odd indexes) have changed\n bindingUpdated(getViewData()[BINDING_INDEX]++, values[i]) && (different = true);\n }\n if (!different) {\n return NO_CHANGE;\n }\n // Build the updated content\n var content = values[0];\n for (var i = 1; i < values.length; i += 2) {\n content += stringify$1(values[i]) + values[i + 1];\n }\n return content;\n}\n/**\n * Creates an interpolation binding with 1 expression.\n *\n * @param prefix static value used for concatenation only.\n * @param v0 value checked for change.\n * @param suffix static value used for concatenation only.\n */\nfunction interpolation1(prefix, v0, suffix) {\n var different = bindingUpdated(getViewData()[BINDING_INDEX]++, v0);\n return different ? prefix + stringify$1(v0) + suffix : NO_CHANGE;\n}\n/** Creates an interpolation binding with 2 expressions. */\nfunction interpolation2(prefix, v0, i0, v1, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated2(viewData[BINDING_INDEX], v0, v1);\n viewData[BINDING_INDEX] += 2;\n return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + suffix : NO_CHANGE;\n}\n/** Creates an interpolation binding with 3 expressions. */\nfunction interpolation3(prefix, v0, i0, v1, i1, v2, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated3(viewData[BINDING_INDEX], v0, v1, v2);\n viewData[BINDING_INDEX] += 3;\n return different ? prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + suffix :\n NO_CHANGE;\n}\n/** Create an interpolation binding with 4 expressions. */\nfunction interpolation4(prefix, v0, i0, v1, i1, v2, i2, v3, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated4(viewData[BINDING_INDEX], v0, v1, v2, v3);\n viewData[BINDING_INDEX] += 4;\n return different ?\n prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) +\n suffix :\n NO_CHANGE;\n}\n/** Creates an interpolation binding with 5 expressions. */\nfunction interpolation5(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated4(viewData[BINDING_INDEX], v0, v1, v2, v3);\n different = bindingUpdated(viewData[BINDING_INDEX] + 4, v4) || different;\n viewData[BINDING_INDEX] += 5;\n return different ?\n prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n stringify$1(v4) + suffix :\n NO_CHANGE;\n}\n/** Creates an interpolation binding with 6 expressions. */\nfunction interpolation6(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated4(viewData[BINDING_INDEX], v0, v1, v2, v3);\n different = bindingUpdated2(viewData[BINDING_INDEX] + 4, v4, v5) || different;\n viewData[BINDING_INDEX] += 6;\n return different ?\n prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n stringify$1(v4) + i4 + stringify$1(v5) + suffix :\n NO_CHANGE;\n}\n/** Creates an interpolation binding with 7 expressions. */\nfunction interpolation7(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated4(viewData[BINDING_INDEX], v0, v1, v2, v3);\n different = bindingUpdated3(viewData[BINDING_INDEX] + 4, v4, v5, v6) || different;\n viewData[BINDING_INDEX] += 7;\n return different ?\n prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + suffix :\n NO_CHANGE;\n}\n/** Creates an interpolation binding with 8 expressions. */\nfunction interpolation8(prefix, v0, i0, v1, i1, v2, i2, v3, i3, v4, i4, v5, i5, v6, i6, v7, suffix) {\n var viewData = getViewData();\n var different = bindingUpdated4(viewData[BINDING_INDEX], v0, v1, v2, v3);\n different = bindingUpdated4(viewData[BINDING_INDEX] + 4, v4, v5, v6, v7) || different;\n viewData[BINDING_INDEX] += 8;\n return different ?\n prefix + stringify$1(v0) + i0 + stringify$1(v1) + i1 + stringify$1(v2) + i2 + stringify$1(v3) + i3 +\n stringify$1(v4) + i4 + stringify$1(v5) + i5 + stringify$1(v6) + i6 + stringify$1(v7) + suffix :\n NO_CHANGE;\n}\n/** Store a value in the `data` at a given `index`. */\nfunction store(index, value) {\n var tView = getTView();\n // We don't store any static data for local variables, so the first time\n // we see the template, we should store as null to avoid a sparse array\n var adjustedIndex = index + HEADER_OFFSET;\n if (adjustedIndex >= tView.data.length) {\n tView.data[adjustedIndex] = null;\n }\n getViewData()[adjustedIndex] = value;\n}\n/**\n * Retrieves a local reference from the current contextViewData.\n *\n * If the reference to retrieve is in a parent view, this instruction is used in conjunction\n * with a nextContext() call, which walks up the tree and updates the contextViewData instance.\n *\n * @param index The index of the local ref in contextViewData.\n */\nfunction reference(index) {\n var contextViewData = getContextViewData();\n return loadInternal(index, contextViewData);\n}\nfunction loadQueryList(queryListIdx) {\n var viewData = getViewData();\n ngDevMode && assertDefined(viewData[CONTENT_QUERIES], 'Content QueryList array should be defined if reading a query.');\n ngDevMode && assertDataInRange(queryListIdx, viewData[CONTENT_QUERIES]);\n return viewData[CONTENT_QUERIES][queryListIdx];\n}\n/** Retrieves a value from current `viewData`. */\nfunction load(index) {\n return loadInternal(index, getViewData());\n}\n/** Gets the current binding value. */\nfunction getBinding(bindingIndex) {\n var viewData = getViewData();\n ngDevMode && assertDataInRange(viewData[bindingIndex]);\n ngDevMode &&\n assertNotEqual(viewData[bindingIndex], NO_CHANGE, 'Stored value should never be NO_CHANGE.');\n return viewData[bindingIndex];\n}\n/** Updates binding if changed, then returns whether it was updated. */\nfunction bindingUpdated(bindingIndex, value) {\n var viewData = getViewData();\n var checkNoChangesMode = getCheckNoChangesMode();\n ngDevMode && assertNotEqual(value, NO_CHANGE, 'Incoming value should never be NO_CHANGE.');\n ngDevMode && assertLessThan(bindingIndex, viewData.length, \"Slot should have been initialized to NO_CHANGE\");\n if (viewData[bindingIndex] === NO_CHANGE) {\n viewData[bindingIndex] = value;\n }\n else if (isDifferent(viewData[bindingIndex], value, checkNoChangesMode)) {\n throwErrorIfNoChangesMode(getCreationMode(), checkNoChangesMode, viewData[bindingIndex], value);\n viewData[bindingIndex] = value;\n }\n else {\n return false;\n }\n return true;\n}\n/** Updates binding and returns the value. */\nfunction updateBinding(bindingIndex, value) {\n return getViewData()[bindingIndex] = value;\n}\n/** Updates 2 bindings if changed, then returns whether either was updated. */\nfunction bindingUpdated2(bindingIndex, exp1, exp2) {\n var different = bindingUpdated(bindingIndex, exp1);\n return bindingUpdated(bindingIndex + 1, exp2) || different;\n}\n/** Updates 3 bindings if changed, then returns whether any was updated. */\nfunction bindingUpdated3(bindingIndex, exp1, exp2, exp3) {\n var different = bindingUpdated2(bindingIndex, exp1, exp2);\n return bindingUpdated(bindingIndex + 2, exp3) || different;\n}\n/** Updates 4 bindings if changed, then returns whether any was updated. */\nfunction bindingUpdated4(bindingIndex, exp1, exp2, exp3, exp4) {\n var different = bindingUpdated2(bindingIndex, exp1, exp2);\n return bindingUpdated2(bindingIndex + 2, exp3, exp4) || different;\n}\nfunction directiveInject(token, flags) {\n if (flags === void 0) { flags = InjectFlags.Default; }\n token = resolveForwardRef(token);\n return getOrCreateInjectable(getPreviousOrParentTNode(), getViewData(), token, flags);\n}\n/**\n * Facade for the attribute injection from DI.\n */\nfunction injectAttribute(attrNameToInject) {\n return injectAttributeImpl(getPreviousOrParentTNode(), attrNameToInject);\n}\n/**\n * Registers a QueryList, associated with a content query, for later refresh (part of a view\n * refresh).\n */\nfunction registerContentQuery(queryList, currentDirectiveIndex) {\n var viewData = getViewData();\n var tView = getTView();\n var savedContentQueriesLength = (viewData[CONTENT_QUERIES] || (viewData[CONTENT_QUERIES] = [])).push(queryList);\n if (getFirstTemplatePass()) {\n var tViewContentQueries = tView.contentQueries || (tView.contentQueries = []);\n var lastSavedDirectiveIndex = tView.contentQueries.length ? tView.contentQueries[tView.contentQueries.length - 2] : -1;\n if (currentDirectiveIndex !== lastSavedDirectiveIndex) {\n tViewContentQueries.push(currentDirectiveIndex, savedContentQueriesLength - 1);\n }\n }\n}\nvar CLEAN_PROMISE = _CLEAN_PROMISE;\nfunction initializeTNodeInputs(tNode) {\n // If tNode.inputs is undefined, a listener has created outputs, but inputs haven't\n // yet been checked.\n if (tNode) {\n if (tNode.inputs === undefined) {\n // mark inputs as checked\n tNode.inputs = generatePropertyAliases(tNode.flags, 0 /* Input */);\n }\n return tNode.inputs;\n }\n return null;\n}\nfunction delegateToClassInput(tNode) {\n return tNode.flags & 32768 /* hasClassInput */;\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 */\nvar ViewRef = /** @class */ (function () {\n function ViewRef(_view, _context, _componentIndex) {\n this._context = _context;\n this._componentIndex = _componentIndex;\n this._appRef = null;\n this._viewContainerRef = null;\n /**\n * @internal\n */\n this._tViewNode = null;\n this._view = _view;\n }\n Object.defineProperty(ViewRef.prototype, \"rootNodes\", {\n get: function () {\n if (this._view[HOST] == null) {\n var tView = this._view[HOST_NODE];\n return collectNativeNodes(this._view, tView, []);\n }\n return [];\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ViewRef.prototype, \"context\", {\n get: function () { return this._context ? this._context : this._lookUpContext(); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ViewRef.prototype, \"destroyed\", {\n get: function () {\n return (this._view[FLAGS] & 32 /* Destroyed */) === 32 /* Destroyed */;\n },\n enumerable: true,\n configurable: true\n });\n ViewRef.prototype.destroy = function () {\n if (this._viewContainerRef && viewAttached(this._view)) {\n this._viewContainerRef.detach(this._viewContainerRef.indexOf(this));\n this._viewContainerRef = null;\n }\n destroyLView(this._view);\n };\n ViewRef.prototype.onDestroy = function (callback) { storeCleanupFn(this._view, callback); };\n /**\n * Marks a view and all of its ancestors dirty.\n *\n * It also triggers change detection by calling `scheduleTick` internally, which coalesces\n * multiple `markForCheck` calls to into one change detection run.\n *\n * This can be used to ensure an {@link ChangeDetectionStrategy#OnPush OnPush} component is\n * checked when it needs to be re-rendered but the two normal triggers haven't marked it\n * dirty (i.e. inputs haven't changed and events haven't fired in the view).\n *\n * \n *\n * @usageNotes\n * ### Example\n *\n * ```typescript\n * @Component({\n * selector: 'my-app',\n * template: `Number of ticks: {{numberOfTicks}}`\n * changeDetection: ChangeDetectionStrategy.OnPush,\n * })\n * class AppComponent {\n * numberOfTicks = 0;\n *\n * constructor(private ref: ChangeDetectorRef) {\n * setInterval(() => {\n * this.numberOfTicks++;\n * // the following is required, otherwise the view will not be updated\n * this.ref.markForCheck();\n * }, 1000);\n * }\n * }\n * ```\n */\n ViewRef.prototype.markForCheck = function () { markViewDirty(this._view); };\n /**\n * Detaches the view from the change detection tree.\n *\n * Detached views will not be checked during change detection runs until they are\n * re-attached, even if they are dirty. `detach` can be used in combination with\n * {@link ChangeDetectorRef#detectChanges detectChanges} to implement local change\n * detection checks.\n *\n * \n * \n *\n * @usageNotes\n * ### Example\n *\n * The following example defines a component with a large list of readonly data.\n * Imagine the data changes constantly, many times per second. For performance reasons,\n * we want to check and update the list every five seconds. We can do that by detaching\n * the component's change detector and doing a local check every five seconds.\n *\n * ```typescript\n * class DataProvider {\n * // in a real application the returned data will be different every time\n * get data() {\n * return [1,2,3,4,5];\n * }\n * }\n *\n * @Component({\n * selector: 'giant-list',\n * template: `\n *
Data {{d}}
\n * `,\n * })\n * class GiantList {\n * constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {\n * ref.detach();\n * setInterval(() => {\n * this.ref.detectChanges();\n * }, 5000);\n * }\n * }\n *\n * @Component({\n * selector: 'app',\n * providers: [DataProvider],\n * template: `\n * \n * `,\n * })\n * class App {\n * }\n * ```\n */\n ViewRef.prototype.detach = function () { this._view[FLAGS] &= ~8 /* Attached */; };\n /**\n * Re-attaches a view to the change detection tree.\n *\n * This can be used to re-attach views that were previously detached from the tree\n * using {@link ChangeDetectorRef#detach detach}. Views are attached to the tree by default.\n *\n * \n *\n * @usageNotes\n * ### Example\n *\n * The following example creates a component displaying `live` data. The component will detach\n * its change detector from the main change detector tree when the component's live property\n * is set to false.\n *\n * ```typescript\n * class DataProvider {\n * data = 1;\n *\n * constructor() {\n * setInterval(() => {\n * this.data = this.data * 2;\n * }, 500);\n * }\n * }\n *\n * @Component({\n * selector: 'live-data',\n * inputs: ['live'],\n * template: 'Data: {{dataProvider.data}}'\n * })\n * class LiveData {\n * constructor(private ref: ChangeDetectorRef, private dataProvider: DataProvider) {}\n *\n * set live(value) {\n * if (value) {\n * this.ref.reattach();\n * } else {\n * this.ref.detach();\n * }\n * }\n * }\n *\n * @Component({\n * selector: 'my-app',\n * providers: [DataProvider],\n * template: `\n * Live Update: \n * \n * `,\n * })\n * class AppComponent {\n * live = true;\n * }\n * ```\n */\n ViewRef.prototype.reattach = function () { this._view[FLAGS] |= 8 /* Attached */; };\n /**\n * Checks the view and its children.\n *\n * This can also be used in combination with {@link ChangeDetectorRef#detach detach} to implement\n * local change detection checks.\n *\n * \n * \n *\n * @usageNotes\n * ### Example\n *\n * The following example defines a component with a large list of readonly data.\n * Imagine, the data changes constantly, many times per second. For performance reasons,\n * we want to check and update the list every five seconds.\n *\n * We can do that by detaching the component's change detector and doing a local change detection\n * check every five seconds.\n *\n * See {@link ChangeDetectorRef#detach detach} for more information.\n */\n ViewRef.prototype.detectChanges = function () {\n var rendererFactory = getRendererFactory();\n if (rendererFactory.begin) {\n rendererFactory.begin();\n }\n detectChanges(this.context);\n if (rendererFactory.end) {\n rendererFactory.end();\n }\n };\n /**\n * Checks the change detector and its children, and throws if any changes are detected.\n *\n * This is used in development mode to verify that running change detection doesn't\n * introduce other changes.\n */\n ViewRef.prototype.checkNoChanges = function () { checkNoChanges(this.context); };\n ViewRef.prototype.attachToViewContainerRef = function (vcRef) { this._viewContainerRef = vcRef; };\n ViewRef.prototype.detachFromAppRef = function () { this._appRef = null; };\n ViewRef.prototype.attachToAppRef = function (appRef) { this._appRef = appRef; };\n ViewRef.prototype._lookUpContext = function () {\n return this._context = this._view[PARENT][this._componentIndex];\n };\n return ViewRef;\n}());\n/** @internal */\nvar RootViewRef = /** @class */ (function (_super) {\n __extends(RootViewRef, _super);\n function RootViewRef(_view) {\n var _this = _super.call(this, _view, null, -1) || this;\n _this._view = _view;\n return _this;\n }\n RootViewRef.prototype.detectChanges = function () { detectChangesInRootView(this._view); };\n RootViewRef.prototype.checkNoChanges = function () { checkNoChangesInRootView(this._view); };\n Object.defineProperty(RootViewRef.prototype, \"context\", {\n get: function () { return null; },\n enumerable: true,\n configurable: true\n });\n return RootViewRef;\n}(ViewRef));\nfunction collectNativeNodes(lView, parentTNode, result) {\n var tNodeChild = parentTNode.child;\n while (tNodeChild) {\n result.push(getNativeByTNode(tNodeChild, lView));\n if (tNodeChild.type === 4 /* ElementContainer */) {\n collectNativeNodes(lView, tNodeChild, result);\n }\n tNodeChild = tNodeChild.next;\n }\n return result;\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 * Creates an ElementRef from the most recent node.\n *\n * @returns The ElementRef instance to use\n */\nfunction injectElementRef(ElementRefToken) {\n return createElementRef(ElementRefToken, getPreviousOrParentTNode(), getViewData());\n}\nvar R3ElementRef;\n/**\n * Creates an ElementRef given a node.\n *\n * @param ElementRefToken The ElementRef type\n * @param tNode The node for which you'd like an ElementRef\n * @param view The view to which the node belongs\n * @returns The ElementRef instance to use\n */\nfunction createElementRef(ElementRefToken, tNode, view) {\n if (!R3ElementRef) {\n // TODO: Fix class name, should be ElementRef, but there appears to be a rollup bug\n R3ElementRef = /** @class */ (function (_super) {\n __extends(ElementRef_, _super);\n function ElementRef_() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n return ElementRef_;\n }(ElementRefToken));\n }\n return new R3ElementRef(getNativeByTNode(tNode, view));\n}\nvar R3TemplateRef;\n/**\n * Creates a TemplateRef given a node.\n *\n * @returns The TemplateRef instance to use\n */\nfunction injectTemplateRef(TemplateRefToken, ElementRefToken) {\n return createTemplateRef(TemplateRefToken, ElementRefToken, getPreviousOrParentTNode(), getViewData());\n}\n/**\n * Creates a TemplateRef and stores it on the injector.\n *\n * @param TemplateRefToken The TemplateRef type\n * @param ElementRefToken The ElementRef type\n * @param hostTNode The node that is requesting a TemplateRef\n * @param hostView The view to which the node belongs\n * @returns The TemplateRef instance to use\n */\nfunction createTemplateRef(TemplateRefToken, ElementRefToken, hostTNode, hostView) {\n if (!R3TemplateRef) {\n // TODO: Fix class name, should be TemplateRef, but there appears to be a rollup bug\n R3TemplateRef = /** @class */ (function (_super) {\n __extends(TemplateRef_, _super);\n function TemplateRef_(_declarationParentView, elementRef, _tView, _renderer, _queries, _injectorIndex) {\n var _this = _super.call(this) || this;\n _this._declarationParentView = _declarationParentView;\n _this.elementRef = elementRef;\n _this._tView = _tView;\n _this._renderer = _renderer;\n _this._queries = _queries;\n _this._injectorIndex = _injectorIndex;\n return _this;\n }\n TemplateRef_.prototype.createEmbeddedView = function (context, container$$1, hostTNode, hostView, index) {\n var lView = createEmbeddedViewAndNode(this._tView, context, this._declarationParentView, this._renderer, this._queries, this._injectorIndex);\n if (container$$1) {\n insertView(lView, container$$1, hostView, index, hostTNode.index);\n }\n renderEmbeddedTemplate(lView, this._tView, context, 1 /* Create */);\n var viewRef = new ViewRef(lView, context, -1);\n viewRef._tViewNode = lView[HOST_NODE];\n return viewRef;\n };\n return TemplateRef_;\n }(TemplateRefToken));\n }\n if (hostTNode.type === 0 /* Container */) {\n var hostContainer = hostView[hostTNode.index];\n ngDevMode && assertDefined(hostTNode.tViews, 'TView must be allocated');\n return new R3TemplateRef(hostView, createElementRef(ElementRefToken, hostTNode, hostView), hostTNode.tViews, getRenderer(), hostContainer[QUERIES], hostTNode.injectorIndex);\n }\n else {\n return null;\n }\n}\nvar R3ViewContainerRef;\n/**\n * Creates a ViewContainerRef and stores it on the injector. Or, if the ViewContainerRef\n * already exists, retrieves the existing ViewContainerRef.\n *\n * @returns The ViewContainerRef instance to use\n */\nfunction injectViewContainerRef(ViewContainerRefToken, ElementRefToken) {\n var previousTNode = getPreviousOrParentTNode();\n return createContainerRef(ViewContainerRefToken, ElementRefToken, previousTNode, getViewData());\n}\nvar NodeInjector$1 = /** @class */ (function () {\n function NodeInjector$$1(_tNode, _hostView) {\n this._tNode = _tNode;\n this._hostView = _hostView;\n }\n NodeInjector$$1.prototype.get = function (token, notFoundValue) {\n return getOrCreateInjectable(this._tNode, this._hostView, token, InjectFlags.Default, notFoundValue);\n };\n return NodeInjector$$1;\n}());\n/**\n * Creates a ViewContainerRef and stores it on the injector.\n *\n * @param ViewContainerRefToken The ViewContainerRef type\n * @param ElementRefToken The ElementRef type\n * @param hostTNode The node that is requesting a ViewContainerRef\n * @param hostView The view to which the node belongs\n * @returns The ViewContainerRef instance to use\n */\nfunction createContainerRef(ViewContainerRefToken, ElementRefToken, hostTNode, hostView) {\n if (!R3ViewContainerRef) {\n // TODO: Fix class name, should be ViewContainerRef, but there appears to be a rollup bug\n R3ViewContainerRef = /** @class */ (function (_super) {\n __extends(ViewContainerRef_, _super);\n function ViewContainerRef_(_lContainer, _hostTNode, _hostView) {\n var _this = _super.call(this) || this;\n _this._lContainer = _lContainer;\n _this._hostTNode = _hostTNode;\n _this._hostView = _hostView;\n _this._viewRefs = [];\n return _this;\n }\n Object.defineProperty(ViewContainerRef_.prototype, \"element\", {\n get: function () {\n return createElementRef(ElementRefToken, this._hostTNode, this._hostView);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ViewContainerRef_.prototype, \"injector\", {\n get: function () { return new NodeInjector$1(this._hostTNode, this._hostView); },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ViewContainerRef_.prototype, \"parentInjector\", {\n /** @deprecated No replacement */\n get: function () {\n var parentLocation = getParentInjectorLocation(this._hostTNode, this._hostView);\n var parentView = getParentInjectorView(parentLocation, this._hostView);\n var parentTNode = getParentInjectorTNode(parentLocation, this._hostView, this._hostTNode);\n return !hasParentInjector(parentLocation) || parentTNode == null ?\n new NullInjector() :\n new NodeInjector$1(parentTNode, parentView);\n },\n enumerable: true,\n configurable: true\n });\n ViewContainerRef_.prototype.clear = function () {\n while (this._lContainer[VIEWS].length) {\n this.remove(0);\n }\n };\n ViewContainerRef_.prototype.get = function (index) { return this._viewRefs[index] || null; };\n Object.defineProperty(ViewContainerRef_.prototype, \"length\", {\n get: function () { return this._lContainer[VIEWS].length; },\n enumerable: true,\n configurable: true\n });\n ViewContainerRef_.prototype.createEmbeddedView = function (templateRef, context, index) {\n var adjustedIdx = this._adjustIndex(index);\n var viewRef = templateRef\n .createEmbeddedView(context || {}, this._lContainer, this._hostTNode, this._hostView, adjustedIdx);\n viewRef.attachToViewContainerRef(this);\n this._viewRefs.splice(adjustedIdx, 0, viewRef);\n return viewRef;\n };\n ViewContainerRef_.prototype.createComponent = function (componentFactory, index, injector, projectableNodes, ngModuleRef) {\n var contextInjector = injector || this.parentInjector;\n if (!ngModuleRef && contextInjector) {\n ngModuleRef = contextInjector.get(NgModuleRef, null);\n }\n var componentRef = componentFactory.create(contextInjector, projectableNodes, undefined, ngModuleRef);\n this.insert(componentRef.hostView, index);\n return componentRef;\n };\n ViewContainerRef_.prototype.insert = function (viewRef, index) {\n if (viewRef.destroyed) {\n throw new Error('Cannot insert a destroyed View in a ViewContainer!');\n }\n var lView = viewRef._view;\n var adjustedIdx = this._adjustIndex(index);\n insertView(lView, this._lContainer, this._hostView, adjustedIdx, this._hostTNode.index);\n var beforeNode = getBeforeNodeForView(adjustedIdx, this._lContainer[VIEWS], this._lContainer[NATIVE]);\n addRemoveViewFromContainer(lView, true, beforeNode);\n viewRef.attachToViewContainerRef(this);\n this._viewRefs.splice(adjustedIdx, 0, viewRef);\n return viewRef;\n };\n ViewContainerRef_.prototype.move = function (viewRef, newIndex) {\n var index = this.indexOf(viewRef);\n this.detach(index);\n this.insert(viewRef, this._adjustIndex(newIndex));\n return viewRef;\n };\n ViewContainerRef_.prototype.indexOf = function (viewRef) { return this._viewRefs.indexOf(viewRef); };\n ViewContainerRef_.prototype.remove = function (index) {\n var adjustedIdx = this._adjustIndex(index, -1);\n removeView(this._lContainer, this._hostTNode, adjustedIdx);\n this._viewRefs.splice(adjustedIdx, 1);\n };\n ViewContainerRef_.prototype.detach = function (index) {\n var adjustedIdx = this._adjustIndex(index, -1);\n detachView(this._lContainer, adjustedIdx, !!this._hostTNode.detached);\n return this._viewRefs.splice(adjustedIdx, 1)[0] || null;\n };\n ViewContainerRef_.prototype._adjustIndex = function (index, shift) {\n if (shift === void 0) { shift = 0; }\n if (index == null) {\n return this._lContainer[VIEWS].length + shift;\n }\n if (ngDevMode) {\n assertGreaterThan(index, -1, 'index must be positive');\n // +1 because it's legal to insert at the end.\n assertLessThan(index, this._lContainer[VIEWS].length + 1 + shift, 'index');\n }\n return index;\n };\n return ViewContainerRef_;\n }(ViewContainerRefToken));\n }\n ngDevMode && assertNodeOfPossibleTypes(hostTNode, 0 /* Container */, 3 /* Element */, 4 /* ElementContainer */);\n var lContainer;\n var slotValue = hostView[hostTNode.index];\n if (isLContainer(slotValue)) {\n // If the host is a container, we don't need to create a new LContainer\n lContainer = slotValue;\n lContainer[ACTIVE_INDEX] = -1;\n }\n else {\n var commentNode = hostView[RENDERER].createComment(ngDevMode ? 'container' : '');\n ngDevMode && ngDevMode.rendererCreateComment++;\n // A container can be created on the root (topmost / bootstrapped) component and in this case we\n // can't use LTree to insert container's marker node (both parent of a comment node and the\n // commend node itself is located outside of elements hold by LTree). In this specific case we\n // use low-level DOM manipulation to insert container's marker (comment) node.\n if (isRootView(hostView)) {\n var renderer = hostView[RENDERER];\n var hostNative = getNativeByTNode(hostTNode, hostView);\n var parentOfHostNative = nativeParentNode(renderer, hostNative);\n nativeInsertBefore(renderer, parentOfHostNative, commentNode, nativeNextSibling(renderer, hostNative));\n }\n else {\n appendChild(commentNode, hostTNode, hostView);\n }\n hostView[hostTNode.index] = lContainer =\n createLContainer(slotValue, hostTNode, hostView, commentNode, true);\n addToViewTree(hostView, hostTNode.index, lContainer);\n }\n return new R3ViewContainerRef(lContainer, hostTNode, hostView);\n}\n/** Returns a ChangeDetectorRef (a.k.a. a ViewRef) */\nfunction injectChangeDetectorRef() {\n return createViewRef(getPreviousOrParentTNode(), getViewData(), null);\n}\n/**\n * Creates a ViewRef and stores it on the injector as ChangeDetectorRef (public alias).\n *\n * @param hostTNode The node that is requesting a ChangeDetectorRef\n * @param hostView The view to which the node belongs\n * @param context The context for this change detector ref\n * @returns The ChangeDetectorRef to use\n */\nfunction createViewRef(hostTNode, hostView, context) {\n if (isComponent(hostTNode)) {\n var componentIndex = hostTNode.flags >> 16 /* DirectiveStartingIndexShift */;\n var componentView = getComponentViewByIndex(hostTNode.index, hostView);\n return new ViewRef(componentView, context, componentIndex);\n }\n else if (hostTNode.type === 3 /* Element */) {\n var hostComponentView = findComponentView(hostView);\n return new ViewRef(hostComponentView, hostComponentView[CONTEXT], -1);\n }\n return null;\n}\nfunction getOrCreateRenderer2(view) {\n var renderer = view[RENDERER];\n if (isProceduralRenderer(renderer)) {\n return renderer;\n }\n else {\n throw new Error('Cannot inject Renderer2 when the application uses Renderer3!');\n }\n}\n/** Returns a Renderer2 (or throws when application was bootstrapped with Renderer3) */\nfunction injectRenderer2() {\n return getOrCreateRenderer2(getViewData());\n}\n\n/**\n * Returns the component instance associated with a given DOM host element.\n * Elements which don't represent components return `null`.\n *\n * @param element Host DOM element from which the component should be retrieved for.\n *\n * ```\n * \n * #VIEW\n *
\n * \n *
\n * \n *\n * expect(getComponent() instanceof ChildComponent).toBeTruthy();\n * expect(getComponent() instanceof MyApp).toBeTruthy();\n * ```\n *\n * @publicApi\n */\nfunction getComponent(element) {\n if (!(element instanceof Node))\n throw new Error('Expecting instance of DOM Node');\n var context = loadContext(element);\n if (context.component === undefined) {\n context.component = getComponentAtNodeIndex(context.nodeIndex, context.lViewData);\n }\n return context.component;\n}\n/**\n * Returns the component instance associated with view which owns the DOM element (`null`\n * otherwise).\n *\n * @param element DOM element which is owned by an existing component's view.\n *\n * ```\n * \n * #VIEW\n *
\n * \n *
\n * \n *\n * expect(getViewComponent() instanceof MyApp).toBeTruthy();\n * expect(getViewComponent()).toEqual(null);\n * ```\n *\n * @publicApi\n */\nfunction getViewComponent(element) {\n var context = loadContext(element);\n var lView = context.lViewData;\n while (lView[PARENT] && lView[HOST] === null) {\n // As long as lView[HOST] is null we know we are part of sub-template such as `*ngIf`\n lView = lView[PARENT];\n }\n return lView[FLAGS] & 64 /* IsRoot */ ? null : lView[CONTEXT];\n}\n/**\n * Returns the `RootContext` instance that is associated with\n * the application where the target is situated.\n *\n */\nfunction getRootContext$1(target) {\n var lViewData = Array.isArray(target) ? target : loadContext(target).lViewData;\n var rootLViewData = getRootView$1(lViewData);\n return rootLViewData[CONTEXT];\n}\n/**\n * Retrieve all root components.\n *\n * Root components are those which have been bootstrapped by Angular.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nfunction getRootComponents(target) {\n return __spread(getRootContext$1(target).components);\n}\n/**\n * Retrieves an `Injector` associated with the element, component or directive.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nfunction getInjector(target) {\n var context = loadContext(target);\n var tNode = context.lViewData[TVIEW].data[context.nodeIndex];\n return new NodeInjector$1(tNode, context.lViewData);\n}\n/**\n * Retrieves directives associated with a given DOM host element.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nfunction getDirectives(target) {\n var context = loadContext(target);\n if (context.directives === undefined) {\n context.directives = getDirectivesAtNodeIndex(context.nodeIndex, context.lViewData, false);\n }\n return context.directives || [];\n}\n/**\n * Returns LContext associated with a target passed as an argument.\n * Throws if a given target doesn't have associated LContext.\n *\n */\nfunction loadContext(target) {\n var context = getContext(target);\n if (!context) {\n throw new Error(ngDevMode ? \"Unable to find context associated with \" + stringify$1(target) :\n 'Invalid ng target');\n }\n return context;\n}\n/**\n * Retrieve the root view from any component by walking the parent `LViewData` until\n * reaching the root `LViewData`.\n *\n * @param componentOrView any component or view\n *\n */\nfunction getRootView$1(componentOrView) {\n var lViewData;\n if (Array.isArray(componentOrView)) {\n ngDevMode && assertDefined(componentOrView, 'lViewData');\n lViewData = componentOrView;\n }\n else {\n ngDevMode && assertDefined(componentOrView, 'component');\n lViewData = readPatchedLViewData(componentOrView);\n }\n while (lViewData && !(lViewData[FLAGS] & 64 /* IsRoot */)) {\n lViewData = lViewData[PARENT];\n }\n return lViewData;\n}\n/**\n * Retrieve map of local references.\n *\n * The references are retrieved as a map of local reference name to element or directive instance.\n *\n * @param target A DOM element, component or directive instance.\n *\n * @publicApi\n */\nfunction getLocalRefs(target) {\n var context = loadContext(target);\n if (context.localRefs === undefined) {\n context.localRefs = discoverLocalRefs(context.lViewData, context.nodeIndex);\n }\n return context.localRefs || {};\n}\n/**\n * Retrieve the host element of the component.\n *\n * Use this function to retrieve the host element of the component. The host\n * element is the element which the component is associated with.\n *\n * @param directive Component or Directive for which the host element should be retrieved.\n *\n * @publicApi\n */\nfunction getHostElement(directive) {\n return getContext(directive).native;\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 * Adds a player to an element, directive or component instance that will later be\n * animated once change detection has passed.\n *\n * When a player is added to a reference it will stay active until `player.destroy()`\n * is called. Once called then the player will be removed from the active players\n * present on the associated ref instance.\n *\n * To get a list of all the active players on an element see [getPlayers].\n *\n * @param ref The element, directive or component that the player will be placed on.\n * @param player The player that will be triggered to play once change detection has run.\n */\nfunction addPlayer(ref, player) {\n var context = getContext(ref);\n if (!context) {\n ngDevMode && throwInvalidRefError();\n return;\n }\n var element$$1 = context.native;\n var lViewData = context.lViewData;\n var playerContext = getOrCreatePlayerContext(element$$1, context);\n var rootContext = getRootContext$1(lViewData);\n addPlayerInternal(playerContext, rootContext, element$$1, player, 0, ref);\n scheduleTick(rootContext, 2 /* FlushPlayers */);\n}\n/**\n * Returns a list of all the active players present on the provided ref instance (which can\n * be an instance of a directive, component or element).\n *\n * This function will only return players that have been added to the ref instance using\n * `addPlayer` or any players that are active through any template styling bindings\n * (`[style]`, `[style.prop]`, `[class]` and `[class.name]`).\n *\n * @publicApi\n */\nfunction getPlayers(ref) {\n var context = getContext(ref);\n if (!context) {\n ngDevMode && throwInvalidRefError();\n return [];\n }\n var stylingContext = getStylingContext(context.nodeIndex - HEADER_OFFSET, context.lViewData);\n var playerContext = stylingContext ? getPlayerContext(stylingContext) : null;\n return playerContext ? getPlayersInternal(playerContext) : [];\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/**\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 introduces series of globally accessible debug tools\n * to allow for the Angular debugging story to function.\n *\n * To see this in action run the following command:\n *\n * bazel run --define=compile=aot\n * //packages/core/test/bundling/todo:devserver\n *\n * Then load `localhost:5432` and start using the console tools.\n */\n/**\n * This value reflects the property on the window where the dev\n * tools are patched (window.ng).\n * */\nvar GLOBAL_PUBLISH_EXPANDO_KEY = 'ng';\n/*\n * Publishes a collection of default debug tools onto `window._ng_`.\n *\n * These functions are available globally when Angular is in development\n * mode and are automatically stripped away from prod mode is on.\n */\nvar _published = false;\nfunction publishDefaultGlobalUtils() {\n if (!_published) {\n _published = true;\n publishGlobalUtil('getComponent', getComponent);\n publishGlobalUtil('getViewComponent', getViewComponent);\n publishGlobalUtil('getHostElement', getHostElement);\n publishGlobalUtil('getInjector', getInjector);\n publishGlobalUtil('getRootComponents', getRootComponents);\n publishGlobalUtil('getDirectives', getDirectives);\n publishGlobalUtil('getPlayers', getPlayers);\n publishGlobalUtil('markDirty', markDirty);\n }\n}\n/**\n * Publishes the given function to `window.ngDevMode` so that it can be\n * used from the browser console when an application is not in production.\n */\nfunction publishGlobalUtil(name, fn) {\n var w = _global;\n ngDevMode && assertDefined(fn, 'function not defined');\n if (w) {\n var container = w[GLOBAL_PUBLISH_EXPANDO_KEY];\n if (!container) {\n container = w[GLOBAL_PUBLISH_EXPANDO_KEY] = {};\n }\n container[name] = fn;\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 * Bootstraps a Component into an existing host element and returns an instance\n * of the component.\n *\n * Use this function to bootstrap a component into the DOM tree. Each invocation\n * of this function will create a separate tree of components, injectors and\n * change detection cycles and lifetimes. To dynamically insert a new component\n * into an existing tree such that it shares the same injection, change detection\n * and object lifetime, use {@link ViewContainer#createComponent}.\n *\n * @param componentType Component to bootstrap\n * @param options Optional parameters which control bootstrapping\n */\nfunction renderComponent(componentType /* Type as workaround for: Microsoft/TypeScript/issues/4881 */, opts) {\n if (opts === void 0) { opts = {}; }\n ngDevMode && publishDefaultGlobalUtils();\n ngDevMode && assertComponentType(componentType);\n var rendererFactory = opts.rendererFactory || domRendererFactory3;\n var sanitizer = opts.sanitizer || null;\n var componentDef = getComponentDef(componentType);\n if (componentDef.type != componentType)\n componentDef.type = componentType;\n // The first index of the first selector is the tag name.\n var componentTag = componentDef.selectors[0][0];\n var hostRNode = locateHostElement(rendererFactory, opts.host || componentTag);\n var rootFlags = componentDef.onPush ? 4 /* Dirty */ | 64 /* IsRoot */ :\n 2 /* CheckAlways */ | 64 /* IsRoot */;\n var rootContext = createRootContext(opts.scheduler, opts.playerHandler);\n var renderer = rendererFactory.createRenderer(hostRNode, componentDef);\n var rootView = createLViewData(null, renderer, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, undefined, opts.injector || null);\n var oldView = enterView(rootView, null);\n var component;\n try {\n if (rendererFactory.begin)\n rendererFactory.begin();\n var componentView = createRootComponentView(hostRNode, componentDef, rootView, renderer, sanitizer);\n component = createRootComponent(componentView, componentDef, rootView, rootContext, opts.hostFeatures || null);\n refreshDescendantViews(rootView, null);\n }\n finally {\n leaveView(oldView);\n if (rendererFactory.end)\n rendererFactory.end();\n }\n return component;\n}\n/**\n * Creates the root component view and the root component node.\n *\n * @param rNode Render host element.\n * @param def ComponentDef\n * @param rootView The parent view where the host node is stored\n * @param renderer The current renderer\n * @param sanitizer The sanitizer, if provided\n *\n * @returns Component view created\n */\nfunction createRootComponentView(rNode, def, rootView, renderer, sanitizer) {\n resetComponentState();\n var tView = rootView[TVIEW];\n var componentView = createLViewData(rootView, renderer, getOrCreateTView(def.template, def.consts, def.vars, def.directiveDefs, def.pipeDefs, def.viewQuery), null, def.onPush ? 4 /* Dirty */ : 2 /* CheckAlways */, sanitizer);\n var tNode = createNodeAtIndex(0, 3 /* Element */, rNode, null, null);\n if (tView.firstTemplatePass) {\n diPublicInInjector(getOrCreateNodeInjectorForNode(tNode, rootView), rootView, def.type);\n tNode.flags = 4096 /* isComponent */;\n initNodeFlags(tNode, rootView.length, 1);\n queueComponentIndexForCheck(tNode);\n }\n // Store component view at node index, with node as the HOST\n componentView[HOST] = rootView[HEADER_OFFSET];\n componentView[HOST_NODE] = tNode;\n return rootView[HEADER_OFFSET] = componentView;\n}\n/**\n * Creates a root component and sets it up with features and host bindings. Shared by\n * renderComponent() and ViewContainerRef.createComponent().\n */\nfunction createRootComponent(componentView, componentDef, rootView, rootContext, hostFeatures) {\n var tView = rootView[TVIEW];\n // Create directive instance with factory() and store at next index in viewData\n var component = instantiateRootComponent(tView, rootView, componentDef);\n rootContext.components.push(component);\n componentView[CONTEXT] = component;\n hostFeatures && hostFeatures.forEach(function (feature) { return feature(component, componentDef); });\n if (tView.firstTemplatePass)\n prefillHostVars(tView, rootView, componentDef.hostVars);\n return component;\n}\nfunction createRootContext(scheduler, playerHandler) {\n return {\n components: [],\n scheduler: scheduler || defaultScheduler,\n clean: CLEAN_PROMISE,\n playerHandler: playerHandler || null,\n flags: 0 /* Empty */\n };\n}\n/**\n * Used to enable lifecycle hooks on the root component.\n *\n * Include this feature when calling `renderComponent` if the root component\n * you are rendering has lifecycle hooks defined. Otherwise, the hooks won't\n * be called properly.\n *\n * Example:\n *\n * ```\n * renderComponent(AppComponent, {features: [RootLifecycleHooks]});\n * ```\n */\nfunction LifecycleHooksFeature(component, def) {\n var rootTView = readPatchedLViewData(component)[TVIEW];\n var dirIndex = rootTView.data.length - 1;\n queueInitHooks(dirIndex, def.onInit, def.doCheck, rootTView);\n queueLifecycleHooks(dirIndex << 16 /* DirectiveStartingIndexShift */ | 1, rootTView);\n}\n/**\n * Retrieve the root context for any component by walking the parent `LView` until\n * reaching the root `LView`.\n *\n * @param component any component\n */\nfunction getRootContext$2(component) {\n var rootContext = getRootView(component)[CONTEXT];\n ngDevMode && assertDefined(rootContext, 'rootContext');\n return rootContext;\n}\n/**\n * Wait on component until it is rendered.\n *\n * This function returns a `Promise` which is resolved when the component's\n * change detection is executed. This is determined by finding the scheduler\n * associated with the `component`'s render tree and waiting until the scheduler\n * flushes. If nothing is scheduled, the function returns a resolved promise.\n *\n * Example:\n * ```\n * await whenRendered(myComponent);\n * ```\n *\n * @param component Component to wait upon\n * @returns Promise which resolves when the component is rendered.\n */\nfunction whenRendered(component) {\n return getRootContext$2(component).clean;\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 * Determines if a definition is a {@link ComponentDef} or a {@link DirectiveDef}\n * @param definition The definition to examine\n */\nfunction isComponentDef$1(definition) {\n var def = definition;\n return typeof def.template === 'function';\n}\nfunction getSuperType(type) {\n return Object.getPrototypeOf(type.prototype).constructor;\n}\n/**\n * Merges the definition from a super class to a sub class.\n * @param definition The definition that is a SubClass of another directive of component\n */\nfunction InheritDefinitionFeature(definition) {\n var superType = getSuperType(definition.type);\n var _loop_1 = function () {\n var e_1, _a;\n var superDef = undefined;\n if (isComponentDef$1(definition)) {\n // Don't use getComponentDef/getDirectiveDef. This logic relies on inheritance.\n superDef = superType.ngComponentDef || superType.ngDirectiveDef;\n }\n else {\n if (superType.ngComponentDef) {\n throw new Error('Directives cannot inherit Components');\n }\n // Don't use getComponentDef/getDirectiveDef. This logic relies on inheritance.\n superDef = superType.ngDirectiveDef;\n }\n var baseDef = superType.ngBaseDef;\n // Some fields in the definition may be empty, if there were no values to put in them that\n // would've justified object creation. Unwrap them if necessary.\n if (baseDef || superDef) {\n var writeableDef = definition;\n writeableDef.inputs = maybeUnwrapEmpty(definition.inputs);\n writeableDef.declaredInputs = maybeUnwrapEmpty(definition.declaredInputs);\n writeableDef.outputs = maybeUnwrapEmpty(definition.outputs);\n }\n if (baseDef) {\n // Merge inputs and outputs\n fillProperties(definition.inputs, baseDef.inputs);\n fillProperties(definition.declaredInputs, baseDef.declaredInputs);\n fillProperties(definition.outputs, baseDef.outputs);\n }\n if (superDef) {\n // Merge hostBindings\n var prevHostBindings_1 = definition.hostBindings;\n var superHostBindings_1 = superDef.hostBindings;\n if (superHostBindings_1) {\n if (prevHostBindings_1) {\n definition.hostBindings = function (directiveIndex, elementIndex) {\n superHostBindings_1(directiveIndex, elementIndex);\n prevHostBindings_1(directiveIndex, elementIndex);\n };\n definition.hostVars += superDef.hostVars;\n }\n else {\n definition.hostBindings = superHostBindings_1;\n }\n }\n // Merge View Queries\n if (isComponentDef$1(definition) && isComponentDef$1(superDef)) {\n var prevViewQuery_1 = definition.viewQuery;\n var superViewQuery_1 = superDef.viewQuery;\n if (superViewQuery_1) {\n if (prevViewQuery_1) {\n definition.viewQuery = function (rf, ctx) {\n superViewQuery_1(rf, ctx);\n prevViewQuery_1(rf, ctx);\n };\n }\n else {\n definition.viewQuery = superViewQuery_1;\n }\n }\n }\n // Merge Content Queries\n var prevContentQueries_1 = definition.contentQueries;\n var superContentQueries_1 = superDef.contentQueries;\n if (superContentQueries_1) {\n if (prevContentQueries_1) {\n definition.contentQueries = function (dirIndex) {\n superContentQueries_1(dirIndex);\n prevContentQueries_1(dirIndex);\n };\n }\n else {\n definition.contentQueries = superContentQueries_1;\n }\n }\n // Merge Content Queries Refresh\n var prevContentQueriesRefresh_1 = definition.contentQueriesRefresh;\n var superContentQueriesRefresh_1 = superDef.contentQueriesRefresh;\n if (superContentQueriesRefresh_1) {\n if (prevContentQueriesRefresh_1) {\n definition.contentQueriesRefresh = function (directiveIndex, queryIndex) {\n superContentQueriesRefresh_1(directiveIndex, queryIndex);\n prevContentQueriesRefresh_1(directiveIndex, queryIndex);\n };\n }\n else {\n definition.contentQueriesRefresh = superContentQueriesRefresh_1;\n }\n }\n // Merge inputs and outputs\n fillProperties(definition.inputs, superDef.inputs);\n fillProperties(definition.declaredInputs, superDef.declaredInputs);\n fillProperties(definition.outputs, superDef.outputs);\n // Inherit hooks\n // Assume super class inheritance feature has already run.\n definition.afterContentChecked =\n definition.afterContentChecked || superDef.afterContentChecked;\n definition.afterContentInit = definition.afterContentInit || superDef.afterContentInit;\n definition.afterViewChecked = definition.afterViewChecked || superDef.afterViewChecked;\n definition.afterViewInit = definition.afterViewInit || superDef.afterViewInit;\n definition.doCheck = definition.doCheck || superDef.doCheck;\n definition.onDestroy = definition.onDestroy || superDef.onDestroy;\n definition.onInit = definition.onInit || superDef.onInit;\n // Run parent features\n var features = superDef.features;\n if (features) {\n try {\n for (var features_1 = __values(features), features_1_1 = features_1.next(); !features_1_1.done; features_1_1 = features_1.next()) {\n var feature = features_1_1.value;\n if (feature && feature.ngInherit) {\n feature(definition);\n }\n }\n }\n catch (e_1_1) { e_1 = { error: e_1_1 }; }\n finally {\n try {\n if (features_1_1 && !features_1_1.done && (_a = features_1.return)) _a.call(features_1);\n }\n finally { if (e_1) throw e_1.error; }\n }\n }\n return \"break\";\n }\n else {\n // Even if we don't have a definition, check the type for the hooks and use those if need be\n var superPrototype = superType.prototype;\n if (superPrototype) {\n definition.afterContentChecked =\n definition.afterContentChecked || superPrototype.afterContentChecked;\n definition.afterContentInit =\n definition.afterContentInit || superPrototype.afterContentInit;\n definition.afterViewChecked =\n definition.afterViewChecked || superPrototype.afterViewChecked;\n definition.afterViewInit = definition.afterViewInit || superPrototype.afterViewInit;\n definition.doCheck = definition.doCheck || superPrototype.doCheck;\n definition.onDestroy = definition.onDestroy || superPrototype.onDestroy;\n definition.onInit = definition.onInit || superPrototype.onInit;\n }\n }\n superType = Object.getPrototypeOf(superType);\n };\n while (superType) {\n var state_1 = _loop_1();\n if (state_1 === \"break\")\n break;\n }\n}\nfunction maybeUnwrapEmpty(value) {\n if (value === EMPTY) {\n return {};\n }\n else if (value === EMPTY_ARRAY) {\n return [];\n }\n else {\n return value;\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 */\nvar PRIVATE_PREFIX = '__ngOnChanges_';\n/**\n * The NgOnChangesFeature decorates a component with support for the ngOnChanges\n * lifecycle hook, so it should be included in any component that implements\n * that hook.\n *\n * If the component or directive uses inheritance, the NgOnChangesFeature MUST\n * be included as a feature AFTER {@link InheritDefinitionFeature}, otherwise\n * inherited properties will not be propagated to the ngOnChanges lifecycle\n * hook.\n *\n * Example usage:\n *\n * ```\n * static ngComponentDef = defineComponent({\n * ...\n * inputs: {name: 'publicName'},\n * features: [NgOnChangesFeature]\n * });\n * ```\n */\nfunction NgOnChangesFeature(definition) {\n var declaredToMinifiedInputs = definition.declaredInputs;\n var proto = definition.type.prototype;\n var _loop_1 = function (declaredName) {\n if (declaredToMinifiedInputs.hasOwnProperty(declaredName)) {\n var minifiedKey = declaredToMinifiedInputs[declaredName];\n var privateMinKey_1 = PRIVATE_PREFIX + minifiedKey;\n // Walk the prototype chain to see if we find a property descriptor\n // That way we can honor setters and getters that were inherited.\n var originalProperty = undefined;\n var checkProto = proto;\n while (!originalProperty && checkProto &&\n Object.getPrototypeOf(checkProto) !== Object.getPrototypeOf(Object.prototype)) {\n originalProperty = Object.getOwnPropertyDescriptor(checkProto, minifiedKey);\n checkProto = Object.getPrototypeOf(checkProto);\n }\n var getter = originalProperty && originalProperty.get;\n var setter_1 = originalProperty && originalProperty.set;\n // create a getter and setter for property\n Object.defineProperty(proto, minifiedKey, {\n get: getter ||\n (setter_1 ? undefined : function () { return this[privateMinKey_1]; }),\n set: function (value) {\n var simpleChanges = this[PRIVATE_PREFIX];\n if (!simpleChanges) {\n simpleChanges = {};\n // Place where we will store SimpleChanges if there is a change\n Object.defineProperty(this, PRIVATE_PREFIX, { value: simpleChanges, writable: true });\n }\n var isFirstChange = !this.hasOwnProperty(privateMinKey_1);\n var currentChange = simpleChanges[declaredName];\n if (currentChange) {\n currentChange.currentValue = value;\n }\n else {\n simpleChanges[declaredName] =\n new SimpleChange(this[privateMinKey_1], value, isFirstChange);\n }\n if (isFirstChange) {\n // Create a place where the actual value will be stored and make it non-enumerable\n Object.defineProperty(this, privateMinKey_1, { value: value, writable: true });\n }\n else {\n this[privateMinKey_1] = value;\n }\n if (setter_1)\n setter_1.call(this, value);\n },\n // Make the property configurable in dev mode to allow overriding in tests\n configurable: !!ngDevMode\n });\n }\n };\n for (var declaredName in declaredToMinifiedInputs) {\n _loop_1(declaredName);\n }\n // If an onInit hook is defined, it will need to wrap the ngOnChanges call\n // so the call order is changes-init-check in creation mode. In subsequent\n // change detection runs, only the check wrapper will be called.\n if (definition.onInit != null) {\n definition.onInit = onChangesWrapper(definition.onInit);\n }\n definition.doCheck = onChangesWrapper(definition.doCheck);\n}\n// This option ensures that the ngOnChanges lifecycle hook will be inherited\n// from superclasses (in InheritDefinitionFeature).\nNgOnChangesFeature.ngInherit = true;\nfunction onChangesWrapper(delegateHook) {\n return function () {\n var simpleChanges = this[PRIVATE_PREFIX];\n if (simpleChanges != null) {\n this.ngOnChanges(simpleChanges);\n this[PRIVATE_PREFIX] = null;\n }\n if (delegateHook)\n delegateHook.apply(this);\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 * An internal token whose presence in an injector indicates that the injector should treat itself\n * as a root scoped injector when processing requests for unknown tokens which may indicate\n * they are provided in the root scope.\n */\nvar APP_ROOT = new InjectionToken('The presence of this token marks an injector as being the root injector.');\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 * Marker which indicates that a value has not yet been created from the factory function.\n */\nvar NOT_YET = {};\n/**\n * Marker which indicates that the factory function for a token is in the process of being called.\n *\n * If the injector is asked to inject a token with its value set to CIRCULAR, that indicates\n * injection of a dependency has recursively attempted to inject the original token, and there is\n * a circular dependency among the providers.\n */\nvar CIRCULAR$1 = {};\nvar EMPTY_ARRAY$1 = [];\n/**\n * A lazily initialized NullInjector.\n */\nvar NULL_INJECTOR$2 = undefined;\nfunction getNullInjector() {\n if (NULL_INJECTOR$2 === undefined) {\n NULL_INJECTOR$2 = new NullInjector();\n }\n return NULL_INJECTOR$2;\n}\n/**\n * Create a new `Injector` which is configured using a `defType` of `InjectorType`s.\n *\n * @publicApi\n */\nfunction createInjector(defType, parent, additionalProviders) {\n if (parent === void 0) { parent = null; }\n if (additionalProviders === void 0) { additionalProviders = null; }\n parent = parent || getNullInjector();\n return new R3Injector(defType, additionalProviders, parent);\n}\nvar R3Injector = /** @class */ (function () {\n function R3Injector(def, additionalProviders, parent) {\n var _this = this;\n this.parent = parent;\n /**\n * Map of tokens to records which contain the instances of those tokens.\n */\n this.records = new Map();\n /**\n * The transitive set of `InjectorType`s which define this injector.\n */\n this.injectorDefTypes = new Set();\n /**\n * Set of values instantiated by this injector which contain `ngOnDestroy` lifecycle hooks.\n */\n this.onDestroy = new Set();\n /**\n * Flag indicating that this injector was previously destroyed.\n */\n this.destroyed = false;\n // Start off by creating Records for every provider declared in every InjectorType\n // included transitively in `def`.\n var dedupStack = [];\n deepForEach([def], function (injectorDef) { return _this.processInjectorType(injectorDef, [], dedupStack); });\n additionalProviders &&\n deepForEach(additionalProviders, function (provider) { return _this.processProvider(provider); });\n // Make sure the INJECTOR token provides this injector.\n this.records.set(INJECTOR$1, makeRecord(undefined, this));\n // Detect whether this injector has the APP_ROOT_SCOPE token and thus should provide\n // any injectable scoped to APP_ROOT_SCOPE.\n this.isRootInjector = this.records.has(APP_ROOT);\n // Eagerly instantiate the InjectorType classes themselves.\n this.injectorDefTypes.forEach(function (defType) { return _this.get(defType); });\n }\n /**\n * Destroy the injector and release references to every instance or provider associated with it.\n *\n * Also calls the `OnDestroy` lifecycle hooks of every instance that was created for which a\n * hook was found.\n */\n R3Injector.prototype.destroy = function () {\n this.assertNotDestroyed();\n // Set destroyed = true first, in case lifecycle hooks re-enter destroy().\n this.destroyed = true;\n try {\n // Call all the lifecycle hooks.\n this.onDestroy.forEach(function (service) { return service.ngOnDestroy(); });\n }\n finally {\n // Release all references.\n this.records.clear();\n this.onDestroy.clear();\n this.injectorDefTypes.clear();\n }\n };\n R3Injector.prototype.get = function (token, notFoundValue, flags) {\n if (notFoundValue === void 0) { notFoundValue = THROW_IF_NOT_FOUND; }\n if (flags === void 0) { flags = InjectFlags.Default; }\n this.assertNotDestroyed();\n // Set the injection context.\n var previousInjector = setCurrentInjector(this);\n try {\n // Check for the SkipSelf flag.\n if (!(flags & InjectFlags.SkipSelf)) {\n // SkipSelf isn't set, check if the record belongs to this injector.\n var record = this.records.get(token);\n if (record === undefined) {\n // No record, but maybe the token is scoped to this injector. Look for an ngInjectableDef\n // with a scope matching this injector.\n var def = couldBeInjectableType(token) && getInjectableDef(token);\n if (def && this.injectableDefInScope(def)) {\n // Found an ngInjectableDef and it's scoped to this injector. Pretend as if it was here\n // all along.\n record = makeRecord(injectableDefFactory(token), NOT_YET);\n this.records.set(token, record);\n }\n }\n // If a record was found, get the instance for it and return it.\n if (record !== undefined) {\n return this.hydrate(token, record);\n }\n }\n // Select the next injector based on the Self flag - if self is set, the next injector is\n // the NullInjector, otherwise it's the parent.\n var nextInjector = !(flags & InjectFlags.Self) ? this.parent : getNullInjector();\n return nextInjector.get(token, notFoundValue);\n }\n finally {\n // Lastly, clean up the state by restoring the previous injector.\n setCurrentInjector(previousInjector);\n }\n };\n R3Injector.prototype.assertNotDestroyed = function () {\n if (this.destroyed) {\n throw new Error('Injector has already been destroyed.');\n }\n };\n /**\n * Add an `InjectorType` or `InjectorDefTypeWithProviders` and all of its transitive providers\n * to this injector.\n */\n R3Injector.prototype.processInjectorType = function (defOrWrappedDef, parents, dedupStack) {\n var _this = this;\n defOrWrappedDef = resolveForwardRef(defOrWrappedDef);\n if (!defOrWrappedDef)\n return;\n // Either the defOrWrappedDef is an InjectorType (with ngInjectorDef) or an\n // InjectorDefTypeWithProviders (aka ModuleWithProviders). Detecting either is a megamorphic\n // read, so care is taken to only do the read once.\n // First attempt to read the ngInjectorDef.\n var def = getInjectorDef(defOrWrappedDef);\n // If that's not present, then attempt to read ngModule from the InjectorDefTypeWithProviders.\n var ngModule = (def == null) && defOrWrappedDef.ngModule || undefined;\n // Determine the InjectorType. In the case where `defOrWrappedDef` is an `InjectorType`,\n // then this is easy. In the case of an InjectorDefTypeWithProviders, then the definition type\n // is the `ngModule`.\n var defType = (ngModule === undefined) ? defOrWrappedDef : ngModule;\n // Check for circular dependencies.\n if (ngDevMode && parents.indexOf(defType) !== -1) {\n var defName = stringify(defType);\n throw new Error(\"Circular dependency in DI detected for type \" + defName + \". Dependency path: \" + parents.map(function (defType) { return stringify(defType); }).join(' > ') + \" > \" + defName + \".\");\n }\n // Check for multiple imports of the same module\n if (dedupStack.indexOf(defType) !== -1) {\n return;\n }\n // If defOrWrappedType was an InjectorDefTypeWithProviders, then .providers may hold some\n // extra providers.\n var providers = (ngModule !== undefined) && defOrWrappedDef.providers ||\n EMPTY_ARRAY$1;\n // Finally, if defOrWrappedType was an `InjectorDefTypeWithProviders`, then the actual\n // `InjectorDef` is on its `ngModule`.\n if (ngModule !== undefined) {\n def = getInjectorDef(ngModule);\n }\n // If no definition was found, it might be from exports. Remove it.\n if (def == null) {\n return;\n }\n // Track the InjectorType and add a provider for it.\n this.injectorDefTypes.add(defType);\n this.records.set(defType, makeRecord(def.factory));\n // Add providers in the same way that @NgModule resolution did:\n // First, include providers from any imports.\n if (def.imports != null) {\n // Before processing defType's imports, add it to the set of parents. This way, if it ends\n // up deeply importing itself, this can be detected.\n ngDevMode && parents.push(defType);\n // Add it to the set of dedups. This way we can detect multiple imports of the same module\n dedupStack.push(defType);\n try {\n deepForEach(def.imports, function (imported) { return _this.processInjectorType(imported, parents, dedupStack); });\n }\n finally {\n // Remove it from the parents set when finished.\n ngDevMode && parents.pop();\n }\n }\n // Next, include providers listed on the definition itself.\n if (def.providers != null) {\n deepForEach(def.providers, function (provider) { return _this.processProvider(provider); });\n }\n // Finally, include providers from an InjectorDefTypeWithProviders if there was one.\n deepForEach(providers, function (provider) { return _this.processProvider(provider); });\n };\n /**\n * Process a `SingleProvider` and add it.\n */\n R3Injector.prototype.processProvider = function (provider) {\n // Determine the token from the provider. Either it's its own token, or has a {provide: ...}\n // property.\n provider = resolveForwardRef(provider);\n var token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);\n // Construct a `Record` for the provider.\n var record = providerToRecord(provider);\n if (!isTypeProvider(provider) && provider.multi === true) {\n // If the provider indicates that it's a multi-provider, process it specially.\n // First check whether it's been defined already.\n var multiRecord_1 = this.records.get(token);\n if (multiRecord_1) {\n // It has. Throw a nice error if\n if (multiRecord_1.multi === undefined) {\n throw new Error(\"Mixed multi-provider for \" + token + \".\");\n }\n }\n else {\n multiRecord_1 = makeRecord(undefined, NOT_YET, true);\n multiRecord_1.factory = function () { return injectArgs(multiRecord_1.multi); };\n this.records.set(token, multiRecord_1);\n }\n token = provider;\n multiRecord_1.multi.push(provider);\n }\n else {\n var existing = this.records.get(token);\n if (existing && existing.multi !== undefined) {\n throw new Error(\"Mixed multi-provider for \" + stringify(token));\n }\n }\n this.records.set(token, record);\n };\n R3Injector.prototype.hydrate = function (token, record) {\n if (record.value === CIRCULAR$1) {\n throw new Error(\"Circular dep for \" + stringify(token));\n }\n else if (record.value === NOT_YET) {\n record.value = CIRCULAR$1;\n record.value = record.factory();\n }\n if (typeof record.value === 'object' && record.value && hasOnDestroy(record.value)) {\n this.onDestroy.add(record.value);\n }\n return record.value;\n };\n R3Injector.prototype.injectableDefInScope = function (def) {\n if (!def.providedIn) {\n return false;\n }\n else if (typeof def.providedIn === 'string') {\n return def.providedIn === 'any' || (def.providedIn === 'root' && this.isRootInjector);\n }\n else {\n return this.injectorDefTypes.has(def.providedIn);\n }\n };\n return R3Injector;\n}());\nfunction injectableDefFactory(token) {\n var injectableDef = getInjectableDef(token);\n if (injectableDef === null) {\n if (token instanceof InjectionToken) {\n throw new Error(\"Token \" + stringify(token) + \" is missing an ngInjectableDef definition.\");\n }\n // TODO(alxhub): there should probably be a strict mode which throws here instead of assuming a\n // no-args constructor.\n return function () { return new token(); };\n }\n return injectableDef.factory;\n}\nfunction providerToRecord(provider) {\n var factory = providerToFactory(provider);\n if (isValueProvider(provider)) {\n return makeRecord(undefined, provider.useValue);\n }\n else {\n return makeRecord(factory, NOT_YET);\n }\n}\n/**\n * Converts a `SingleProvider` into a factory function.\n *\n * @param provider provider to convert to factory\n */\nfunction providerToFactory(provider) {\n var factory = undefined;\n if (isTypeProvider(provider)) {\n return injectableDefFactory(resolveForwardRef(provider));\n }\n else {\n if (isValueProvider(provider)) {\n factory = function () { return resolveForwardRef(provider.useValue); };\n }\n else if (isExistingProvider(provider)) {\n factory = function () { return inject(resolveForwardRef(provider.useExisting)); };\n }\n else if (isFactoryProvider(provider)) {\n factory = function () { return provider.useFactory.apply(provider, __spread(injectArgs(provider.deps || []))); };\n }\n else {\n var classRef_1 = resolveForwardRef(provider.useClass || provider.provide);\n if (hasDeps(provider)) {\n factory = function () { return new ((classRef_1).bind.apply((classRef_1), __spread([void 0], injectArgs(provider.deps))))(); };\n }\n else {\n return injectableDefFactory(classRef_1);\n }\n }\n }\n return factory;\n}\nfunction makeRecord(factory, value, multi) {\n if (value === void 0) { value = NOT_YET; }\n if (multi === void 0) { multi = false; }\n return {\n factory: factory,\n value: value,\n multi: multi ? [] : undefined,\n };\n}\nfunction deepForEach(input, fn) {\n input.forEach(function (value) { return Array.isArray(value) ? deepForEach(value, fn) : fn(value); });\n}\nfunction isValueProvider(value) {\n return USE_VALUE in value;\n}\nfunction isExistingProvider(value) {\n return !!value.useExisting;\n}\nfunction isFactoryProvider(value) {\n return !!value.useFactory;\n}\nfunction isTypeProvider(value) {\n return typeof value === 'function';\n}\nfunction hasDeps(value) {\n return !!value.deps;\n}\nfunction hasOnDestroy(value) {\n return typeof value === 'object' && value != null && value.ngOnDestroy &&\n typeof value.ngOnDestroy === 'function';\n}\nfunction couldBeInjectableType(value) {\n return (typeof value === 'function') ||\n (typeof value === 'object' && value instanceof InjectionToken);\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 * Resolves the providers which are defined in the DirectiveDef.\n *\n * When inserting the tokens and the factories in their respective arrays, we can assume that\n * this method is called first for the component (if any), and then for other directives on the same\n * node.\n * As a consequence,the providers are always processed in that order:\n * 1) The view providers of the component\n * 2) The providers of the component\n * 3) The providers of the other directives\n * This matches the structure of the injectables arrays of a view (for each node).\n * So the tokens and the factories can be pushed at the end of the arrays, except\n * in one case for multi providers.\n *\n * @param def the directive definition\n * @param providers: Array of `providers`.\n * @param viewProviders: Array of `viewProviders`.\n */\nfunction providersResolver(def, providers, viewProviders) {\n var viewData = getViewData();\n var tView = viewData[TVIEW];\n if (tView.firstTemplatePass) {\n var isComponent$$1 = isComponentDef(def);\n // The list of view providers is processed first, and the flags are updated\n resolveProvider$1(viewProviders, tView.data, tView.blueprint, isComponent$$1, true);\n // Then, the list of providers is processed, and the flags are updated\n resolveProvider$1(providers, tView.data, tView.blueprint, isComponent$$1, false);\n }\n}\n/**\n * Resolves a provider and publishes it to the DI system.\n */\nfunction resolveProvider$1(provider, tInjectables, lInjectablesBlueprint, isComponent$$1, isViewProvider) {\n provider = resolveForwardRef(provider);\n if (Array.isArray(provider)) {\n // Recursively call `resolveProvider`\n // Recursion is OK in this case because this code will not be in hot-path once we implement\n // cloning of the initial state.\n for (var i = 0; i < provider.length; i++) {\n resolveProvider$1(provider[i], tInjectables, lInjectablesBlueprint, isComponent$$1, isViewProvider);\n }\n }\n else {\n var viewData = getViewData();\n var token = isTypeProvider(provider) ? provider : resolveForwardRef(provider.provide);\n var providerFactory = providerToFactory(provider);\n var previousOrParentTNode = getPreviousOrParentTNode();\n var beginIndex = previousOrParentTNode.providerIndexes & 65535 /* ProvidersStartIndexMask */;\n var endIndex = previousOrParentTNode.flags >> 16 /* DirectiveStartingIndexShift */;\n var cptViewProvidersCount = previousOrParentTNode.providerIndexes >> 16 /* CptViewProvidersCountShift */;\n if (isTypeProvider(provider) || !provider.multi) {\n // Single provider case: the factory is created and pushed immediately\n var factory = new NodeInjectorFactory(providerFactory, isViewProvider, directiveInject);\n var existingFactoryIndex = indexOf(token, tInjectables, isViewProvider ? beginIndex : beginIndex + cptViewProvidersCount, endIndex);\n if (existingFactoryIndex == -1) {\n diPublicInInjector(getOrCreateNodeInjectorForNode(previousOrParentTNode, viewData), viewData, token);\n tInjectables.push(token);\n previousOrParentTNode.flags += 1 << 16 /* DirectiveStartingIndexShift */;\n if (isViewProvider) {\n previousOrParentTNode.providerIndexes +=\n 65536 /* CptViewProvidersCountShifter */;\n }\n lInjectablesBlueprint.push(factory);\n viewData.push(factory);\n }\n else {\n lInjectablesBlueprint[existingFactoryIndex] = factory;\n viewData[existingFactoryIndex] = factory;\n }\n }\n else {\n // Multi provider case:\n // We create a multi factory which is going to aggregate all the values.\n // Since the output of such a factory depends on content or view injection,\n // we create two of them, which are linked together.\n //\n // The first one (for view providers) is always in the first block of the injectables array,\n // and the second one (for providers) is always in the second block.\n // This is important because view providers have higher priority. When a multi token\n // is being looked up, the view providers should be found first.\n // Note that it is not possible to have a multi factory in the third block (directive block).\n //\n // The algorithm to process multi providers is as follows:\n // 1) If the multi provider comes from the `viewProviders` of the component:\n // a) If the special view providers factory doesn't exist, it is created and pushed.\n // b) Else, the multi provider is added to the existing multi factory.\n // 2) If the multi provider comes from the `providers` of the component or of another\n // directive:\n // a) If the multi factory doesn't exist, it is created and provider pushed into it.\n // It is also linked to the multi factory for view providers, if it exists.\n // b) Else, the multi provider is added to the existing multi factory.\n var existingProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex + cptViewProvidersCount, endIndex);\n var existingViewProvidersFactoryIndex = indexOf(token, tInjectables, beginIndex, beginIndex + cptViewProvidersCount);\n var doesProvidersFactoryExist = existingProvidersFactoryIndex >= 0 &&\n lInjectablesBlueprint[existingProvidersFactoryIndex];\n var doesViewProvidersFactoryExist = existingViewProvidersFactoryIndex >= 0 &&\n lInjectablesBlueprint[existingViewProvidersFactoryIndex];\n if (isViewProvider && !doesViewProvidersFactoryExist ||\n !isViewProvider && !doesProvidersFactoryExist) {\n // Cases 1.a and 2.a\n diPublicInInjector(getOrCreateNodeInjectorForNode(previousOrParentTNode, viewData), viewData, token);\n var factory = multiFactory(isViewProvider ? multiViewProvidersFactoryResolver : multiProvidersFactoryResolver, lInjectablesBlueprint.length, isViewProvider, isComponent$$1, providerFactory);\n if (!isViewProvider && doesViewProvidersFactoryExist) {\n lInjectablesBlueprint[existingViewProvidersFactoryIndex].providerFactory = factory;\n }\n tInjectables.push(token);\n previousOrParentTNode.flags += 1 << 16 /* DirectiveStartingIndexShift */;\n if (isViewProvider) {\n previousOrParentTNode.providerIndexes +=\n 65536 /* CptViewProvidersCountShifter */;\n }\n lInjectablesBlueprint.push(factory);\n viewData.push(factory);\n }\n else {\n // Cases 1.b and 2.b\n multiFactoryAdd(lInjectablesBlueprint[isViewProvider ? existingViewProvidersFactoryIndex : existingProvidersFactoryIndex], providerFactory, !isViewProvider && isComponent$$1);\n }\n if (!isViewProvider && isComponent$$1 && doesViewProvidersFactoryExist) {\n lInjectablesBlueprint[existingViewProvidersFactoryIndex].componentProviders++;\n }\n }\n }\n}\n/**\n * Add a factory in a multi factory.\n */\nfunction multiFactoryAdd(multiFactory, factory, isComponentProvider) {\n multiFactory.multi.push(factory);\n if (isComponentProvider) {\n multiFactory.componentProviders++;\n }\n}\n/**\n * Returns the index of item in the array, but only in the begin to end range.\n */\nfunction indexOf(item, arr, begin, end) {\n for (var i = begin; i < end; i++) {\n if (arr[i] === item)\n return i;\n }\n return -1;\n}\n/**\n * Use this with `multi` `providers`.\n */\nfunction multiProvidersFactoryResolver(_, tData, lData, tNode) {\n return multiResolve(this.multi, []);\n}\n/**\n * Use this with `multi` `viewProviders`.\n *\n * This factory knows how to concatenate itself with the existing `multi` `providers`.\n */\nfunction multiViewProvidersFactoryResolver(_, tData, lData, tNode) {\n var factories = this.multi;\n var result;\n if (this.providerFactory) {\n var componentCount = this.providerFactory.componentProviders;\n var multiProviders = getNodeInjectable(tData, lData, this.providerFactory.index, tNode);\n // Copy the section of the array which contains `multi` `providers` from the component\n result = multiProviders.slice(0, componentCount);\n // Insert the `viewProvider` instances.\n multiResolve(factories, result);\n // Copy the section of the array which contains `multi` `providers` from other directives\n for (var i = componentCount; i < multiProviders.length; i++) {\n result.push(multiProviders[i]);\n }\n }\n else {\n result = [];\n // Insert the `viewProvider` instances.\n multiResolve(factories, result);\n }\n return result;\n}\n/**\n * Maps an array of factories into an array of values.\n */\nfunction multiResolve(factories, result) {\n for (var i = 0; i < factories.length; i++) {\n var factory = factories[i];\n result.push(factory());\n }\n return result;\n}\n/**\n * Creates a multi factory.\n */\nfunction multiFactory(factoryFn, index, isViewProvider, isComponent$$1, f) {\n var factory = new NodeInjectorFactory(factoryFn, isViewProvider, directiveInject);\n factory.multi = [];\n factory.index = index;\n factory.componentProviders = 0;\n multiFactoryAdd(factory, f, isComponent$$1 && !isViewProvider);\n return factory;\n}\n\n/**\n * This feature resolves the providers of a directive (or component),\n * and publish them into the DI system, making it visible to others for injection.\n *\n * For example:\n * class ComponentWithProviders {\n * constructor(private greeter: GreeterDE) {}\n *\n * static ngComponentDef = defineComponent({\n * type: ComponentWithProviders,\n * selectors: [['component-with-providers']],\n * factory: () => new ComponentWithProviders(directiveInject(GreeterDE as any)),\n * consts: 1,\n * vars: 1,\n * template: function(fs: RenderFlags, ctx: ComponentWithProviders) {\n * if (fs & RenderFlags.Create) {\n * text(0);\n * }\n * if (fs & RenderFlags.Update) {\n * textBinding(0, bind(ctx.greeter.greet()));\n * }\n * },\n * features: [ProvidersFeature([GreeterDE])]\n * });\n * }\n *\n * @param definition\n */\nfunction ProvidersFeature(providers, viewProviders) {\n if (viewProviders === void 0) { viewProviders = []; }\n return function (definition) {\n definition.providersResolver = function (def) {\n return providersResolver(def, providers, viewProviders);\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 * Represents a component created by a `ComponentFactory`.\n * Provides access to the component instance and related objects,\n * and provides the means of destroying the instance.\n *\n * @publicApi\n */\nvar ComponentRef = /** @class */ (function () {\n function ComponentRef() {\n }\n return ComponentRef;\n}());\n/**\n * @publicApi\n */\nvar ComponentFactory = /** @class */ (function () {\n function ComponentFactory() {\n }\n return ComponentFactory;\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 noComponentFactoryError(component) {\n var error = Error(\"No component factory found for \" + stringify(component) + \". Did you add it to @NgModule.entryComponents?\");\n error[ERROR_COMPONENT] = component;\n return error;\n}\nvar ERROR_COMPONENT = 'ngComponent';\nvar _NullComponentFactoryResolver = /** @class */ (function () {\n function _NullComponentFactoryResolver() {\n }\n _NullComponentFactoryResolver.prototype.resolveComponentFactory = function (component) {\n throw noComponentFactoryError(component);\n };\n return _NullComponentFactoryResolver;\n}());\n/**\n * @publicApi\n */\nvar ComponentFactoryResolver = /** @class */ (function () {\n function ComponentFactoryResolver() {\n }\n ComponentFactoryResolver.NULL = new _NullComponentFactoryResolver();\n return ComponentFactoryResolver;\n}());\nvar CodegenComponentFactoryResolver = /** @class */ (function () {\n function CodegenComponentFactoryResolver(factories, _parent, _ngModule) {\n this._parent = _parent;\n this._ngModule = _ngModule;\n this._factories = new Map();\n for (var i = 0; i < factories.length; i++) {\n var factory = factories[i];\n this._factories.set(factory.componentType, factory);\n }\n }\n CodegenComponentFactoryResolver.prototype.resolveComponentFactory = function (component) {\n var factory = this._factories.get(component);\n if (!factory && this._parent) {\n factory = this._parent.resolveComponentFactory(component);\n }\n if (!factory) {\n throw noComponentFactoryError(component);\n }\n return new ComponentFactoryBoundToModule(factory, this._ngModule);\n };\n return CodegenComponentFactoryResolver;\n}());\nvar ComponentFactoryBoundToModule = /** @class */ (function (_super) {\n __extends(ComponentFactoryBoundToModule, _super);\n function ComponentFactoryBoundToModule(factory, ngModule) {\n var _this = _super.call(this) || this;\n _this.factory = factory;\n _this.ngModule = ngModule;\n _this.selector = factory.selector;\n _this.componentType = factory.componentType;\n _this.ngContentSelectors = factory.ngContentSelectors;\n _this.inputs = factory.inputs;\n _this.outputs = factory.outputs;\n return _this;\n }\n ComponentFactoryBoundToModule.prototype.create = function (injector, projectableNodes, rootSelectorOrNode, ngModule) {\n return this.factory.create(injector, projectableNodes, rootSelectorOrNode, ngModule || this.ngModule);\n };\n return ComponentFactoryBoundToModule;\n}(ComponentFactory));\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 wrapper around a native element inside of a View.\n *\n * An `ElementRef` is backed by a render-specific element. In the browser, this is usually a DOM\n * element.\n *\n * @security Permitting direct access to the DOM can make your application more vulnerable to\n * XSS attacks. Carefully review any use of `ElementRef` in your code. For more detail, see the\n * [Security Guide](http://g.co/ng/security).\n *\n * @publicApi\n */\n// Note: We don't expose things like `Injector`, `ViewContainer`, ... here,\n// i.e. users have to ask for what they need. With that, we can build better analysis tools\n// and could do better codegen in the future.\nvar ElementRef = /** @class */ (function () {\n function ElementRef(nativeElement) {\n this.nativeElement = nativeElement;\n }\n /** @internal */\n ElementRef.__NG_ELEMENT_ID__ = function () { return SWITCH_ELEMENT_REF_FACTORY(ElementRef); };\n return ElementRef;\n}());\nvar SWITCH_ELEMENT_REF_FACTORY__POST_R3__ = injectElementRef;\nvar SWITCH_ELEMENT_REF_FACTORY__PRE_R3__ = noop;\nvar SWITCH_ELEMENT_REF_FACTORY = SWITCH_ELEMENT_REF_FACTORY__PRE_R3__;\n\n/**\n * @license\n * Copyright Google Inc. All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n/**\n * @deprecated Use `RendererType2` (and `Renderer2`) instead.\n * @publicApi\n */\nvar RenderComponentType = /** @class */ (function () {\n function RenderComponentType(id, templateUrl, slotCount, encapsulation, styles, animations) {\n this.id = id;\n this.templateUrl = templateUrl;\n this.slotCount = slotCount;\n this.encapsulation = encapsulation;\n this.styles = styles;\n this.animations = animations;\n }\n return RenderComponentType;\n}());\n/**\n * @deprecated Debug info is handled internally in the view engine now.\n */\nvar RenderDebugInfo = /** @class */ (function () {\n function RenderDebugInfo() {\n }\n return RenderDebugInfo;\n}());\n/**\n * @deprecated Use the `Renderer2` instead.\n * @publicApi\n */\nvar Renderer = /** @class */ (function () {\n function Renderer() {\n }\n return Renderer;\n}());\nvar Renderer2Interceptor = new InjectionToken('Renderer2Interceptor');\n/**\n * Injectable service that provides a low-level interface for modifying the UI.\n *\n * Use this service to bypass Angular's templating and make custom UI changes that can't be\n * expressed declaratively. For example if you need to set a property or an attribute whose name is\n * not statically known, use {@link Renderer#setElementProperty setElementProperty} or\n * {@link Renderer#setElementAttribute setElementAttribute} respectively.\n *\n * If you are implementing a custom renderer, you must implement this interface.\n *\n * The default Renderer implementation is `DomRenderer`. Also available is `WebWorkerRenderer`.\n *\n * @deprecated Use `RendererFactory2` instead.\n * @publicApi\n */\nvar RootRenderer = /** @class */ (function () {\n function RootRenderer() {\n }\n return RootRenderer;\n}());\n/**\n * Creates and initializes a custom renderer that implements the `Renderer2` base class.\n *\n * @publicApi\n */\nvar RendererFactory2 = /** @class */ (function () {\n function RendererFactory2() {\n }\n return RendererFactory2;\n}());\n/**\n * Flags for renderer-specific style modifiers.\n * @publicApi\n */\nvar RendererStyleFlags2;\n(function (RendererStyleFlags2) {\n /**\n * Marks a style as important.\n */\n RendererStyleFlags2[RendererStyleFlags2[\"Important\"] = 1] = \"Important\";\n /**\n * Marks a style as using dash case naming (this-is-dash-case).\n */\n RendererStyleFlags2[RendererStyleFlags2[\"DashCase\"] = 2] = \"DashCase\";\n})(RendererStyleFlags2 || (RendererStyleFlags2 = {}));\n/**\n * Extend this base class to implement custom rendering. By default, Angular\n * renders a template into DOM. You can use custom rendering to intercept\n * rendering calls, or to render to something other than DOM.\n *\n * Create your custom renderer using `RendererFactory2`.\n *\n * Use a custom renderer to bypass Angular's templating and\n * make custom UI changes that can't be expressed declaratively.\n * For example if you need to set a property or an attribute whose name is\n * not statically known, use the `setProperty()` or\n * `setAttribute()` method.\n *\n * @publicApi\n */\nvar Renderer2 = /** @class */ (function () {\n function Renderer2() {\n }\n /** @internal */\n Renderer2.__NG_ELEMENT_ID__ = function () { return SWITCH_RENDERER2_FACTORY(); };\n return Renderer2;\n}());\nvar SWITCH_RENDERER2_FACTORY__POST_R3__ = injectRenderer2;\nvar SWITCH_RENDERER2_FACTORY__PRE_R3__ = noop;\nvar SWITCH_RENDERER2_FACTORY = SWITCH_RENDERER2_FACTORY__PRE_R3__;\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 * @description Represents the version of Angular\n *\n * @publicApi\n */\nvar Version = /** @class */ (function () {\n function Version(full) {\n this.full = full;\n this.major = full.split('.')[0];\n this.minor = full.split('.')[1];\n this.patch = full.split('.').slice(2).join('.');\n }\n return Version;\n}());\n/**\n * @publicApi\n */\nvar VERSION = new Version('7.1.4');\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 ComponentFactoryResolver$1 = /** @class */ (function (_super) {\n __extends(ComponentFactoryResolver$$1, _super);\n function ComponentFactoryResolver$$1() {\n return _super !== null && _super.apply(this, arguments) || this;\n }\n ComponentFactoryResolver$$1.prototype.resolveComponentFactory = function (component) {\n ngDevMode && assertComponentType(component);\n var componentDef = getComponentDef(component);\n return new ComponentFactory$1(componentDef);\n };\n return ComponentFactoryResolver$$1;\n}(ComponentFactoryResolver));\nfunction toRefArray(map) {\n var array = [];\n for (var nonMinified in map) {\n if (map.hasOwnProperty(nonMinified)) {\n var minified = map[nonMinified];\n array.push({ propName: minified, templateName: nonMinified });\n }\n }\n return array;\n}\n/**\n * Default {@link RootContext} for all components rendered with {@link renderComponent}.\n */\nvar ROOT_CONTEXT = new InjectionToken('ROOT_CONTEXT_TOKEN', { providedIn: 'root', factory: function () { return createRootContext(inject(SCHEDULER)); } });\n/**\n * A change detection scheduler token for {@link RootContext}. This token is the default value used\n * for the default `RootContext` found in the {@link ROOT_CONTEXT} token.\n */\nvar SCHEDULER = new InjectionToken('SCHEDULER_TOKEN', {\n providedIn: 'root',\n factory: function () { return defaultScheduler; },\n});\n/**\n * A function used to wrap the `RendererFactory2`.\n * Used in tests to change the `RendererFactory2` into a `DebugRendererFactory2`.\n */\nvar WRAP_RENDERER_FACTORY2 = new InjectionToken('WRAP_RENDERER_FACTORY2');\nvar NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR = {};\nfunction createChainedInjector(rootViewInjector, moduleInjector) {\n return {\n get: function (token, notFoundValue) {\n var value = rootViewInjector.get(token, NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR);\n if (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR) {\n // Return the value from the root element injector when\n // - it provides it\n // (value !== NOT_FOUND_CHECK_ONLY_ELEMENT_INJECTOR)\n return value;\n }\n return moduleInjector.get(token, notFoundValue);\n }\n };\n}\n/**\n * Render3 implementation of {@link viewEngine_ComponentFactory}.\n */\nvar ComponentFactory$1 = /** @class */ (function (_super) {\n __extends(ComponentFactory$$1, _super);\n function ComponentFactory$$1(componentDef) {\n var _this = _super.call(this) || this;\n _this.componentDef = componentDef;\n _this.componentType = componentDef.type;\n _this.selector = componentDef.selectors[0][0];\n _this.ngContentSelectors = [];\n return _this;\n }\n Object.defineProperty(ComponentFactory$$1.prototype, \"inputs\", {\n get: function () {\n return toRefArray(this.componentDef.inputs);\n },\n enumerable: true,\n configurable: true\n });\n Object.defineProperty(ComponentFactory$$1.prototype, \"outputs\", {\n get: function () {\n return toRefArray(this.componentDef.outputs);\n },\n enumerable: true,\n configurable: true\n });\n ComponentFactory$$1.prototype.create = function (injector, projectableNodes, rootSelectorOrNode, ngModule) {\n var isInternalRootView = rootSelectorOrNode === undefined;\n var rendererFactory;\n if (ngModule) {\n var wrapper = ngModule.injector.get(WRAP_RENDERER_FACTORY2, function (v) { return v; });\n rendererFactory = wrapper(ngModule.injector.get(RendererFactory2));\n }\n else {\n rendererFactory = domRendererFactory3;\n }\n var hostRNode = isInternalRootView ?\n elementCreate(this.selector, rendererFactory.createRenderer(null, this.componentDef)) :\n locateHostElement(rendererFactory, rootSelectorOrNode);\n var rootFlags = this.componentDef.onPush ? 4 /* Dirty */ | 64 /* IsRoot */ :\n 2 /* CheckAlways */ | 64 /* IsRoot */;\n var rootContext = ngModule && !isInternalRootView ? ngModule.injector.get(ROOT_CONTEXT) : createRootContext();\n var renderer = rendererFactory.createRenderer(hostRNode, this.componentDef);\n var rootViewInjector = ngModule ? createChainedInjector(injector, ngModule.injector) : injector;\n if (rootSelectorOrNode && hostRNode) {\n ngDevMode && ngDevMode.rendererSetAttribute++;\n isProceduralRenderer(renderer) ?\n renderer.setAttribute(hostRNode, 'ng-version', VERSION.full) :\n hostRNode.setAttribute('ng-version', VERSION.full);\n }\n // Create the root view. Uses empty TView and ContentTemplate.\n var rootView = createLViewData(null, renderer, createTView(-1, null, 1, 0, null, null, null), rootContext, rootFlags, undefined, rootViewInjector);\n // rootView is the parent when bootstrapping\n var oldView = enterView(rootView, null);\n var component;\n var tElementNode;\n try {\n if (rendererFactory.begin)\n rendererFactory.begin();\n var componentView = createRootComponentView(hostRNode, this.componentDef, rootView, renderer);\n tElementNode = getTNode(0, rootView);\n // Transform the arrays of native nodes into a structure that can be consumed by the\n // projection instruction. This is needed to support the reprojection of these nodes.\n if (projectableNodes) {\n var index = 0;\n var tView = rootView[TVIEW];\n var projection$$1 = tElementNode.projection = [];\n for (var i = 0; i < projectableNodes.length; i++) {\n var nodeList = projectableNodes[i];\n var firstTNode = null;\n var previousTNode = null;\n for (var j = 0; j < nodeList.length; j++) {\n if (tView.firstTemplatePass) {\n // For dynamically created components such as ComponentRef, we create a new TView for\n // each insert. This is not ideal since we should be sharing the TViews.\n // Also the logic here should be shared with `component.ts`'s `renderComponent`\n // method.\n tView.expandoStartIndex++;\n tView.blueprint.splice(++index + HEADER_OFFSET, 0, null);\n tView.data.splice(index + HEADER_OFFSET, 0, null);\n rootView.splice(index + HEADER_OFFSET, 0, null);\n }\n var tNode = createNodeAtIndex(index, 3 /* Element */, nodeList[j], null, null);\n previousTNode ? (previousTNode.next = tNode) : (firstTNode = tNode);\n previousTNode = tNode;\n }\n projection$$1.push(firstTNode);\n }\n }\n // TODO: should LifecycleHooksFeature and other host features be generated by the compiler and\n // executed here?\n // Angular 5 reference: https://stackblitz.com/edit/lifecycle-hooks-vcref\n component = createRootComponent(componentView, this.componentDef, rootView, rootContext, [LifecycleHooksFeature]);\n refreshDescendantViews(rootView, 1 /* Create */);\n }\n finally {\n leaveView(oldView, true);\n if (rendererFactory.end)\n rendererFactory.end();\n }\n var componentRef = new ComponentRef$1(this.componentType, component, createElementRef(ElementRef, tElementNode, rootView), rootView, tElementNode);\n if (isInternalRootView) {\n // The host element of the internal root view is attached to the component's host view node\n componentRef.hostView._tViewNode.child = tElementNode;\n }\n return componentRef;\n };\n return ComponentFactory$$1;\n}(ComponentFactory));\nvar componentFactoryResolver = new ComponentFactoryResolver$1();\n/**\n * Represents an instance of a Component created via a {@link ComponentFactory}.\n *\n * `ComponentRef` provides access to the Component Instance as well other objects related to this\n * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}\n * method.\n *\n */\nvar ComponentRef$1 = /** @class */ (function (_super) {\n __extends(ComponentRef$$1, _super);\n function ComponentRef$$1(componentType, instance, location, _rootView, _tNode) {\n var _this = _super.call(this) || this;\n _this.location = location;\n _this._rootView = _rootView;\n _this._tNode = _tNode;\n _this.destroyCbs = [];\n _this.instance = instance;\n _this.hostView = _this.changeDetectorRef = new RootViewRef(_rootView);\n _this.hostView._tViewNode = createViewNode(-1, _rootView);\n _this.componentType = componentType;\n return _this;\n }\n Object.defineProperty(ComponentRef$$1.prototype, \"injector\", {\n get: function () { return new NodeInjector(this._tNode, this._rootView); },\n enumerable: true,\n configurable: true\n });\n ComponentRef$$1.prototype.destroy = function () {\n ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');\n this.destroyCbs.forEach(function (fn) { return fn(); });\n this.destroyCbs = null;\n };\n ComponentRef$$1.prototype.onDestroy = function (callback) {\n ngDevMode && assertDefined(this.destroyCbs, 'NgModule already destroyed');\n this.destroyCbs.push(callback);\n };\n return ComponentRef$$1;\n}(ComponentRef));\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 */\nvar _devMode = true;\nvar _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 * @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 */\nvar InertBodyHelper = /** @class */ (function () {\n function InertBodyHelper(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 var 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 '